cpar.h

//==========================================================================
//   CPAR.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 __CPAR_H
#define __CPAR_H

#include "cownedobject.h"
#include "cexpression.h"
#include "cexception.h"

NAMESPACE_BEGIN

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',
        LONG = 'L',
        STRING = 'S',
        XML = 'X'
    };

  private:
    cComponent *ownercomponent;
    cParImpl *p;
    cComponent *evalcontext;

  private:
    // private constructor -- only cComponent is allowed to create parameters
    cPar() {ownercomponent = evalcontext = NULL; p = NULL;}
    // 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: applies the default value if there is one
    void acceptDefault();
    // internal
    void setImpl(cParImpl *p);
    // internal
    cParImpl *impl() const {return p;}
    // internal
    cParImpl *copyIfShared();

  public:
    virtual ~cPar();

    virtual const char *getName() const;

    virtual std::string info() const;

    virtual std::string detailedInfo() const;

    virtual cObject *getOwner() const;

    void operator=(const cPar& other);

    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& setLongValue(long 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=NULL);

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



    bool boolValue() const;

    long longValue() const;

    double doubleValue() const;

    const char *getUnit() const;

    const char *stringValue() const;

    std::string stdstringValue() const;

    cXMLElement *xmlValue() const;

    cExpression *getExpression() const;

    cComponent *getEvaluationContext() const  {return evalcontext;}


    void read();  //XXX make private, as it no longer evaluates non-volatile parameters!
    void finalize(); //XXX name not good! make private!

    void convertToConst();

    std::string str() const;

    void parse(const char *text);


    cPar& operator=(bool b)  {return setBoolValue(b);}

    cPar& operator=(char c)  {return setLongValue((long)c);}

    cPar& operator=(unsigned char c)  {return setLongValue((long)c);}

    cPar& operator=(int i)  {return setLongValue((long)i);}

    cPar& operator=(unsigned int i)  {return setLongValue((long)i);}

    cPar& operator=(short i)  {return setLongValue((long)i);}

    cPar& operator=(unsigned short i)  {return setLongValue((long)i);}

    cPar& operator=(long l)  {return setLongValue(l);}

    cPar& operator=(unsigned long l) {return setLongValue((long)l);}

    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 (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