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);
      };
      inline QString name() const {
        return (QString) m_name;
      };
      bool isNamed(const QString &match) const {
        return PvlKeyword::stringEqual(match, (QString)m_name);
      }
      inline QString type() const {
        return m_name.name();
      };
      inline int keywords() const {
        return m_keywords.size();
      };
 
      void clear() {
        m_keywords.clear();
      };
      enum InsertMode { Append, Replace };
      void addKeyword(const PvlKeyword &keyword,
                      const InsertMode mode = Append);
 
 
      void operator+= (const PvlKeyword &keyword) {
        addKeyword(keyword);
      };
 
      PvlKeyword &findKeyword(const QString &name);
      PvlKeyword &operator[](const QString &name) {
        return findKeyword(name);
      };
      PvlKeyword &operator[](const int index);
 
      PvlKeyword &operator[](const char *name) {
        return operator[](QString(name));
      };
 
      const PvlKeyword &findKeyword(const QString &name) const;
      const PvlKeyword &operator[](const QString &name) const {
        return findKeyword(name);
      };
      const PvlKeyword &operator[](const int index) const;
 
      PvlKeyword operator[](const char *name) const {
        return operator[](QString(name));
      };
 
      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();
      };
 
      ConstPvlKeywordIterator begin() const {
        return m_keywords.begin();
      };
 
      PvlKeywordIterator end() {
        return m_keywords.end();
      };
 
      ConstPvlKeywordIterator end() const {
        return m_keywords.end();
      };
 
      void deleteKeyword(const QString &name);
      void deleteKeyword(const int index);
 
      bool cleanDuplicateKeywords();
 
      void operator-= (const QString &name) {
        deleteKeyword(name);
      };
      void operator-= (const PvlKeyword &key) {
        deleteKeyword(key.name());
      };
      QString fileName() const {
        return m_filename;
      };
 
      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;
      }
 
      PvlContainer *m_formatTemplate;
 
      void validateAllKeywords(PvlContainer &pPvlCont);
 
      void validateRepeatOption(PvlKeyword & pPvlTmplKwrd, PvlContainer & pPvlCont);
  };
 
  std::ostream &operator<<(std::ostream &os, PvlContainer &container);
};
 
#endif