cparimpl.h

//==========================================================================
//   CPARIMPL.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 __CPARIMPL_H
#define __CPARIMPL_H

#include "cpar.h"
#include "cexpression.h"
#include "cstringpool.h"
#include "cexception.h"

NAMESPACE_BEGIN

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


class SIM_API cParImpl : public cNamedObject
{
  protected:
    // various flags, stored in cNamedObject::flags
    enum {
      FL_ISVOLATILE = 4,  // whether it was declared as "volatile" in NED
      FL_ISEXPR = 8,      // whether it stores a constant or an expression
      FL_ISSHARED = 16,   // used by cPar only: whether this object is shared among multiple cPars
      FL_CONTAINSVALUE = 32, // whether it has a value
      FL_ISSET = 64       // whether the contained value is just a default value (false) or the set value (true)
    };

  private:
    // unit (s, mW, GHz, baud, etc); optional
    const char *unitp; // stringpooled

    // global variables for statistics
    static long total_parimpl_objs;
    static long live_parimpl_objs;
    static cStringPool unitStringPool;

  private:
    void copy(const cParImpl& other);

  public:
    typedef cPar::Type Type;

  protected:
    cNEDValue evaluate(cExpression *expr, cComponent *context) const;

  public:

    explicit cParImpl();

    cParImpl(const cParImpl& other) : cNamedObject(other) {unitp = NULL; copy(other);}

    virtual ~cParImpl();

    cParImpl& operator=(const cParImpl& otherpar);

    virtual std::string info() const;

    virtual std::string detailedInfo() const;

    virtual cParImpl *dup() const;

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);

    virtual Type getType() const = 0;

    virtual bool isNumeric() const = 0;

    virtual bool isVolatile() const {return flags & FL_ISVOLATILE;}

    virtual bool isExpression() const {return flags & FL_ISEXPR;}

    virtual bool isShared() const {return flags & FL_ISSHARED;}

    virtual bool containsValue() const  {return flags & FL_CONTAINSVALUE;}

    virtual bool isSet() const {return flags & FL_ISSET;}

    virtual void setIsVolatile(bool f) {setFlag(FL_ISVOLATILE,f);}

    virtual void setIsShared(bool f) {setFlag(FL_ISSHARED,f);}

    virtual void setIsSet(bool f) {setFlag(FL_ISSET,f);}

    virtual const char *getUnit() const;

    virtual void setUnit(const char *s);


    virtual void setBoolValue(bool b) = 0;

    virtual void setLongValue(long l) = 0;

    virtual void setDoubleValue(double d) = 0;

    virtual void setStringValue(const char *s) = 0;

    virtual void setStringValue(const std::string& s)  {setStringValue(s.c_str());}

    virtual void setXMLValue(cXMLElement *node) = 0;

    virtual void setExpression(cExpression *e) = 0;


    virtual bool boolValue(cComponent *context) const = 0;

    virtual long longValue(cComponent *context) const = 0;

    virtual double doubleValue(cComponent *context) const = 0;

    virtual const char *stringValue(cComponent *context) const = 0;

    virtual std::string stdstringValue(cComponent *context) const = 0;

    virtual cXMLElement *xmlValue(cComponent *context) const = 0;

    virtual cExpression *getExpression() const = 0;


    virtual void convertToConst(cComponent *context) = 0;

    virtual bool containsConstSubexpressions() const;

    virtual void evaluateConstSubexpressions(cComponent *context);

    virtual std::string str() const = 0;

    virtual void parse(const char *text) = 0;

    static cParImpl *createWithType(Type type);


    virtual int compare(const cParImpl *other) const;

    static long getTotalParImplObjectCount() {return total_parimpl_objs;}

    static long getLiveParImplObjectCount() {return live_parimpl_objs;}

    static void resetParImplObjectCounters()  {total_parimpl_objs=live_parimpl_objs=0L;}
};

NAMESPACE_END


#endif