PvlContainer.h

#ifndef PvlContainer_h
#define PvlContainer_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include "PvlKeyword.h"
 
template<typename T> class QList;
 
namespace Isis {
  class PvlContainer {
    public:
      PvlContainer(const QString &type);
      PvlContainer(const QString &type, const QString &name);
      PvlContainer(const PvlContainer &other);

      void setName(const QString &name) {
        m_name.setValue(name);
      };
      void setName(const QString &name) {…}

      inline QString name() const {
        return (QString) m_name;
      };
      inline QString name() const  {…}

      bool isNamed(const QString &match) const {
        return PvlKeyword::stringEqual(match, (QString)m_name);
      }
      bool isNamed(const QString &match) const  {…}

      inline QString type() const {
        return m_name.name();
      };
      inline QString type() const  {…}

      inline int keywords() const {
        return m_keywords.size();
      };
      inline int keywords() const  {…}

      void clear() {
        m_keywords.clear();
      };
      void clear() {…}

      enum InsertMode { Append, Replace };
      void addKeyword(const PvlKeyword &keyword,
                      const InsertMode mode = Append);
 

      void operator+= (const PvlKeyword &keyword) {
        addKeyword(keyword);
      };
      void operator+= (const PvlKeyword &keyword) {…}
 
      PvlKeyword &findKeyword(const QString &name);
      PvlKeyword &operator[](const QString &name) {
        return findKeyword(name);
      };
      PvlKeyword &operator[](const QString &name) {…}
      PvlKeyword &operator[](const int index);

      PvlKeyword &operator[](const char *name) {
        return operator[](QString(name));
      };
      PvlKeyword &operator[](const char *name) {…}
 
      const PvlKeyword &findKeyword(const QString &name) const;
 
      const PvlKeyword &operator[](const QString &name) const {
        return findKeyword(name);
      };
      const PvlKeyword &operator[](const QString &name) const  {…}
      const PvlKeyword &operator[](const int index) const;

      PvlKeyword operator[](const char *name) const {
        return operator[](QString(name));
      };
      PvlKeyword operator[](const char *name) const  {…}
 
      bool hasKeyword(const QString &name) const;
      typedef QList<PvlKeyword>::iterator PvlKeywordIterator;

      typedef QList<PvlKeyword>::const_iterator ConstPvlKeywordIterator;
 
 
      PvlKeywordIterator findKeyword(const QString &name,
                                     PvlKeywordIterator beg,
                                     PvlKeywordIterator end);
 
      ConstPvlKeywordIterator findKeyword(const QString &name,
                                          ConstPvlKeywordIterator beg,
                                          ConstPvlKeywordIterator end) const;
 
      PvlKeywordIterator addKeyword(const PvlKeyword &keyword,
                                    PvlKeywordIterator pos);

      PvlKeywordIterator begin() {
        return m_keywords.begin();
      };
      PvlKeywordIterator begin() {…}

      ConstPvlKeywordIterator begin() const {
        return m_keywords.begin();
      };
      ConstPvlKeywordIterator begin() const  {…}

      PvlKeywordIterator end() {
        return m_keywords.end();
      };
      PvlKeywordIterator end() {…}

      ConstPvlKeywordIterator end() const {
        return m_keywords.end();
      };
      ConstPvlKeywordIterator end() const  {…}
 
      void deleteKeyword(const QString &name);
      void deleteKeyword(const int index);
 
      bool cleanDuplicateKeywords();

      void operator-= (const QString &name) {
        deleteKeyword(name);
      };
      void operator-= (const QString &name) {…}

      void operator-= (const PvlKeyword &key) {
        deleteKeyword(key.name());
      };
      void operator-= (const PvlKeyword &key) {…}

      QString fileName() const {
        return m_filename;
      };
      QString fileName() const  {…}
 
      void setFormatTemplate(PvlContainer &ref) {
        m_formatTemplate = &ref;
      };
 
      bool hasFormatTemplate() {
        return m_formatTemplate != NULL;
      };
 
      PvlContainer *formatTemplate() {
        return m_formatTemplate;
      };
 
      PvlFormat *format() {
        return m_name.format();
      }
      void setFormat(PvlFormat *format) {
        m_name.setFormat(format);
      }
 
      int indent() {
        return m_name.indent();
      }
      void setIndent(int indent) {
        m_name.setIndent(indent);
      }
 
      inline int comments() const {
        return m_name.comments();
      };
      QString comment(const int index) const {
        return m_name.comment(index);
      }
 
      void addComment(const QString &comment) {
        m_name.addComment(comment);
      }
 
      PvlKeyword &nameKeyword() {
        return m_name;
      }
      const PvlKeyword &nameKeyword() const {
        return m_name;
      }
 
      const PvlContainer &operator=(const PvlContainer &other);
 
    protected:
      QString m_filename;                   
      PvlKeyword m_name;                   
      QList<PvlKeyword> m_keywords; 
 
      void init();

      void setFileName(const QString &filename) {
        m_filename = filename;
      }
      void setFileName(const QString &filename) {…}
 
      PvlContainer *m_formatTemplate;

      void validateAllKeywords(PvlContainer &pPvlCont);

      void validateRepeatOption(PvlKeyword & pPvlTmplKwrd, PvlContainer & pPvlCont);
  };
  class PvlContainer {…};
 
  std::ostream &operator<<(std::ostream &os, PvlContainer &container);
};
 
#endif