eval.h

#ifndef _MBXMLUTILS_EVAL_H_
#define _MBXMLUTILS_EVAL_H_
 
#include <fmatvec/atom.h>
#include <boost/filesystem.hpp>
#include <xercesc/util/XercesDefs.hpp>
#include <mbxmlutilshelper/dom.h>
#include <mbxmlutilshelper/thislinelocation.h>
#include <unordered_map>
#include <stack>
 
#define MBXMLUTILS_EVAL_CONCAT1(X, Y) X##Y
#define MBXMLUTILS_EVAL_CONCAT(X, Y) MBXMLUTILS_EVAL_CONCAT1(X, Y)
#define MBXMLUTILS_EVAL_APPENDLINE(X) MBXMLUTILS_EVAL_CONCAT(X, __LINE__)
 
#define MBXMLUTILS_EVAL_REGISTER(T) \
  namespace { \
    struct Reg { \
      Reg() { Eval::registerEvaluator<T>(); } \
    } MBXMLUTILS_EVAL_APPENDLINE(regDummy); \
  }
 
namespace XERCES_CPP_NAMESPACE {
  class DOMElement;
  class DOMAttr;
  class DOMDocument;
}
 
namespace MBXMLUtils {
 
bool tryDouble2Int(double d, int &i);
 
class CodeString : public std::string {
  public:
    CodeString(const std::string &str) : std::string(str) {}
};
 
// Store the current directory in the ctor an restore in the dtor
class PreserveCurrentDir {
  public:
    PreserveCurrentDir() {
      dir=boost::filesystem::current_path();
    }
    ~PreserveCurrentDir() {
      boost::filesystem::current_path(dir);
    }
  private:
    boost::filesystem::path dir;
};
 
class Eval;
 
class NewParamLevel {
  public:
    NewParamLevel(std::shared_ptr<Eval> oe_, bool newLevel_=true);
    ~NewParamLevel();
    
    NewParamLevel(const NewParamLevel& other) = delete; // copy constructor
    NewParamLevel(NewParamLevel&& other) = delete; // move constructor
    NewParamLevel& operator=(const NewParamLevel& other) = delete; // copy assignment
    NewParamLevel& operator=(NewParamLevel&& other) = delete; // move assignment
  protected:
    static void* operator new(std::size_t); // no heap allocation allowed
    static void* operator new[](std::size_t); // no heap allocation allowed
 
    std::shared_ptr<Eval> oe;
    bool newLevel;
};
 
class Eval : public std::enable_shared_from_this<Eval>, virtual public fmatvec::Atom {
  public:
    friend class NewParamLevel;
 
    enum ValueType {
      ScalarType,
      VectorType,
      MatrixType,
      StringType,
      FunctionType
    };
 
    using Value = std::shared_ptr<void>;
 
    static boost::filesystem::path installPath;
 
  protected:
    Eval(std::vector<boost::filesystem::path> *dependencies_);
  public:
    ~Eval() override;
 
    Eval(const Eval& other) = delete; // copy constructor
    Eval(Eval&& other) = delete; // move constructor
    Eval& operator=(const Eval& other) = delete; // copy assignment
    Eval& operator=(Eval&& other) = delete; // move assignment
 
    static std::shared_ptr<Eval> createEvaluator(const std::string &evalName, std::vector<boost::filesystem::path> *dependencies_=nullptr);
 
    // Register a new evaluator.
    template<class E>
    static void registerEvaluator() {
      getEvaluators()[E::getNameStatic()]=&newEvaluator<E>;
    }
 
    virtual std::string getName() const=0;
 
    void addParam(const std::string &paramName, const Value& value);
    void addParamSet(const xercesc::DOMElement *e);
 
    virtual void addImport(const std::string &code, const xercesc::DOMElement *e, const std::string &action="")=0;
    
    Value eval(const xercesc::DOMElement *e);
 
    Value eval(const xercesc::DOMAttr *a);
 
    Value eval(const std::string &str, const xercesc::DOMElement *e=nullptr, bool skipRet=false);
 
    template<typename T>
    T cast(const Value &value) const;
 
    virtual std::string getStringRepresentation(const Value &x) const;
 
    virtual bool valueIsOfType(const Value &value, ValueType type) const=0;
 
    Value stringToValue(const std::string &str, const xercesc::DOMElement *e=nullptr, bool fullEval=true, bool skipRet=false) const;
 
    template<class T>
    Value create(const T& v) const;
 
    template<class T>
    std::string createSourceCode(const T& v) const;
 
    virtual std::map<boost::filesystem::path, std::pair<boost::filesystem::path, bool> >& requiredFiles() const=0;
 
    virtual void convertIndex(Value &v, bool evalTo1Based)=0;
 
    static void setValue(xercesc::DOMElement *e, const Value &v);
 
    virtual Value callFunction(const std::string &name, const std::vector<Value>& args) const=0;
 
    size_t getStackSize() { assert(paramStack.size()==importStack.size()); return paramStack.size(); }
 
  protected:
    virtual Value createFunctionIndep(int dim) const = 0;
    virtual Value createFunctionDep(const std::vector<Value>& v) const=0;
    virtual Value createFunctionDep(const std::vector<std::vector<Value> >& v) const=0;
    virtual Value createFunction(const std::vector<Value> &indeps, const Value &dep) const = 0;
 
    void pushContext();
 
    void popContext();
 
    std::vector<boost::filesystem::path> *dependencies;
 
    // map of the current parameters
    std::unordered_map<std::string, Value> currentParam;
    // stack of parameters
    std::stack<std::unordered_map<std::string, Value> > paramStack;
 
    // current imports
    std::unordered_map<std::string, Value> currentImport;
    // stack of imports
    std::stack<std::unordered_map<std::string, Value> > importStack;
 
    virtual Value fullStringToValue(const std::string &str, const xercesc::DOMElement *e, bool skipRet=false) const=0;
 
    std::string partialStringToString(const std::string &str, const xercesc::DOMElement *e) const;
 
    template<class E>
    static std::shared_ptr<Eval> newEvaluator(std::vector<boost::filesystem::path>* dependencies_) {
      return std::shared_ptr<E>(new E(dependencies_));
    }
 
    void addStaticDependencies(const xercesc::DOMElement *e) const;
 
    static void printEvaluatorMsg(const std::ostringstream &str, MsgType msgType);
 
  private:
    // virtual spezialization of cast(const Value &value)
    virtual double                            cast_double              (const Value &value) const=0;
    virtual std::vector<double>               cast_vector_double       (const Value &value) const=0;
    virtual std::vector<std::vector<double> > cast_vector_vector_double(const Value &value) const=0;
    virtual std::string                       cast_string              (const Value &value) const=0;
    // spezialization of cast(const Value &value)
    CodeString          cast_CodeString  (const Value &value) const;
    int                 cast_int         (const Value &value) const;
 
    // virtual spezialization of create(...)
    virtual Value create_double                   (const double& v) const=0;
    virtual Value create_vector_double            (const std::vector<double>& v) const=0;
    virtual Value create_vector_vector_double     (const std::vector<std::vector<double> >& v) const=0;
    virtual Value create_string                   (const std::string& v) const=0;
 
    // virtual spezialization of createSourceCode(...)
    virtual std::string createSourceCode_double                   (const double& v) const=0;
    virtual std::string createSourceCode_vector_double            (const std::vector<double>& v) const=0;
    virtual std::string createSourceCode_vector_vector_double     (const std::vector<std::vector<double> >& v) const=0;
    virtual std::string createSourceCode_string                   (const std::string& v) const=0;
 
    virtual std::string serializeFunction(const Value &x) const = 0;
 
    Value handleUnit(const xercesc::DOMElement *e, const Value &ret);
 
    static std::map<std::string, std::string> units;
 
    static std::map<std::string, std::function<std::shared_ptr<Eval>(std::vector<boost::filesystem::path>*)> >& getEvaluators();
 
};
 
// specializations
template<> std::string Eval::cast<std::string>(const Value &value) const;
template<> CodeString Eval::cast<CodeString>(const Value &value) const;
template<> double Eval::cast<double>(const Value &value) const;
template<> int Eval::cast<int>(const Value &value) const;
template<> std::vector<double> Eval::cast<std::vector<double> >(const Value &value) const;
template<> std::vector<std::vector<double> > Eval::cast<std::vector<std::vector<double> > >(const Value &value) const;
 
// spezializations for create
template<> Eval::Value Eval::create<double>                               (const double& v) const;
template<> Eval::Value Eval::create<std::vector<double> >                 (const std::vector<double>& v) const;
template<> Eval::Value Eval::create<std::vector<std::vector<double> > >   (const std::vector<std::vector<double> >& v) const;
template<> Eval::Value Eval::create<std::string>                          (const std::string& v) const;
 
// spezializations for createSourceCode
template<> std::string Eval::createSourceCode<double>                               (const double& v) const;
template<> std::string Eval::createSourceCode<std::vector<double> >                 (const std::vector<double>& v) const;
template<> std::string Eval::createSourceCode<std::vector<std::vector<double> > >   (const std::vector<std::vector<double> >& v) const;
template<> std::string Eval::createSourceCode<std::string>                          (const std::string& v) const;
 
} // end namespace MBXMLUtils
 
#endif