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 "simutil.h"

namespace omnetpp {

class cParImpl;
class cExpression;
class cXMLElement;
class cProperties;
class cComponent;

class SIM_API cPar : public cObject
{
    friend class cComponent;
  public:
    enum Type {
        BOOL = 'B',
        DOUBLE = 'D',
        INT = 'L',
        STRING = 'S',
        XML = 'X',
        LONG = INT // for backward compatibility
    };

  private:
    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();
    // internal: called each time after the value of this object changes.
    void afterChange();

  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 isExpression() const;

    bool isShared() const;

    bool isSet() const;

    bool containsValue() const;

    cProperties *getProperties() const;


    cPar& setBoolValue(bool b);

    cPar& setIntValue(intpar_t l);

    _OPPDEPRECATED cPar& setLongValue(intpar_t l) {return setIntValue(l);}

    cPar& setDoubleValue(double d);

    cPar& setStringValue(const char *s);

    cPar& setStringValue(const std::string& s)  {setStringValue(s.c_str()); return *this;}

    cPar& setXMLValue(cXMLElement *node);

    cPar& setExpression(cExpression *e, cComponent *evalcontext=nullptr);

    void setEvaluationContext(cComponent *ctx)  {evalContext = ctx;}


    bool boolValue() const;

    intpar_t intValue() const;

    _OPPDEPRECATED intpar_t longValue() const {return intValue();}

    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();}

    cXMLElement *xmlValue() const;

    cExpression *getExpression() const;

    cComponent *getEvaluationContext() const  {return evalContext;}

    void convertToConst();

    void parse(const char *text);


    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<intpar_t>(i, this));}

    cPar& operator=(long long i)  {return setIntValue(checked_int_cast<intpar_t>(i, this));}

    cPar& operator=(unsigned long long i)  {return setIntValue(checked_int_cast<intpar_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=(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 cXMLElement *() const  {return xmlValue();}
};

}  // namespace omnetpp


#endif