PvlFormat.cpp

Go to the documentation of this file.

#include "IException.h"
#include "IString.h"
#include "Message.h"
#include "FileName.h"
#include "PvlKeyword.h"
#include "TextFile.h"
#include "Pvl.h"
#include "PvlFormat.h"

using namespace std;

namespace Isis {

  /*
  * Constructs an empty PvlFormat
  */
  PvlFormat::PvlFormat() {
    Init();
  }


  /*
  * Constructs a PvlFormat using the file name to ingest as the keyword to type
  * mapping. This is provided as a convience for child objects. The map is not
  * used for output of PvlKeywords in Normal Isis format.
  *
  * @param file A file name with keyword=type. Where KEYWORD is the name of a
  * keyword in this PvlKeyword and TYPE is one of [QString | integer | float ]
  */
  PvlFormat::PvlFormat(const QString &file) {
    Init();
    Add(file);
  }


  /*
  * Constructs a PvlFormat using the specified pre populated Pvl map of keyword
  * name (QString) vs keyword type (KeywordType).
  *
  * @param keywordType A Pvl with keyword=type. Where keyword is the name of a
  * keyword in a PvlKeyword and type is one of [QString | integer | float ]
  */
  PvlFormat::PvlFormat(Pvl &keywordType) {
    Init();
    Add(keywordType);
  }


  void PvlFormat::Init() {
    p_keywordMap.Clear();
    p_keywordMapFile.clear();
    p_charLimit = 80;
  }


  /*
  * Add the contents of a file to the keyword type mapping. The file should
  * contain KEYWORD=TYPE (one per line), where TYPE is one of the QStrings
  * KeywordType can convert.
  */
  void PvlFormat::Add(const QString &file) {
    p_keywordMapFile = file;

    // Open the file and internalize it into the Pvl map
    try {
      Pvl pvl(file);
      Add(pvl);
    }
    catch(IException &e) {
      QString msg;
      msg += "Unable to open or read keyword to type mapping file [";
      msg += file + "]";
      throw IException(e, IException::Programmer, msg, _FILEINFO_);
    }
  }


  /*
  * Add the contents of a Pvl to the keyword type mapping. The pvl should
  * contain KEYWORD=TYPE, where TYPE is one of the QStrings KeywordType can
  * convert.
  */
  void PvlFormat::Add(Pvl &pvl) {
    for(int i = 0; i < pvl.Keywords(); ++i) {
      PvlKeyword &key = pvl[i];
      QString name = key.Name().toUpper();
      QString type = key[0].toUpper();
      PvlKeyword newKey(name, type);
      for(int j = 1; j < key.Size(); ++j) newKey.AddValue(key[j]);
      // Make sure we don't duplicate Keys
      if (p_keywordMap.HasKeyword(name)) {
        p_keywordMap.DeleteKeyword(name);
      }
      p_keywordMap.AddKeyword(newKey);
    }
  }


  /*
  * Returns the type of the keyword from the supplied map if any
  *
  * @param keyword The PvlKeyword to have its type returned
  */
  KeywordType PvlFormat::Type(const PvlKeyword &keyword) {
    QString name = keyword.Name().toUpper();
    if(p_keywordMap.HasKeyword(name)) {
      PvlKeyword &key = p_keywordMap.FindKeyword(name);
      return ToKeywordType(key[0]);
    }
    return NoTypeKeyword;
  }


  /*
  * Returns the number of digits of accuracy (right of decimal place) this
  * keyword should be output with
  *
  * @param keyword The PvlKeyword the accuracy is need for
  * @return The number of decimal places to be output. If this number is not
  *         available in keyword map return -1.
  */
  int PvlFormat::Accuracy(const PvlKeyword &keyword) {
    QString name = keyword.Name().toUpper();
    if(p_keywordMap.HasKeyword(name)) {
      PvlKeyword &key = p_keywordMap.FindKeyword(name);
      if(key.Size() > 1) {
        return toInt(key[1]);
      }
    }
    return -1;
  }


  /*
  * Returns the keyword name and value(s) formatted in "Normal" Isis format
  *
  * @param keyword The PvlKeyword to be formatted
  * @param num Use the ith value of the keyword
  */
  QString PvlFormat::FormatValue(const PvlKeyword &keyword, int num) {

    QString val;
    val.clear();

    // Find out if the units are the same for all values
    bool singleUnit = IsSingleUnit(keyword);

    // Create a Null value if the value index is greater than the number of values
    if(num >= keyword.Size()) {
      return "Null";
    }

    // Create a Null value if the requested index is an empty QString
    if(keyword[num].size() == 0) {
      val += "Null";
    }
    else {
      val += keyword[num];
    }

    val = AddQuotes(val);

    // If it is an array start it off with a paren
    if((keyword.Size() > 1) && (num == 0)) {
      val = "(" + val;
    }

    // Add the units to this value
    if((!singleUnit) && (keyword.Unit(num).size() > 0)) {
      val += " <" + keyword.Unit(num) + ">";
    }

    // Add a comma for arrays
    if(num != keyword.Size() - 1) {
      val += ", ";
    }
    // If it is an array close it off
    else if(keyword.Size() > 1) {
      val += ")";
    }

    // Add the units to the end if all values have the same units
    if((singleUnit) && (num == keyword.Size() - 1) &&
        (keyword.Unit(num).size() > 0)) {
      val += " <" + keyword.Unit(num) + ">";
    }

    return val;
  }


  /*
  * Format the name of the container
  *
  * @param keyword The PvlContainer being closed.
  */
  QString PvlFormat::FormatName(const PvlKeyword &keyword) {
    return keyword.Name();
  }


  /*
  * Format the end of a container
  *
  * @param name The text used to signify the end of a container
  * @param keyword The PvlContainer being closed.
  */
  QString PvlFormat::FormatEnd(const QString name,
                                   const PvlKeyword &keyword) {
    return "End_" + FormatName(keyword);
  };


  /*
  * Add single or double quotes around a value if necessary. The Isis definition
  * of when quotes are necessary is used.
  *
  * @param value The PvlKeyword value to be quoted if necessary.
  */
  QString PvlFormat::AddQuotes(const QString value) {
    QString val = value;

    bool needQuotes = false;

    // find out if we need quotes and what kind of quotes might already exist
    char existingQuoteType = '\0';
    for(int pos = 0; !needQuotes && pos < val.size(); pos++) {
      // check for values indicating we need quotes, if we have a sequence
      //   it should already be properly quoted...
      if(pos == 0) {
        if(val[pos] == '(' && val[val.size() - 1] == ')') break;
        if(val[pos] == '{' && val[val.size() - 1] == '}') break;
      }

      if(val[pos] == ' ' || val[pos] == '(' ||
          val[pos] == '(' || val[pos] == ')' ||
          val[pos] == '{' || val[pos] == '}' ||
          val[pos] == ',') {
        needQuotes = true;
      }

      if(pos == val.size() - 1 && val[pos] == '-')
        needQuotes = true;

      // remember if we are a quote, what quote type we are
      if(existingQuoteType == '\0') {
        if(val[pos] == '"') {
          existingQuoteType = '"';
        }
        else if(val[pos] == '\'') {
          existingQuoteType = '\'';
        }
      }
      else {
        // make sure we dont have mixing of our outside quote type
        if(val[pos] == '"' || val[pos] == '\'') {
          val[pos] = existingQuoteType;
        }
      }
    }

    // figure out what kind of quotes we want to add
    char quoteValue = '"';

    if(existingQuoteType == '"') {
      quoteValue = '\'';
    }

    if(needQuotes) {
      val = quoteValue + val + quoteValue;
    }

    return val;
  }


  bool PvlFormat::IsSingleUnit(const PvlKeyword &keyword) {

    // See if the units are all the same
    bool singleUnit = true;
    for(int i = 0; i < keyword.Size(); i ++) {
      if(!keyword.StringEqual(keyword.Unit(i), keyword.Unit(0))) {
        singleUnit = false;
      }
    }

    return singleUnit;
  }
}