PvlKeyword.h

#ifndef PvlKeyword_h
#define PvlKeyword_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include <vector>
#include <map>
#include <iostream>
 
#include <QString>
#include <QVariant>
#include <QVarLengthArray>
 
#include "Constants.h"
#include "IString.h"
 
#include <nlohmann/json.hpp>
 
namespace Isis {
  class PvlSequence;
  class PvlFormat;

  class PvlKeyword {
    public:
      PvlKeyword();
      PvlKeyword(QString name);
      PvlKeyword(QString name, QString value,
                 QString unit = "");
      PvlKeyword(QString name, std::vector<std::string> vecValue,
                 QString unit = "");
      PvlKeyword(const PvlKeyword &other);
      ~PvlKeyword();
 
      void setName(QString name);

      QString name() const {
        if(m_name)
          return m_name;
        else
          return "";
      };

      bool isNamed(QString name) const {
        return stringEqual(name, this->name());
      };
 
      void setValue(QString value, QString unit = "");
      void setJsonValue(nlohmann::json jsonobj, QString unit = "");
 
      void setUnits(QString units);
      void setUnits(QString value, QString units);
 
      PvlKeyword &operator=(QString value);
 
      void addValue(QString value, QString unit = "");
      void addJsonValue(nlohmann::json jsonobj, QString unit = "");
 
      PvlKeyword &operator+=(QString value);

      int size() const {
        return m_values.size();
      };
      bool isNull(const int index = 0) const;
      void clear();
 
      friend std::istream &operator>>(std::istream &is, PvlKeyword &result);
      friend std::ostream &operator<<(std::ostream &os,
                                      const PvlKeyword &keyword);

      operator double() const {
        return toDouble(operator[](0));
      };

      operator int() const {
        return toInt(operator[](0));
      };

      operator Isis::BigInt() const {
        return toBigInt(operator[](0));
      };
 
      operator QString() const;
 
      const QString &operator[](int index) const;
      QString &operator[](int index);
      QString unit(const int index = 0) const;
 
      void addComment(QString comment);
      void addCommentWrapped(QString comment);
 
      void addComments(const std::vector<QString> &comments);

      int comments() const {
        return (m_comments ? m_comments->size() : 0);
      };
      QString comment(const int index) const;
      void clearComment();

      bool operator==(const PvlKeyword &key) const {
        if(!m_name && !key.m_name) return true;
        if(!m_name || !key.m_name) return false;
 
        return (stringEqual(m_name, key.m_name));
      };

      bool operator!=(const PvlKeyword &key) const {
        return !(*this == key);
      };
 
      bool isEquivalent(QString string1, int index = 0) const;

      void setWidth(int width) {
        m_width = width;
      };

      void setIndent(int indent) {
        m_indent = indent;
      };

      int width() const {
        return m_width;
      };

      int indent() const {
        return m_indent;
      };
 
      PvlKeyword &operator=(Isis::PvlSequence &seq);
 
      void setFormat(PvlFormat *formatter);
      PvlFormat *format();
 
      static bool stringEqual(const QString &string1,
                              const QString &string2);
 
 
      static QString readLine(std::istream &is, bool insideComment);
 
      static bool readCleanKeyword(QString keyword,
                                   std::vector< QString > &keywordComments,
                                   QString &keywordName,
                                   std::vector< std::pair<QString, QString> >
                                   &keywordValues);
 
      static QString readValue(QString &keyword, bool &quoteProblem);
      static QString readValue(QString &keyword, bool &quoteProblem,
                                   const std::vector< std::pair<char, char> > &
                                   otherDelimiters);
 
      const PvlKeyword &operator=(const PvlKeyword &other);

      void validateKeyword(PvlKeyword & pvlKwrd, QString psValueType="", PvlKeyword* pvlKwrdRange=NULL);
 
    protected:
      QString reform(const QString &value) const;
      QString toPvl(const QString &value) const;
      QString toIPvl(const QString &value) const;
      std::ostream &writeWithWrap(std::ostream &os,
                                  const QString &textToWrite,
                                  int startColumn,
                                  PvlFormat &format) const;

      PvlFormat *m_formatter;
 
    private:
      char * m_name;

      QVarLengthArray<QString, 1> m_values;

      std::vector<QString> *m_units;

      std::vector<QString> *m_comments;
 
      void init();
 
      void writeSpaces(std::ostream &, int) const;

      int m_width;
      int m_indent;
  };
};
 
#endif