IsisAml.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <sstream>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>
 
#include "FileName.h"
#include "IException.h"
#include "IsisAml.h"
#include "IsisXMLChTrans.h"
#include "IString.h"
#include "Preference.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"
#include "PvlObject.h"
 
using namespace std;
 
namespace XERCES = XERCES_CPP_NAMESPACE;
 
IsisAml::IsisAml(const QString &xmlfile) {
  StartParser(xmlfile.toLatin1().data());
}
 
IsisAml::~IsisAml() {
}
 
void IsisAml::PutAsString(const QString &paramName,
                          const QString &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been entered.";
    throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
  }
 
  param->values.clear();
  param->values.push_back(value);
 
}
 
void IsisAml::PutAsString(const QString &paramName,
                          const vector<QString> &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been entered.";
    throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
  }
 
  param->values.resize(value.size());
  param->values = value;
 
}
 
 
// Public: Sets the value member of a parameter of type QString whose name
// starts with paramName
 
void IsisAml::PutString(const QString &paramName, const QString &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "string" && param->type != "combo") {
    QString message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.clear();
  param->values.push_back(value);
 
  Verify(param);
}
 
 
// Public: Sets the value member of a parameter of type QString whose name
// starts with paramName
void IsisAml::PutString(const QString &paramName,
                        const vector<QString> &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "string" && param->type != "combo") {
    QString message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.resize(value.size());
  param->values = value;
 
  Verify(param);
}
 
 
// Public: Sets the value member of a parameter of type filename whose name
// starts with paramName
 
void IsisAml::PutFileName(const QString &paramName,
                          const QString &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if((param->type != "filename") && (param->type != "cube")) {
    QString message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.clear();
  param->values.push_back(value);
 
  Verify(param);
}
 
 
// Public: Sets the value member of a parameter of type filename whose name
// starts with paramName
 
void IsisAml::PutFileName(const QString &paramName,
                          const vector<QString> &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if((param->type != "filename") && (param->type != "cube")) {
    QString message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.resize(value.size());
  param->values = value;
 
  Verify(param);
}
 
 
// Public: Sets the value member of a parameter of type integer whose name
// starts with paramName
 
void IsisAml::PutInteger(const QString &paramName,
                         const int &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "integer") {
    QString message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.clear();
  param->values.push_back(Isis::toString(value));
 
  Verify(param);
}
 
 
// Public: Sets the value member of a parameter of type integer whose name
// starts with paramName
 
void IsisAml::PutInteger(const QString &paramName,
                         const vector<int> &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "integer") {
    QString message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.resize(value.size());
  for(unsigned int i = 0; i < value.size(); i++) {
    param->values[i] = Isis::toString(value[i]);
  }
 
  Verify(param);
}
 
 
 
 
// Public: Sets the value member of a parameter of type double whose name
// starts with paramName
void IsisAml::PutDouble(const QString &paramName,
                        const double &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "double") {
    QString message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.clear();
  param->values.push_back(Isis::toString(value));
 
  Verify(param);
}
 
 
// Public: Sets the value member of a parameter of type double whose name
// starts with paramName
void IsisAml::PutDouble(const QString &paramName,
                        const vector<double> &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "double") {
    QString message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.resize(value.size());
  for(unsigned int i = 0; i < value.size(); i++) {
    param->values[i] = Isis::toString(value[i]);
  }
 
  Verify(param);
}
 
 
 
// Public: Sets the value member of a parameter of type boolean whose name
// starts with paramName
void IsisAml::PutBoolean(const QString &paramName,
                         const bool &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "boolean") {
    QString message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.clear();
  if(value) {
    param->values.push_back("YES");
  }
  else {
    param->values.push_back("NO");
  }
 
  Verify(param);
}
 
 
// Public: Sets the value member of a parameter of type boolean whose name
// starts with paramName
void IsisAml::PutBoolean(const QString &paramName,
                         const vector<bool> &value) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "boolean") {
    QString message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() > 0) {
    QString message = "A value for this parameter [" + paramName + "] has "
                     "already been saved (possibly by IsisGui). If you need to "
                     "change the value use \"Clear\" before the Put.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  param->values.resize(value.size());
  for(unsigned int i = 0; i < value.size(); i++) {
    if(value[i]) {
      param->values.push_back("YES");
    }
    else {
      param->values.push_back("NO");
    }
  }
 
  Verify(param);
}
 
 
// Accessor methods for getting the value(s) of a parameter
 
// Public: Returns the first element of the value member of a parameter whos
// name starts with paramName as a QString. Any type can be retrieve with this member.
QString IsisAml::GetAsString(const QString &paramName) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
  QString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
 
  return value;
}
 
// Public: Returns the value member of a parameter whose name starts with paramName
// as a vector<QString>
void IsisAml::GetAsString(const QString &paramName,
                          vector<QString> &values) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  values.clear();
  QString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++)
        values.push_back(param->defaultValues[i]);
    }
  }
  else {
    for(unsigned int i = 0; i < param->values.size(); i++)
      values.push_back(param->values[i]);
  }
 
  return;
}
 
 
// Public: Returns the first element of the value member of a parameter whose
// name starts with paramName as a QString/filename
QString IsisAml::GetFileName(const QString &paramName, QString extension) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if((param->type != "filename") && (param->type != "cube")) {
    QString message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  QString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
 
  Isis::FileName name(value);
  if(extension != "") name = name.addExtension(extension);
  value = name.expanded();
 
  return value;
}
 
 
// Public: Returns the value member of a parameter whose name starts with paramName
// as a vector<QString/filename>
void IsisAml::GetFileName(const QString &paramName,
                          vector<QString> &values) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if((param->type != "filename") && (param->type != "cube")) {
    QString message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  values.clear();
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++) {
        Isis::FileName name(param->defaultValues[i]);
        values.push_back(name.expanded());
      }
    }
  }
  else {
    for(unsigned int i = 0; i < param->values.size(); i++) {
      Isis::FileName name(param->values[i]);
      values.push_back(name.expanded());
    }
  }
 
  return;
}
 
 
// Public: Returns the first element of the value member of a parameter whos
// name starts with paramName as a QString
QString IsisAml::GetString(const QString &paramName) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
  QString value;
 
  if(param->type != "string" && param->type != "combo") {
    QString message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
    // If there is a list of legal values return the list option that matches
    // or begins with what was entered rather than exactly what was entered
    if(param->listOptions.size() > 0) {
      value = value.toUpper();
      int found = -1;
      int foundcount = 0;
      for(unsigned int p = 0; p < param->listOptions.size(); p++) {
        QString option = param->listOptions[p].value;
        option = option.toUpper();
        if(value == option) {
          return value;
        }
        else if(value.startsWith(option) || option.startsWith(value)) {
          found = p;
          foundcount = foundcount + 1;
        }
      }
      if(foundcount == 0) {
        QString message = "Value [" + value + "] for parameter [" +
                          paramName + "] is not a valid value.";
        throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
      }
      if(foundcount > 1) {
        QString message = "Value [" + value + "] for parameter [" +
                          paramName + "] is not unique.";
        throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
      }
      return param->listOptions[found].value;
    }
 
    // Just return what is in the value
    else {
      value = param->values[0];
    }
  }
  return value;
}
 
 
// Public: Returns the value member of a parameter whose name starts with paramName
// as a vector<QString>
void IsisAml::GetString(const QString &paramName,
                        vector<QString> &values) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->type != "string" && param->type != "combo") {
    QString message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  values.clear();
  QString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++)
        values.push_back(param->defaultValues[i]);
    }
  }
  else {
    for(unsigned int i = 0; i < param->values.size(); i++)
      values.push_back(param->values[i]);
  }
 
  return;
}
 
 
 
// Public: Returns the first element of the value member of a parameter whos
// name starts with paramName as an integer
int IsisAml::GetInteger(const QString &paramName) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->type != "integer") {
    QString message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  Isis::IString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
 
  return value.ToInteger();
}
 
 
// Public: Returns the value member of a parameter whose name starts with paramName
// as a vector<int>
void IsisAml::GetInteger(const QString &paramName,
                         vector<int> &values) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->type != "integer") {
    QString message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  values.clear();
  Isis::IString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++)
        value = param->defaultValues[i];
      values.push_back(value.ToInteger());
    }
  }
  else {
    for(unsigned int i = 0; i < param->values.size(); i++)
      value = param->values[i];
    values.push_back(value.ToInteger());
  }
 
  return;
}
 
 
 
// Public: Returns the first element of the value member of a parameter whos
// name starts with paramName as a doubble
double IsisAml::GetDouble(const QString &paramName) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->type != "double") {
    QString message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  Isis::IString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
 
  return value.ToDouble();
}
 
// Public: Returns the value member of a parameter whose name starts with paramName
// as a vector<doubble>
void IsisAml::GetDouble(const QString &paramName,
                        vector<double> &values) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->type != "double") {
    QString message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  values.clear();
  Isis::IString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++)
        value = param->defaultValues[i];
      values.push_back(value.ToDouble());
    }
  }
  else {
    for(unsigned int i = 0; i < param->values.size(); i++)
      value = param->values[i];
    values.push_back(value.ToDouble());
  }
 
  return;
}
 
 
// Public: Returns the first element of the value member of a parameter whos
// name starts with paramName as a bool
bool IsisAml::GetBoolean(const QString &paramName) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->type != "boolean") {
    QString message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  QString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
 
  return Isis::toBool(value);
 
}
 
 
// Public: Returns the value member of a parameter whose name starts with paramName
// as a vector<bool>
void IsisAml::GetBoolean(const QString &paramName,
                         vector<bool> &values) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->type != "boolean") {
    QString message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  values.clear();
  vector <QString> value;
  QString tmp;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      QString message = "Parameter [" + paramName + "] has no value.";
      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    }
    else {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++) {
        tmp = param->defaultValues[i].toUpper();
        value.push_back(tmp);
      }
    }
  }
  else {
    for(unsigned int i = 0; i < param->values.size(); i++) {
      tmp = param->values[i].toUpper();
      value.push_back(tmp);
    }
  }
 
  for(unsigned int i = 0; i < value.size(); i++) {
    values.push_back(StringToBool(value[i]));
 
  }
 
  return;
}
QString IsisAml::ProgramName() const {
  QString tmp = name;
  return tmp;
}
 
 
QString IsisAml::Brief() const {
  return brief;
}
 
 
QString IsisAml::Description() const {
  return description;
}
 
int IsisAml::NumGroups() const {
  return groups.size();
}
 
QString IsisAml::GroupName(const int &index) const {
  QString s = groups[index].name;
  return s;
}
 
int IsisAml::GroupIndex(const QString & grpName) const {
  for(int i=0; i<(int)groups.size(); i++) {
    if(Isis::IString(grpName).DownCase() == Isis::IString(groups[i].name).DownCase()) {
      return i;
    }
  }
  return -1;
}
 
void IsisAml::CreatePVL(Isis::Pvl &pvlDef , QString guiGrpName, QString pvlObjName, QString pvlGrpName, vector<QString> & include) {
 
  Isis::PvlObject *pvlObj = NULL;
  if (pvlObjName != "") {
    pvlObj = new Isis::PvlObject(pvlObjName);
  }
 
  // Get Gui Group index
  int grpIndex= GroupIndex(guiGrpName);
 
  if (pvlGrpName == "" || grpIndex == -1 ) {
    QString errMsg = "Must provide Group Name\n";
    throw Isis::IException(Isis::IException::User, errMsg, _FILEINFO_);
  }
 
  Isis::PvlGroup grp(pvlGrpName);
  for(int i=0; i<NumParams(grpIndex); i++) {
    QString paramName = ParamName(grpIndex, i);
 
    if(IsParamInPvlInclude(paramName,include)) {
      Isis::IString paramType = Isis::IString(ParamType(grpIndex, i)).DownCase();
      if(paramType == "double") {
        grp += Isis::PvlKeyword(paramName, Isis::toString(GetDouble(paramName)));
      }
      if(paramType == "integer") {
        grp += Isis::PvlKeyword(paramName, Isis::toString(GetInteger(paramName)));
      }
      if(paramType == "boolean") {
        grp += Isis::PvlKeyword(paramName, Isis::toString(GetBoolean(paramName)));
      }
      if(paramType == "string" || paramType == "filename" || paramType == "combo") {
        grp += Isis::PvlKeyword(paramName, GetAsString(paramName));
      }
    }
  }
 
  if(pvlObj != NULL) {
    *pvlObj += grp;
    pvlDef  += *pvlObj;
    delete (pvlObj);
    pvlObj = NULL;
  }
  else {
    pvlDef += grp;
  }
}
 
bool IsisAml::IsParamInPvlInclude(QString & paramName, vector<QString> & include) {
 
  for(int i=0; i<(int)include.size(); i++) {
    if(Isis::IString(paramName).DownCase() == Isis::IString(include[i]).DownCase()) {
      return true;
    }
  }
  return false;
}
int IsisAml::NumParams(const int &group) const {
  return groups[group].parameters.size();
}
 
QString IsisAml::ParamName(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].name;
  return s;
}
 
QString IsisAml::ParamBrief(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].brief;
  return s;
}
 
QString IsisAml::ParamDescription(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].description;
  return s;
}
 
QString IsisAml::ParamMinimum(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].minimum;
  return s;
}
 
QString IsisAml::ParamMaximum(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].maximum;
  return s;
}
 
QString IsisAml::ParamMinimumInclusive(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].minimum_inclusive;
  return s;
}
 
QString IsisAml::ParamMaximumInclusive(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].maximum_inclusive;
  return s;
}
 
QString IsisAml::ParamOdd(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].odd;
  return s;
}
 
int IsisAml::ParamGreaterThanSize(const int &group, const int &param) const {
  return groups[group].parameters[param].greaterThan.size();
}
 
int IsisAml::ParamGreaterThanOrEqualSize(const int &group,
    const int &param) const {
  return groups[group].parameters[param].greaterThanOrEqual.size();
}
 
int IsisAml::ParamLessThanSize(const int &group, const int &param) const {
  return groups[group].parameters[param].lessThan.size();
}
 
int IsisAml::ParamLessThanOrEqualSize(const int &group,
                                      const int &param) const {
  return groups[group].parameters[param].lessThanOrEqual.size();
}
 
int IsisAml::ParamNotEqualSize(const int &group, const int &param) const {
  return groups[group].parameters[param].notEqual.size();
}
 
QString IsisAml::ParamGreaterThan(const int &group, const int &param,
                                 const int &great) const {
  QString s = groups[group].parameters[param].greaterThan[great];
  return s;
}
 
QString IsisAml::ParamGreaterThanOrEqual(const int &group, const int &param,
                                        const int &great) const {
  QString s = groups[group].parameters[param].greaterThanOrEqual[great];
  return s;
}
 
QString IsisAml::ParamLessThan(const int &group, const int &param,
                              const int &les) const {
  QString s = groups[group].parameters[param].lessThan[les];
  return s;
}
 
QString IsisAml::ParamLessThanOrEqual(const int &group, const int &param,
                                     const int &les) const {
  QString s = groups[group].parameters[param].lessThanOrEqual[les];
  return s;
}
 
QString IsisAml::ParamNotEqual(const int &group, const int &param,
                              const int &notEq) const {
  QString s = groups[group].parameters[param].notEqual[notEq];
  return s;
}
 
QString IsisAml::ParamExclude(const int &group, const int &param,
                             const int &exclude) const {
  QString s = groups[group].parameters[param].exclude[exclude];
  return s;
}
 
QString IsisAml::ParamInclude(const int &group, const int &param,
                             const int &include) const {
  QString s = groups[group].parameters[param].include[include];
  return s;
}
 
 
QString IsisAml::ParamType(const int &group, const int &param) const {
  QString s = groups[group].parameters[param].type;
  return s;
}
 
QString IsisAml::ParamDefault(const int &group, const int &param) const {
  QString s;
  if(groups[group].parameters[param].defaultValues.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].defaultValues[0];
  }
  return s;
}
 
QString IsisAml::ParamInternalDefault(const int &group, const int &param) const {
  QString s;
  if(groups[group].parameters[param].internalDefault.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].internalDefault;
  }
  return s;
}
 
QString IsisAml::ParamFilter(const int &group, const int &param) const {
  QString s;
  if(groups[group].parameters[param].filter.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].filter;
  }
  return s;
}
 
QString IsisAml::ParamPath(const int &group, const int &param) const {
  QString s;
  if(groups[group].parameters[param].path.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].path;
  }
  return s;
}
 
QString IsisAml::ParamFileMode(const int &group, const int &param) const {
  QString s;
  if(groups[group].parameters[param].fileMode.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].fileMode;
  }
  return s;
}
 
int IsisAml::ParamListSize(const int &group, const int &param) const {
  return groups[group].parameters[param].listOptions.size();
}
 
 
QString IsisAml::ParamListValue(const int &group, const int &param,
                               const int &option) const {
  QString s = groups[group].parameters[param].listOptions[option].value;
  return s;
}
 
QString IsisAml::ParamListBrief(const int &group, const int &param,
                               const int &option) const {
  QString s = groups[group].parameters[param].listOptions[option].brief;
  return s;
}
 
QString IsisAml::ParamListDescription(const int &group, const int &param,
                                     const int &option) const {
  QString s = groups[group].parameters[param].listOptions[option].description;
  return s;
}
 
int IsisAml::ParamListExcludeSize(const int &group, const int &param,
                                  const int &option) const {
  return groups[group].parameters[param].listOptions[option].exclude.size();
}
 
QString IsisAml::ParamListExclude(const int &group, const int &param,
                                 const int &option, const int &exclude) const {
  QString s = groups[group].parameters[param].listOptions[option].exclude[exclude];
  return s;
}
 
int IsisAml::ParamListIncludeSize(const int &group, const int &param,
                                  const int &option) const {
  return groups[group].parameters[param].listOptions[option].include.size();
}
 
QString IsisAml::ParamListInclude(const int &group, const int &param,
                                 const int &option, const int &include) const {
  QString s = groups[group].parameters[param].listOptions[option].include[include];
  return s;
}
 
int IsisAml::ParamExcludeSize(const int &group, const int &param) const {
  return groups[group].parameters[param].exclude.size();
}
 
int IsisAml::ParamIncludeSize(const int &group, const int &param) const {
  return groups[group].parameters[param].include.size();
}
 
QString IsisAml::PixelType(const int &group, const int &param) const {
  return groups[group].parameters[param].pixelType;
}
 
int IsisAml::HelpersSize(const int &group, const int &param) const {
  return groups[group].parameters[param].helpers.size();
}
 
QString IsisAml::HelperButtonName(const int &group, const int &param,
                                 const int &helper) const {
  return groups[group].parameters[param].helpers[helper].name;
}
 
QString IsisAml::HelperFunction(const int &group, const int &param,
                               const int &helper) const {
  return groups[group].parameters[param].helpers[helper].function;
}
 
QString IsisAml::HelperBrief(const int &group, const int &param,
                            const int &helper) const {
  return groups[group].parameters[param].helpers[helper].brief;
}
 
QString IsisAml::HelperDescription(const int &group, const int &param,
                                  const int &helper) const {
  return groups[group].parameters[param].helpers[helper].description;
}
 
QString IsisAml::HelperIcon(const int &group, const int &param,
                           const int &helper) const {
  return groups[group].parameters[param].helpers[helper].icon;
}
 
bool IsisAml::WasEntered(const QString &paramName) const {
 
  const IsisParameterData *param = ReturnParam(paramName);
 
  if(param->values.size() == 0) {
    return false;
  }
 
  return true;
}
 
void IsisAml::Clear(const QString &paramName) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
  param->values.clear();
 
  param->outCubeAtt.setAttributes("+" + param->pixelType);
  param->inCubeAtt.setAttributes("");
 
  return;
}
 
 
Isis::CubeAttributeInput &IsisAml::GetInputAttribute(const QString &paramName) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "cube") {
    QString message = "Unable to get input cube attributes.  Parameter ["
      + paramName + "] is not a cube. Parameter type = [" + param->type + "].";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  QString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      value.clear();
//      QString message = "Parameter [" + paramName + "] has no value.";
//      throw Isis::IException(Isis::IException::User,message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
  if(param->fileMode == "input") {
    param->inCubeAtt.setAttributes(value);
  }
  else {
    QString message = "Unable to get input cube attributes.  Parameter ["
      + paramName + "] is not an input. Parameter fileMode = [" + param->fileMode + "].";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
  return param->inCubeAtt;
}
 
Isis::CubeAttributeOutput &IsisAml::GetOutputAttribute(const QString &paramName) {
 
  IsisParameterData *param = const_cast <IsisParameterData *>(ReturnParam(paramName));
 
  if(param->type != "cube") {
    QString message = "Unable to get output cube attributes.  Parameter ["
      + paramName + "] is not a cube. Parameter type = [" + param->type + "].";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
 
  QString value;
  if(param->values.size() == 0) {
    if(param->defaultValues.size() == 0) {
      value.clear();
//      QString message = "Parameter [" + paramName + "] has no value.";
//      throw Isis::IException(Isis::IException::User,message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
  if(param->fileMode == "output") {
    param->outCubeAtt.setAttributes("+" + param->pixelType);
    param->outCubeAtt.addAttributes(Isis::FileName(value));
  }
  else {
    QString message = "Unable to get output cube attributes.  Parameter ["
      + paramName + "] is not an output. Parameter fileMode = [" + param->fileMode + "].";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
  return param->outCubeAtt;
}
 
const IsisParameterData *IsisAml::ReturnParam(const QString &paramName) const {
  Isis::IString pn = paramName;
  pn.UpCase();
  int found = 0;
  bool exact = false;
  const IsisParameterData *param = NULL;
  Isis::IString cur_pn;
 
  for(unsigned int g = 0; g < groups.size(); g++) {
    for(unsigned int p = 0; p < groups[g].parameters.size(); p++) {
      cur_pn = groups[g].parameters[p].name;
      cur_pn.UpCase();
      if(cur_pn.find(pn) == 0) {
        if(cur_pn == pn) {
          if(exact) {
            QString message = "Parameter [" + paramName + "] is not unique.";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
          else {
            exact = true;
            found = 0;
            param = &(groups[g].parameters[p]);
          }
        }
        else if(!exact) {
          found++;
          param = &(groups[g].parameters[p]);
        }
      }
    }
  }
  if(param == NULL) {
    QString message = "Unknown parameter [" + paramName + "].";
    throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
  }
  else if((found > 1) && (!exact)) {
    QString message = "Parameter [" + paramName + "] is not unique.";
    throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
  }
  return param;
}
 
void IsisAml::Verify(const IsisParameterData *param) {
 
  // Check to make sure the value QString can be converted to the correct type
  for(unsigned int i = 0; i < param->values.size(); i++) {
    if(param->type == "integer") {
      try {
        Isis::IString value(param->values[i]);
        value.ToInteger();
      }
      catch(Isis::IException &e) {
        QString message = "Unable to convert [" + param->values[i] + "] to an integer,"
                         " parameter [" + param->name + "].";
        throw Isis::IException(e, Isis::IException::User, message, _FILEINFO_);
      }
    }
    else if(param->type == "double") {
      try {
        Isis::IString value(param->values[i]);
        value.ToDouble();
      }
      catch(Isis::IException &e) {
        QString message = "Unable to convert [" + param->values[i] + "] to a double,"
                         " parameter [" + param->name + "].";
        throw Isis::IException(e, Isis::IException::User, message, _FILEINFO_);
      }
    }
    else if(param->type == "boolean") {
      QString v = param->values[i].toUpper();
 
      try {
        StringToBool(v);
      }
      catch(Isis::IException &e) {
        QString message = "Illegal value for [" + param->name + "], [" + param->values[i] + "].";
        throw Isis::IException(e, Isis::IException::User, message, _FILEINFO_);
      }
    }
    else if(param->type == "filename") {
      // If this is an output file and a file with this name already exists,
      // check user filename customization preferences.
      QString value(param->values[i]);
      Isis::FileName name(value);
      value = name.expanded();
      if(name.fileExists() && param->fileMode == "output") {
        CheckFileNamePreference(value, param->name);
      }
    }
    // THIS IS CURRENTLY HANDLED IN THE CUBE CLASS, see CubeIoHandler.cpp
    // 2010-07-15 Jeannie Walldren
    //
    //  else if(param->type == "cube") {
    //    Isis::IString value(param->values[i]);
    //    Isis::FileName name(value);
    //    value = name.expanded();
    //    if (name.Exists() && param->fileMode == "output"
    //        && Isis::Preference::Preferences().findGroup("CubeCustomization").findKeyword("Overwrite")[0] == "Error") {
    //      QString message = "Invalid output cube for [" + param->name + "]. The cube file [" + value + "] already exists.  " +
    //                       "The user preference cube customization group is set to disallow cube overwrites.";
    //      throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
    //    }
    //  }
  }
 
  // Check the default values if there were no values
  if(param->values.size() == 0) {
    for(unsigned int i = 0; i < param->defaultValues.size(); i++) {
      // Check to make sure the DefaultValue QString can be converted to the
      // correct type
      if(param->type == "integer") {
        try {
          Isis::IString value(param->defaultValues[i]);
          value.ToInteger();
        }
        catch(Isis::IException &e) {
          QString message = "Unable to convert default [" + param->defaultValues[i] +
                           "] to an integer, parameter [" + param->name + "].";
          throw Isis::IException(e, Isis::IException::Programmer, message, _FILEINFO_);
        }
      }
      else if(param->type == "double") {
        try {
          Isis::IString value(param->defaultValues[i]);
          value.ToDouble();
        }
        catch(Isis::IException &e) {
          QString message = "Unable to convert default [" + param->defaultValues[i] +
                           "] to a double, parameter [" + param->name + "].";
          throw Isis::IException(e, Isis::IException::Programmer, message, _FILEINFO_);
        }
      }
      else if(param->type == "boolean") {
        QString v = param->defaultValues[i].toUpper();
 
        try {
          StringToBool(v);
        }
        catch(Isis::IException &e) {
          QString message = "Illegal default value for [" + param->name + "], ["
                           + param->defaultValues[i] + "].";
          throw Isis::IException(e, Isis::IException::User, message, _FILEINFO_);
        }
      }
      else if(param->type == "filename") {
        // Put something here once we figure out what to do with filenames
        QString value(param->defaultValues[i]);
        Isis::FileName name(value);
        value = name.expanded();
        if(name.fileExists() && param->fileMode == "output") {
          CheckFileNamePreference(value, param->name);
        }
      }
    }
  }
 
  // Check the values against the values list if there is one
  if(param->listOptions.size() > 0) {
    for(unsigned int i = 0; i < param->values.size(); i++) {
      Isis::IString value = param->values[i];
      value = value.UpCase();
      int partial = 0;
      bool exact = false;
      for(unsigned int p = 0; p < param->listOptions.size(); p++) {
        Isis::IString option = param->listOptions[p].value;
        option = option.UpCase();
        // Check to see if the value matches the list option exactly
        if(value == option) {
          // If we already have one exact match then there is an error
          if(exact) {
            QString message = "Duplicate list options [" +
                             param->listOptions[p].value +
                             "] in parameter [" + param->name + "].";
            throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
          }
          exact = true;
        }
        // Check for a partial match
        // Compare the shorter of the two (values[i]) to a subQString of the
        // longer QString (listOptions[p].value)
        else if(option.compare(0, min(value.size(), option.size()),
                               value, 0, min(value.size(), option.size())) == 0) {
          partial++;
        }
      }
      if(!exact && partial == 0) {
        QString message = "Value of [" + param->name + "] must be one of [" +
                         param->listOptions[0].value;
        for(unsigned int p = 1; p < param->listOptions.size(); p++) {
          message += ", " + param->listOptions[p].value;
        }
        message += "].";
        throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
      }
      else if(!exact && partial > 1) {
        QString msg = "Value of [" + param->name +
                     "] does not match a list option uniquely.";
        throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
      }
    }
  }
 
  // Check the values against the minimum
  if(param->minimum.length() > 0) {
    QString incl = param->minimum_inclusive;
    for(unsigned int i = 0; i < param->values.size(); i++) {
      if(param->type == "integer") {
        QString value(param->values[i]);
        int temp = Isis::toInt(value);
        value = param->minimum;
        int min = Isis::toInt(value);
        if(StringToBool(incl) && (temp < min)) {
          QString message = "Parameter [" + param->name +
                           "] must be greater than or equal to [" + param->minimum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
        else if(!StringToBool(incl) && (temp <= min)) {
          QString message = "Parameter [" + param->name +
                           "] must be greater than [" + param->minimum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
      }
      else if(param->type == "double") {
        Isis::IString value(param->values[i]);
        double temp = value.ToDouble();
        value = param->minimum;
        double min = value.ToDouble();
        if(StringToBool(incl) && (temp < min)) {
          QString message = "Parameter [" + param->name +
                           "] must be greater than or equal to [" + param->minimum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
        else if(!StringToBool(incl) && (temp <= min)) {
          QString message = "Parameter [" + param->name +
                           "] must be greater than [" + param->minimum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
      }
    }
    if(param->values.size() == 0) {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++) {
        if(param->type == "integer") {
          Isis::IString value(param->defaultValues[i]);
          int temp = value.ToInteger();
          value = param->minimum;
          int min = value.ToInteger();
          if(StringToBool(incl) && (temp < min)) {
            QString message = "Parameter [" + param->name +
                             "] must be greater than or equal to [" + param->minimum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
          else if(!StringToBool(incl) && (temp <= min)) {
            QString message = "Parameter [" + param->name +
                             "] must be greater than [" + param->minimum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
        }
        else if(param->type == "double") {
          Isis::IString value(param->defaultValues[i]);
          double temp = value.ToDouble();
          value = param->minimum;
          double min = value.ToDouble();
          if(StringToBool(incl) && (temp < min)) {
            QString message = "Parameter [" + param->name +
                             "] must be greater than or equal to [" + param->minimum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
          else if(!StringToBool(incl) && (temp <= min)) {
            QString message = "Parameter [" + param->name +
                             "] must be greater than [" + param->minimum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
        }
      }
    }
  }
 
  // Check the values against the maximum
  if(param->maximum.length() > 0) {
    QString incl = param->maximum_inclusive.toLower();
    for(unsigned int i = 0; i < param->values.size(); i++) {
      if(param->type == "integer") {
        QString value(param->values[i]);
        int temp = Isis::toInt(value);
        value = param->maximum;
        int max = Isis::toInt(value);
        if(StringToBool(incl) && (temp > max)) {
          QString message = "Parameter [" + param->name +
                           "] must be less than or equal to [" + param->maximum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
        else if(!StringToBool(incl) && (temp >= max)) {
          QString message = "Parameter [" + param->name +
                           "] must be less than [" + param->maximum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
      }
      else if(param->type == "double") {
        Isis::IString value(param->values[i]);
        double temp = value.ToDouble();
        value = param->maximum;
        double max = value.ToDouble();
        if(StringToBool(incl) && (temp > max)) {
          QString message = "Parameter [" + param->name +
                           "] must be less than or equal to [" + param->maximum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
        else if(!StringToBool(incl) && (temp >= max)) {
          QString message = "Parameter [" + param->name +
                           "] must be less than [" + param->maximum + "].";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
      }
    }
    if(param->values.size() == 0) {
      for(unsigned int i = 0; i < param->defaultValues.size(); i++) {
        if(param->type == "integer") {
          Isis::IString value(param->defaultValues[i]);
          int temp = value.ToInteger();
          value = param->maximum;
          int max = value.ToInteger();
          if(StringToBool(incl) && (temp > max)) {
            QString message = "Parameter [" + param->name +
                             "] must be less than or equal to [" + param->maximum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
          else if(!StringToBool(incl) && (temp >= max)) {
            QString message = "Parameter [" + param->name +
                             "] must be less than [" + param->maximum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
        }
        else if(param->type == "double") {
          Isis::IString value(param->defaultValues[i]);
          double temp = value.ToDouble();
          value = param->maximum;
          double max = value.ToDouble();
          if(StringToBool(incl) && (temp > max)) {
            QString message = "Parameter [" + param->name +
                             "] must be less than or equal to [" + param->maximum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
          else if(!StringToBool(incl) && (temp >= max)) {
            QString message = "Parameter [" + param->name +
                             "] must be less than [" + param->maximum + "].";
            throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
          }
        }
      }
    }
  }
 
  // Check the value for an odd test
  QString odd = param->odd.toLower();
 
  if((odd != "") || StringToBool(odd)) {
    if(param->type != "integer") {
      QString message = "Parameter [" + param->name +
                       "] must be of type integer to have an [odd] test.";
      throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
    }
    else {
      for(unsigned int i = 0; i < param->values.size(); i++) {
        Isis::IString value(param->values[i]);
        if((value.ToInteger() % 2) != 1) {
          QString message = "Value for [" + param->name + "] must be odd.";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
      }
    }
  }
  return;
}
 
 
void IsisAml::CheckFileNamePreference(QString filename, QString paramname) {
  Isis::PvlGroup fileCustomization = Isis::Preference::Preferences().findGroup("FileCustomization");
  QString overwritePreference = fileCustomization.findKeyword("Overwrite")[0].simplified().trimmed();
  QString temp = overwritePreference;
  if(overwritePreference.toUpper() == "ERROR") {
    QString message = "Invalid output filename for [" + paramname + "]. The file [" + filename + "] already exists.  " +
                     "The user preference file customization group is set to disallow file overwrites.";
    throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
  }
  else if(overwritePreference.toUpper() != "ALLOW") { // not set to ERROR or ALLOW
    QString message = "Invalid entry in user preference file FileCustomization group.";
    message += "  Overwrite = [" + temp + "].  Valid values: [Allow] or [Error].";
    throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
  }
}
 
 
void IsisAml::VerifyAll() {
  for(unsigned int g = 0; g < groups.size(); g++) {
    for(unsigned int p = 0; p < groups[g].parameters.size(); p++) {
      IsisParameterData *param = &(this->groups[g].parameters[p]);
 
      Verify(param);
 
      // Check the values for inclusive clauses
      for(unsigned int item = 0; item < param->include.size(); item++) {
        // If this parameter is a boolean and it is true/yes
        // all included parameters must have some type of value
        if(param->type == "boolean") {
          if(((param->values.size() > 0) && StringToBool(param->values[0])) ||
              ((param->values.size() == 0) && (param->defaultValues.size() > 0)
               && StringToBool(param->defaultValues[0]))) {
 
            const IsisParameterData *param2 = ReturnParam(param->include[item]);
            if((param2->values.size()) == 0 &&
                (param2->defaultValues.size() == 0) &&
                (param2->internalDefault.size() == 0)) {
              QString message = "Parameter [" + param2->name +
                               "] must be used if parameter [" +
                               param->name + "] equates to true.";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
        // This parameter is NOT a boolean but the other one might be
        else {
          // If the other parameter is a boolean and it is true/yes
          // then this parameter must have some type of value
          const IsisParameterData *param2 = ReturnParam(param->include[item]);
          if(param2->type == "boolean") {
            if(((param2->values.size() > 0) && StringToBool(param2->values[0])) ||
                ((param2->values.size() == 0) && (param2->defaultValues.size() > 0) &&
                 StringToBool(param2->defaultValues[0]))) {
              if((param->values.size()) == 0 &&
                  (param->defaultValues.size() == 0) &&
                  (param->internalDefault.size() == 0)) {
                QString message = "Parameter [" + param2->name +
                                 "] must be used if parameter [" +
                                 param->name + "] is used.";
                throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
              }
            }
          }
          // Neithter parameter is a boolean so
          // If this one has a value the other parameter must have some type of value
          else {
            if(param->values.size() > 0 &&
                param2->values.size() == 0 &&
                param2->defaultValues.size() == 0 &&
                param2->internalDefault.size() == 0) {
              QString message = "Parameter [" + param2->name +
                               "] must be used if parameter [" +
                               param->name + "] is used.";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
      }
      // Check the values for exclusive clauses
      for(unsigned int item = 0; item < param->exclude.size(); item++) {
        // If this parameter is a boolean that is true/yes
        // the other parameter should not have a value
        if(param->type == "boolean") {
          if(((param->values.size() > 0) && StringToBool(param->values[0])) ||
              ((param->values.size() == 0) && (param->defaultValues.size() > 0) &&
               StringToBool(param->defaultValues[0]))) {
 
            const IsisParameterData *param2 = ReturnParam(param->exclude[item]);
            if(param2->values.size() > 0) {
              QString message = "Parameter [" + param2->name +
                               "] must NOT be used if parameter [" +
                               param->name + "] equates to true.";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
        // This parameter is NOT a boolean but the other one might be
        else {
          const IsisParameterData *param2 = ReturnParam(param->exclude[item]);
          if(param2->type == "boolean") {
            if(((param2->values.size() > 0) && StringToBool(param2->values[0])) ||
                ((param2->values.size() == 0) && (param2->defaultValues.size() > 0) &&
                 StringToBool(param2->defaultValues[0]))) {
              if(param->values.size() > 0) {
                QString message = "Parameter [" + param2->name +
                                 "] must be used if parameter [" +
                                 param->name + "] is used.";
                throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
              }
            }
          }
          // Neither parameter is a boolean
          else {
            if(param->values.size() > 0 && param2->values.size() > 0) {
              QString message = "Parameter [" + param2->name +
                               "] must NOT be used if parameter [" +
                               param->name + "] is used.";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
      }
 
      // Check the values for greaterThan clauses
      if(param->values.size() > 0) {
        for(unsigned int item = 0; item < param->greaterThan.size(); item++) {
          const IsisParameterData *param2 = ReturnParam(param->greaterThan[item]);
          if(param2->values.size() != 0) {
            double double1, double2;
            if(param->type == "integer") {
              double1 = (double) GetInteger(param->name);
            }
            else if(param->type == "double") {
              double1 = GetDouble(param->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(param2->type == "integer") {
              double2 = GetInteger(param2->name);
            }
            else if(param2->type == "double") {
              double2 = GetDouble(param2->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(double2 >= double1) {
              QString message = "Parameter [" + param->name +
                               "] must be greater than parameter [" +
                               param2->name + "].";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
      }
 
      // Check the values for greaterThanOrEqual clauses
      if(param->values.size() > 0) {
        for(unsigned int item = 0; item < param->greaterThanOrEqual.size(); item++) {
          const IsisParameterData *param2 =
            ReturnParam(param->greaterThanOrEqual[item]);
          if(param2->values.size() != 0) {
            double double1, double2;
            if(param->type == "integer") {
              double1 = (double) GetInteger(param->name);
            }
            else if(param->type == "double") {
              double1 = GetDouble(param->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(param2->type == "integer") {
              double2 = GetInteger(param2->name);
            }
            else if(param2->type == "double") {
              double2 = GetDouble(param2->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(double2 > double1) {
              QString message = "Parameter [" + param->name +
                               "] must be greater than or equal to parameter [" +
                               param2->name + "].";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
      }
      // Check the values for lessThan clauses
      if(param->values.size() > 0) {
        for(unsigned int item = 0; item < param->lessThan.size(); item++) {
          const IsisParameterData *param2 = ReturnParam(param->lessThan[item]);
          if(param2->values.size() != 0) {
            double double1, double2;
            if(param->type == "integer") {
              double1 = (double) GetInteger(param->name);
            }
            else if(param->type == "double") {
              double1 = GetDouble(param->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(param2->type == "integer") {
              double2 = GetInteger(param2->name);
            }
            else if(param2->type == "double") {
              double2 = GetDouble(param2->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(double2 <= double1) {
              QString message = "Parameter [" + param->name +
                               "] must be less than parameter [" +
                               param2->name + "].";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
      }
 
      // Check the values for lessThanOrEqual clauses
      if(param->values.size() > 0) {
        for(unsigned int item = 0; item < param->lessThanOrEqual.size(); item++) {
          const IsisParameterData *param2 =
            ReturnParam(param->lessThanOrEqual[item]);
          if(param2->values.size() != 0) {
            double double1, double2;
            if(param->type == "integer") {
              double1 = (double) GetInteger(param->name);
            }
            else if(param->type == "double") {
              double1 = GetDouble(param->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(param2->type == "integer") {
              double2 = GetInteger(param2->name);
            }
            else if(param2->type == "double") {
              double2 = GetDouble(param2->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(double2 < double1) {
              QString message = "Parameter [" + param->name +
                               "] must be less than or equal to parameter [" +
                               param2->name + "].";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
      }
 
      // Check the values for notEqual clauses
      if(param->values.size() > 0) {
        for(unsigned int item = 0; item < param->notEqual.size(); item++) {
          const IsisParameterData *param2 = ReturnParam(param->notEqual[item]);
          if(param2->values.size() != 0) {
            double double1, double2;
            if(param->type == "integer") {
              double1 = (double) GetInteger(param->name);
            }
            else if(param->type == "double") {
              double1 = GetDouble(param->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(param2->type == "integer") {
              double2 = GetInteger(param2->name);
            }
            else if(param2->type == "double") {
              double2 = GetDouble(param2->name);
            }
            else {
              QString msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::IException(Isis::IException::Programmer, msg, _FILEINFO_);
            }
 
            if(double2 == double1) {
              QString message = "Parameter [" + param->name +
                               "] must NOT be equal to parameter [" +
                               param2->name + "].";
              throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
            }
          }
        }
      }
 
      // If this parameter has a value, and a list/option/exclude, make sure
      // the excluded parameter has NO value
      if(((param->values.size() > 0) || (param->defaultValues.size())) > 0) {
        for(unsigned int o2 = 0; o2 < param->listOptions.size(); o2++) {
          QString value, option;
          if(param->type == "string"  || param->type == "combo") {
            value = GetString(param->name);
            value = value.toUpper();
            option = param->listOptions[o2].value;
            option = option.toUpper();
          }
          else if(param->type == "integer") {
            value = GetAsString(param->name);
            value = value.trimmed();
            option = param->listOptions[o2].value;
            option = option.trimmed();
          }
          if(value == option) {
            for(unsigned int e2 = 0; e2 < param->listOptions[o2].exclude.size(); e2++) {
              const IsisParameterData *param2 =
                ReturnParam(param->listOptions[o2].exclude[e2]);
              if(param2->values.size() > 0) {
                QString message = "Parameter [" + param2->name +
                                 "] can not be entered if parameter [" +
                                 param->name + "] is equal to [" +
                                 value + "]";
                throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
              }
            }
          }
        }
      }
 
      // If this parameter has a value, and a list/option/include, make sure
      // the included parameter has a value
      if(((param->values.size() > 0) || (param->defaultValues.size())) > 0) {
        for(unsigned int o2 = 0; o2 < param->listOptions.size(); o2++) {
          QString value, option;
          if(param->type == "string"  || param->type == "combo") {
            value = GetString(param->name);
            value = value.toUpper();
            option = param->listOptions[o2].value;
            option = option.toUpper();
          }
          else if(param->type == "integer") {
            value = GetAsString(param->name);
            value = value.trimmed();
            option = param->listOptions[o2].value;
            option = option.trimmed();
          }
          if(value == option) {
            for(unsigned int e2 = 0; e2 < param->listOptions[o2].include.size(); e2++) {
              const IsisParameterData *param2 =
                ReturnParam(param->listOptions[o2].include[e2]);
              if((param2->values.size() == 0) &&
                  (param2->defaultValues.size() == 0)) {
                QString message = "Parameter [" + param2->name +
                                 "] must be entered if parameter [" +
                                 param->name + "] is equal to [" +
                                 value + "]";
                throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
              }
            }
          }
        }
      }
 
      // If this parameter has no value, default value or internal default
      // value then it must be excluded by some other parameter with an
      // exclude or list/option/exclude
      //   OR
      // it must include a boolean which is false
      if((param->values.size() == 0) && (param->defaultValues.size() == 0) &&
          (param->internalDefault.size() == 0)) {
        bool excluded = false;
        // See if another parameter has a list option excluding this parameter
        for(unsigned int g2 = 0; g2 < groups.size(); g2++) {
          for(unsigned int p2 = 0; p2 < groups[g2].parameters.size(); p2++) {
            for(unsigned int o2 = 0;
                o2 < groups[g2].parameters[p2].listOptions.size(); o2++) {
              for(unsigned int e2 = 0;
                  e2 < groups[g2].parameters[p2].listOptions[o2].exclude.size();
                  e2++) {
                QString excl =
                  this->groups[g2].parameters[p2].listOptions[o2].exclude[e2];
                if(excl == param->name) {
                  excluded = true;
                  break;
                }
              }
            }
 
            if(groups[g2].parameters[p2].type == "boolean") {
              const IsisParameterData *param2 = &groups[g2].parameters[p2];
              if(((param2->values.size() > 0) && !StringToBool(param2->values[0])) ||
                  ((param2->values.size() == 0) && (param2->defaultValues.size() > 0) &&
                   !StringToBool(param2->defaultValues[0]))) {
                for(unsigned int e2 = 0; e2 < groups[g2].parameters[p2].include.size();
                    e2++) {
                  QString incl =
                    this->groups[g2].parameters[p2].include[e2];
                  if(incl == param->name) {
                    excluded = true;
                  }
                }
              }
              else if(((param2->values.size() > 0) && StringToBool(param2->values[0])) ||
                      ((param2->values.size() == 0) && (param2->defaultValues.size() > 0) &&
                       StringToBool(param2->defaultValues[0]))) {
                for(unsigned int e2 = 0; e2 < groups[g2].parameters[p2].exclude.size();
                    e2++) {
                  QString excl =
                    this->groups[g2].parameters[p2].exclude[e2];
                  if(excl == param->name) {
                    excluded = true;
                  }
                }
              }
            }
          }
        }
 
        // See if this parameter excludes any other (this implies the other
        // one also excludes this one too
        for(unsigned int item = 0; item < param->exclude.size(); item++) {
          const IsisParameterData *param2 = ReturnParam(param->exclude[item]);
          if((param2->values.size() != 0) ||
              (param2->defaultValues.size() != 0) ||
              (param2->internalDefault.size() != 0)) {
            if(param2->type != "boolean") {
              excluded = true;
            }
            else {
              if(((param2->values.size() > 0) && !StringToBool(param2->values[0])) ||
                  ((param2->values.size() == 0) && (param2->defaultValues.size() > 0) &&
                   !StringToBool(param2->defaultValues[0]))) {
                excluded = true;
              }
            }
          }
        }
 
        // See if this parameter includes a boolean that is false
        // then it doesn't need a value
        for(unsigned int item = 0; item < param->include.size(); item++) {
          const IsisParameterData *param2 = ReturnParam(param->include[item]);
          if(param2->type == "boolean") {
            if(((param2->values.size() > 0) && !StringToBool(param2->values[0])) ||
                ((param2->values.size() == 0) && (param2->defaultValues.size() > 0) &&
                 !StringToBool(param2->defaultValues[0]))) {
              excluded = true;
            }
          }
        }
 
        if(!excluded) {
          QString message = "Parameter [" + param->name + "] must be entered.";
          throw Isis::IException(Isis::IException::User, message, _FILEINFO_);
        }
      }
    }
  }
}
 
bool IsisAml::StringToBool(QString value) const {
 
  value = value.toUpper();
  if(value == "") {
    return false;
  }
  else if(!value.compare("NO")) {
    return false;
  }
  else if(!value.compare("FALSE")) {
    return false;
  }
  else if(!value.compare("F")) {
    return false;
  }
  else if(!value.compare("N")) {
    return false;
  }
  else if(!value.compare("YES")) {
    return true;
  }
  else if(!value.compare("TRUE")) {
    return true;
  }
  else if(!value.compare("Y")) {
    return true;
  }
  else if(!value.compare("T")) {
    return true;
  }
  else {
    QString message = "Invalid boolean value [" + value + "].";
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
  }
  return false;
}
 
 
void IsisAml::CommandLine(Isis::Pvl &cont) const {
  Isis::PvlGroup group("UserParameters");
 
  // Add appropriate keywords
  for(unsigned int g = 0; g < groups.size(); g++) {
    for(unsigned int p = 0; p < groups[g].parameters.size(); p++) {
      const IsisParameterData *param = ReturnParam(ParamName(g, p));
      // If this param has a value add it to the command line
      if(param->values.size() > 0) {
        Isis::PvlKeyword paramKeyword(param->name);
 
        for(unsigned int value = 0; value < param->values.size(); value++) {
          paramKeyword.addValue(param->values[value]);
        }
 
        group += paramKeyword;
      }
 
      // Or if it has a default value add it to the command line
      else if(param->defaultValues.size() > 0) {
        Isis::PvlKeyword paramKeyword(param->name);
 
        for(unsigned int value = 0;
           value < param->defaultValues.size();
           value++) {
          paramKeyword.addValue(param->defaultValues[value]);
        }
 
        group += paramKeyword;
      }
    }
  }
  // Remove excluded keywords
  for(unsigned int g = 0; g < groups.size(); g++) {
    for(unsigned int p = 0; p < groups[g].parameters.size(); p++) {
      const IsisParameterData *param = ReturnParam(ParamName(g, p));
 
      if(((param->values.size() > 0) || (param->defaultValues.size())) > 0) {
        for(unsigned int o2 = 0; o2 < param->listOptions.size(); o2++) {
          Isis::IString value, option;
          if(param->type == "string"  || param->type == "combo") {
            value = GetAsString(param->name);
            value = value.UpCase();
            option = param->listOptions[o2].value;
            option = option.UpCase();
          }
          else if(param->type == "integer") {
            value = GetAsString(param->name);
            value = value.Trim("\n\r\t\f\v\b");
            option = param->listOptions[o2].value;
            option = option.Trim("\n\r\t\f\v\b");
          }
          if(value == option) {
            for(unsigned int e2 = 0; e2 < param->listOptions[o2].exclude.size(); e2++) {
              const IsisParameterData *param2 =
                ReturnParam(param->listOptions[o2].exclude[e2]);
              if(group.hasKeyword(param2->name)) {
                group.deleteKeyword(param2->name);
              }
            }
          }
        }
      }
    }
  }
 
  cont.clear();
  cont.addGroup(group);
  return;
}
 
 
QString IsisAml::Version() const {
  QString st = "000-00-00";
  for(unsigned int i = 0; i < changes.size(); i++) {
    if(changes[i].date > st) st = changes[i].date;
  }
  return st;
}
 
 
void IsisAml::StartParser(const char *xmlfile) {
 
  // Initialize the XML system
  try {
    XERCES::XMLPlatformUtils::Initialize();
  }
 
  catch(const XERCES::XMLException &toCatch) {
 
    QString message = "Error during XML parser initialization" +
                     (QString)XERCES::XMLString::transcode(toCatch.getMessage());
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
    return;
  }
 
  //
  //  Create a SAX parser object. Then, set it to validate for an IsisAml file
  //
  parser = XERCES::XMLReaderFactory::createXMLReader();
 
//  SAX2XMLReader::ValSchemes valScheme = SAX2XMLReader::Val_Auto;
  XERCES::SAX2XMLReader::ValSchemes valScheme = XERCES::SAX2XMLReader::Val_Never;
  if(valScheme == XERCES::SAX2XMLReader::Val_Auto) {
    parser->setFeature(XERCES::XMLString::transcode("http://xml.org/sax/features/validation"), true);
    parser->setFeature(XERCES::XMLString::transcode("http://apache.org/xml/features/validation/dynamic"), true);
  }
  else if(valScheme == XERCES::SAX2XMLReader::Val_Never) {
    parser->setFeature(XERCES::XMLString::transcode("http://xml.org/sax/features/validation"), false);
  }
 
  else if(valScheme == XERCES::SAX2XMLReader::Val_Always) {
    parser->setFeature(XERCES::XMLString::transcode("http://xml.org/sax/features/validation"), true);
    parser->setFeature(XERCES::XMLString::transcode("http://apache.org/xml/features/validation/dynamic"), false);
  }
 
//  bool doSchema = true;
  bool doSchema = false;
  parser->setFeature(XERCES::XMLString::transcode("http://apache.org/xml/features/validation/schema"), doSchema);
 
  bool schemaFullChecking = false;
  parser->setFeature(XERCES::XMLString::transcode("http://apache.org/xml/features/validation/schema-full-checking"), schemaFullChecking);
 
  //  Create the handler object for an application
  //  Then parse the file
  char *encodingName = const_cast<char *>("LATIN1");
  bool expandNamespaces = false ;
 
  try {
    IsisAmlData *mydata = this;
    appHandler = new IsisXMLApplication(encodingName, expandNamespaces, parser, mydata);
    parser->parse(xmlfile);
  }
  catch (const XERCES::XMLException &toCatch) {
    QString message = "Error in application XML file: " + 
                     (QString)XERCES::XMLString::transcode(toCatch.getMessage());
    throw Isis::IException(Isis::IException::Programmer, message, _FILEINFO_);
    XERCES::XMLPlatformUtils::Terminate();
    return;
  }
  // This Exception is thrown whenever an error is encountered while parsing an XML file.
  // Stacked error messages are generated containing the file path and additional data about where the error occurred.
  catch (Isis::IException &e) {
      QString filePath = (QString) xmlfile;
      QString previousErrorMessage = (QString) e.toString();
      QString additionalErrorMessage = "Error while parsing application XML file [" + filePath + "]";
 
      throw Isis::IException(Isis::IException::Programmer, additionalErrorMessage + "\n" + previousErrorMessage, _FILEINFO_);
      XERCES::XMLPlatformUtils::Terminate();
      return;
  }
 
  //  Delete the parser
  delete parser;
  XERCES::XMLPlatformUtils::Terminate();
  delete appHandler;
  return;
}