cdynamicexpression.h

//==========================================================================
//   CDYNAMICEXPRESSION.H  - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//  Author: Andras Varga
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CDYNAMICEXPRESSION_H
#define __CDYNAMICEXPRESSION_H

#include "cnedvalue.h"
#include "cexpression.h"
#include "cstringpool.h"

NAMESPACE_BEGIN

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;
      private:
        // Types:
        //  - bool
        //  - double (there is no long -- we calculate everything in 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, DBL, STR, XML, MATHFUNC, NEDFUNC, FUNCTOR, OP, CONSTSUBEXPR} type;
        static cStringPool stringPool;
        union {
            bool b;
            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)  {type=BOOL; b=_b;}

        void operator=(int _i)  {type=DBL; d.d=_i; d.unit=NULL;}

        void operator=(short _i)  {type=DBL; d.d=_i; d.unit=NULL;}

        void operator=(long _l)  {type=DBL; d.d=_l; d.unit=NULL;}

        void operator=(double _d)  {type=DBL; d.d=_d; d.unit=NULL;}

        void setUnit(const char *s)  {ASSERT(type==DBL); d.unit = stringPool.get(s);}

        void operator=(const char *_s)  {type=STR; s = stringPool.get(_s);}

        void operator=(cXMLElement *_x)  {type=XML; x=_x;}

        void operator=(cNEDMathFunction *_f)  {type=MATHFUNC; ASSERT(_f); f=_f;}

        void set(cNEDFunction *f, int argc)  {type=NEDFUNC; ASSERT(f); nf.f=f; nf.argc=argc;}

        void operator=(Functor *f)  {type=FUNCTOR; ASSERT(f); fu=f;}

        void operator=(OpType _op)  {type=OP; op=_op;}

        void operator=(cExpression *_expr)  {type=CONSTSUBEXPR; constExpr=_expr;}

        int compare(const Elem& other) 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(cComponent *context, cNEDValue args[], int numargs) = 0;
        virtual std::string str(std::string args[], int numargs) = 0;
    };

  protected:
    Elem *elems;
    int size;

  private:
    void copy(const cDynamicExpression& other);

  public:

    explicit cDynamicExpression();

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

    virtual ~cDynamicExpression();

    cDynamicExpression& operator=(const cDynamicExpression& other);


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

    virtual std::string info() const;

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

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

    virtual cNEDValue evaluate(cComponent *context) const;

    virtual bool boolValue(cComponent *context);

    virtual long longValue(cComponent *context, const char *expectedUnit=NULL);

    virtual double doubleValue(cComponent *context, const char *expectedUnit=NULL);

    virtual std::string stringValue(cComponent *context);

    virtual cXMLElement *xmlValue(cComponent *context);

    virtual std::string str() const;

    virtual void parse(const char *text);

    virtual int compare(const cExpression *other) const;

    virtual bool isAConstant() const;

    virtual bool containsConstSubexpressions() const;

    virtual void evaluateConstSubexpressions(cComponent *context);

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

};

NAMESPACE_END


#endif