cnedvalue.h

//==========================================================================
//   CNEDVALUE.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_CNEDVALUE_H
#define __OMNETPP_CNEDVALUE_H

#include <string>
#include "simkerneldefs.h"
#include "cexception.h"
#include "simutil.h"

namespace omnetpp {

class cPar;
class cXMLElement;
class cDynamicExpression;

class SIM_API cNedValue
{
    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', XML='X', DBL=DOUBLE, STR=STRING} type;

  private:
    bool bl;
    intpar_t intv;
    double dbl;
    const char *unit; // for INT/DOUBLE; must point to string constant or pooled string; may be nullptr
    std::string s;
    cXMLElement *xml;
    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:
    cNedValue()  {type=UNDEF;}
    cNedValue(bool b)  {set(b);}
    cNedValue(int l)  {set((intpar_t)l);}
    cNedValue(int l, const char *unit)  {set((intpar_t)l, unit);}
    cNedValue(intpar_t l)  {set(l);}
    cNedValue(intpar_t l, const char *unit)  {set(l, unit);}
    cNedValue(double d)  {set(d);}
    cNedValue(double d, const char *unit)  {set(d,unit);}
    cNedValue(const char *s)  {set(s);}
    cNedValue(const std::string& s)  {set(s);}
    cNedValue(cXMLElement *x)  {set(x);}
    cNedValue(const cPar& par) {set(par);}

    void operator=(const cNedValue& other);

    Type getType() const  {return 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;

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

    static const char *getPooled(const char *s);


    void set(bool b) {type=BOOL; bl=b;}

    void set(intpar_t l, const char *unit=nullptr) {type=INT; intv=l; this->unit=unit;}

    void set(int l, const char *unit=nullptr) {set((intpar_t)l, unit);}

    void set(double d, const char *unit=nullptr) {type=DOUBLE; dbl=d; this->unit=unit;}

    void setPreservingUnit(intpar_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(cXMLElement *x) {type=XML; xml=x;}

    void set(const cPar& par);


    bool boolValue() const {assertType(BOOL); return bl;}

    intpar_t intValue() const;

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

    intpar_t intValueInUnit(const char *targetUnit) const;

    double doubleValue() const;

    double doubleValueInUnit(const char *targetUnit) const;

    const char *getUnit() const {return (type==DOUBLE || type==INT) ? unit : nullptr;}

    const char *stringValue() const {assertType(STRING); return s.c_str();}

    const std::string& stdstringValue() const {assertType(STRING); return s;}

    cXMLElement *xmlValue() const {assertType(XML); return xml;}


    cNedValue& operator=(bool b)  {set(b); return *this;}

    cNedValue& operator=(char c)  {set((intpar_t)c); return *this;}

    cNedValue& operator=(unsigned char c)  {set((intpar_t)c); return *this;}

    cNedValue& operator=(short i)  {set((intpar_t)i); return *this;}

    cNedValue& operator=(unsigned short i)  {set((intpar_t)i); return *this;}

    cNedValue& operator=(int i)  {set((intpar_t)i); return *this;}

    cNedValue& operator=(unsigned int i)  {set((intpar_t)i); return *this;}

    cNedValue& operator=(long l)  {set((intpar_t)l); return *this;}

    cNedValue& operator=(unsigned long l) {set(checked_int_cast<intpar_t>(l, OVERFLOW_MSG)); return *this;}

    cNedValue& operator=(long long l)  {set(checked_int_cast<intpar_t>(l, OVERFLOW_MSG)); return *this;}

    cNedValue& operator=(unsigned long long l) {set(checked_int_cast<intpar_t>(l, OVERFLOW_MSG)); return *this;}

    cNedValue& operator=(double d)  {set(d); return *this;}

    cNedValue& operator=(long double d)  {set((double)d); return *this;}

    cNedValue& operator=(const char *s)  {set(s); return *this;}

    cNedValue& operator=(const std::string& s)  {set(s); return *this;}

    cNedValue& operator=(cXMLElement *node)  {set(node); return *this;}

    cNedValue& operator=(const cPar& par)  {set(par); 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 cXMLElement *() const  {return xmlValue();}
};

// cNEDValue was renamed cNedValue in OMNeT++ 5.3; typedef added for compatibility
typedef cNedValue cNEDValue;

}  // namespace omnetpp

#endif