PvlFlatMap.h

#ifndef PvlFlatMap_h
#define PvlFlatMap_h
 
/* SPDX-License-Identifier: CC0-1.0 */
// Qt library
#include <QMap>
#include <QString>
#include <QStringList>
 
// PvlConstraints type
#include "PvlKeyword.h"
 
namespace Isis {
 
  class FileName;
  class PvlContainer;
  class PvlGroup;
  class PvlObject;
 
  class PvlConstraints {
    public:
      PvlConstraints();
      PvlConstraints(const QString &keyListFile);
      virtual ~PvlConstraints();
  
      int excludeSize() const;
      int includeSize() const;
      int keyListSize() const;
  
      void addExclude(const QString &name);
      void addInclude(const QString &name);
      void addKeyToList(const QString &name);
  
      void addExclude(const QStringList &other);
      void addInclude(const QStringList &other);
      void addKeyToList(const QStringList &other);
  
      void addKeyToList(const FileName &fileName);
 
      bool isExcluded(const QString &name) const;
      bool isIncluded(const QString &name) const;
      bool isKeyInList(const QString &name) const;
  
      const QStringList &excludes() const;
      const QStringList &includes() const;
      const QStringList &keyList()  const;
      
      static PvlConstraints withExcludes(const QStringList &excludes);
      static PvlConstraints withIncludes(const QStringList &includes);
  
    private:
      void readKeyListFile(const FileName &fname);
 
      QStringList m_excludes; 
      QStringList m_includes; 
      QStringList m_keylist;  
  
  };
 
 
  class PvlFlatMap : public QMap<QString, PvlKeyword> {
  
    public:
      typedef QMap<QString,PvlKeyword>::const_iterator ConstPvlFlatMapIterator;
      typedef QMap<QString,PvlKeyword>::iterator       PvlFlatMapIterator;
  
      PvlFlatMap();
      PvlFlatMap(const PvlFlatMap &other);
      PvlFlatMap(const PvlFlatMap &pmap1, 
                 const PvlFlatMap &pmap2);
      PvlFlatMap(const PvlObject &pvl, 
                 const PvlConstraints &constraints = PvlConstraints());
      PvlFlatMap(const PvlContainer &pvl, 
                 const PvlConstraints &constraints = PvlConstraints());
      virtual ~PvlFlatMap();
  
      bool exists(const QString &key) const;
      int  count(const QString &key) const;
      bool isNull(const QString &key, 
                  const int index = 0) const;
 
      void add(const QString &key, 
               const QString &value);
      void add(const PvlKeyword &keyword);
  
      void append(const PvlKeyword &key);
      void append(const QString &key, 
                  const QString &value);
  
      bool erase(const QString &key);
  
      QString get(const QString &key, 
                  const int &index = 0) const;
      QString get(const QString &key, 
                  const QString &defValue, 
                  const int &index = 0) const;
  
      // QString value(const QString &key) const;
      QString operator()(const QString &name) const;
      QStringList allValues(const QString &key) const;
  
      PvlKeyword keyword(const QString &key) const;
  
      int merge(const PvlFlatMap &other);
      
      static QStringList keywordValues(const PvlKeyword &keyword);
  
    private:
      int loadObject(const PvlObject &object, 
                     const PvlConstraints &constraints);
      int loadGroups(const PvlObject &object, 
                     const PvlConstraints &constraints);
      int loadGroup(const PvlGroup &group, 
                    const PvlConstraints &constraints);
      int loadKeywords(const PvlContainer &pvl, 
                       const PvlConstraints &constraints);
  };
 
} // Namespace Isis
 
#endif