PvlContainer.h

Go to the documentation of this file.

#ifndef PvlContainer_h
#define PvlContainer_h

#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