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 = 'L';     // S/B/L/D/F/T/P/O
    bool changedFlag = false;
    bool takeOwnership = false;
 
    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