Changeset 1726

Timestamp:

Sep 7, 2008, 2:55:22 AM (16 years ago)

Author:

landauf

Message:

several changes in MultiType:

• added a const char* constructor to fix a bug
• fixed unexpected behavior when assigning another MultiType: setValue(MultiType) converts now the value of the other MultiType to the current type
• added copy(MultiType) function to assign value AND type of the other MultiType
• it's now possible to convert the type of a MultiType by either calling convert<T>() or convert(MT_Type)
• convert(MultiType) converts the current value to the type of the other MultiType
• setValue<type>(othertype value) will now convert value from othertype to type by using Convert.h instead of a typecast

Location:

code/branches/core3/src/util

Files:

• MultiType.cc (modified) (1 diff)
• MultiType.h (modified) (5 diffs)
• MultiTypeValue.h (modified) (1 diff)

code/branches/core3/src/util/MultiType.cc

@@ -30 +30 @@
 #include "MultiTypeValue.h"
 
-void MultiType::setType(MT_Type type)
+void MultiType::convert(MT_Type type)
 {
     switch (type)
     {
         case MT_char:
-            this->setType<char>(); break;
+            this->convert<char>(); break;
         case MT_uchar:
-            this->setType<unsigned char>(); break;
+            this->convert<unsigned char>(); break;
         case MT_short:
-            this->setType<short>(); break;
+            this->convert<short>(); break;
         case MT_ushort:
-            this->setType<unsigned short>(); break;
+            this->convert<unsigned short>(); break;
         case MT_int:
-            this->setType<int>(); break;
+            this->convert<int>(); break;
         case MT_uint:
-            this->setType<unsigned int>(); break;
+            this->convert<unsigned int>(); break;
         case MT_long:
-            this->setType<long>(); break;
+            this->convert<long>(); break;
         case MT_ulong:
-            this->setType<unsigned long>(); break;
+            this->convert<unsigned long>(); break;
         case MT_longlong:
-            this->setType<long long>(); break;
+            this->convert<long long>(); break;
         case MT_ulonglong:
-            this->setType<unsigned long long>(); break;
+            this->convert<unsigned long long>(); break;
         case MT_float:
-            this->setType<float>(); break;
+            this->convert<float>(); break;
         case MT_double:
-            this->setType<double>(); break;
+            this->convert<double>(); break;
         case MT_longdouble:
-            this->setType<long double>(); break;
+            this->convert<long double>(); break;
         case MT_bool:
-            this->setType<bool>(); break;
+            this->convert<bool>(); break;
         case MT_void:
-            this->setType<void*>(); break;
+            this->convert<void*>(); break;
         case MT_string:
-            this->setType<std::string>(); break;
+            this->convert<std::string>(); break;
         case MT_vector2:
-            this->setType<orxonox::Vector2>(); break;
+            this->convert<orxonox::Vector2>(); break;
         case MT_vector3:
-            this->setType<orxonox::Vector3>(); break;
+            this->convert<orxonox::Vector3>(); break;
         case MT_vector4:
-            this->setType<orxonox::Vector4>(); break;
+            this->convert<orxonox::Vector4>(); break;
         case MT_colourvalue:
-            this->setType<orxonox::ColourValue>(); break;
+            this->convert<orxonox::ColourValue>(); break;
         case MT_quaternion:
-            this->setType<orxonox::Quaternion>(); break;
+            this->convert<orxonox::Quaternion>(); break;
         case MT_radian:
-            this->setType<orxonox::Radian>(); break;
+            this->convert<orxonox::Radian>(); break;
         case MT_degree:
-            this->setType<orxonox::Degree>(); break;
+            this->convert<orxonox::Degree>(); break;
         default:
             this->reset(); break;

code/branches/core3/src/util/MultiType.h

@@ -82 +82 @@
         virtual MT_ValueBase* clone() const = 0;
 
+        virtual void reset() = 0;
+        virtual void assimilate(const MultiType& other) = 0;
         const MT_Type& getType() const { return this->type_; }
 
@@ -162 +164 @@
         inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }
         inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }
+        inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); }
         inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }
         inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }
@@ -167 +170 @@
         inline ~MultiType() { if (this->value_) { delete this->value_; } }
 
-        template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value);          return (*this); }
-        inline                       MultiType& operator=(const MultiType& other) { this->setValue(other);          return (*this); }
-        inline                       MultiType& operator=(MT_Type type)           { this->setType(type);            return (*this); }
+        template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); }
+        inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); }
+        inline                       MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); }
 
         inline void                                   setValue(const char& value);
@@ -195 +198 @@
         inline void                                   setValue(const orxonox::Degree& value);
         template <typename V> inline void             setValue(V* value)               { if (this->value_) { this->value_->setValue((void*)value); } else { this->assignValue((void*)value); } }
-        inline void                                   setValue(const MultiType& other) { this->value_ = (other.value_) ? other.value_->clone() : 0; }
-        template <typename T, typename V> inline void setValue(const V& value)         { this->assignValue((T)value); }
+        void                                          setValue(const MultiType& other) { if (this->value_) { this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } } }
+        template <typename T, typename V> inline void setValue(const V& value)         { this->setType<T>(); this->setValue(value); }
         inline void                                   setValue(const char* value);
 
-        template <typename T> inline void convert() { this->setValue<T>((T)(*this)); }
-
-        inline void                       reset()   { if (this->value_) { delete this->value_; this->value_ = 0; } }
-
-        template <typename T> inline void setType()                       { this->assignValue(T());         }
-        inline void                       setType(const MultiType& other) { this->setType(other.getType()); }
-        void                              setType(MT_Type type);
+        inline void                       copy(const MultiType& other)    { if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
+
+        template <typename T> inline void convert()                       { this->setValue<T>((T)(*this));  }
+        inline void                       convert(const MultiType& other) { this->convert(other.getType()); }
+        void                              convert(MT_Type type);
+
+        inline void                       reset()                         { if (this->value_) { delete this->value_; this->value_ = 0; } }
+
+        template <typename T> inline void setType()                       { this->assignValue(T());             }
+        inline void                       setType(const MultiType& other) { this->setType(other.getType());     }
+        inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); }
 
         operator char()                  const;
@@ -376 +383 @@
 inline void MultiType::setValue(const long double& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
 inline void MultiType::setValue(const bool& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(      void* const& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
 inline void MultiType::setValue(const std::string& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
 inline void MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }

code/branches/core3/src/util/MultiTypeValue.h

@@ -40 +40 @@
 
     inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
+    inline void reset() { this->value_ = T(); }
+    inline void assimilate(const MultiType& other) { if (other.value_) { this->value_ = other.operator T(); } else { this->value_ = T(); } }
 
     inline void setValue(const char& value)                 { this->value_ = getConvertedValue<char,                 T>(value); }