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

Go to the documentation of this file.

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

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

#ifndef __mlObjMgrAttribute_H
#define __mlObjMgrAttribute_H

#ifndef __MLObjMgrSystem_H
#include "MLObjMgrSystem.h"
#endif

#ifndef __mlObjMgrData_H
#include "mlObjMgrData.h"
#endif

#ifndef __mlObjMgrObjectID_H
#include "mlObjMgrObjectID.h"
#endif
#ifndef __mlObjMgrFlags_H
#include "mlObjMgrFlags.h"
#endif
#ifndef __mlObjMgrAttributes_H
#include "mlObjMgrAttributes.h"
#endif

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);
         virtual ~omAttribute();

         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);
         ATTRIBUTE_OP_HEADER(bool);
         ATTRIBUTE_OP_HEADER(double);
         ATTRIBUTE_OP_HEADER(vec3);
         ATTRIBUTE_OP_HEADER(vec4);
         ATTRIBUTE_OP_HEADER(mat4);
         ATTRIBUTE_OP_HEADER(std_string);
         ATTRIBUTE_OP_HEADER(std_MLint32Vec);
         ATTRIBUTE_OP_HEADER(omMessage);
         ATTRIBUTE_OP_HEADER(std_vec3Vec);
         ATTRIBUTE_OP_HEADER(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