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

Go to the documentation of this file.

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

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

#ifndef __mlObjMgrSubDataType_H
#define __mlObjMgrSubDataType_H

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

#ifndef __mlObjMgrDataType_H
#include "mlObjMgrDataType.h"
#endif
#ifndef __mlRuntimeSubClass_H
#include <mlRuntimeSubClass.h>
#endif


//  Macros

#define QUOTE(data) #data

#define DATA_TYPE_HEADER(dataType)                                                                                              \
   class MLOBJMGR_EXPORT omData_##dataType : public omDataType                                                                  \
   {                                                                                                                            \
      ML_CLASS_HEADER(omData_##dataType)                                                                                        \
                                                                                                                                \
      protected:                                                                                                                \
                                                                                                                                \
         dataType  _value;                                                                                                      \
                                                                                                                                \
      public:                                                                                                                   \
                                                                                                                                \
         omData_##dataType() : omDataType() {}                                                                                  \
         omData_##dataType(const omData_##dataType &type) : omDataType(), _value(type._value) {}                                \
         omData_##dataType(const dataType &value) : omDataType(), _value(value) {}                                              \
         inline omData_##dataType &operator =(const omData_##dataType &type) {                                                  \
            assign(type._value); return *this;                                                                                  \
         }                                                                                                                      \
         inline omData_##dataType &operator =(const dataType &value) {                                                          \
            assign(value); return *this;                                                                                        \
         }                                                                                                                      \
         virtual void assign(const dataType &value) {                                                                           \
            _value = value;                                                                                                     \
         }                                                                                                                      \
         inline operator dataType() const {                                                                                     \
            return _value;                                                                                                      \
         }                                                                                                                      \
         inline bool operator ==(const dataType &value) const {                                                                 \
            return _value == value;                                                                                             \
         }                                                                                                                      \
         inline bool operator !=(const dataType &value) const {                                                                 \
            return _value != value;                                                                                             \
         }                                                                                                                      \
         inline bool operator ==(const omData_##dataType &value) const {                                                        \
            return _value == value._value;                                                                                      \
         }                                                                                                                      \
         inline bool operator !=(const omData_##dataType &value) const {                                                        \
            return _value != value._value;                                                                                      \
         }                                                                                                                      \
         virtual std::string getStringValue() const;                                                                            \
         virtual void        setStringValue(const std::string &value);                                                          \
   };

#define DATA_TYPE_SOURCE(dataType,getStringCode,setStringCode)                                                                  \
   ML_CLASS_SOURCE(omData_##dataType, omDataType);                                                                              \
   std::string omData_##dataType::getStringValue() const {                                                                      \
      getStringCode                                                                                                             \
   }                                                                                                                            \
   void        omData_##dataType::setStringValue(const std::string &value) {                                                    \
      setStringCode                                                                                                             \
   }

#define DATA_OP_HEADER(dataType,defaultValue)                                                                                   \
   omData(const dataType &value) : _data(NULL) {                                                                                \
      assign(value);                                                                                                            \
   }                                                                                                                            \
   omData &operator =(const dataType &value) {                                                                                  \
      assign(value); return *this;                                                                                              \
   }                                                                                                                            \
   virtual void assign(const dataType &value);                                                                                  \
   operator dataType() const {                                                                                                  \
      return (_data) ? (dataType)(*(omData_##dataType *)_data) : defaultValue;                                                  \
   }                                                                                                                            \
   inline void set_##dataType(const dataType &value) {                                                                          \
      *this = (const dataType &)value;                                                                                          \
   }                                                                                                                            \
   inline dataType get_##dataType() const {                                                                                     \
      return (_data) ? (dataType)(*(omData_##dataType *)_data) : defaultValue;                                                  \
   }

#define DATA_OP_SOURCE(dataType)                                                                                                \
   void omData::assign(const dataType &value) {                                                                                 \
      if(_data == NULL) {                                                                                                       \
         createDataType(QUOTE(omData_##dataType));                                                                              \
                                                                                                                                \
         if(_data == NULL)                                                                                                      \
            return;                                                                                                             \
      }                                                                                                                         \
                                                                                                                                \
      *(omData_##dataType *)_data = value;                                                                                      \
   }

#endif // __mlObjMgrSubDataType_H