cpar.h

//==========================================================================
//   CPAR.H  - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cPar       : general value holding class
//    cModulePar : specialized cPar that serves as module parameter
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2005 Andras Varga

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

#ifndef __CPAR_H
#define __CPAR_H

#include "cobject.h"

#define SHORTSTR  27


//=== classes declared here:
class  cPar;
class  cModulePar;

//=== class mentioned
class  cStatistic;
class  cXMLElement;


//==========================================================================

class SIM_API cExpression
{
  public:
    virtual ~cExpression() {}
    virtual std::string getAsText() = 0;
    virtual bool parseText(const char *text) = 0;
    virtual cExpression *dup() = 0;
};

class SIM_API cDoubleExpression : public cExpression
{
  public:
    virtual std::string getAsText();
    virtual bool parseText(const char *text);
    virtual double evaluate() = 0;
};

//==========================================================================

class SIM_API cPar : public cObject
{
  public:
    struct ExprElem
    {
        // Type chars:
        //   D  double constant
        //   P  pointer to "external" cPar (owned by someone else)
        //   R  "reference": the cPar will be dup()'ped and the copy kept
        //   0/1/2/3  function with 0/1/2/3 arguments
        //   @  math operator (+-*%/^=!<{>}?); see cPar::evaluate()
        //
        char type;    // D/P/R/0/1/2/3/@ (see above)
        union {
            double d;           // D
            cPar *p;            // P/R
            MathFuncNoArg f0;   // 0
            MathFunc1Arg  f1;   // 1
            MathFunc2Args f2;   // 2
            MathFunc3Args f3;   // 3
            MathFunc4Args f4;   // 4
            char op;            // @, op = +-*/%^=!<{>}?
        };

        void operator=(int _i)            {type='D'; d=_i;  }

        void operator=(long _l)           {type='D'; d=_l;  }

        void operator=(double _d)         {type='D'; d=_d;  }

        void operator=(cPar *_p)          {type='P'; p=_p;  }

        void operator=(cPar& _r);         //{type='R'; p=(cPar *)_r.dup();} See after cPar!

        void operator=(MathFuncNoArg _f)  {type='0'; f0=_f;}

        void operator=(MathFunc1Arg  _f)  {type='1'; f1=_f;}

        void operator=(MathFunc2Args _f)  {type='2'; f2=_f;}

        void operator=(MathFunc3Args _f)  {type='3'; f3=_f;}

        void operator=(MathFunc4Args _f)  {type='4'; f4=_f;}

        void operator=(char _op)          {type='@'; op=_op;}
    };

  protected:
    static char *possibletypes;
  private:
    char typechar;     // S/B/L/D/F/T/X/C/P/O/I
    bool inputflag;
    bool changedflag;
    bool tkownership;
    opp_string promptstr; // prompt text used when the value is being input

    union {    // Take care of 'operator=()' when changing this!!!
       struct { bool sht; char *str;            } ls;   // S:long string
       struct { bool sht; char str[SHORTSTR+1]; } ss;   // S:short str
       struct { long val;                       } lng;  // L:long,B:bool
       struct { double val;                     } dbl;  // D:double
       struct { MathFunc f; int argc;
                double p1,p2,p3,p4;             } func; // F:math function
       struct { cStatistic *res;                } dtr;  // T:distribution
       struct { cDoubleExpression *expr;        } cexpr;// C:compiled expression
       struct { ExprElem *xelem; int n;         } expr; // X:expression
       struct { cPar *par;                      } ind;  // I:indirection
       struct { void *ptr;
                VoidDelFunc delfunc;
                VoidDupFunc dupfunc;
                size_t itemsize;                } ptr;  // P:void* pointer
       struct { cObject *obj;                   } obj;  // O:object pointer
       struct { cXMLElement *node;              } xmlp; // M:XML element pointer
    };

  private:
    // helper func: destruct old value
    void deleteold();

    // helper func: evaluates expression (X)
    double evaluate();

    // helper func: rand.num with given distr.(T)
    double fromstat();

    // setFromText() helper func.
    bool setfunction(char *w);

  protected:

    virtual void beforeChange();

    virtual void afterChange();

  public:

    cPar(const cPar& other);

    explicit cPar(const char *name=NULL);

    explicit cPar(const char *name, cPar& other);

    virtual ~cPar();

    cPar& operator=(const cPar& otherpar);


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

    virtual std::string info() const;

    virtual void writeContents(std::ostream& os);

    virtual void forEachChild(cVisitor *v);

    virtual void netPack(cCommBuffer *buffer);

    virtual void netUnpack(cCommBuffer *buffer);


    cPar& setBoolValue(bool b);

    cPar& setLongValue(long l);

    cPar& setStringValue(const char *s);

    cPar& setDoubleValue(double d);

    cPar& setDoubleValue(cStatistic *res);

    cPar& setDoubleValue(ExprElem *x, int n);

    cPar& setDoubleValue(cDoubleExpression *expr);

    cPar& setDoubleValue(MathFuncNoArg f);

    cPar& setDoubleValue(MathFunc1Arg  f, double p1);

    cPar& setDoubleValue(MathFunc2Args f, double p1, double p2);

    cPar& setDoubleValue(MathFunc3Args f, double p1, double p2, double p3);

    cPar& setDoubleValue(MathFunc4Args f, double p1, double p2, double p3, double p4);

    cPar& setPointerValue(void *ptr);

    cPar& setObjectValue(cObject *obj);

    cPar& setXMLValue(cXMLElement *node);

    void configPointer( VoidDelFunc delfunc, VoidDupFunc dupfunc, size_t itemsize=0);

    void takeOwnership(bool tk) {tkownership=tk;}

    bool takeOwnership() const   {return tkownership;}


    bool boolValue();

    long longValue();

    const char *stringValue();

    double doubleValue();

    void *pointerValue();

    cObject *objectValue();

    cXMLElement *xmlValue();


    cPar& setRedirection(cPar *par);

    bool isRedirected() const {return typechar=='I';}

    cPar *redirection();

    void cancelRedirection();


    char type() const;

    bool isNumeric() const;

    const char *prompt() ;

    void setPrompt(const char *s);

    void setInput(bool ip);

    bool isInput() const;

    bool changed();


    cPar& read();

    void convertToConst();

    bool equalsTo(cPar *par);


    virtual std::string getAsText() const;

    virtual bool setFromText(const char *text, char tp);


    cPar& operator=(bool b)          {return setBoolValue(b);}

    cPar& operator=(const char *s)   {return setStringValue(s);}

    cPar& operator=(char c)          {return setLongValue((long)c);}

    cPar& operator=(unsigned char c) {return setLongValue((long)c);}

    cPar& operator=(int i)           {return setLongValue((long)i);}

    cPar& operator=(unsigned int i)  {return setLongValue((long)i);}

    cPar& operator=(long l)          {return setLongValue(l);}

    cPar& operator=(unsigned long l) {return setLongValue((long)l);}

    cPar& operator=(double d)        {return setDoubleValue(d);}

    cPar& operator=(long double d)   {return setDoubleValue((double)d);}

    cPar& operator=(void *ptr)       {return setPointerValue(ptr);}

    cPar& operator=(cObject *obj)    {return setObjectValue(obj);}

    cPar& operator=(cXMLElement *node) {return setXMLValue(node);}

    operator bool()          {return boolValue();}

    operator const char *()  {return stringValue();}

    operator char()          {return (char)longValue();}

    operator unsigned char() {return (unsigned char)longValue();}

    operator int()           {return (int)longValue();}

    operator unsigned int()  {return (unsigned int)longValue();}

    operator long()          {return longValue();}

    operator unsigned long() {return longValue();}

    operator double()        {return doubleValue();}

    operator long double()   {return doubleValue();}

    operator void *()        {return pointerValue();}

    operator cObject *()     {return objectValue();}

    operator cXMLElement *() {return xmlValue();}



    static int cmpbyvalue(cObject *one, cObject *other);
};

// this function cannot be defined within ExprElem because of declaration order
inline void cPar::ExprElem::operator=(cPar& _r)  {type='R'; p=(cPar *)_r.dup();}

//==========================================================================

class SIM_API cModulePar : public cPar
{
    friend class cModule;
  private:
    cModule *omodp;              // owner module

  private:
    // helper function
    void _construct();

  public:

    cModulePar(const cPar& other);

    explicit cModulePar(const char *name=NULL);

    explicit cModulePar(const char *name, cPar& other);

    virtual ~cModulePar();

    cModulePar& operator=(const cModulePar& otherpar);


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

    virtual std::string fullPath() const;

    virtual const char *fullPath(char *buffer, int bufsize) const;


    void setOwnerModule(cModule *om)   {omodp=om;}

    cModule *ownerModule() const        {return omodp;}
};

inline std::ostream& operator<< (std::ostream& os, const cPar& o) {
    return os << o.getAsText();
}

inline std::ostream& operator<< (std::ostream& os, cPar& o) {
    return os << o.getAsText();
}


//=== operators dealing with cPars
//
// These operators were removed -- see ChangeLog, Jan 17 2000 entry.
//

//#ifndef NO_CPAR_OPERATIONS
//#ifdef  LONG_CPAR_OPERATIONS
// inline int operator<(cPar& p, cPar& q)  {return (long)p<(long)q;}
// inline int operator<(long d, cPar& p)   {return d<(long)p;}
// inline int operator<(cPar& p, long d)   {return (long)p<d;}
// inline int operator>(cPar& p, cPar& q)  {return (long)p>(long)q;}
// inline int operator>(long d, cPar& p)   {return d>(long)p;}
// inline int operator>(cPar& p, long d)   {return (long)p>d;}
//
// inline int operator<=(cPar& p, cPar& q) {return (long)p<=(long)q;}
// inline int operator<=(long d, cPar& p)  {return d<=(long)p;}
// inline int operator<=(cPar& p, long d)  {return (long)p<=d;}
// inline int operator>=(cPar& p, cPar& q) {return (long)p>=(long)q;}
// inline int operator>=(long d, cPar& p)  {return d>=(long)p;}
// inline int operator>=(cPar& p, long d)  {return (long)p>=d;}
//
// inline long operator+(cPar& p, cPar& q) {return (long)p+(long)q;}
// inline long operator+(long d, cPar& p)  {return d+(long)p;}
// inline long operator+(cPar& p, long d)  {return (long)p+d;}
// inline long operator-(cPar& p, cPar& q) {return (long)p-(long)q;}
// inline long operator-(long d, cPar& p)  {return d-(long)p;}
// inline long operator-(cPar& p, long d)  {return (long)p-d;}
//
// inline long operator*(cPar& p, cPar& q)  {return (long)p*(long)q;}
// inline long operator*(long d, cPar& p)   {return d*(long)p;}
// inline long operator*(cPar& p, long d)   {return (long)p*d;}
// inline long operator/(cPar& p, cPar& q)  {return (long)p/(long)q;}
// inline long operator/(long d, cPar& p)   {return d/(long)p;}
// inline long operator/(cPar& p, long d)   {return (long)p/d;}
//
//#else
//
// inline int operator<(cPar& p, cPar& q)  {return (double)p<(double)q;}
// inline int operator<(double d, cPar& p) {return d<(double)p;}
// inline int operator<(cPar& p, double d) {return (double)p<d;}
// inline int operator>(cPar& p, cPar& q)  {return (double)p>(double)q;}
// inline int operator>(double d, cPar& p) {return d>(double)p;}
// inline int operator>(cPar& p, double d) {return (double)p>d;}
//
// inline int operator<=(cPar& p, cPar& q)  {return (double)p<=(double)q;}
// inline int operator<=(double d, cPar& p) {return d<=(double)p;}
// inline int operator<=(cPar& p, double d) {return (double)p<=d;}
// inline int operator>=(cPar& p, cPar& q)  {return (double)p>=(double)q;}
// inline int operator>=(double d, cPar& p) {return d>=(double)p;}
// inline int operator>=(cPar& p, double d) {return (double)p>=d;}
//
// inline double operator+(cPar& p, cPar& q)  {return (double)p+(double)q;}
// inline double operator+(double d, cPar& p) {return d+(double)p;}
// inline double operator+(cPar& p, double d) {return (double)p+d;}
// inline double operator-(cPar& p, cPar& q)  {return (double)p-(double)q;}
// inline double operator-(double d, cPar& p) {return d-(double)p;}
// inline double operator-(cPar& p, double d) {return (double)p-d;}
//
// inline double operator*(cPar& p, cPar& q)  {return (double)p*(double)q;}
// inline double operator*(double d, cPar& p) {return d*(double)p;}
// inline double operator*(cPar& p, double d) {return (double)p*d;}
// inline double operator/(cPar& p, cPar& q)  {return (double)p/(double)q;}
// inline double operator/(double d, cPar& p) {return d/(double)p;}
// inline double operator/(cPar& p, double d) {return (double)p/d;}
//#endif
//#endif

#endif

---