mlObjMgrObject.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_OBJ_MGR_OBJECT_H
#define ML_OBJ_MGR_OBJECT_H
 
 
 
#include "MLObjMgrSystem.h"
#include <mlBase.h>
#include "mlObjMgrObjectID.h"
#include "mlObjMgrAttribute.h"
 
 
#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() override;
 
         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