cdynamicexpression.h

//==========================================================================
//   CDYNAMICEXPRESSION.H  - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_CDYNAMICEXPRESSION_H
#define __OMNETPP_CDYNAMICEXPRESSION_H
 
#include <map>
#include "cvalue.h"
#include "cexpression.h"
#include "cownedobject.h"
#include "fileline.h"
 
namespace omnetpp {
 
namespace common { class Expression; }
 
class cXMLElement;
class cPar;
class cNedMathFunction;
class cNedFunction;
 
class SIM_API cDynamicExpression : public cExpression
{
  public:
    class SIM_API IResolver {
      public:
        virtual ~IResolver() {}
        virtual IResolver *dup() const = 0;
 
        virtual cValue readVariable(Context *context, const char *name) {return cValue();}
 
        virtual cValue readVariable(Context *context, const char *name, intval_t index) {return cValue();}
 
        virtual cValue readMember(Context *context, const cValue& object, const char *name) {return cValue();}
 
        virtual cValue readMember(Context *context, const cValue& object, const char *name, intval_t index) {return cValue();}
 
        virtual cValue callFunction(Context *context, const char *name, cValue argv[], int argc) {return cValue();}
 
        virtual cValue callMethod(Context *context, const cValue& object, const char *name, cValue argv[], int argc) {return cValue();}
    };
 
    typedef IResolver ResolverBase;
 
    class SIM_API SymbolTable : public IResolver {
      private:
        std::map<std::string, cValue> variables;
        std::map<std::string, std::vector<cValue>> arrays;
      public:
        SymbolTable() {}
        SymbolTable(const std::map<std::string, cValue>& variables) : variables(variables) {}
        SymbolTable(const std::map<std::string, cValue>& variables, const std::map<std::string, std::vector<cValue>>& arrays) : variables(variables), arrays(arrays) {}
        virtual SymbolTable *dup() const override {return new SymbolTable(variables, arrays);}
        virtual cValue readVariable(Context *context, const char *name) override;
        virtual cValue readVariable(Context *context, const char *name, intval_t index) override;
    };
 
  protected:
    common::Expression *expression = nullptr;
    IResolver *resolver = nullptr;
    FileLine sourceLoc;
 
  private:
    void copy(const cDynamicExpression& other);
 
  public:
 
    explicit cDynamicExpression();
 
    cDynamicExpression(const cDynamicExpression& other) : cExpression(other) {copy(other);}
 
    virtual ~cDynamicExpression();
 
    cDynamicExpression& operator=(const cDynamicExpression& other);
 
    virtual cDynamicExpression *dup() const override  {return new cDynamicExpression(*this);}
 
    virtual std::string str() const override;
 
    virtual void parse(const char *text) override;
 
    virtual void parse(const char *text, IResolver *resolver) {parse(text); setResolver(resolver);}
 
    virtual void parse(const char *text, const std::map<std::string,cValue>& symbolTable) {parse(text); setResolver(new SymbolTable(symbolTable));}
 
    virtual void setResolver(IResolver *resolver);
 
    virtual IResolver *getResolver() const {return resolver;}
 
    virtual void parseNedExpr(const char *text);
 
    virtual cValue evaluate(Context *context) const override;
 
    virtual bool boolValue(Context *context) const override;
 
    virtual intval_t intValue(Context *context, const char *expectedUnit=nullptr) const override;
 
    virtual double doubleValue(Context *context, const char *expectedUnit=nullptr) const override;
 
    virtual std::string stringValue(Context *context) const override;
 
    virtual cXMLElement *xmlValue(Context *context) const override;
 
    using cExpression::evaluate;
    using cExpression::boolValue;
    using cExpression::intValue;
    using cExpression::doubleValue;
    using cExpression::stringValue;
    using cExpression::xmlValue;
 
    virtual int compare(const cExpression *other) const override;
 
    virtual bool isAConstant() const override;
 
    void setSourceLocation(FileLine loc) {sourceLoc = loc;}
 
    virtual std::string getSourceLocation() const override {return sourceLoc.str();}
 
    static double convertUnit(double d, const char *unit, const char *targetUnit);
};
 
class cOwnedDynamicExpression : public cOwnedObject, public cDynamicExpression
{
  private:
    virtual void parsimPack(cCommBuffer *) const override {throw cRuntimeError(this, E_CANTPACK);}
    virtual void parsimUnpack(cCommBuffer *) override {throw cRuntimeError(this, E_CANTPACK);}
 
  public:
 
    explicit cOwnedDynamicExpression(const char *name=nullptr) : cOwnedObject(name) {}
 
    explicit cOwnedDynamicExpression(const cOwnedDynamicExpression& other) : cOwnedObject(other), cDynamicExpression(other) {}
 
    cOwnedDynamicExpression& operator=(const cOwnedDynamicExpression& other) = default;
 
 
    virtual cOwnedDynamicExpression *dup() const override  {return new cOwnedDynamicExpression(*this);}
 
    virtual std::string str() const override { return cDynamicExpression::str(); }
};
 
}  // namespace omnetpp
 
 
#endif