PvlObject.h

Go to the documentation of this file.

#ifndef PvlObject_h
#define PvlObject_h

#include <algorithm>

#include "PvlContainer.h"
#include "PvlGroup.h"

#include <QMetaType>

template<typename T> class QList;

namespace Isis {
  class PvlObject : public Isis::PvlContainer {
    public:
      PvlObject();
      PvlObject(const QString &name);
      PvlObject(const PvlObject &other);

      friend std::ostream &operator<<(std::ostream &os, Isis::PvlObject &object);
      friend std::istream &operator>>(std::istream &is, PvlObject &result);

      int groups() const {
        return m_groups.size();
      };

      PvlGroup &group(const int index);
      const PvlGroup &group(const int index) const;

      typedef QList<Isis::PvlGroup>::iterator PvlGroupIterator;
      typedef QList<Isis::PvlGroup>::const_iterator ConstPvlGroupIterator;


      PvlGroupIterator beginGroup() {
        return m_groups.begin();
      };


      ConstPvlGroupIterator beginGroup() const {
        return m_groups.begin();
      };


      PvlGroupIterator endGroup() {
        return m_groups.end();
      };


      ConstPvlGroupIterator endGroup() const {
        return m_groups.end();
      };


      PvlGroupIterator findGroup(const QString &name,
                                 PvlGroupIterator beg,
                                 PvlGroupIterator end) {
        Isis::PvlGroup temp(name);
        return std::find(beg, end, temp);
      }


      ConstPvlGroupIterator findGroup(const QString &name,
                                      ConstPvlGroupIterator beg,
                                      ConstPvlGroupIterator end) const {
        Isis::PvlGroup temp(name);
        return std::find(beg, end, temp);
      }


      enum FindOptions {
        None,
        Traverse
      };

      // The using statements below are used to make the PvlContainer's version
      // of FindKeyword and HasKeyword visible to other code that otherwise would not be
      // able to see those versions.
      using PvlContainer::findKeyword;


      PvlKeyword &findKeyword(const QString &kname,
                              FindOptions opts);


      using PvlContainer::hasKeyword;


      bool hasKeyword(const QString &kname,
                      FindOptions opts) const;

      Isis::PvlGroup &findGroup(const QString &name,
                                FindOptions opts = None);

      const Isis::PvlGroup &findGroup(const QString &name,
                                      FindOptions opts = None) const;
      void addGroup(const Isis::PvlGroup &group) {
        m_groups.push_back(group);
        //m_groups[m_groups.size()-1].SetFileName(FileName());
      };

      using PvlContainer::operator+=;
      void operator+= (const Isis::PvlGroup &group) {
        addGroup(group);
      }
      void operator+= (const Isis::PvlObject &obj) {
        addObject(obj);
      }

      void deleteGroup(const QString &name);

      void deleteGroup(const int index);


      bool hasGroup(const QString &name) const {
        if(findGroup(name, beginGroup(), endGroup()) == endGroup()) return false;
        return true;
      }

      int objects() const {
        return m_objects.size();
      };

      PvlObject &object(const int index);
      const PvlObject &object(const int index) const;

      typedef QList<PvlObject>::iterator PvlObjectIterator;
      typedef QList<PvlObject>::const_iterator ConstPvlObjectIterator;


      PvlObjectIterator beginObject() {
        return m_objects.begin();
      };


      ConstPvlObjectIterator beginObject() const {
        return m_objects.begin();
      };


      PvlObjectIterator endObject() {
        return m_objects.end();
      };


      ConstPvlObjectIterator endObject() const {
        return m_objects.end();
      };


      PvlObjectIterator findObject(const QString &name,
                                   PvlObjectIterator beg,
                                   PvlObjectIterator end) {
        PvlObject temp(name);
        return std::find(beg, end, temp);
      }


      ConstPvlObjectIterator findObject(const QString &name,
                                        ConstPvlObjectIterator beg,
                                        ConstPvlObjectIterator end) const {
        PvlObject temp(name);
        return std::find(beg, end, temp);
      }


      PvlObject &findObject(const QString &name,
                            FindOptions opts = None);

      const PvlObject &findObject(const QString &name,
                                  FindOptions opts = None) const;

      void addObject(const PvlObject &object) {
        m_objects.push_back(object);
        m_objects[m_objects.size()-1].setFileName(fileName());
      }

      void deleteObject(const QString &name);
      void deleteObject(const int index);


      bool hasObject(const QString &name) const {
        if(findObject(name, beginObject(), endObject()) == endObject()) return false;
        return true;
      }


      bool operator==(const PvlObject &object) const {
        return PvlKeyword::stringEqual(object.name(), this->name());
      }


      void clear() {
        Isis::PvlContainer::clear();
        m_objects.clear();
        m_groups.clear();
      }

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

      void validateObject(PvlObject & pPvlObj);

    private:
      QList<PvlObject> m_objects;    
      QList<PvlGroup> m_groups;
  };
}

Q_DECLARE_METATYPE(Isis::PvlObject);

#endif