Isis 3.0 Object Programmers' Reference

Home

---

IsisAml.cpp

Go to the documentation of this file.

using namespace std;

#include <sstream>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>

#include "iException.h"
#include "IsisAml.h"
#include "IsisXMLChTrans.h"
#include "Filename.h"
#include "iString.h"

namespace XERCES = XERCES_CPP_NAMESPACE;

IsisAml::IsisAml (const std::string &xmlfile) {
  StartParser (xmlfile.c_str());
}

IsisAml::~IsisAml () {
}

void IsisAml::PutAsString (const std::string &paramName,
                           const std::string &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->values.size () > 0) {
    string message = "A value for this parameter [" + paramName + "] has "
                     "already been entered.";
    throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
  }

  param->values.clear();
  param->values.push_back (value);

}

void IsisAml::PutAsString (const std::string &paramName,
                           const std::vector<std::string> &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->values.size () > 0) {
    string message = "A value for this parameter [" + paramName + "] has "
                     "already been entered.";
    throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
  }

  param->values.resize(value.size());
  param->values = value;

}


// Public: Sets the value member of a parameter of type string whos name
// starts with paramName

void IsisAml::PutString (const std::string &paramName, const std::string &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "string") {
    string message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(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 string whos name
// starts with paramName
void IsisAml::PutString (const std::string &paramName,
                         const std::vector<std::string> &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "string") {
    string message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(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 whos name
// starts with paramName

void IsisAml::PutFilename (const std::string &paramName,
                           const std::string &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if ((param->type != "filename") && (param->type != "cube")) {
    string message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(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 whos name
// starts with paramName

void IsisAml::PutFilename (const std::string &paramName,
                           const std::vector<std::string> &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if ((param->type != "filename") && (param->type != "cube")) {
    string message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(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 whos name
// starts with paramName

void IsisAml::PutInteger (const std::string &paramName,
                          const int &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "integer") {
    string message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }
  
  param->values.clear();
  param->values.push_back (Isis::iString(value));

  Verify (param);
}


// Public: Sets the value member of a parameter of type integer whos name
// starts with paramName

void IsisAml::PutInteger (const std::string &paramName,
                          const std::vector<int> &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "integer") {
    string message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  param->values.resize (value.size());
  for (unsigned int i = 0; i < value.size(); i++) {
    param->values[i] = Isis::iString(value[i]);
  }

  Verify (param);
}




// Public: Sets the value member of a parameter of type double whos name
// starts with paramName
void IsisAml::PutDouble (const std::string &paramName,
                         const double &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "double") {
    string message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  param->values.clear();
  param->values.push_back (Isis::iString(value));

  Verify (param);
}


// Public: Sets the value member of a parameter of type double whos name
// starts with paramName
void IsisAml::PutDouble (const std::string &paramName,
                         const std::vector<double> &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "double") {
    string message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  param->values.resize (value.size());
  for (unsigned int i = 0; i < value.size(); i++) {
    param->values[i] = Isis::iString(value[i]);
  }

  Verify (param);
}



// Public: Sets the value member of a parameter of type boolean whos name
// starts with paramName
void IsisAml::PutBoolean (const std::string &paramName,
                          const bool &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "boolean") {
    string message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(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 whos name
// starts with paramName
void IsisAml::PutBoolean (const std::string &paramName,
                          const std::vector<bool> &value) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "boolean") {
    string message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size () > 0) {
    string 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::Message(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 string. Any type can be retrieve with this member.
string IsisAml::GetAsString (const std::string &paramName) const {

  const IsisParameterData *param = ReturnParam (paramName);
  string value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 whos name starts with paramName
// as a vector<string>
void IsisAml::GetAsString (const std::string &paramName,
                           std::vector<std::string> &values) const{

  const IsisParameterData *param = ReturnParam (paramName);

  values.clear();
  string value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 a string/filename
string IsisAml::GetFilename (const std::string &paramName, std::string extension) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if ((param->type != "filename") && (param->type != "cube")) {
    string message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  string value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }

  Isis::Filename name(value);
  if (extension != "") name.AddExtension(extension);
  value = name.Expanded();

  return value;
}


// Public: Returns the value member of a parameter whos name starts with paramName
// as a vector<string/filename>
void IsisAml::GetFilename (const std::string &paramName,
                           std::vector<std::string> &values) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if ((param->type != "filename") && (param->type != "cube")) {
    string message = "Parameter [" + paramName + "] is not a filename.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  values.clear();
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 string
string IsisAml::GetString (const std::string &paramName) const {

  const IsisParameterData *param = ReturnParam (paramName);
  Isis::iString value;

  if (param->type != "string") {
    string message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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.UpCase();
      int found = -1;
      for (unsigned int p=0; p<param->listOptions.size (); p++) {
        Isis::iString option = param->listOptions[p].value;
        option = option.UpCase();
        if (value == option) {
          return value;
        }
        else if (value.compare(0, min(value.size(), option.size()),
                               option ,0, min(value.size(), option.size())) == 0) {
          if (found != -1) {
            string message = "Value [" + value + "] for parameter [" +
                             paramName + "] is not unique.";
            throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
          }
          found = p;
        }
      }
      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 whos name starts with paramName
// as a vector<string>
void IsisAml::GetString (const std::string &paramName,
                         std::vector<std::string> &values) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->type != "string") {
    string message = "Parameter [" + paramName + "] is not a string.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  values.clear();
  string value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 std::string &paramName) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->type != "integer") {
    string message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  Isis::iString value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 whos name starts with paramName
// as a vector<int>
void IsisAml::GetInteger (const std::string &paramName,
                          std::vector<int> &values) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->type != "integer") {
    string message = "Parameter [" + paramName + "] is not an integer.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  values.clear();
  Isis::iString value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 std::string &paramName) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->type != "double") {
    string message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  Isis::iString value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 whos name starts with paramName
// as a vector<doubble>
void IsisAml::GetDouble (const std::string &paramName,
                         std::vector<double> &values) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->type != "double") {
    string message = "Parameter [" + paramName + "] is not a double.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  values.clear();
  Isis::iString value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(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 std::string &paramName) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->type != "boolean") {
    string message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  Isis::iString value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }

  return StringToBool (value);

}


// Public: Returns the value member of a parameter whos name starts with paramName
// as a vector<bool>
void IsisAml::GetBoolean (const std::string &paramName,
                          std::vector<bool> &values) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->type != "boolean") {
    string message = "Parameter [" + paramName + "] is not a boolean.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  values.clear();
  vector <string> value;
  Isis::iString tmp;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      string message = "Parameter [" + paramName + "] has no value.";
      throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
    }
    else {
      for (unsigned int i = 0; i<param->defaultValues.size(); i++) {
        tmp = param->defaultValues[i];
        tmp.UpCase();
        value.push_back (tmp);
      }
    }
  }
  else {
    for (unsigned int i = 0; i<param->values.size(); i++) {
      tmp = param->values[i];
      tmp.UpCase();
      value.push_back (tmp);
    }
  }

  for (unsigned int i = 0; i<value.size(); i++) {
    values.push_back (StringToBool (value[i]));

  }

  return;
}
string IsisAml::ProgramName () const {
  string tmp = name;
  return tmp;
}


string IsisAml::Brief () const {
  return brief;
}


string IsisAml::Description () const {
  return description;
}

int IsisAml::NumGroups () const {
  return groups.size();
}

string IsisAml::GroupName (const int &index) const {
  string s = groups[index].name;
  return s;
}

int IsisAml::NumParams (const int &group) const {
  return groups[group].parameters.size();
}

string IsisAml::ParamName (const int &group, const int &param) const {
   string s = groups[group].parameters[param].name;
  return s;
}

string IsisAml::ParamBrief (const int &group, const int &param) const {
  string s = groups[group].parameters[param].brief;
 return s;
}

string IsisAml::ParamDescription (const int &group, const int &param) const {
  string s = groups[group].parameters[param].description;
  return s;
}

string IsisAml::ParamMinimum (const int &group, const int &param) const {
  string s = groups[group].parameters[param].minimum;
  return s;
}

string IsisAml::ParamMaximum (const int &group, const int &param) const {
  string s = groups[group].parameters[param].maximum;
  return s;
}

string IsisAml::ParamMinimumInclusive (const int &group, const int &param) const {
  string s = groups[group].parameters[param].minimum_inclusive;
  return s;
}

string IsisAml::ParamMaximumInclusive (const int &group, const int &param) const {
  string s = groups[group].parameters[param].maximum_inclusive;
  return s;
}

string IsisAml::ParamOdd (const int &group, const int &param) const {
  string 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();
}

string IsisAml::ParamGreaterThan (const int &group, const int &param,
                     const int &great) const {
  string s = groups[group].parameters[param].greaterThan[great];
  return s;
}

string IsisAml::ParamGreaterThanOrEqual (const int &group, const int &param,
                     const int &great) const {
  string s = groups[group].parameters[param].greaterThanOrEqual[great];
  return s;
}

string IsisAml::ParamLessThan (const int &group, const int &param,
                     const int &les) const {
  string s = groups[group].parameters[param].lessThan[les];
  return s;
}

string IsisAml::ParamLessThanOrEqual (const int &group, const int &param,
                     const int &les) const {
  string s = groups[group].parameters[param].lessThanOrEqual[les];
  return s;
}

string IsisAml::ParamNotEqual (const int &group, const int &param,
                     const int &notEq) const {
  string s = groups[group].parameters[param].notEqual[notEq];
  return s;
}

string IsisAml::ParamExclude (const int &group, const int &param,
                     const int &exclude) const {
  string s = groups[group].parameters[param].exclude[exclude];
  return s;
}

string IsisAml::ParamInclude (const int &group, const int &param,
                     const int &include) const {
  string s = groups[group].parameters[param].include[include];
  return s;
}


string IsisAml::ParamType (const int &group, const int &param) const {
   string s = groups[group].parameters[param].type;
  return s;
}

string IsisAml::ParamDefault (const int &group, const int &param) const {
  string s;
  if (groups[group].parameters[param].defaultValues.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].defaultValues[0];
  }
  return s;
}

string IsisAml::ParamInternalDefault (const int &group, const int &param) const {
  string s;
  if (groups[group].parameters[param].internalDefault.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].internalDefault;
  }
  return s;
}

string IsisAml::ParamFilter (const int &group, const int &param) const {
  string s;
  if (groups[group].parameters[param].filter.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].filter;
  }
  return s;
}

string IsisAml::ParamPath (const int &group, const int &param) const {
  string s;
  if (groups[group].parameters[param].path.size() == 0) {
    s = "";
  }
  else {
    s = groups[group].parameters[param].path;
  }
  return s;
}

string IsisAml::ParamFileMode (const int &group, const int &param) const {
  string 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();
}


string IsisAml::ParamListValue (const int &group, const int &param,
                                const int &option) const {
  string s = groups[group].parameters[param].listOptions[option].value;
  return s;
}

string IsisAml::ParamListBrief (const int &group, const int &param,
                                const int &option) const {
  string s = groups[group].parameters[param].listOptions[option].brief;
  return s;
}

string IsisAml::ParamListDescription (const int &group, const int &param,
                                      const int &option) const {
  string 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();
}

string IsisAml::ParamListExclude (const int &group, const int &param,
                                  const int &option, const int &exclude) const {
  string 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();
}

string IsisAml::ParamListInclude (const int &group, const int &param,
                                  const int &option, const int &include) const {
  string 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();
}

string 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();
}

string IsisAml::HelperButtonName (const int &group, const int &param, 
                               const int &helper) const {
  return groups[group].parameters[param].helpers[helper].name;
}

string IsisAml::HelperFunction (const int &group, const int &param, 
                             const int &helper) const {
  return groups[group].parameters[param].helpers[helper].function;
}

string IsisAml::HelperBrief (const int &group, const int &param, 
                             const int &helper) const {
  return groups[group].parameters[param].helpers[helper].brief;
}

string IsisAml::HelperDescription (const int &group, const int &param, 
                                   const int &helper) const {
  return groups[group].parameters[param].helpers[helper].description;
}

string IsisAml::HelperIcon (const int &group, const int &param, 
                         const int &helper) const {
  return groups[group].parameters[param].helpers[helper].icon;
}

bool IsisAml::WasEntered (const std::string &paramName) const {

  const IsisParameterData *param = ReturnParam (paramName);

  if (param->values.size() == 0) {
    return false;
  }

  return true;
}

void IsisAml::Clear (const std::string &paramName) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));
  param->values.clear();

  param->outCubeAtt.Reset();
  param->outCubeAtt.Set("+"+param->pixelType);
  param->inCubeAtt.Reset();

  return;
}


Isis::CubeAttributeInput& IsisAml::GetInputAttribute (const std::string &paramName) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "cube") {
    string message = "Parameter [" + paramName + "] is not a cube.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  string value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      value.clear();
//      string message = "Parameter [" + paramName + "] has no value.";
//      throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
  if (param->fileMode == "input") {
    param->inCubeAtt.Reset();
    param->inCubeAtt.Set(value);
  }
  else {
    string message = "Parameter [" + paramName + "] does not contain an [input] file";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }
  return param->inCubeAtt;
}

Isis::CubeAttributeOutput& IsisAml::GetOutputAttribute (const std::string &paramName) {

  IsisParameterData *param = const_cast <IsisParameterData *> (ReturnParam (paramName));

  if (param->type != "cube") {
    string message = "Parameter [" + paramName + "] is not a cube.";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }

  string value;
  if (param->values.size() == 0) {
    if (param->defaultValues.size() == 0) {
      value.clear();
//      string message = "Parameter [" + paramName + "] has no value.";
//      throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
    }
    else {
      value = param->defaultValues[0];
    }
  }
  else {
    value = param->values[0];
  }
  if (param->fileMode == "output") {
    param->outCubeAtt.Reset();
    param->outCubeAtt.Set("+"+param->pixelType);
    param->outCubeAtt.Set(value);
  }
  else {
    string message = "Parameter [" + paramName + "] does not contain an [output] file";
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
  }
  return param->outCubeAtt;
}

const IsisParameterData *IsisAml::ReturnParam (const std::string &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) {
            string message = "Parameter [" + paramName + "] is not unique.";
            throw Isis::iException::Message(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) {
    string message = "Unknown parameter [" + paramName + "].";
    throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
  }
  else if ((found > 1) && (!exact)) {
      string message = "Parameter [" + paramName + "] is not unique.";
      throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
  }
  return param;
}

void IsisAml::Verify (const IsisParameterData *param) {

  // Check to make sure the value string 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) {
        string message = "Unable to convert [" + param->values[i] + "] to an integer,"
                         " parameter [" + param->name + "].";
        throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
      }
    }
    else if (param->type == "double") {
      try {
        Isis::iString value (param->values[i]);
        value.ToDouble();
      }
      catch (Isis::iException &e) {
        string message = "Unable to convert [" + param->values[i] + "] to a double,"
                         " parameter [" + param->name + "].";
        throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
      }
    }
    else if (param->type == "boolean") {
      Isis::iString v = param->values[i];
      v.UpCase();

      try {
        StringToBool (v);
      }
      catch (Isis::iException &e) {
        string message = "Illegal value for [" + param->name + "], [" + param->values[i] + "].";
        throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
      }
    }
    else if (param->type == "filename") {
      // Put something here once we figure out what to do with filenames
    }
  }

  // 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 string can be converted to the
      // correct type
      if (param->type == "integer") {
        try {
          Isis::iString value (param->defaultValues[i]);
          value.ToInteger();
        }
        catch (Isis::iException &e) {
          string message = "Unable to convert default [" + param->defaultValues[i] +
                           "] to an integer, parameter [" + param->name + "].";
          throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
        }
      }
      else if (param->type == "double") {
        try {
          Isis::iString value (param->defaultValues[i]);
          value.ToDouble();
        }
        catch (Isis::iException &e) {
          string message = "Unable to convert default [" + param->defaultValues[i] +
                           "] to a double, parameter [" + param->name + "].";
          throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
        }
      }
      else if (param->type == "boolean") {
        Isis::iString v = param->defaultValues[i];
        v.UpCase();

        try {
          StringToBool (v);
        }
        catch (Isis::iException &e) {
          string message = "Illegal default value for [" + param->name + "], [" 
            + param->defaultValues[i] + "].";
          throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
        }
      }
      else if (param->type == "filename") {
        // Put something here once we figure out what to do with filenames
      }
    }
  }

  // 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) {
            string message = "Duplicate list options [" +
                             param->listOptions[p].value +
                             "] in parameter [" + param->name + "].";
            throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
          }
          exact = true;
        }
        // Check for a partial match
        // Compare the shorter of the two (values[i]) to a substring of the
        // longer string (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) {
        string 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::Message(Isis::iException::User,message, _FILEINFO_);
      }
      else if (!exact && partial > 1) {
        string msg = "Value of [" + param->name +
                     "] does not match a list option uniquely.";
        throw Isis::iException::Message(Isis::iException::Programmer,msg, _FILEINFO_);
      }
    }
  }

  // Check the values against the minimum
  if (param->minimum.length () > 0) {
    Isis::iString incl = param->minimum_inclusive;
    for (unsigned int i=0; i<param->values.size (); i++) {
      if (param->type == "integer") {
        Isis::iString value (param->values[i]);
        int temp = value.ToInteger();
        value = param->minimum;
        int min = value.ToInteger();
        if (StringToBool(incl) && (temp < min)) {
          string message = "Parameter [" + param->name + 
            "] must be greater than or equal to [" + param->minimum + "].";
          throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
        }
        else if (!StringToBool(incl) && (temp <= min)) {
          string message = "Parameter [" + param->name + 
            "] must be greater than [" + param->minimum + "].";
          throw Isis::iException::Message(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)) {
          string message = "Parameter [" + param->name + 
            "] must be greater than or equal to [" + param->minimum + "].";
          throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
        }
        else if (!StringToBool(incl) && (temp <= min)) {
          string message = "Parameter [" + param->name + 
            "] must be greater than [" + param->minimum + "].";
          throw Isis::iException::Message(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)) {
            string message = "Parameter [" + param->name + 
              "] must be greater than or equal to [" + param->minimum + "].";
            throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
          }
          else if (!StringToBool(incl) && (temp <= min)) {
            string message = "Parameter [" + param->name + 
              "] must be greater than [" + param->minimum + "].";
            throw Isis::iException::Message(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)) {
            string message = "Parameter [" + param->name + 
              "] must be greater than or equal to [" + param->minimum + "].";
            throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
          }
          else if (!StringToBool(incl) && (temp <= min)) {
            string message = "Parameter [" + param->name + 
              "] must be greater than [" + param->minimum + "].";
            throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
          }
        }
      }
    }
  }

  // Check the values against the maximum
  if (param->maximum.length () > 0) {
    Isis::iString incl = param->maximum_inclusive;
    incl.DownCase();
    for (unsigned int i=0; i<param->values.size (); i++) {
      if (param->type == "integer") {
        Isis::iString value (param->values[i]);
        int temp = value.ToInteger();
        value = param->maximum;
        int max = value.ToInteger();
        if (StringToBool(incl) && (temp > max)) {
          string message = "Parameter [" + param->name + 
            "] must be less than or equal to [" + param->maximum + "].";
          throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
        }
        else if (!StringToBool(incl) && (temp >= max)) {
          string message = "Parameter [" + param->name + 
            "] must be less than [" + param->maximum + "].";
          throw Isis::iException::Message(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)) {
          string message = "Parameter [" + param->name + 
            "] must be less than or equal to [" + param->maximum + "].";
          throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
        }
        else if (!StringToBool(incl) && (temp >= max)) {
          string message = "Parameter [" + param->name + 
            "] must be less than [" + param->maximum + "].";
          throw Isis::iException::Message(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)) {
            string message = "Parameter [" + param->name + 
              "] must be less than or equal to [" + param->maximum + "].";
            throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
          }
          else if (!StringToBool(incl) && (temp >= max)) {
            string message = "Parameter [" + param->name + 
              "] must be less than [" + param->maximum + "].";
            throw Isis::iException::Message(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)) {
            string message = "Parameter [" + param->name + 
              "] must be less than or equal to [" + param->maximum + "].";
            throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
          }
          else if (!StringToBool(incl) && (temp >= max)) {
            string message = "Parameter [" + param->name + 
              "] must be less than [" + param->maximum + "].";
            throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
          }
        }
      }
    }
  }

  // Check the value for an odd test
  Isis::iString odd = param->odd;
  odd.DownCase();

  if ((odd != "") || StringToBool(odd)) {
    if (param->type != "integer") {
      string message = "Parameter [" + param->name + 
        "] must be of type integer to have an [odd] test.";
      throw Isis::iException::Message(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) {
          string message = "Value for [" + param->name + "] must be odd.";
          throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
        }
      }
    }
  }
  return;
}


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)) {
              string message = "Parameter [" + param2->name +
                               "] must be used if parameter [" +
                               param->name + "] equates to true.";
              throw Isis::iException::Message(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)) {
                string message = "Parameter [" + param2->name +
                                 "] must be used if parameter [" +
                                 param->name + "] is used.";
                throw Isis::iException::Message(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) {
              string message = "Parameter [" + param2->name +
                               "] must be used if parameter [" +
                               param->name + "] is used.";
              throw Isis::iException::Message(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) {
              string message = "Parameter [" + param2->name +
                               "] must NOT be used if parameter [" +
                               param->name + "] equates to true.";
              throw Isis::iException::Message(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) {
                string message = "Parameter [" + param2->name +
                                 "] must be used if parameter [" +
                                 param->name + "] is used.";
                throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
              }
            }
          }
          // Neither parameter is a boolean
          else {
            if (param->values.size() > 0 && param2->values.size() > 0) {
              string message = "Parameter [" + param2->name +
                               "] must NOT be used if parameter [" +
                               param->name + "] is used.";
              throw Isis::iException::Message(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 {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (param2->type == "integer") {
              double2 = GetInteger (param2->name);
            }
            else if (param2->type == "double") {
              double2 = GetDouble (param2->name);
            }
            else {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (double2 >= double1) {
              string message = "Parameter [" + param->name +
                               "] must be greater than parameter [" +
                               param2->name + "].";
              throw Isis::iException::Message(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 {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (param2->type == "integer") {
              double2 = GetInteger (param2->name);
            }
            else if (param2->type == "double") {
              double2 = GetDouble (param2->name);
            }
            else {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (double2 > double1) {
              string message = "Parameter [" + param->name +
                               "] must be greater than or equal to parameter [" +
                               param2->name + "].";
              throw Isis::iException::Message(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 {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (param2->type == "integer") {
              double2 = GetInteger (param2->name);
            }
            else if (param2->type == "double") {
              double2 = GetDouble (param2->name);
            }
            else {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (double2 <= double1) {
              string message = "Parameter [" + param->name +
                               "] must be less than parameter [" +
                               param2->name + "].";
              throw Isis::iException::Message(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 {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (param2->type == "integer") {
              double2 = GetInteger (param2->name);
            }
            else if (param2->type == "double") {
              double2 = GetDouble (param2->name);
            }
            else {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (double2 < double1) {
              string message = "Parameter [" + param->name +
                               "] must be less than or equal to parameter [" +
                               param2->name + "].";
              throw Isis::iException::Message(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 {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (param2->type == "integer") {
              double2 = GetInteger (param2->name);
            }
            else if (param2->type == "double") {
              double2 = GetDouble (param2->name);
            }
            else {
              string msg = "Parameter is not INTEGER or DOUBLE type [" +
                           param->name + "]";
              throw Isis::iException::Message(Isis::iException::Programmer,msg,_FILEINFO_);
            }

            if (double2 == double1) {
              string message = "Parameter [" + param->name +
                               "] must NOT be equal to parameter [" +
                               param2->name + "].";
              throw Isis::iException::Message(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++) {
          Isis::iString value, option;
          if (param->type == "string") {
            value = GetString (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 (param2->values.size() > 0) {
                string message = "Parameter [" + param2->name +
                                 "] can not be entered if parameter [" +
                                 param->name + "] is equal to [" +
                                 value + "]";
                throw Isis::iException::Message(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++) {
          Isis::iString value, option;
          if (param->type == "string") {
            value = GetString (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].include.size();e2++) {
              const IsisParameterData *param2 =
                  ReturnParam (param->listOptions[o2].include[e2]);
              if ((param2->values.size() == 0) &&
                  (param2->defaultValues.size() == 0)) {
                string message = "Parameter [" + param2->name +
                                 "] must be entered if parameter [" +
                                 param->name + "] is equal to [" +
                                 value + "]";
                throw Isis::iException::Message(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++) {
                string 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++) {
                  string 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++) {
                  string 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) {
          string message = "Parameter [" + param->name + "] must be entered.";
          throw Isis::iException::Message(Isis::iException::User,message, _FILEINFO_);
        }
      }
    }
  }
}

bool IsisAml::StringToBool (Isis::iString value) const {

  value.UpCase ();
  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 {
    string message = "Invalid boolean value [" + value + "].";
    throw Isis::iException::Message(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) {
        group += Isis::PvlKeyword(param->name, param->values[0]);
      }

      // Or if it has a default value add it to the command line
      else if (param->defaultValues.size() > 0) {
        group += Isis::PvlKeyword(param->name, param->defaultValues[0]);
      }
    }
  }
  // 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") {
            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;
}


string IsisAml::Version () const {
  string 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) {
    string message = "Error during XML parser initialization" +
                     (string)XERCES::XMLString::transcode(toCatch.getMessage());
    throw Isis::iException::Message(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 = "LATIN1";
  bool expandNamespaces = false ;

  try {
    IsisAmlData *mydata = this;
    appHandler = new IsisXMLApplication (encodingName, expandNamespaces, parser, mydata);
    parser->parse(xmlfile);
  }
  catch (const XERCES::XMLException& toCatch) {
    string message = "Error in application XML file: " +
                     (string)XERCES::XMLString::transcode(toCatch.getMessage());
    throw Isis::iException::Message(Isis::iException::Programmer,message, _FILEINFO_);
    XERCES::XMLPlatformUtils::Terminate();
    return;
  }

  //  Delete the parser
  delete parser;
  XERCES::XMLPlatformUtils::Terminate();
  delete appHandler;
  return;
}