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

Go to the documentation of this file.

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

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

#ifndef __mlObjMgrAttribute_Message_H
#define __mlObjMgrAttribute_Message_H

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

#ifndef __mlObjMgrDataType_H
#include "mlObjMgrDataType.h"
#endif


ML_START_NAMESPACE

   template <typename T>
   class omMessageT : public std::basic_string<T>
   {
      typedef std::basic_string<T> inherited;

      public:

         omMessageT() : inherited() {}

         omMessageT(const omMessageT &msg) : inherited(msg) {}

         explicit omMessageT(const char *str) : inherited(str) {}

         explicit omMessageT(const std::basic_string<T> &str) : inherited(str) {}

         omMessageT &operator=(const omMessageT &msg) {
            ((inherited *)this)->assign(msg);

            return *this;
         }

         bool operator ==(const omMessageT &) const {
            return false;
         }
         bool operator !=(const omMessageT &) const {
            return true;
         }
      
         operator const omMessageT &() const {
            return *this;
         }

         operator const std::basic_string<T> &() const {
            return *this;
         }
   };

   typedef omMessageT<char> omMessage;

   class MLOBJMGR_EXPORT omData_omMessage : public omDataType
   {
      ML_CLASS_HEADER(omData_omMessage)

      typedef omDataType inherited;
   
      protected:

         omMessage _value;

      public:

         omData_omMessage() {}
         omData_omMessage(const omData_omMessage &msg) : omDataType(), _value(msg._value) {}
         omData_omMessage(const omMessage &value) : omDataType(), _value(value) {}

         inline omData_omMessage &operator =(const omData_omMessage &msg) {
            assign(msg._value); return *this;
         }
         inline omData_omMessage &operator =(const omMessage &value) {
            assign(value); return *this;
         }
         virtual void assign(const omMessage &value) {
            _value = value;
         }

         operator const omMessage &() const {
            return _value;
         }

         bool operator ==(const omMessage &value) const {
            return _value == value;
         }
         bool operator !=(const omMessage &value) const {
            return _value != value;
         }

         virtual std::string getStringValue() const {
            return _value;
         }
         virtual void        setStringValue(const std::string &value) {
            assign((omMessage)value);
         }
   };

   class MLOBJMGR_EXPORT omAttribute_omMessage : public omData_omMessage
   {
      ML_CLASS_HEADER(omAttribute_omMessage)

      typedef omData_omMessage inherited;
   
      public:

         omAttribute_omMessage() {}
         omAttribute_omMessage(const omAttribute_omMessage &msg) : inherited(msg) {}
         omAttribute_omMessage(const omMessage &value) : inherited(value) {}

         virtual ~omAttribute_omMessage() {}

         virtual void assign(const omMessage &value);
   };

ML_END_NAMESPACE

#endif // __mlObjMgrAttribute_Message_H