cparimpl.h

//==========================================================================
//   CPARIMPL.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_CPARIMPL_H
#define __OMNETPP_CPARIMPL_H
 
#include "cpar.h"
#include "cexpression.h"
#include "cexception.h"
#include "fileline.h"
#include "opp_pooledstring.h"
 
namespace omnetpp {
 
class cExpression;
class cXMLElement;
class cProperties;
class cComponent;
 
namespace internal {
 
class SIM_API cParImpl : public cNamedObject
{
  protected:
    // various flags, stored in cNamedObject::flags
    enum {
      FL_ISVOLATILE = 4,  // whether it was declared as "volatile" in NED
      FL_ISEXPR = 8,      // whether it stores a constant or an expression
      FL_ISSHARED = 16,   // used by cPar only: whether this object is shared among multiple cPars
      FL_CONTAINSVALUE = 32, // whether it has a value
      FL_ISSET = 64,      // whether the contained value is just a default value (false) or the set value (true)
      FL_ISMUTABLE = 128  // whether it was declared as "mutable" in NED
    };
 
  private:
    // unit (s, mW, GHz, baud, etc); optional
    opp_staticpooledstring unit = nullptr;
 
    // base directory for interpreting relative path names in the expression (e.g. xmldoc())
    opp_staticpooledstring baseDirectory = nullptr;
 
    // global variables for statistics
    static long totalParimplObjs;
    static long liveParimplObjs;
 
  private:
    void copy(const cParImpl& other);
 
  public:
    typedef cPar::Type Type;
 
  protected:
    cValue evaluate(cExpression *expr, cComponent *context) const;
 
  public:
 
    explicit cParImpl();
 
    cParImpl(const cParImpl& other) : cNamedObject(other) {copy(other);}
 
    virtual ~cParImpl();
 
    cParImpl& operator=(const cParImpl& otherpar);
 
    virtual cParImpl *dup() const override;
 
    virtual void parsimPack(cCommBuffer *buffer) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
    virtual Type getType() const = 0;
 
    virtual bool isNumeric() const = 0;
 
    virtual bool isVolatile() const {return flags & FL_ISVOLATILE;}
 
    virtual bool isMutable() const {return flags & FL_ISMUTABLE;}
 
    virtual bool isExpression() const {return flags & FL_ISEXPR;}
 
    virtual bool isShared() const {return flags & FL_ISSHARED;}
 
    virtual bool containsValue() const  {return flags & FL_CONTAINSVALUE;}
 
    virtual bool isSet() const {return flags & FL_ISSET;}
 
    virtual void setIsVolatile(bool f) {setFlag(FL_ISVOLATILE,f);}
 
    virtual void setIsMutable(bool f) {setFlag(FL_ISMUTABLE,f);}
 
    virtual void setIsShared(bool f) {setFlag(FL_ISSHARED,f);}
 
    virtual void setIsSet(bool f) {setFlag(FL_ISSET,f);}
 
    virtual const char *getUnit() const {return unit.c_str();}
 
    virtual void setUnit(const char *s) {unit = s;}
 
    virtual const char *getBaseDirectory() const {return baseDirectory.c_str();}
 
    virtual void setBaseDirectory(const char *s) {baseDirectory = s;}
 
 
    virtual void setBoolValue(bool b) = 0;
 
    virtual void setIntValue(intval_t l) = 0;
 
    virtual void setDoubleValue(double d) = 0;
 
    virtual void setStringValue(const char *s) = 0;
 
    virtual void setStringValue(const std::string& s)  {setStringValue(s.c_str());}
 
    virtual void setObjectValue(cObject *object) = 0;
 
    virtual void setXMLValue(cXMLElement *node) = 0;
 
    virtual void setExpression(cExpression *e) = 0;
 
 
    virtual bool boolValue(cComponent *context) const = 0;
 
    virtual intval_t intValue(cComponent *context) const = 0;
 
    virtual double doubleValue(cComponent *context) const = 0;
 
    virtual const char *stringValue(cComponent *context) const = 0;
 
    virtual std::string stdstringValue(cComponent *context) const = 0;
 
    virtual cObject *objectValue(cComponent *context) const = 0;
 
    virtual cXMLElement *xmlValue(cComponent *context) const = 0;
 
    virtual cExpression *getExpression() const = 0;
 
 
    virtual void convertToConst(cComponent *context) = 0;
 
    virtual void parse(const char *text, FileLine loc) = 0;
 
    static cParImpl *createWithType(Type type);
 
    virtual int compare(const cParImpl *other) const;
 
    virtual void forEachChild(cVisitor *v, cComponent *context) {}
 
    using cObject::forEachChild;
 
    static long getTotalParImplObjectCount() {return totalParimplObjs;}
 
    static long getLiveParImplObjectCount() {return liveParimplObjs;}
 
    static void resetParImplObjectCounters()  {totalParimplObjs=liveParimplObjs=0L;}
};
 
}  // namespace internal
}  // namespace omnetpp
 
 
#endif