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 "cnedvalue.h"
#include "cexpression.h"
#include "cstringpool.h"

namespace omnetpp {

class cXMLElement;
class cPar;
class cNedMathFunction;
class cNedFunction;

class SIM_API cDynamicExpression : public cExpression
{
  public:
    enum OpType {
        ADD, SUB, MUL, DIV, MOD, POW, NEG,
        EQ, NE, GT, GE, LT, LE, IIF, AND, OR, XOR, NOT,
        BIN_AND, BIN_OR, BIN_XOR, BIN_NOT, LSHIFT, RSHIFT
    };

    class Functor; // forward decl

    class SIM_API Elem
    {
      friend class cDynamicExpression;
      public:
        // Types:
        //  - bool
        //  - intpar_t
        //  - double
        //  - string
        //  - pointer to an "external" cXMLElement
        //  - cNedMathFunction: function with 0/1/2/3/4 double arguments
        //  - cNedFunction: function taking/returning cNedValue (NedFunction)
        //  - functor
        //  - math operator (+-*/%^...)
        //  - constant subexpression
        //
        enum Type {UNDEF, BOOL, INT, DBL, STR, XML, MATHFUNC, NEDFUNC, FUNCTOR, OP, CONSTSUBEXPR};
      private:
        static cStringPool stringPool;
        Type type;
        union {
            bool b;
            struct {intpar_t i; const char *unit;} i;
            struct {double d; const char *unit;} d;
            const char *s; // points into stringPool
            cXMLElement *x;
            cNedMathFunction *f;
            struct {cNedFunction *f; int argc;} nf;
            Functor *fu;
            OpType op;
            cExpression *constExpr;
        };

      private:
        void copy(const Elem& other);
        void deleteOld();

      public:
        Elem()  {type=UNDEF;}
        Elem(const Elem& other)  {type=UNDEF; copy(other);}
        ~Elem();

        void operator=(const Elem& other);

        void operator=(bool b);

        void operator=(intpar_t i);

        void operator=(double d);

        void setUnit(const char *s);

        void operator=(const char *s);

        void operator=(cXMLElement *x);

        void operator=(cNedMathFunction *f);

        void set(cNedFunction *f, int argc);

        void operator=(Functor *f);

        void operator=(OpType op);

        void operator=(cExpression* expr);

        Type getType() const {return type;}

        bool isNumericConstant() const {return type==INT || type==DBL;}

        void negate();

        bool getBoolConstant() const {ASSERT(type==BOOL); return b;}

        intpar_t getIntConstant() const {ASSERT(type==INT); return i.i;}

        double getDoubleConstant() const {ASSERT(type==DBL); return d.d;}

        const char *getUnit() const {return (type==INT) ? i.unit : (type==DBL) ? d.unit : nullptr;}

        const char *getStringConstant() const {ASSERT(type==STR); return s;}

        cXMLElement *getXMLElement() const {ASSERT(type==XML); return x;}

        cNedMathFunction *getMathFunction() const {ASSERT(type==MATHFUNC); return f;}

        cNedFunction *getNedFunction() const {ASSERT(type==NEDFUNC); return nf.f;}

        int getNedFunctionNumArgs() const {ASSERT(type==NEDFUNC); return nf.argc;}

        Functor *getFunctor() const {ASSERT(type==FUNCTOR); return fu;}

        OpType getOperation() const {ASSERT(type==OP); return op;}

        cExpression *getConstSubexpression() const {ASSERT(type==CONSTSUBEXPR); return constExpr;}

        int compare(const Elem& other) const;

        static const char *getOpName(OpType op);

        std::string str() const;
    };

    class SIM_API Functor : public cObject
    {
      public:
        virtual const char *getArgTypes() const = 0;
        virtual int getNumArgs() const {return strlen(getArgTypes());}
        virtual char getReturnType() const = 0;
        virtual cNedValue evaluate(Context *context, cNedValue args[], int numargs) = 0;
        virtual std::string str(std::string args[], int numargs) = 0;
        using cObject::str;
        typedef cDynamicExpression::Context Context;
    };


  protected:
    Elem *elems;
    int size;

  private:
    void copy(const cDynamicExpression& other);
    void bringToCommonTypeAndUnit(cNedValue& a, cNedValue& b) const;
    static void ensureNoLogarithmicUnit(const cNedValue& v);

  public:

    explicit cDynamicExpression();

    cDynamicExpression(const cDynamicExpression& other) : cExpression(other) {elems=nullptr; copy(other);}

    virtual ~cDynamicExpression();

    cDynamicExpression& operator=(const cDynamicExpression& other);


    virtual cDynamicExpression *dup() const override  {return new cDynamicExpression(*this);}

    virtual std::string str() const override;

    // Note: parsimPack()/parsimUnpack() de-inherited in cExpression.

    virtual void setExpression(Elem e[], int size);

    virtual cNedValue evaluate(Context *context) const override;

    virtual bool boolValue(Context *context) const override;

    virtual intpar_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 void parse(const char *text) override;

    virtual int compare(const cExpression *other) const override;

    virtual bool isAConstant() const;

    virtual bool containsConstSubexpressions() const override;

    virtual void evaluateConstSubexpressions(Context *context) override;

    static double convertUnit(double d, const char *unit, const char *targetUnit);

};


}  // namespace omnetpp


#endif