PvlTranslationTable.cpp

Go to the documentation of this file.

#include <fstream>
#include <sstream>

#include <QDebug>

#include "IException.h"
#include "IString.h"
#include "Message.h"
#include "Pvl.h"
#include "PvlTranslationTable.h"

using namespace std;
namespace Isis {

  PvlTranslationTable::PvlTranslationTable(FileName transFile) {
    AddTable(transFile.expanded());
  }


  PvlTranslationTable::PvlTranslationTable(std::istream &istr) {
    istr >> p_trnsTbl;
  }


  PvlTranslationTable::PvlTranslationTable() {
  }


  PvlTranslationTable::~PvlTranslationTable() {
  }


  Pvl &PvlTranslationTable::TranslationTable() {
    return p_trnsTbl;
  }


  const Pvl &PvlTranslationTable::TranslationTable() const {
    return p_trnsTbl;
  }


  void PvlTranslationTable::AddTable(const QString &transFile) {
    p_trnsTbl.read(FileName(transFile).expanded());
  }


  void PvlTranslationTable::AddTable(std::istream &transStm) {
    transStm >> p_trnsTbl;
    
    // pair< name, size > of acceptable keywords.
    // A size of -1 means non-zero size.
    vector< pair<QString, int> > validKeywordSizes = validKeywords();

    for (int i = 0; i < p_trnsTbl.groups(); i++) {
      PvlGroup currGroup = p_trnsTbl.group(i);

      if (!currGroup.hasKeyword("InputKey")) {
        QString message = "Unable to find InputKey for group ["
                         + currGroup.name() + "] in file [" +
                         p_trnsTbl.fileName() + "]";
        throw IException(IException::User, message, _FILEINFO_);
      }

      for (int j = 0; j < currGroup.keywords(); j++) {
        bool validKeyword = false;
        bool keywordSizeMismatch = false;

        const PvlKeyword &currKey = currGroup[j];

        // Test this keyword for validity
        for (int key = 0;
            !validKeyword && key < (int)validKeywordSizes.size();
            key++) {

          // If this is the right keyword (names match) then test sizes
          if (currKey.name() == validKeywordSizes[key].first) {

            // if -1 then test that size() > 0
            if (validKeywordSizes[key].second == -1) {
              if (currKey.size() > 0) {
                validKeyword = true;
              }
            }
            // otherwise should exact match
            else if (currKey.size() == validKeywordSizes[key].second) {
              validKeyword = true;
            }
            else {
              keywordSizeMismatch = true;
            }
          }

        }

        // if we had an error report it
        if (!validKeyword) {
          if (!keywordSizeMismatch) {
            QString message = "Keyword [" + currKey.name();
            message += "] is not a valid keyword.";
            message += " Error in file [" + p_trnsTbl.fileName() + "]" ;

            throw IException(IException::User, message, _FILEINFO_);
          }
          else {
            QString message = "Keyword [" + currKey.name();
            message += "] does not have the correct number of elements.";
            message += " Error in file [" + p_trnsTbl.fileName() + "]" ;

            throw IException(IException::User, message, _FILEINFO_);
          }

        }
      }
    }
  }
  
  
  vector< pair<QString, int> > PvlTranslationTable::validKeywords() const {

    vector< pair<QString, int> > validKeywords;
    validKeywords.push_back(pair<QString, int>("Translation",           2));
    validKeywords.push_back(pair<QString, int>("OutputName",            1));
    validKeywords.push_back(pair<QString, int>("InputGroup",           -1));
    validKeywords.push_back(pair<QString, int>("InputPosition",        -1));
    validKeywords.push_back(pair<QString, int>("OutputPosition",       -1));
    validKeywords.push_back(pair<QString, int>("Auto",                  0));
    validKeywords.push_back(pair<QString, int>("Optional",              0));
    validKeywords.push_back(pair<QString, int>("InputKey",              1));
    validKeywords.push_back(pair<QString, int>("InputDefault",         -1));
    validKeywords.push_back(pair<QString, int>("InputKeyDependencies", -1));

    return validKeywords;
  }


  QString PvlTranslationTable::Translate(const QString translationGroupName,
                                         const QString inputKeyValue) const {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    // If no input value was passed in search using the input default
    QString tmpFValue = inputKeyValue;
    if (tmpFValue.isEmpty()) {
      if (translationGroup.hasKeyword("InputDefault")) {
        tmpFValue = (QString) translationGroup["InputDefault"];
      }
      else {
        QString msg = "No value or default value to translate for ";
        msg += "translation group [";
        msg += translationGroupName;
        msg += "] in file [" + p_trnsTbl.fileName() + "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
    }

    // Search the Translation keywords for a match to the input value
    Pvl::ConstPvlKeywordIterator it = translationGroup.findKeyword("Translation",
                                      translationGroup.begin(),
                                      translationGroup.end());

    while (it != translationGroup.end()) {
      const PvlKeyword &key = *it;
      // compare the value from the input file to the second value of each Translation in the trans file.
      // ignore cases for input values  
      if (QString::compare((QString) key[1], tmpFValue, Qt::CaseInsensitive) == 0) {
        return key[0];
      }
      else if ((QString) key[1] == "*") {
        if ((QString) key[0] == "*") {
          return tmpFValue;
        }
        else {
          return key[0];
        }
      }

      it = translationGroup.findKeyword("Translation", it + 1, translationGroup.end());
    }

    QString msg = "Unable to find a translation value for [" +
                 translationGroupName +  ", " + inputKeyValue + "] in file [" +
                 p_trnsTbl.fileName() + "]";

    throw IException(IException::Programmer, msg, _FILEINFO_);
  }


  PvlKeyword PvlTranslationTable::InputGroup(const QString translationGroupName,
                                             const int inst) const {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    //bool foundLegalInputGroup = false;

    Pvl::ConstPvlKeywordIterator it = translationGroup.findKeyword("InputPosition",
                                      translationGroup.begin(),
                                      translationGroup.end());

    int currentInstance = 0;

    // If no InputPosition keyword exists, the answer is root
    if (inst == 0 && it == translationGroup.end()) {
      PvlKeyword root("InputPosition");
      root += "ROOT";
      return root;
    }

    while (it != translationGroup.end()) {
      const PvlKeyword &result = *it;

      // This check is to prevent backtracking to the old "value,value" way of
      //   doing translation file input groups for the new keyword. Flag it
      //   immediately to give a good error message.
      if (result.size() == 1 && result[0].contains(",")) {
        QString msg = "Keyword [InputPosition] cannot have a comma [,] in ";
        msg += " the value [";
        msg += result[0];
        msg += "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
      else {
        //foundLegalInputGroup = true;

        if (currentInstance == inst) {
          return result;
        }

        currentInstance ++;
      }

      it = translationGroup.findKeyword("InputPosition", it + 1, translationGroup.end());
    }

    /* Error if no containers were listed
    if (!foundLegalInputGroup) {
      QString msg = "No input position found for translation [";
      msg += translationGroupName;
      msg += "] in translation file [";
      msg += p_trnsTbl.FileName();
      msg += "]";
      throw IException::Message(IException::Programmer, msg, _FILEINFO_);
    }*/

    PvlKeyword empty;
    return empty;
  }


  QString PvlTranslationTable::InputKeywordName(const QString translationGroupName) const {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    if (translationGroup.hasKeyword("InputKey")) return translationGroup["InputKey"];

    return "";
  }


  QString PvlTranslationTable::InputDefault(const QString translationGroupName) const {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    if (translationGroup.hasKeyword("InputDefault")) return translationGroup["InputDefault"];

    return "";
  }


  bool PvlTranslationTable::hasInputDefault(const QString translationGroupName) {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    if (translationGroup.hasKeyword("InputDefault")) return true;

    return false;
  }


  bool PvlTranslationTable::IsAuto(const QString translationGroupName) {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    if (translationGroup.hasKeyword("Auto")) return true;

    return false;
  }


  bool PvlTranslationTable::IsOptional(const QString translationGroupName) {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    if (translationGroup.hasKeyword("Optional")) return true;

    return false;
  }


  PvlKeyword PvlTranslationTable::OutputPosition(const QString translationGroupName) {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    if (!translationGroup.hasKeyword("OutputPosition")) {
      QString msg = "Unable to find translation keyword [OutputPostion] in [" +
                   translationGroupName + "] in file [" + p_trnsTbl.fileName() + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);

    }

    return translationGroup["OutputPosition"];
  }


  QString PvlTranslationTable::OutputName(const QString translationGroupName) {

    const PvlGroup &translationGroup = findTranslationGroup(translationGroupName);

    if (translationGroup.hasKeyword("OutputName")) {
      return translationGroup["OutputName"];
    }

    return "";
  }

  const PvlGroup &PvlTranslationTable::findTranslationGroup(const QString translationGroupName) const {
    if (!p_trnsTbl.hasGroup(translationGroupName)) {
      QString msg = "Unable to find translation group [" + translationGroupName +
                   "] in file [" + p_trnsTbl.fileName() + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return p_trnsTbl.findGroup(translationGroupName);
  }
} // end namespace isis