PvlTranslationTable.cpp

Go to the documentation of this file.

#include <fstream>
#include <sstream>

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

using namespace std;
namespace Isis {

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

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

  PvlTranslationTable::PvlTranslationTable() {
  }

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

  void PvlTranslationTable::AddTable(std::istream &transStm) {
    transStm >> p_trnsTbl;

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

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

      // pair< name, size > of acceptable keywords.
      // A size of -1 means non-zero size.
      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));

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

        const PvlKeyword &currKey = currGrp[j];

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

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

            // if -1 then test that size() > 0
            if(validKeywords[key].second == -1) {
              if(currKey.size() > 0) {
                validKeyword = true;
              }
            }
            // otherwise should exact match
            else if(currKey.size() == validKeywords[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_);
          }

        }
      }
    }
  }

  QString PvlTranslationTable::Translate(const QString nName,
                                        const QString fValue) const {
    if(!p_trnsTbl.hasGroup(nName)) {
      QString msg = "Unable to find translation group [" +
                   nName + "] in file [" + p_trnsTbl.fileName() + "]";

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

    const PvlGroup &tgrp = p_trnsTbl.findGroup(nName);

    // If no input value was passed in search using the input default
    QString tmpFValue = fValue;
    if(tmpFValue.isEmpty()) {
      if(tgrp.hasKeyword("InputDefault")) {
        tmpFValue = (QString) tgrp["InputDefault"];
      }
      else {
        QString msg = "No value or default value to translate for ";
        msg += "translation group [";
        msg += nName;
        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 = tgrp.findKeyword("Translation",
                                      tgrp.begin(),
                                      tgrp.end());

    while(it != tgrp.end()) {
      const PvlKeyword &key = *it;
      if((QString) key[1] == tmpFValue) {
        return key[0];
      }
      else if((QString) key[1] == "*") {
        if((QString) key[0] == "*") {
          return tmpFValue;
        }
        else {
          return key[0];
        }
      }

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

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

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

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

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

    const PvlGroup &transGrp = p_trnsTbl.findGroup(nName);

    //bool foundLegalInputGroup = false;

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

    int currentInstance = 0;

    // If no InputGroup keywords exist, the answer is root
    if(inst == 0 && it == transGrp.end()) {
      PvlKeyword root("InputPosition");
      root += "ROOT";
      return root;
    }

    while(it != transGrp.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 = transGrp.findKeyword("InputPosition", it + 1, transGrp.end());
    }

    /* Error if no containers were listed
    if(!foundLegalInputGroup) {
      QString msg = "No input position found for translation [";
      msg += nName;
      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 nName) const {

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

    Isis::PvlGroup tgrp = p_trnsTbl.findGroup(nName);
    if(tgrp.hasKeyword("InputKey")) return tgrp["InputKey"];

    return "";
  }

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

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

    Isis::PvlGroup tgrp = p_trnsTbl.findGroup(nName);
    if(tgrp.hasKeyword("InputDefault")) return tgrp["InputDefault"];

    return "";
  }

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

    Isis::PvlGroup &tgrp = p_trnsTbl.findGroup(nName);
    if(tgrp.hasKeyword("Auto")) return true;

    return false;
  }

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

    Isis::PvlGroup &tgrp = p_trnsTbl.findGroup(nName);
    if(tgrp.hasKeyword("Optional")) return true;

    return false;
  }

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

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

    }

    return tgrp["OutputPosition"];
  }


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

    Isis::PvlGroup tgrp = p_trnsTbl.findGroup(nName);
    if(tgrp.hasKeyword("OutputName")) {
      return tgrp["OutputName"];
    }

    return "";
  }
} // end namespace isis