MeVisLab/Standard/Sources/ML/MLObjMgr/ObjMgr/mlObjMgrObject.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------

#ifndef __mlObjMgrObject_H
#define __mlObjMgrObject_H

#ifndef __MLObjMgrSystem_H
#include "MLObjMgrSystem.h"
#endif
#ifndef __mlBase_H
#include <mlBase.h>
#endif
#ifndef __mlObjMgrObjectID_H
#include "mlObjMgrObjectID.h"
#endif
#ifndef __mlObjMgrAttribute_H
#include "mlObjMgrAttribute.h"
#endif


#define omID_WHITECARD  "*"


ML_START_NAMESPACE

   // Forward declaration of classes
   class omObjectContainer;
   class ObjMgr;

   class MLOBJMGR_EXPORT omObject : public Base, protected std::map<omIDType, omAttributesVector>
   {
      friend class omObjectContainer;

      typedef Base inherited;
      typedef std::map<omIDType, omAttributesVector> attMtx;
   
      ML_CLASS_HEADER(omObject)
      
      protected:

         omFlags   _flags;

         omIDType  _id;
         
         ObjMgr   *_objMgr;

         void               setID(const omIDType &id);

      public:

         typedef attMtx::iterator        iterator;
         typedef attMtx::const_iterator  const_iterator;
         
         omObject();
         omObject(const omObject &obj);
         ~omObject();

         inline ObjMgr     *objMgr() {
            return _objMgr;
         }
         
         omFlags           &flags() {
            return _flags;
         }
         const omFlags     &flags() const {
            return _flags;
         }

         omObject          &operator =(const omObject &obj);

         inline bool        isValid() const {
            return _id != omID_DEFAULT;
         }         

         inline const omIDType &getID() const {
            return _id;
         }
         
         omIDType           generateID(MLuint32 minID= 0, MLuint32 maxID= omID_MAX, const std::string &prefix= "") const;

         omAttributesVector &createLayer(MLuint32 minID= 0, MLuint32 maxID= omID_MAX, const std::string &prefix= "");

         omAttributesVector       &operator [](const omIDType &layer);

         const omAttributesVector &operator [](const omIDType &layer) const;

         omAttributesVector       &getLayer(const omIDType &layer);

         omAttribute       &getAttribute(const omIDType &layer, const omIDType &item);

         const omAttribute &getAttribute(const omIDType &layer, const omIDType &item) const;

         inline bool        hasAttribute(const omIDType &layer, const omIDType &item) const {
            return getAttribute(layer, item).isValid();
         }

         void               removeAttribute(const omIDType &layer, const omIDType &item);

         std::vector<std::pair<omIDType,omIDType> > evalAttrAddrExpr(const std::string &layerRegEx, const std::string &itemRegEx) const;

         inline bool        exists(const omIDType &layer) const {
            return attMtx::find(layer) != attMtx::end();
         }

         void               erase(const omIDType &layer);

         void               clear();

         inline size_t      size() const {
            return attMtx::size();
         }

         inline bool        empty() const {
            return attMtx::empty();
         }

         inline attMtx::iterator begin() {
            return attMtx::begin();
         }
         inline attMtx::iterator end() {
            return attMtx::end();
         }

         inline attMtx::const_iterator begin() const {
            return attMtx::begin();
         }
         inline attMtx::const_iterator end() const {
            return attMtx::end();
         }
   };

ML_END_NAMESPACE

#endif // __mlObjMgrObject_H