cnedvalue.h

//==========================================================================
//   CNEDVALUE.H  - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//  Author: Andras Varga
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CNEDVALUE_H
#define __CNEDVALUE_H

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

NAMESPACE_BEGIN

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', DBL='D', STR='S', XML='X'} type;

  private:
    bool bl;
    double dbl;
    const char *dblunit; // string constants or pooled strings; may be NULL
    std::string s;
    cXMLElement *xml;

  private:
#ifdef NDEBUG
    void assertType(Type) const {}
#else
    void assertType(Type t) const {if (type!=t) cannotCastError(t);}
#endif
    void cannotCastError(Type t) const;

  public:
    cNEDValue()  {type=UNDEF;}
    cNEDValue(bool b)  {set(b);}
    cNEDValue(long l)  {set(l);}
    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==DBL;}

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

    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(long l) {type=DBL; dbl=l; dblunit=NULL;}

    void set(double d, const char *unit=NULL) {type=DBL; dbl=d; dblunit=unit;}

    void setPreservingUnit(double d) {assertType(DBL); dbl=d;}

    void setUnit(const char *unit) {assertType(DBL); dblunit=unit;}

    void convertTo(const char *unit);

    void set(const char *s) {type=STR; this->s=s?s:"";}

    void set(const std::string& s) {type=STR; this->s=s;}

    void set(cXMLElement *x) {type=XML; xml=x;}

    void set(const cPar& par);


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

    long longValue() const {assertType(DBL); return (long)dbl;}

    double doubleValue() const {assertType(DBL); return dbl;}

    double doubleValueInUnit(const char *unit) const {return convertUnit(dbl, dblunit, unit);}

    const char *getUnit() const {assertType(DBL); return dblunit;}

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

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

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


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

    cNEDValue& operator=(char c)  {set((long)c); return *this;}

    cNEDValue& operator=(unsigned char c)  {set((long)c); return *this;}

    cNEDValue& operator=(int i)  {set((long)i); return *this;}

    cNEDValue& operator=(unsigned int i)  {set((long)i); return *this;}

    cNEDValue& operator=(short i)  {set((long)i); return *this;}

    cNEDValue& operator=(unsigned short i)  {set((long)i); return *this;}

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

    cNEDValue& operator=(unsigned long l) {set((long)l); 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 (char)longValue();}

    operator unsigned char() const  {return (unsigned char)longValue();}

    operator int() const  {return (int)longValue();}

    operator unsigned int() const  {return (unsigned int)longValue();}

    operator short() const  {return (short)longValue();}

    operator unsigned short() const  {return (unsigned short)longValue();}

    operator long() const  {return longValue();}

    operator unsigned long() const  {return longValue();}

    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_END

#endif