cproperty.h

//==========================================================================
//  CPROPERTY.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

/*--------------------------------------------------------------*
  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 __CPROPERTY_H
#define __CPROPERTY_H

#include <map>
#include <vector>
#include "simkerneldefs.h"
#include "globals.h"
#include "cobject.h"
#include "cstringpool.h"
#include "cproperties.h"

NAMESPACE_BEGIN


class SIM_API cProperty : public cNamedObject
{
  public:
    static const char *DEFAULTKEY;

  private:
    enum {
      FL_ISLOCKED = 4,
      FL_ISIMPLICIT = 8,
    };

  protected:
    // property names, keys and values are all stringpooled to reduce memory consumption
    static cStringPool stringPool;

    cProperties *ownerp;

    const char *propindex;
    mutable const char *propfullname;

    typedef std::vector<const char *> CharPtrVector;
    CharPtrVector keyv;
    std::vector<CharPtrVector> valuesv;

  private:
    void copy(const cProperty& other);

  protected:
    static void releaseValues(CharPtrVector& vals);
    int findKey(const char *key) const;
    CharPtrVector& getValuesVector(const char *key) const;

  public:
    // internal: locks the object against modifications. It cannot be unlocked
    // -- one must copy contents to an unlocked object, or call dup()
    // (new objects are created in unlocked state).
    virtual void lock() {setFlag(FL_ISLOCKED, true);}

    // internal:
    virtual bool isLocked() const {return flags&FL_ISLOCKED;}

    // internal: set the containing cProperties
    virtual void setOwner(cProperties *p) {ownerp = p;}

  public:

    explicit cProperty(const char *name=NULL, const char *index=NULL);

    cProperty(const cProperty& other) : cNamedObject(other) {setFlag(FL_ISLOCKED,false); propindex=propfullname=NULL; copy(other);}

    virtual ~cProperty();

    cProperty& operator=(const cProperty& other);

    virtual void setName(const char *name);

    virtual const char *getFullName() const;

    virtual cProperty *dup() const   {return new cProperty(*this);}

    virtual std::string info() const;

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);

    virtual void setIndex(const char *index);

    virtual const char *getIndex() const;

    virtual void setIsImplicit(bool b);

    virtual bool isImplicit() const;

    virtual const std::vector<const char *>& getKeys() const;

    virtual bool containsKey(const char *key) const;

    virtual void addKey(const char *key);

    virtual int getNumValues(const char *key) const;

    virtual void setNumValues(const char *key, int size);

    virtual const char *getValue(const char *key, int index=0) const;

    virtual void setValue(const char *key, int index, const char *value);

    virtual void erase(const char *key);
};

NAMESPACE_END


#endif