cmsgpar.h

//==========================================================================
//   CMSGPAR.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_CMSGPAR_H
#define __OMNETPP_CMSGPAR_H

#include "cownedobject.h"
#include "cnedmathfunction.h"

namespace omnetpp {

class  cStatistic;
class  cXMLElement;


class SIM_API cMsgPar : public cOwnedObject
{
  public:
    typedef void (*VoidDelFunc)(void *);

    typedef void *(*VoidDupFunc)(void *);

  protected:
    static const char *possibleTypes;

  private:
    enum { SHORTSTR_MAXLEN = 27 };

    char typeChar;     // S/B/L/D/F/T/P/O
    bool changedFlag;
    bool takeOwnership;

    union {
       struct { bool sht; char *str;  } ls;   // S:long string
       struct { bool sht; char str[SHORTSTR_MAXLEN+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 { void *ptr;
                VoidDelFunc delfunc;
                VoidDupFunc dupfunc;
                size_t itemsize;      } ptr;  // P:void* pointer
       struct { cOwnedObject *obj;    } obj;  // O:object pointer
       struct { cXMLElement *node;    } xmlp; // M:XML element pointer
    };

  private:
    void copy(const cMsgPar& other);

    // helper func: destruct old value
    void deleteOld();

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

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

  protected:

    virtual void beforeChange();

    virtual void afterChange();

  public:

    cMsgPar(const cMsgPar& other);

    explicit cMsgPar(const char *name=nullptr);

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

    virtual ~cMsgPar();

    cMsgPar& operator=(const cMsgPar& otherpar);


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

    virtual std::string str() const override;

    virtual void forEachChild(cVisitor *v) override;

    virtual void parsimPack(cCommBuffer *buffer) const override;

    virtual void parsimUnpack(cCommBuffer *buffer) override;


    cMsgPar& setBoolValue(bool b);

    cMsgPar& setLongValue(long l);

    cMsgPar& setStringValue(const char *s);

    cMsgPar& setDoubleValue(double d);

    cMsgPar& setDoubleValue(cStatistic *res);

    cMsgPar& setDoubleValue(MathFuncNoArg f);

    cMsgPar& setDoubleValue(MathFunc1Arg  f, double p1);

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

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

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

    cMsgPar& setPointerValue(void *ptr);

    cMsgPar& setObjectValue(cOwnedObject *obj);

    cMsgPar& setXMLValue(cXMLElement *node);

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

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

    bool getTakeOwnership() const   {return takeOwnership;}


    bool boolValue();

    long longValue();

    const char *stringValue();

    double doubleValue();

    void *pointerValue();

    cOwnedObject *getObjectValue();

    cXMLElement *xmlValue();


    char getType() const;

    bool isNumeric() const;

    bool isConstant() const;

    bool hasChanged();

    void convertToConst();

    bool equalsTo(cMsgPar *par);

    virtual bool parse(const char *text, char type='?');


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

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

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

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

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

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

    cMsgPar& operator=(short i)  {return setLongValue((long)i);}

    cMsgPar& operator=(unsigned short i)  {return setLongValue((long)i);}

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

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

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

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

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

    cMsgPar& operator=(cOwnedObject *obj)  {return setObjectValue(obj);}

    cMsgPar& 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 short()  {return (short)longValue();}

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

    operator long()  {return longValue();}

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

    operator double()  {return doubleValue();}

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

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

    operator cOwnedObject *()  {return getObjectValue();}

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

}  // namespace omnetpp


#endif