cpar.h

//==========================================================================
//   CPAR.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_CPAR_H
#define __OMNETPP_CPAR_H
 
#include "cownedobject.h"
#include "cexpression.h"
#include "cexception.h"
#include "fileline.h"
 
namespace omnetpp {
 
class cExpression;
class cXMLElement;
class cProperties;
class cComponent;
class cValue;
 
namespace internal { class cParImpl; }
 
class SIM_API cPar : public cObject
{
    friend class cComponent;
  public:
    enum Type {
        BOOL = 'B',
        DOUBLE = 'D',
        INT = 'L',
        STRING = 'S',
        OBJECT = 'O',
        XML = 'X',
        LONG = INT // for backward compatibility
    };
 
  private:
    typedef internal::cParImpl cParImpl;
    cComponent *ownerComponent;
    cParImpl *p;
    cComponent *evalContext;
 
  private:
    // private constructor and destructor -- only cComponent is allowed to create parameters
    cPar() {ownerComponent = evalContext = nullptr; p = nullptr;}
    virtual ~cPar();
    // internal, called from cComponent
    void init(cComponent *ownercomponent, cParImpl *p);
    // internal
    void moveto(cPar& other);
    // internal: called each time before the value of this object changes.
    void beforeChange(bool isInternalChange=false);
    // internal: called each time after the value of this object changes.
    void afterChange();
    // internal: replace expression with the value it evaluates to
    void doConvertToConst(bool isInternalChange=true);
 
 
  public:
    // internal, used by cComponent::finalizeParameters()
    void read();
    // internal, used by cComponent::finalizeParameters()
    void finalize();
    // internal: applies the default value if there is one
    void acceptDefault();
    // internal
    void setImpl(cParImpl *p);
    // internal
    cParImpl *impl() const {return p;}
    // internal
    cParImpl *copyIfShared();
 
#ifdef SIMFRONTEND_SUPPORT
    // internal
    virtual bool hasChangedSince(int64_t lastRefreshSerial);
#endif
 
  public:
    void operator=(const cPar& other);
 
    virtual const char *getName() const override;
 
    virtual std::string str() const override;
 
    virtual cObject *getOwner() const override; // note: cannot return cComponent* (covariant return type) due to declaration order
 
    virtual void forEachChild(cVisitor *v) override;
 
    Type getType() const;
 
    static const char *getTypeName(Type t);
 
    bool isNumeric() const;
 
    bool isVolatile() const;
 
    bool isMutable() const;
 
    bool isExpression() const;
 
    bool isShared() const;
 
    bool isSet() const;
 
    bool containsValue() const;
 
    cProperties *getProperties() const;
 
    cComponent *getOwnerComponent() const { return ownerComponent;}
 
    virtual const char *getBaseDirectory() const;
 
    virtual std::string getSourceLocation() const;
 
 
    cPar& setBoolValue(bool b);
 
    cPar& setIntValue(intval_t l);
 
    cPar& setDoubleValue(double d);
 
    cPar& setStringValue(const char *s);
 
    cPar& setStringValue(const std::string& s)  {setStringValue(s.c_str()); return *this;}
 
    cPar& setObjectValue(cObject *object);
 
    cPar& setXMLValue(cXMLElement *node);
 
    cPar& setValue(const cValue& value);
 
    cPar& setExpression(cExpression *e, cComponent *evalcontext=nullptr);
 
    void setEvaluationContext(cComponent *ctx)  {evalContext = ctx;}
 
 
    bool boolValue() const;
 
    intval_t intValue() const;
 
    double doubleValue() const;
 
    double doubleValueInUnit(const char *targetUnit) const;
 
    const char *getUnit() const;
 
    const char *stringValue() const;
 
    std::string stdstringValue() const;
 
    bool isEmptyString() const {return stdstringValue().empty();}
 
    cObject *objectValue() const;
 
    cXMLElement *xmlValue() const;
 
    cValue getValue() const;
 
    cExpression *getExpression() const;
 
    cComponent *getEvaluationContext() const  {return evalContext;}
 
    void convertToConst() {doConvertToConst(false);}
 
    void parse(const char *text, const char *baseDirectory=nullptr, FileLine loc=FileLine(), bool resetEvalContext=true);
 
 
    cPar& operator=(bool b)  {return setBoolValue(b);}
 
    cPar& operator=(char c)  {return setIntValue(c);}
 
    cPar& operator=(unsigned char c)  {return setIntValue(c);}
 
    cPar& operator=(int i)  {return setIntValue(i);}
 
    cPar& operator=(unsigned int i)  {return setIntValue(i);}
 
    cPar& operator=(short i)  {return setIntValue(i);}
 
    cPar& operator=(unsigned short i)  {return setIntValue(i);}
 
    cPar& operator=(long i)  {return setIntValue(i);}
 
    cPar& operator=(unsigned long i) {return setIntValue(checked_int_cast<intval_t>(i, this));}
 
    cPar& operator=(long long i)  {return setIntValue(checked_int_cast<intval_t>(i, this));}
 
    cPar& operator=(unsigned long long i)  {return setIntValue(checked_int_cast<intval_t>(i, this));}
 
    cPar& operator=(double d)  {return setDoubleValue(d);}
 
    cPar& operator=(long double d)  {return setDoubleValue((double)d);}
 
    cPar& operator=(const char *s)  {return setStringValue(s);}
 
    cPar& operator=(const std::string& s)  {return setStringValue(s);}
 
    cPar& operator=(cObject *object)  {return setObjectValue(object);}
 
    cPar& operator=(cXMLElement *node)  {return setXMLValue(node);}
 
    operator bool() const  {return boolValue();}
 
    operator char() const  {return checked_int_cast<char>(intValue(), this);}
 
    operator unsigned char() const  {return checked_int_cast<unsigned char>(intValue(), this);}
 
    operator int() const  {return checked_int_cast<int>(intValue(), this);}
 
    operator unsigned int() const  {return checked_int_cast<unsigned int>(intValue(), this);}
 
    operator short() const  {return checked_int_cast<short>(intValue(), this);}
 
    operator unsigned short() const  {return checked_int_cast<unsigned short>(intValue(), this);}
 
    operator long() const  {return checked_int_cast<long>(intValue(), this);}
 
    operator unsigned long() const  {return checked_int_cast<unsigned long>(intValue(), this);}
 
    operator long long() const  {return checked_int_cast<long long>(intValue(), this);}
 
    operator unsigned long long() const  {return checked_int_cast<unsigned long long>(intValue(), this);}
 
    operator double() const  {return doubleValue();}
 
    operator long double() const  {return doubleValue();}
 
    operator const char *() const  {return stringValue();}
 
    operator std::string() const  {return stdstringValue();}
 
    operator cObject *() const  {return objectValue();}
 
    operator cXMLElement *() const  {return xmlValue();}
};
 
}  // namespace omnetpp
 
 
#endif