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) {
        p_name.SetValue(name);
      };
      inline QString Name() const {
        return (QString) p_name;
      };
      bool IsNamed(const QString &match) const {
        return PvlKeyword::StringEqual(match, (QString)p_name);
      }
      inline QString Type() const {
        return p_name.Name();
      };
      inline int Keywords() const {
        return p_keywords.size();
      };

      void Clear() {
        p_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 p_keywords.begin();
      };

      ConstPvlKeywordIterator Begin() const {
        return p_keywords.begin();
      };

      PvlKeywordIterator End() {
        return p_keywords.end();
      };

      ConstPvlKeywordIterator End() const {
        return p_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 p_filename;
      };

      void SetFormatTemplate(PvlContainer &ref) {
        p_formatTemplate = &ref;
      };

      bool HasFormatTemplate() {
        return p_formatTemplate != NULL;
      };

      PvlContainer *FormatTemplate() {
        return p_formatTemplate;
      };

      PvlFormat *GetFormat() {
        return p_name.GetFormat();
      }
      void SetFormat(PvlFormat *format) {
        p_name.SetFormat(format);
      }

      int Indent() {
        return p_name.Indent();
      }
      void SetIndent(int indent) {
        p_name.SetIndent(indent);
      }

      inline int Comments() const {
        return p_name.Comments();
      };
      QString Comment(const int index) const {
        return p_name.Comment(index);
      }

      void AddComment(const QString &comment) {
        p_name.AddComment(comment);
      }

      PvlKeyword &GetNameKeyword() {
        return p_name;
      }
      const PvlKeyword &GetNameKeyword() const {
        return p_name;
      }

      const PvlContainer &operator=(const PvlContainer &other);

    protected:
      QString p_filename;                   
      PvlKeyword p_name;                   
      QList<PvlKeyword> p_keywords; 
      void Init();

      void SetFileName(const QString &filename) {
        p_filename = filename;
      }

      PvlContainer *p_formatTemplate;
      
      void ValidateAllKeywords(PvlContainer &pPvlCont);
      
      void ValidateRepeatOption(PvlKeyword & pPvlTmplKwrd, PvlContainer & pPvlCont);
  };

  std::ostream &operator<<(std::ostream &os, PvlContainer &container);
};

#endif