mlObjMgrAttribute.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_ATTRIBUTE_H
#define ML_OBJ_MGR_ATTRIBUTE_H
 
 
 
#include "MLObjMgrSystem.h"
 
#include "mlObjMgrData.h"
 
#include "mlObjMgrObjectID.h"
#include "mlObjMgrFlags.h"
#include "mlObjMgrAttributes.h"
 
ML_UTILS_START_NAMESPACE
 
   // Forward declaration of classes
   class RuntimeType;
 
ML_UTILS_END_NAMESPACE
 
ML_START_NAMESPACE
 
   // Forward declaration of classes
   class omAttributesVector;
   class omObject;
 
   class MLOBJMGR_EXPORT omAttribute : public omData
   {
      typedef omData inherited;
 
      friend class omAttributesVector;
 
      protected:
 
         omFlags             _flags;
 
         omAttributesVector *_parent;
 
         bool                _isContainerValid;
 
         omIDType            _id;
 
      public:
 
         omAttribute();
         omAttribute(const omAttribute &attr);
         ~omAttribute() override;
 
         inline bool               isContainerValid() const {
            return _isContainerValid;
         }
 
         inline const omIDType &getID() const {
            return _id;
         }
 
         inline omAttributesVector       *parent() {
            return _parent;
         }
         inline const omAttributesVector *parent() const {
            return _parent;
         }
 
         inline omFlags           &flags() {
            return _flags;
         }
         inline const omFlags     &flags() const {
            return _flags;
         }
 
         void                      createDataType(const std::string &typeName) {
            inherited::createDataType(typeName);
         }
         void                      createDataType(const RuntimeType *type) {
            inherited::createDataType(type);
         }
 
         void                      createDataType(const std::string &typeName, const std::string &value);
         void                      createDataType(const RuntimeType *type, const std::string &value);
 
         omAttribute              &operator =(const omAttribute &attr);
         virtual void              assign(const omAttribute &attr) {
            inherited::assign(attr);
         }
 
         ATTRIBUTE_OP_HEADER(MLint32, MLint32);
         ATTRIBUTE_OP_HEADER(bool, bool);
         ATTRIBUTE_OP_HEADER(double, double);
         ATTRIBUTE_OP_HEADER(vec3, Vector3);
         ATTRIBUTE_OP_HEADER(vec4, Vector4);
         ATTRIBUTE_OP_HEADER(mat4, Matrix4);
         ATTRIBUTE_OP_HEADER(std_string, std_string);
         ATTRIBUTE_OP_HEADER(std_MLint32Vec, std_MLint32Vec);
         ATTRIBUTE_OP_HEADER(omMessage, omMessage);
         ATTRIBUTE_OP_HEADER(std_vec3Vec, std_vec3Vec);
         ATTRIBUTE_OP_HEADER(BasePtr, BasePtr);
 
         omAttribute              &operator =(const char *value) {
            inherited::operator=(value); return *this;
         }
 
      /* INTERNAL */ public:
 
         inline void markContainerValid(bool trueOrFalse) {
            _isContainerValid = trueOrFalse;
         }
   };
 
 
   class MLOBJMGR_EXPORT omAttributesVector : protected std::map<omIDType, omAttribute>
   {
      friend class omObject;
 
      typedef std::map<omIDType, omAttribute> inherited;
 
      protected:
 
         omFlags      _flags;
 
         omObject    *_parent;
 
         bool         _isValid;
 
         omIDType     _id;
 
      public:
 
         typedef inherited::iterator       iterator;
         typedef inherited::const_iterator const_iterator;
 
         omAttributesVector();
         omAttributesVector(const omAttributesVector &v);
         ~omAttributesVector();
 
         inline const omIDType &getID() const {
            return _id;
         }
 
         inline omObject       *parent() {
            return _parent;
         }
         inline const omObject *parent() const {
            return _parent;
         }
 
         inline omFlags       &flags() {
            return _flags;
         }
         inline const omFlags &flags() const {
            return _flags;
         }
 
         inline bool         isValid() const {
            return _isValid;
         }
 
         omAttributesVector &operator =(const omAttributesVector &v);
 
         omAttribute        &operator [](const omIDType &infoID);
 
         const omAttribute  &operator [](const omIDType &infoID) const;
 
         void                erase(const omIDType &infoID);
 
         void                clear();
 
         inline size_t       size() const {
            return inherited::size();
         }
 
         inline bool         empty() const {
            return inherited::empty();
         }
 
         inline inherited::iterator begin() {
            return inherited::begin();
         }
         inline inherited::iterator end() {
            return inherited::end();
         }
 
         inline inherited::const_iterator begin() const {
            return inherited::begin();
         }
         inline inherited::const_iterator end() const {
            return inherited::end();
         }
 
      /* INTERNAL */ public:
 
         inline void markValid(bool trueOrFalse) {
            _isValid = trueOrFalse;
         }
   };
 
ML_END_NAMESPACE
 
#endif // __mlObjMgrAttribute_H