PvlObject.h

Go to the documentation of this file.

#ifndef PvlObject_h
#define PvlObject_h

#include <algorithm>
#include "PvlContainer.h"
#include "PvlGroup.h"


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 p_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 p_groups.begin();
      };


      ConstPvlGroupIterator BeginGroup() const {
        return p_groups.begin();
      };


      PvlGroupIterator EndGroup() {
        return p_groups.end();
      };


      ConstPvlGroupIterator EndGroup() const {
        return p_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 vissible 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) {
        p_groups.push_back(group);
        //p_groups[p_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 p_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 p_objects.begin();
      };


      ConstPvlObjectIterator BeginObject() const {
        return p_objects.begin();
      };


      PvlObjectIterator EndObject() {
        return p_objects.end();
      };


      ConstPvlObjectIterator EndObject() const {
        return p_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) {
        p_objects.push_back(object);
        p_objects[p_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();
        p_objects.clear();
        p_groups.clear();
      }

      const PvlObject &operator=(const PvlObject &other);
      
      void ValidateObject(PvlObject & pPvlObj);
      
    private:
      QList<PvlObject> p_objects;    
      QList<PvlGroup> p_groups;
  };
}

#endif