VariableList.cxx

Go to the documentation of this file.

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


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

VariableList::VariableList(const std::string& fileName)
{
        this->Read(fileName);
}
/*
        function: Read
        purpose: To read in the evaluator list
        
        input:  fileName        std::string     path to the evaluator list description

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

  if (file.is_open())
  {
    std::string line;

    while (! file.eof() )       // loop through the file
    {
      getline (file,line);

      // Convert line to all 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 variablelist"))
        {
          list = VARIABLELIST;
        }
      }
      // we're in the evaluator list
      else if(list == VARIABLELIST)
      {
        // check to see if it's over
        if(!line.compare("end variablelist"))
        {
          list=0;
        }
        else    // we're still in the evaluator list \o/
        {
          // extract the task name
          size_t found = line.find_first_of("=");
          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
          wxID = wxID.MakeLower();
          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);
          wxFunction = wxFunction.MakeLower();
          function = wxFunction.ToAscii();

          // add to evaluator list
          this->SetVariable(id, function);
        }
      }

    }

    file.close();
    return 0;    
  }
  else
    return -1;
}

std::string VariableList::UpdateString(const std::string& source)
{
        std::string temp = source;

        // first, let's find the first ${ character. 
        size_t find = temp.find_first_of("${");

        // if found, extract what comes before, and what comes after.
        // then find the first } character. extract what comes before, and what comes after.
        if ((int)find != std::string::npos) {
                
        //size_t find;
        //while ( (int) (find = temp.find_first_of("${")) != std::string::npos ){
                std::string before = temp.substr(0, find);
                temp = temp.substr(find+1);

                size_t      found = temp.find_first_of("}");
                std::string var   = temp.substr(1, found-1);
                std::string after = temp.substr(found+1);

                // reassemble
                temp = before + this->GetVariable(var) + after;
                
                // check to see if there are more
                temp = this->UpdateString(temp);
        }
        return temp;
}

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

/*
        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 VariableList::inMap(std::map<S, T> map, S key)
{
        bool flag = 0;

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

        return flag;
}

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