PvlKeyword.h

Go to the documentation of this file.

#ifndef PvlKeyword_h
#define PvlKeyword_h

#include <vector>
#include <map>
#include <iostream>

#include <QVariant>
#include <QVarLengthArray>

#include "iString.h"
#include "Constants.h"

namespace Isis {
  class PvlSequence;
  class PvlFormat;

  class PvlKeyword {
    public:
      PvlKeyword();
      PvlKeyword(const std::string &name);
      PvlKeyword(const std::string &name, const Isis::iString value,
                 const std::string unit = "");
      PvlKeyword(const PvlKeyword &other);
      ~PvlKeyword();

      void SetName(const std::string &name);

      std::string Name() const {
        if(p_name)
          return p_name;
        else
          return "";
      };
      bool IsNamed(const std::string &name) const {
        return StringEqual(name, Name());
      };

      void SetValue(const Isis::iString value, const std::string unit = "");

      void SetUnits(const iString &units);
      void SetUnits(const iString &value, const iString &units);

      PvlKeyword &operator=(const Isis::iString value);

      void AddValue(const Isis::iString value, const std::string unit = "");
      PvlKeyword &operator+=(const Isis::iString value);

      int Size() const {
        return p_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 (double) operator[](0);
      };
      operator int() const {
        return (int) operator[](0);
      };
      operator Isis::BigInt() const {
        return (Isis::BigInt) operator[](0);
      };
      operator std::string() const {
        return (std::string) operator[](0);
      };

      operator QString() const;

      const Isis::iString &operator[](const int index) const;
      Isis::iString &operator[](const int index);
      std::string Unit(const int index = 0) const;

      void AddComment(const std::string &comment);
      void AddCommentWrapped(const std::string &comment);

      void AddComments(const std::vector<std::string> &comments);

      int Comments() const {
        return (p_comments ? p_comments->size() : 0);
      };
      std::string Comment(const int index) const;
      void ClearComments();

      bool operator==(const PvlKeyword &key) const {
        if(!p_name && !key.p_name) return true;
        if(!p_name || !key.p_name) return false;

        return (StringEqual(p_name, key.p_name));
      };

      bool operator!=(const PvlKeyword &key) const {
        return !(*this == key);
      };

      bool IsEquivalent(const std::string &string1, int index = 0) const;

      void SetWidth(int width) {
        p_width = width;
      };

      void SetIndent(int indent) {
        p_indent = indent;
      };

      int Width() const {
        return p_width;
      };

      int Indent() const {
        return p_indent;
      };

      PvlKeyword &operator=(Isis::PvlSequence &seq);

      void SetFormat(PvlFormat *formatter);
      PvlFormat *GetFormat();

      static bool StringEqual(const std::string &string1,
                              const std::string &string2);


      static std::string ReadLine(std::istream &is, bool insideComment);

      static bool ReadCleanKeyword(std::string keyword,
                                   std::vector< std::string > &keywordComments,
                                   std::string &keywordName,
                                   std::vector< std::pair<std::string, std::string> >
                                   &keywordValues);

      static std::string ReadValue(std::string &keyword, bool &quoteProblem);
      static std::string ReadValue(std::string &keyword, bool &quoteProblem,
                                   const std::vector< std::pair<char, char> > &
                                   otherDelimiters);

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

      void ValidateKeyword(PvlKeyword & pvlKwrd, std::string psValueType="", PvlKeyword* pvlKwrdRange=NULL);

    protected:
      std::string Reform(const std::string &value) const;
      std::string ToPvl(const std::string &value) const;
      std::string ToIPvl(const std::string &value) const;
      std::ostream &WriteWithWrap(std::ostream &os,
                                  const std::string &textToWrite,
                                  int startColumn,
                                  PvlFormat &format) const;

      PvlFormat *p_formatter;

    private:
      char * p_name;

      QVarLengthArray<Isis::iString, 1> p_values;

      std::vector<std::string> *p_units;

      std::vector<std::string> *p_comments;

      void Init();

      void WriteSpaces(std::ostream &, int) const;

      int p_width;
      int p_indent;
  };
};

#endif