cproperty.h

//==========================================================================
//  CPROPERTY.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_CPROPERTY_H
#define __OMNETPP_CPROPERTY_H
 
#include <map>
#include <vector>
#include "simkerneldefs.h"
#include "globals.h"
#include "cobject.h"
#include "cproperties.h"
#include "opp_pooledstring.h"
 
namespace omnetpp {
 
 
class SIM_API cProperty : public cNamedObject
{
  public:
    static const char *DEFAULTKEY;
 
  private:
    enum {
      FL_ISLOCKED = 4,
      FL_ISIMPLICIT = 8,
    };
 
  protected:
    cProperties *ownerp = nullptr;
 
    opp_staticpooledstring indexString = nullptr;
    mutable opp_staticpooledstring fullName = nullptr;
 
    struct Value {
        opp_staticpooledstring value;
        opp_staticpooledstring originFile;
        opp_staticpooledstring originType;
    };
    typedef std::vector<Value> ValueList;
    std::vector<opp_staticpooledstring> keyv;
    std::vector<ValueList> valuesv;
 
  private:
    void copy(const cProperty& other);
 
  protected:
    int findKey(const char *key) const;
    ValueList& getValuesVector(const char *key);
    const ValueList& 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;}
 
    // internal: print values in NED syntax
    virtual void printValues(std::ostream& os) const;
 
  public:
 
    explicit cProperty(const char *name=nullptr, const char *index=nullptr);
 
    cProperty(const cProperty& other) : cNamedObject(other) {setFlag(FL_ISLOCKED,false); indexString=fullName=nullptr; copy(other);}
 
    virtual ~cProperty();
 
    cProperty& operator=(const cProperty& other);
 
    virtual void setName(const char *name) override;
 
    virtual const char *getFullName() const override;
 
    virtual cProperty *dup() const override   {return new cProperty(*this);}
 
    virtual std::string str() const override;
 
    virtual void parsimPack(cCommBuffer *buffer) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
    virtual void setIndex(const char *index);
 
    virtual const char *getIndex() const;
 
    virtual void setIsImplicit(bool b);
 
    virtual bool isImplicit() const;
 
    virtual std::vector<const char *> getKeys() const;
 
    virtual bool containsKey(const char *key) const;
 
    virtual void addKey(const char *key);
 
    virtual int getNumKeys() const {return keyv.size();}
 
    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 const char *getValueOriginFile(const char *key="", int index=0) const;
 
    virtual const char *getValueOriginType(const char *key="", int index=0) const;
 
    virtual void setValue(const char *key, int index, const char *value, const char *originFile=nullptr, const char *originType=nullptr);
 
    virtual void erase(const char *key);
 
    virtual void updateWith(const cProperty *other);
};
 
}  // namespace omnetpp
 
 
#endif