EvaluatorList.cpp

Go to the documentation of this file.

  /* +-----------+
         | Libraries |
         +-----------+ */
#include <algorithm>
#include "EvaluatorList.h"
#include "NIREPDefinitions.h"


  /* +----------------+
         | Public Methods |
         +----------------+ */

/*
        function: EvaluatorList
        purpose:  Initialize task with empty, error
*/
EvaluatorList::EvaluatorList()
{
  this->error = false;
        this->SetEvaluatorTask("#", "empty()");
        this->SetEvaluatorTask("!", "error()");
        this->SetVarList(new VariableList());
}


/*
        function: EvaluatorList
        purpose:  Initialize task with empty, error. Reads in evaluator list
        
        input: fileName std::string     path to the evaluator list description
*/
EvaluatorList::EvaluatorList(const std::string& fileName)
{
  this->error = false;
  VariableList* vList = new VariableList(fileName);

        this->SetEvaluatorTask("#", "empty()");
        this->SetEvaluatorTask("!", "error()");
        this->SetVarList(vList);
        error = this->Read(fileName);
}

EvaluatorList::EvaluatorList(const std::string& fileName, VariableList* vList)
{
  this->error = false;
        this->SetEvaluatorTask("#", "empty()");
        this->SetEvaluatorTask("!", "error()");
        this->SetVarList(vList);
        error = this->Read(fileName);
}

EvaluatorList::EvaluatorList(VariableList* vList)
{
  this->error = false;
        this->SetEvaluatorTask("#", "empty()");
        this->SetEvaluatorTask("!", "error()");
        this->SetVarList(vList);
}

/* 
        function: ~EvaluatorList
        purpose: class destructor, destroying references to pointers
*/
EvaluatorList::~EvaluatorList()
{
  vars = NULL;
}

/*
        function: Read
        purpose: To read in the evaluator list
        
        input:  fileName        std::string     path to the evaluator list description

        output: updated task 
*/
bool EvaluatorList::Read(const std::string& fileName)
{
  this->task.clear();
  this->taskFullName.clear();
        std::ifstream file (fileName.c_str());
  int list = 0;

  if (file.is_open())
  {
    // Create a list of Evaluator commands
    EvaluatorCmdList eCmds;
    EvaluatorCmdList::iterator iter;
    for(iter=EvalCmd.begin(); iter != EvalCmd.end(); ++iter){
      eCmds[iter->second] = iter->second;
    }

    std::string line;
    
    while (! file.eof() )       // loop through the file
    {
      getline (file,line);
      // Convert line to lower case for comparison
      std::transform(line.begin(), line.end(), line.begin(), tolower);

          if(list == 0)         // check to see if the evaluator list has started
      {
                // if we find the start designator, update the flag
        if(!line.compare("begin evaluatorlist"))
        {
          list = EVALUATORLIST;
        }
      }
          // we're in the evaluator list
      else if(list == EVALUATORLIST)
      {
                // check to see if it's over
        if(!line.compare("end evaluatorlist"))
        {
          list=0;
        }
        else if(line.compare("") != 0)  // we're still in the evaluator list \o/
        {
                  // extract the task name
                  size_t found = line.find_first_of("=");
      if( found == std::string::npos ) {
        wxString temp(wxT("Error: Missing equal sign in command: "));
        temp.Append(wxString::Format (wxT("%s"), line.c_str()));
        wxLogError(temp);
        return true;
      }
                  std::string id(line, 0,found);        
                  wxString wxID(id.c_str(), wxConvUTF8);        // convert to cstring
                  wxID.Trim();                                  // trim right side
                  wxID.Trim(false);                             // trim left side
                  id = wxID.ToAscii();

                  // extract the expression
                  std::string function(line, found+1,line.length());
                  wxString wxFunction(function.c_str(), wxConvUTF8);
                  wxFunction.Trim();
                  wxFunction.Trim(false);
                  function = wxFunction.ToAscii();

      // FIX THIS SO THAT IT DOES NOT BREAK WITH EXTRA CHARACTERS AFTER THE LAST ")" such as a semicolon
      // THINK ABOUT COUNTING # OF OPEN AND CLOSED PARENTHESES
      size_t firstParentheses=function.find_first_of("(");
      size_t lastParentheses=function.find_first_of(")");
      if( (lastParentheses+1) != function.size() ) {
        wxString temp(wxT("Error: Missing right parentheses in command: "));
        temp.Append(wxString::Format (wxT("%s=%s"), id.c_str(), function.c_str()));
        wxLogError(temp);
        return true;
      }
      else if( firstParentheses == std::string::npos )
      {
        wxString temp(wxT("Error: Missing left parentheses in command:"));
        temp.Append(wxString::Format (wxT("%s=%s"), id.c_str(), function.c_str()));
        wxLogError(temp);
        return true;
      }
      std::string type(function, 0,firstParentheses);

      if( eCmds.find(type) == eCmds.end() ) {
        wxString temp(wxT("Error: Unkown evaluator command:"));
        temp.Append(wxString::Format (wxT("%s for %s=%s"), type.c_str() , id.c_str(), function.c_str()));
        wxLogError(temp);
        return true;
      }
      //if( evaluatorCommands.fList.find(type) == evaluatorCommands.fList.end() ) {
      //  wxString temp = "Error: Unkown evaluator command:";
      //  temp.Append(wxString::Format ("%s for %s=%s", _(type.c_str()) , _(id.c_str()), _(function.c_str())));
      //  ::wxLogError(temp);
      //  return true;
      //}
                
   //   std::vector<std::string> params = this->GetTaskParameters(function);

   //   std::string functionTwo = type;
   //   functionTwo.append("(");
   //   for (int i=0; i < (int) params.size(); i++)
                        //{
                        //      //std::string key = this->vars->GetVariable(params[i]);
                        //      //if (this->vars->GetVariable(params[i]).compare("$") != 0)
                        //      //      params[i] = this->vars->GetVariable(params[i]);
   //     functionTwo.append(params[i]);
   //     functionTwo.append(",");
                        //}
   //   functionTwo.erase(functionTwo.end()-1);
   //   functionTwo.append(")");
      
                  // add to evaluator list
                  //this->SetEvaluatorTask(id, functionTwo);
      this->SetEvaluatorTask(id, function);
        }
      }

    }
    
    file.close();
    return false;    
  }
  wxString temp(wxT("Error: Could not open file: "));
  temp.Append(wxString::Format (wxT("%s"), fileName.c_str()));
  wxLogError(temp);
  return true;
}



/*
        function: Write
        purpose: To save the evaluator list to disk
        
        input:  fileName        std::string     path to the evaluator list description

        output: updated task 
*/
void EvaluatorList::Write(const std::string& fileName)
{
}


/*
function: GetTaskParameters
purpose: Retrieve the parameters for a task
 
 This task retrieves the task's command parameters. For instance, for the 
 task "_A1 = readImage(1,MRI)", this function would return the vector:
        [0] = 1
        [1] = MRI

input: taskName std::string                     the reference name of the task
output: std::vector<std::string>        the parameters of the task
*/
std::vector <std::string> EvaluatorList::GetTaskParameters(const std::string taskName)
{
        std::string temp = taskName;
        std::vector<std::string> params;

        std::string temp2 = temp.substr(temp.size()-1,1);
        // first, see if it is a command like readImage(1,MRI) or if it is a task like _A1
        //if ( ( temp2.compare(")") == 1 ) || (temp2.size() < 1) )
  if ( ( temp2.compare(")") != 0 ) || temp2.empty() )
        {                                                                                               // ex: diff(_A2, _A3)
                if ( this->inMap(this->task,temp) ) {
                        // if it's in the map
                        temp = this->task[temp];
    } else                                                                              // _A1 is NOT found in the map
                {
                        params.push_back("#");
                        return params;
                }
        }

        // first, remove the trailing parenthesis
        //    ex: 
        //              source: viewImage(_A1,MRI) 
        //              temp: viewImage(_A1,MRI
        temp = temp.substr(0,temp.find_last_of(")"));

        // then, extract the variable list
        //        ex:
        //              temp: viewImage(_A1,MRI
        //              temp: _A1,MRI
        temp = temp.substr(temp.find_first_of("(")+1);
        
        // finally, create the vector of parameters
        //        ex:
        //              temp: _A1, MRI
        //              params[0]: _A1
        //                        [1]: MRI
        std::string delim = ",";
        this->StringExplode(temp, delim, &params);

  for (int i=0; i < (int) params.size(); i++)
        {
                //std::string key = this->vars->GetVariable(params[i]);
                if (this->vars->GetVariable(params[i]).compare("$") != 0)
                        params[i] = this->vars->GetVariable(params[i]);
  }
        return params;
}

/*
        function: GetTaskFunction
        purpose: retrieves the task's function
        
        input: const std::string taskName with the name of the task

        output:  std::string with the function used by NIREPEvaluator::evaluate
*/
std::string EvaluatorList::GetTaskFunction(const std::string taskName)
{
  // FIX THIS SO IT IS NOT SO FRAGLE.  THIS CODE ASSUMES THAT THE LAST 
  // CHARACTER OF THE TASK IS A ")".  WHAT IF THERE IS A SPACE AFTERWARDS?
        std::string temp = taskName.substr(taskName.size()-1,1), temp2;

        if ( ( temp.compare(")") == 1 ) || (temp.size() < 1) )
        {                                                                                               // ex: diff(_A2, _A3)
                if ( this->inMap(this->task,taskName) )                 // if it's in the map
                        temp2 = this->task[taskName].substr(0,this->task[taskName].find_first_of("("));
                else                                                    // _A1 is NOT found in the map
                {
                        return "#";
                }
        }
        else
                temp2 = taskName.substr(0,taskName.find_first_of("("));
        return temp2 ;
}


/*
        function: GetTaskKeys
        purpose: retrieves the keys from the tasks map, as strings
        returns: std::vector<std::string> containing the keys (eg: _A1, _A2, etc)
*/
std::vector<std::string> EvaluatorList::GetTaskKeys()
{
        std::vector<std::string> keys;

        for(std::map<std::string, std::string>::iterator it=this->task.begin(); it!=this->task.end(); ++it)
        {
                keys.push_back(it->first);
        }

        return keys;
}


/*
        function: GetTaskValues
        purpose: retrieves the values from the tasks map, as strings
        input: fullName bool flag to determine if the fully qualified name is returned or not. defaults to 0 (no).
        returns: std::vector<std::string> containing the values (eg: readImage(1,MRI), etc)
*/
std::vector<std::string> EvaluatorList::GetTaskValues(bool fullName)
{
        std::vector<std::string> vals;

        for(std::map<std::string, std::string>::iterator it=this->task.begin(); it!=this->task.end(); ++it)
        {
                if (fullName) {
      size_t firstParentheses= it->second.find_first_of("(");
      std::vector<std::string> params = this->GetTaskParameters(it->second);
      std::string type(it->second, 0,firstParentheses);
      std::string functionTwo = type;
      functionTwo.append("(");
      for (int i=0; i < (int) params.size(); i++)
                        {
                                //std::string key = this->vars->GetVariable(params[i]);
        if (this->unwrap(params[i]).compare("#") != 0)
                                        params[i] =this->unwrap(params[i]);
        functionTwo.append(params[i]);
        functionTwo.append(",");
                        }
      functionTwo.erase(functionTwo.end()-1);
      functionTwo.append(")");

      vals.push_back(functionTwo);
      //std::string tempString = this->GetEvaluatorCommand(it->second);
      //if(tempString.compare("#") == 0) {
      //  vals.push_back(it->second);
      //} else {
      //  vals.push_back(tempString);
      //}
                        
    }
                else
                        vals.push_back(it->second);
        }

        return vals;
}


/*
        function: GetTasks
        purpose: retrieves the keys and values from the tasks map, as strings

        inputs:
                keys    std::vector<std::string>* containing the keys (eg: _A1, _A2, etc)
                vals    std::vector<std::string>* containing the values (eg: readImage(1,MRI), etc)
                fullName bool flag to determine if the fully qualified name is returned or not. defaults to 0 (no).
*/
void EvaluatorList::GetTasks(std::vector<std::string> * keys, std::vector<std::string> * values, bool fullName)
{
        *keys = this->GetTaskKeys();
        *values = this->GetTaskValues(fullName);
}



  /* +-----------------+
         | Private Methods |
         +-----------------+ */

/*
        function: unwrap
    purpose: unwraps command strings 
        
         The evaluator list, eList, maps keys against functions (which take parameters
         of other keys) and base functions (which have parameters that don't contain keys).
         This unwraps those keys to their fully formed expression, eg:
                _A1 => readImage(1,MRI)
                _A2 => readImage(2,MRI)
                _A3 => diff(_A1, _A2)
                unwrap(_A3) => diff(readImage(1,MRI),readImage(2,MRI))
        
        input: source std:string containing the source command (ex: _A4)

        output: std:string with the fully unwrapped command 
                 (ex: diff(readImage(1,MRI),readImage(2,MRI))) 
*/
std::string EvaluatorList::unwrap(std::string source)
{
        std::string unwrapped,                          // stores the result
                                fcn;                                    // stores the function from the parsing
        std::vector<std::string> params;        // stores the params from the parsing

        // if it's a readImage(1, MRI) or readCoeff(file), we don't need to unwind further
  if ( (source.compare("#")==0) ||( source.size() == 0 ) )
    return "#";

        // if it's not a read function, if it contains a ), it's a function that
        // needs to be exploded and unwrapped
        //if ( source.substr(source.size(),1).compare(")") == 0 )
  size_t index1 = source.find_last_of(")");
  if ( index1 != std::string::npos )
        {                                                                                               // ex: diff(_A2, _A3)
                        fcn = this->GetTaskFunction(source);
                        params = this->GetTaskParameters(source);

                        for (int i=0; i < (int) params.size(); i++)
                        {
                                //std::string key = this->vars->GetVariable(params[i]);
                                //if (this->vars->GetVariable(params[i]).compare("$") != 0)
                                //      params[i] = this->vars->GetVariable(params[i]);
        if ( this->inMap(this->task, params[i]) )
          params[i] = this->unwrap( params[i] );
                        }       
        }
        else    
        // if it's not a function or a read, it's a key in the evaluator list (eList)
        // and needs to be parsed if it's found, or return an error if it's not found
        {                                                                                               // ex: _A1
                //if ( eList.find(source) < eList.end() )               // _A1 is found in the map

                if ( this->inMap(this->task,source) )
                {
                        fcn = this->GetTaskFunction(task[source]);
                        params = this->GetTaskParameters(task[source]);

      for (int i=0; i < (int) params.size(); i++)
                        {
                                //std::string key = this->vars->GetVariable(params[i]);
                                //if (this->vars->GetVariable(params[i]).compare("$") != 0)
                                //      params[i] = this->vars->GetVariable(params[i]);
        if ( this->inMap(this->task, params[i]) )
          params[i] = this->unwrap( params[i] );
                        }
                }
                else                                                                            // _A1 is NOT found in the map
      return "#";                               
        }

        // start the reassembly -- we've got it parsed now!
        unwrapped  = fcn;                                       // ex: unwrapped = diff
        unwrapped += "(";       // ex: unwrapped = diff(

        // loop through the params vector to unwrap each parameter

          for(int i=0; i < (int) params.size(); i++)
          {
                  //std::string temp = this->unwrap(params[i]);         // unwrap the current param
                
                  //if (temp.size() == 0)                                               // if temp is npos, there was an
                                //unwrapped = "#";                                      // error, so preserve the error
                  //else 
                  //{ // might need to update this once we have diff(_A1,_A2) to properly concat the params
                          //unwrapped += temp;                                          // otherwise, concat the results
        unwrapped += params[i];;


                          if ( i < (int) params.size() - 1 )                            // and if there are more to come
                                  unwrapped += ",";                                     // add a comma
                }


        if (unwrapped.size() > 0 )                      // if it's not errored
                unwrapped += ")";                                                       // end the function

        this->SetFullTaskName(source,unwrapped);
        return unwrapped;
}


/*
        function: parse
        purpose: parses command strings into functions and parameters
        
         The evaluator list, eList, maps keys against functions (which take parameters
         of other keys) and base functions (which have parameters that don't contain keys).
         The first thing the evaluator needs to do to perform a function, given a command
         from the eList is to parse it, to know what it needs to know.

         NOTE: DEPRECATED
        
        input:
         source std:string                               containing the source command (ex: diff(_A1, _A2)
         fcn    std::string*                     reference to the function string
         params std::vector<std::string>* reference to the parameter vector

        output:  
         fcn    std::string*                     containing the function (ex: diff)
         params std::vector<std::string> containing the parameters of the function
                                                                         (ex: [ _A1, _A2 ] )  
*/
void EvaluatorList::parse(std::string source, std::string * fcn, std::vector<std::string> * params)
{
        std::string temp = source;
        
        // first, remove the trailing parenthesis
        //    ex: 
        //              source: viewImage(_A1,MRI) 
        //              temp: viewImage(_A1,MRI
        temp = temp.substr(0,temp.find_last_of(")"));
        
        //then, extract the function
        //        ex:
        //              temp: viewImage(_A1,MRI
        //              fcn: viewImage
        *fcn = temp.substr(0,temp.find_first_of("("));

        // then, extract the variable list
        //        ex:
        //              temp: viewImage(_A1,MRI
        //              temp: _A1,MRI
        temp = temp.substr(temp.find_first_of("(")+1);
        
        // finally, create the vector of parameters
        //        ex:
        //              temp: _A1, MRI
        //              params[0]: _A1
        //                        [1]: MRI
        std::string delim = ",";
        this->StringExplode(temp, delim, params);
}


/*
        function: StringExplode
        purpose: take a string and separate it based on some deliminator
                For instance:
                                fruit = "apple, jackfruit, lemon, orange, pear, pineapple"
                                separator = ","
                                          [ "apple"     ]
                                          [ "jackfruit" ]
                                results = [ "lemon"     ]
                                                  [ "orange"    ]
                                                  [ "pear"      ]
                                                  [ "pineapple" ]
        
        input: 
                str                     std::string                                     string to be exploded
                separator       std::string                                     deliminator

        output:  
                results         std::vector<std::string>        vector of the separated string
    */
void EvaluatorList::StringExplode(std::string str, 
  std::string separator, 
  std::vector<std::string>* results)
{
  size_t found = str.find_first_of(separator);
  while(found != std::string::npos){
    if(found > 0){
      // Strip spaces from left and right of string GEC 7/9/2010 
      wxString temp(str.substr(0,found).c_str(), wxConvUTF8);
      temp.Trim(true);   // Remove spaces from right of string
      temp.Trim(false);  // Remove spaces from left of string
      results->push_back(std::string(temp.mb_str()));
    }
    str = str.substr(found+1);
    found = str.find_first_of(separator);
  }
  if(str.length() > 0){
    // Strip spaces from left and right of string GEC 7/9/2010
    wxString temp(str.c_str(), wxConvUTF8 );
    temp.Trim(true);   // Remove spaces from right of string
    temp.Trim(false);  // Remove spaces from left of string
    results->push_back(std::string(temp.mb_str()));
  }
}

/*
        function: inMap
        purpose:  To determine if a key is in a map
        
        input:
                map             std::map<S, T>  map to be searched
                key             S                               key to be searched

        output:
                true:  if found
                false: if not found
*/
template <typename S, typename T>
bool EvaluatorList::inMap(std::map<S, T> map, S key)
{
        bool flag = false;

        typename std::map<S,T>::iterator keyfound = map.find(key);
  if (keyfound != map.end()){  
    flag = true; 
  }

        return flag;
}

template bool EvaluatorList::inMap(std::map<std::string, std::string> map, std::string key);