PvlObject.h

#ifndef PvlObject_h
#define PvlObject_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include <algorithm>
 
#include "PvlContainer.h"
#include "PvlGroup.h"
 
#include <QMetaType>
 
#include <nlohmann/json.hpp>
 
 
template<typename T> class QList;
 
namespace Isis {
  class PvlObject : public Isis::PvlContainer {
    public:
      PvlObject();
      PvlObject(const QString &name);
      PvlObject(const PvlObject &other);
      PvlObject(const QString &name, const nlohmann::json &jsonobj);
 
      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();
      };
      int groups() const  {…}
 
      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();
      };
      PvlGroupIterator beginGroup() {…}
 

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

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

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

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

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

      enum FindOptions {
        None,
        Traverse
      };
      enum FindOptions {…};
 
      // 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());
      };
      void addGroup(const Isis::PvlGroup &group) {…}
 
      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;
      }
      bool hasGroup(const QString &name) const  {…}

      int objects() const {
        return m_objects.size();
      };
      int objects() const  {…}
 
      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();
      };
      PvlObjectIterator beginObject() {…}
 

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

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

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

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

      ConstPvlObjectIterator findObject(const QString &name,
                                        ConstPvlObjectIterator beg,
                                        ConstPvlObjectIterator end) const {
        PvlObject temp(name);
        return std::find(beg, end, temp);
      }
      ConstPvlObjectIterator findObject(const QString &name, {…}
 
 
      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 addObject(const PvlObject &object) {…}
 
      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 hasObject(const QString &name) const  {…}
 

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

      void clear() {
        Isis::PvlContainer::clear();
        m_objects.clear();
        m_groups.clear();
      }
      void clear() {…}
 
      const PvlObject &operator=(const PvlObject &other);

      void validateObject(PvlObject & pPvlObj);
 
    private:
      QList<PvlObject> m_objects;    
      QList<PvlGroup> m_groups;
  };
  class PvlObject : public Isis::PvlContainer {…};
}
 
Q_DECLARE_METATYPE(Isis::PvlObject);
 
#endif