PvlContainer.cpp

Go to the documentation of this file.

#include <algorithm>

#include <QList>

#include "PvlContainer.h"
#include "Pvl.h"
#include "FileName.h"
#include "IException.h"
#include "Message.h"
#include "PvlFormat.h"

using namespace std;

namespace Isis {

  PvlContainer::PvlContainer(const QString &type) {
    Init();
    p_name.SetName(type);
  }


  PvlContainer::PvlContainer(const QString &type, const QString &name) {
    Init();
    p_name.SetName(type);
    SetName(name);
  }


  PvlContainer::PvlContainer(const PvlContainer &other) {
    *this = other;
  }



  void PvlContainer::Init() {
    p_filename = "";
    p_formatTemplate = NULL;
  }

  Isis::PvlKeyword &PvlContainer::FindKeyword(const QString &name) {
    PvlKeywordIterator key = FindKeyword(name, Begin(), End());
    if(key == End()) {
      QString msg = "PVL Keyword [" + name + "] does not exist in [" +
                   Type() + " = " + Name() + "]";
      if(p_filename.size() > 0) msg += " in file [" + p_filename + "]";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }

    return *key;
  }

  const Isis::PvlKeyword &PvlContainer::FindKeyword(const QString &name) const {
    ConstPvlKeywordIterator key = FindKeyword(name, Begin(), End());
    if(key == End()) {
      QString msg = "PVL Keyword [" + name + "] does not exist in [" +
                   Type() + " = " + Name() + "]";
      if(p_filename.size() > 0) msg += " in file [" + p_filename + "]";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }

    return *key;
  }

  void PvlContainer::DeleteKeyword(const QString &name) {
    PvlKeywordIterator key = FindKeyword(name, Begin(), End());
    if(key == End()) {
      QString msg = "PVL Keyword [" + name + "] does not exist in [" +
                   Type() + " = " + Name() + "]";
      if(p_filename.size() > 0) msg += " in file [" + p_filename + "]";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }

    p_keywords.erase(key);
  }


  void PvlContainer::DeleteKeyword(const int index) {
    if(index >= (int)p_keywords.size() || index < 0) {
      QString msg = "The specified index is out of bounds in PVL [" +
                   Type() + " = " + Name() + "]";
      if(p_filename.size() > 0) msg += " in file [" + p_filename + "]";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }

    PvlKeywordIterator key = Begin();
    for(int i = 0; i < index; i++) key++;

    p_keywords.erase(key);
  }


  bool PvlContainer::CleanDuplicateKeywords() {
    bool keywordDeleted = false;

    for(int index = 0; index < p_keywords.size(); index ++) {
      PvlKeyword &current = p_keywords[index];

      for(PvlKeywordIterator key = Begin() + index + 1; key < End(); key ++) {
        if(current == *key) {
          p_keywords.erase(key);
          keywordDeleted = true;
        }
      }
    }

    return keywordDeleted;
  }


  bool PvlContainer::HasKeyword(const QString &name) const {
    ConstPvlKeywordIterator key = FindKeyword(name, Begin(), End());
    if(key == End()) return false;
    return true;
  }


  PvlKeyword &PvlContainer::operator[](const int index) {
    if(index < 0 || index >= (int)p_keywords.size()) {
      QString msg = Message::ArraySubscriptNotInRange(index);
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return *(p_keywords.begin() + index);
  };


  const Isis::PvlKeyword &PvlContainer::operator[](const int index) const {
    if(index < 0 || index >= (int)p_keywords.size()) {
      QString msg = Message::ArraySubscriptNotInRange(index);
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return *(p_keywords.begin() + index);
  }

  void PvlContainer::AddKeyword(const Isis::PvlKeyword &key,
                                const InsertMode mode) {
    if(mode == Append) {
      p_keywords.push_back(key);
    }
    else if(HasKeyword(key.Name())) {
      Isis::PvlKeyword &outkey = FindKeyword(key.Name());
      outkey = key;
    }
    else {
      p_keywords.push_back(key);
    }
  }

  PvlContainer::PvlKeywordIterator PvlContainer::AddKeyword(const Isis::PvlKeyword &key,
      PvlKeywordIterator pos) {
    return (p_keywords.insert(pos, key));
  }

  ostream &operator<<(std::ostream &os, PvlContainer &container) {

    // Set up a Formatter (This should not be necessary for a container because
    // Object or Group should have done this already, but just in case.
    bool removeFormatter = false;
    if(container.GetFormat() == NULL) {
      container.SetFormat(new PvlFormat());
      removeFormatter = true;
    }

    Isis::PvlContainer outTemplate("DEFAULT_TEMPLATE");
    if(container.HasFormatTemplate()) outTemplate = *(container.FormatTemplate());

    // Look for and process all include files inside the template
    Isis::PvlContainer newTemp(outTemplate.Type());

    // Include files take precedence over all other objects and groups
    for(int i = 0; i < outTemplate.Keywords(); i++) {
      if(outTemplate[i].IsNamed("Isis:PvlTemplate:File")) {
        QString filename = outTemplate[i];
        Isis::FileName file(filename);
        if(!file.fileExists()) {
          QString message = "Could not open the template file [" + filename + "]";
          throw IException(IException::Io, message, _FILEINFO_);
        }
        Isis::Pvl include(file.expanded());

        for(int j = 0; j < include.Keywords(); j++) {
          if(!newTemp.HasKeyword(include[j].Name()))
            newTemp.AddKeyword(include[j]);
        }
      }
      // If it is not an include file keyword add it in place
      else if(!newTemp.HasKeyword(outTemplate[i].Name())) {
        newTemp.AddKeyword(outTemplate[i]);
      }
    }

    outTemplate = newTemp;

    // Figure out the longest keyword
    int width = 0;
    for(int i = 0; i < container.Keywords(); i++) {
      if(container[i].Name().length() > width) width = container[i].Name().length();
    }

    // This number keeps track of the number of keywords written
    int numKeywords = 0;

    // Write out the container using the output format template
    for(int i = 0; i < outTemplate.Keywords(); i++) {
      for(int j = 0; j < container.Keywords(); j++) {
        if(outTemplate[i].Name() != container[j].Name()) continue;
        container[j].SetIndent(container.Indent());
        container[j].SetWidth(width);
        container[j].SetFormat(container.GetFormat());
        // Add a blank line before keyword comments
        if(outTemplate[i].Comments() + container[j].Comments() > 0) os << container.GetFormat()->FormatEOL();
        if(outTemplate[i].Comments() > 0) {
          for(int k = 0; k < outTemplate[i].Comments(); k++) {
            for(int l = 0; l < outTemplate[i].Indent() + container[j].Indent(); l++) os << " ";
            os << outTemplate[i].Comment(k) << container.GetFormat()->FormatEOL();
          }
        }
        os << container[j];
        container[j].SetFormat(NULL);
        container[j].SetIndent(0);
        container[j].SetWidth(0);
        if(++numKeywords < container.Keywords()) {
//          if (j+1 < container.Keywords() && container[j+1].Comments() > 0) os << container.GetFormat()->FormatEOL();
          os << container.GetFormat()->FormatEOL();
        }
      }
    }

    // Output the keywords in the container that were not specified in the template
    for(int i = 0; i < container.Keywords(); i++) {
      if(outTemplate.HasKeyword(container[i].Name())) continue;
      container[i].SetIndent(container.Indent());
      container[i].SetWidth(width);
      container[i].SetFormat(container.GetFormat());
      os << container[i];
      container[i].SetFormat(NULL);
      container[i].SetIndent(0);
      container[i].SetWidth(0);
      if(++numKeywords < container.Keywords()) {
        if(i + 1 < container.Keywords() && container[i+1].Comments() > 0) os << container.GetFormat()->FormatEOL();
        os << container.GetFormat()->FormatEOL();
      }
    }

    if(removeFormatter) {
      delete container.GetFormat();
      container.SetFormat(NULL);
    }

    return os;
  }


  PvlContainer::PvlKeywordIterator PvlContainer::FindKeyword(const QString &name,
      PvlContainer::PvlKeywordIterator beg,
      PvlContainer::PvlKeywordIterator end) {
    PvlKeyword temp(name);
    return find(beg, end, temp);
  };


  PvlContainer::ConstPvlKeywordIterator PvlContainer::FindKeyword(const QString &name,
      PvlContainer::ConstPvlKeywordIterator beg,
      PvlContainer::ConstPvlKeywordIterator end) const {
    PvlKeyword temp(name);
    return find(beg, end, temp);
  };


  const PvlContainer &PvlContainer::operator=(const PvlContainer &other) {
    p_filename = other.p_filename;
    p_name = other.p_name;
    p_keywords = other.p_keywords;
    p_formatTemplate = other.p_formatTemplate;

    return *this;
  }

  void PvlContainer::ValidateAllKeywords(PvlContainer & pPvlCont)
  {
    // Validate the Keywords in the current Object
    int iTmplKeySize = Keywords();
    for(int i=0; i<iTmplKeySize; i++) {
      PvlKeyword & pvlTmplKwrd = (*this)[i];
      QString sKeyName = pvlTmplKwrd.Name();
      bool bKwrdFound = false;

      // These are reserved keywords for properties like "Range", "Value", "Type",
      // "Required" or "Repeated"
      if(sKeyName.contains("__Required") || sKeyName.contains("__Repeated") ||
         sKeyName.contains("__Range") || sKeyName.contains("__Value") ||
         sKeyName.contains("__Type")) {
        continue;
      }

      if(pPvlCont.HasKeyword(sKeyName)) {
        PvlKeyword & pvlKwrd = pPvlCont.FindKeyword(sKeyName);
        QString sTmplKwrdRange = sKeyName + "__Range";
        QString sTmplKwrdValue = sKeyName + "__Value";
        QString sTmplKwrdType  = sKeyName + "__Type";
        QString sType="";
        PvlKeyword pvlTmplKwrdRange, pvlTmplKwrdValue;

        // Check if Type is specified (positive or negative for numbers)
        if(HasKeyword(sTmplKwrdType)) {
          sType = FindKeyword(sTmplKwrdType)[0];
        }
        // Check for Range
        if(HasKeyword(sTmplKwrdRange)) {
          pvlTmplKwrdRange = FindKeyword(sTmplKwrdRange);
          pvlTmplKwrd.ValidateKeyword(pvlKwrd, sType, &pvlTmplKwrdRange);
        }
        // Check for Value
        else if(HasKeyword(sTmplKwrdValue)) {
          pvlTmplKwrdValue = FindKeyword(sTmplKwrdValue);
          pvlTmplKwrd.ValidateKeyword(pvlKwrd, sType, &pvlTmplKwrdValue);
        }
        else {
          pvlTmplKwrd.ValidateKeyword(pvlKwrd, sType);
        }
        pPvlCont.DeleteKeyword(pvlKwrd.Name());
        bKwrdFound = true;
      }
      else {
        bKwrdFound = true;
        QString sOption = sKeyName + "__Required";
        if(HasKeyword(sOption)) {
          PvlKeyword pvlKeyOption = FindKeyword(sOption);
          if(pvlKeyOption[0] == "true") { // Required is true
            bKwrdFound = false;
          }
        }
      }
      if (bKwrdFound == false) {
        QString sErrMsg = "Keyword \"" + sKeyName + "\" Not Found in the Template File\n";
        throw IException(IException::User, sErrMsg, _FILEINFO_);
      }

      // Check for "Repeated" Option
      ValidateRepeatOption(pvlTmplKwrd, pPvlCont);
    }
  }

  void PvlContainer::ValidateRepeatOption(PvlKeyword & pPvlTmplKwrd, PvlContainer & pPvlCont)
  {
    QString sTmplKeyName = pPvlTmplKwrd.Name();

    // Check for the Type
    QString sType = sTmplKeyName + "__Type";
    QString sValueType ="";
    if(HasKeyword(sType)) {
      sValueType = FindKeyword(sType)[0];
    }
    QString sRepeatOption = sTmplKeyName + "__Repeated";
    bool bRepeat =false;
    if(HasKeyword(sRepeatOption)) {
      PvlKeyword pvlKeyOption = FindKeyword(sRepeatOption);
      if(pvlKeyOption[0] == "true") { // Required is true
        bRepeat = true;
      }
    }
    if(bRepeat) {
      int iKeySize = pPvlCont.Keywords();
      for(int j=(iKeySize-1); j>=0; j--) {
        PvlKeyword & pvlKwrd = pPvlCont[j];
        QString sKeyName = pvlKwrd.Name();
        if(sTmplKeyName == sKeyName) {
          pPvlTmplKwrd.ValidateKeyword(pvlKwrd, sValueType);
          pPvlCont.DeleteKeyword(pvlKwrd.Name());
        }
      }
    }
  }

} // end namespace isis