cvalue.h

//==========================================================================
//   CVALUE.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_CVALUE_H
#define __OMNETPP_CVALUE_H
 
#include <string>
#include "simkerneldefs.h"
#include "cexception.h"
#include "opp_string.h"
#include "opp_pooledstring.h"
#include "any_ptr.h"
#include "simutil.h"
 
namespace omnetpp {
 
class cPar;
class cXMLElement;
class cDynamicExpression;
 
class SIM_API cValue
{
    friend class cDynamicExpression;
  public:
    // Note: char codes need to be present and be consistent with cNedFunction::getArgTypes()!
    enum Type {
        UNDEF = 0,
        BOOL = 'B',
        INT = 'L',
        DOUBLE = 'D',
        STRING = 'S',
        POINTER = 'O',
        OBJECT OPP_DEPRECATED_ENUMERATOR("and use cValue::containsObject()") = POINTER,
        XML OPP_DEPRECATED_ENUMERATOR("and use cValue::containsXml()") = POINTER,
        DBL OPP_DEPRECATED_ENUMERATOR("renamed to DOUBLE") = DOUBLE,
        STR OPP_DEPRECATED_ENUMERATOR("renamed to STRING") = STRING
    };
    Type type;
 
  private:
    bool bl;
    intval_t intv;
    double dbl;
    opp_staticpooledstring unit = nullptr; // for INT/DOUBLE; may be nullptr
    std::string s;
    any_ptr ptr;
    static const char *OVERFLOW_MSG;
 
  private:
#ifdef NDEBUG
    void assertType(Type) const {}
#else
    void assertType(Type t) const {if (type!=t) cannotCastError(t);}
#endif
    [[noreturn]] void cannotCastError(Type t) const;
  public:
    // internal, for inspectors only:
    static cObject *getContainedObject(const cValue *p);
 
  public:
    cValue()  {type=UNDEF;}
    cValue(bool b)  {set(b);}
    cValue(int l)  {set((intval_t)l);}
    cValue(int l, const char *unit)  {set((intval_t)l, unit);}
    cValue(intval_t l)  {set(l);}
    cValue(intval_t l, const char *unit)  {set(l, unit);}
    cValue(double d)  {set(d);}
    cValue(double d, const char *unit)  {set(d,unit);}
    cValue(const char *s)  {set(s);}
    cValue(const std::string& s)  {set(s);}
    cValue(const opp_string& s)  {set(s);}
    cValue(any_ptr ptr)  {set(ptr);}
    cValue(cObject *obj)  {set(obj);}
    cValue(const void *) = delete; // prevent non-cObject pointers from silently being converted to bool
    cValue(const cValue&) = default;
 
    void operator=(const cValue& other);
 
    Type getType() const  {return type;}
 
    const char *getTypeName() const  {return getTypeName(type);}
 
    static const char *getTypeName(Type t);
 
    bool isNumeric() const {return type==DOUBLE || type==INT;}
 
    bool isSet() const  {return type!=UNDEF;}
 
    std::string str() const;
 
    bool operator==(const cValue& other);
 
    static double convertUnit(double d, const char *unit, const char *targetUnit);
 
    static double parseQuantity(const char *str, const char *expectedUnit=nullptr);
 
    static double parseQuantity(const char *str, std::string& outActualUnit);
 
 
    void set(bool b) {type=BOOL; bl=b;}
 
    void set(intval_t l, const char *unit=nullptr) {type=INT; intv=l; this->unit=unit;}
 
    void set(int l, const char *unit=nullptr) {set((intval_t)l, unit);}
 
    void set(double d, const char *unit=nullptr) {type=DOUBLE; dbl=d; this->unit=unit;}
 
    void setPreservingUnit(intval_t l) {assertType(INT); intv=l;}
 
    void setPreservingUnit(double d) {assertType(DOUBLE); dbl=d;}
 
    void setUnit(const char *unit);
 
    void convertTo(const char *unit);
 
    void convertToDouble();
 
    void set(const char *s) {type=STRING; this->s=s?s:"";}
 
    void set(const std::string& s) {type=STRING; this->s=s;}
 
    void set(const opp_string& s) {type=STRING; this->s=s.c_str();}
 
    void set(any_ptr ptr) {type=POINTER; this->ptr=ptr;}
 
    void set(cObject *obj) {set(toAnyPtr(obj));}
 
    void set(const void *) = delete;
 
 
    bool boolValue() const {assertType(BOOL); return bl;}
 
    intval_t intValue() const;
 
    intval_t intValueRaw() const;
 
    intval_t intValueInUnit(const char *targetUnit) const;
 
    double doubleValue() const;
 
    double doubleValueRaw() const;
 
    double doubleValueInUnit(const char *targetUnit) const;
 
    const char *getUnit() const {return (type==DOUBLE || type==INT) ? unit.c_str() : nullptr;}
 
    const char *stringValue() const {assertType(STRING); return s.c_str();}
 
    const std::string& stdstringValue() const {assertType(STRING); return s;}
 
    any_ptr pointerValue() const {assertType(POINTER); return ptr;}
 
    bool isNullptr() const {return type==cValue::POINTER && ptr == nullptr;}
 
    bool containsObject() const;
 
    bool containsXML() const;
 
    cObject *objectValue() const;
 
    cXMLElement *xmlValue() const;
 
 
    cValue& operator=(bool b)  {set(b); return *this;}
 
    cValue& operator=(char c)  {set((intval_t)c); return *this;}
 
    cValue& operator=(unsigned char c)  {set((intval_t)c); return *this;}
 
    cValue& operator=(short i)  {set((intval_t)i); return *this;}
 
    cValue& operator=(unsigned short i)  {set((intval_t)i); return *this;}
 
    cValue& operator=(int i)  {set((intval_t)i); return *this;}
 
    cValue& operator=(unsigned int i)  {set((intval_t)i); return *this;}
 
    cValue& operator=(long l)  {set((intval_t)l); return *this;}
 
    cValue& operator=(unsigned long l) {set(checked_int_cast<intval_t>(l, OVERFLOW_MSG)); return *this;}
 
    cValue& operator=(long long l)  {set(checked_int_cast<intval_t>(l, OVERFLOW_MSG)); return *this;}
 
    cValue& operator=(unsigned long long l) {set(checked_int_cast<intval_t>(l, OVERFLOW_MSG)); return *this;}
 
    cValue& operator=(double d)  {set(d); return *this;}
 
    cValue& operator=(long double d)  {set((double)d); return *this;}
 
    cValue& operator=(const char *s)  {set(s); return *this;}
 
    cValue& operator=(const std::string& s)  {set(s); return *this;}
 
    cValue& operator=(any_ptr ptr)  {set(ptr); return *this;}
 
    cValue& operator=(cObject *obj)  {set(obj); return *this;}
 
    operator bool() const  {return boolValue();}
 
    operator char() const  {return checked_int_cast<char>(intValue(), OVERFLOW_MSG);}
 
    operator unsigned char() const  {return checked_int_cast<unsigned char>(intValue(), OVERFLOW_MSG);}
 
    operator int() const  {return checked_int_cast<int>(intValue(), OVERFLOW_MSG);}
 
    operator unsigned int() const  {return checked_int_cast<unsigned int>(intValue(), OVERFLOW_MSG);}
 
    operator short() const  {return checked_int_cast<short>(intValue(), OVERFLOW_MSG);}
 
    operator unsigned short() const  {return checked_int_cast<unsigned short>(intValue(), OVERFLOW_MSG);}
 
    operator long() const  {return checked_int_cast<long>(intValue(), OVERFLOW_MSG);}
 
    operator unsigned long() const  {return checked_int_cast<unsigned long>(intValue(), OVERFLOW_MSG);}
 
    operator long long() const  {return checked_int_cast<long long>(intValue(), OVERFLOW_MSG);}
 
    operator unsigned long long() const  {return checked_int_cast<unsigned long long>(intValue(), OVERFLOW_MSG);}
 
    operator double() const  {return doubleValue();}
 
    operator long double() const  {return doubleValue();}
 
    operator const char *() const  {return stringValue();}
 
    operator std::string() const  {return stdstringValue();}
 
    operator any_ptr() const  {return pointerValue();}
 
    operator cObject *() const  {return objectValue();}
 
    operator cXMLElement *() const  {return xmlValue();}
};
 
// cNedValue was renamed cValue in OMNeT++ 6.0; typedef added for compatibility
typedef cValue cNedValue;
typedef cValue cNEDValue;
 
}  // namespace omnetpp
 
#endif