C:/Programs/source/NIREP/DisplayDescription/EvaluatorList/EvaluatorList.h

#pragma once
#ifndef _EVALUATOR_LIST_H_
#define _EVALUATOR_LIST_H_

/* +-----------+
   | Libraries |
   +-----------+ */
#include <map>
#include <string>
#include <vector>

#include <iostream>
#include <fstream>


#include  "wx/wxprec.h"
#include "../VariableList/VariableList.h"



#ifndef WX_PRECOMP
#include  "wx/wx.h"
#endif



/* +--------+
         | Macros |
         +--------+ */
#define EVALUATORLIST 2



/* +---------+
   | Classes |
   +---------+ */
class EvaluatorList {
  public:

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

        EvaluatorList();
        EvaluatorList(VariableList* vList);  
        EvaluatorList(const std::string& fileName);  
        EvaluatorList(const std::string& fileName, VariableList* vList);  
        
        ~EvaluatorList();


        bool Read(const std::string& fileName);  


        void Write(const std::string& fileName); 

        void SetVarList(VariableList* list){this->vars = list;}

        void SetEvaluatorTask(std::string taskName, std::string fullName){this->task[taskName] = fullName;}  


        std::vector <std::string> GetTaskParameters(const std::string taskName);


        std::string GetTaskFunction(const std::string taskName);
        
        
        std::vector<std::string> GetTaskKeys();

        
        std::vector<std::string> GetTaskValues(bool fullName=0);

        void GetTasks(std::vector<std::string> * keys, std::vector<std::string> * values, bool fullName=0);

        void SetFullTaskName(std::string taskName, std::string fullName){ this->taskFullName[taskName]=fullName; }  
        
        std::string GetFullTaskName(std::string taskName){ 
                return (this->inMap(this->taskFullName, taskName))?this->taskFullName[taskName]:"!"; 
        }  

        std::string GetEvaluatorCommand(const std::string& taskName) { 
    if (this->inMap(this->taskFullName,taskName)) {
      return this->taskFullName[taskName];
    } else {
      return this->unwrap(taskName);
    }
    
                //return (this->inMap(this->taskFullName,taskName))?this->taskFullName[taskName]:this->unwrap(taskName); 
        }

        std::map<std::string, std::string>* GetList() { return &(this->task); }  

  void ClearTaskFullName(){taskFullName.clear();};

  bool AnyError(){return error;};


  private:

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

        std::string unwrap(std::string source);
        

        void parse(std::string source, std::string * fcn, std::vector<std::string> * params);


        void StringExplode(std::string str, std::string separator, std::vector<std::string> * results);

        
        template <typename S, typename T>
        bool inMap(std::map<S, T> map, S key);

        
  /* +-------------------+
         | Private Parameters |
         +-------------------+ */
        std::map<std::string, std::string> task;  //Container of the evaluator list <taskName, taskExpression>
        std::map<std::string, std::string> taskFullName; // <taskName, fully qualified expression>
        VariableList* vars;                                             // variable list
  bool error;

};

#endif