Changeset 11071 for code/trunk/src/libraries/util/MultiType.h

Timestamp:

Jan 17, 2016, 10:29:21 PM (8 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/util/MultiType.h (modified) (15 diffs)

code/trunk/src/libraries/util/MultiType.h

@@ -132 +132 @@
         template <typename T> friend class MT_Value;
 
-        struct Type
+        /**
+            @brief Enum of all possible types of a MultiType.
+        */
+        enum class Type : uint8_t
         {
-            /**
-                @brief Enum of all possible types of a MultiType.
-            */
-            enum Enum
-            {
-                Null,
-                Char,
-                UnsignedChar,
-                Short,
-                UnsignedShort,
-                Int,
-                UnsignedInt,
-                Long,
-                UnsignedLong,
-                LongLong,
-                UnsignedLongLong,
-                Float,
-                Double,
-                LongDouble,
-                Bool,
-                VoidPointer,
-                String,
-                Vector2,
-                Vector3,
-                Vector4,
-                ColourValue,
-                Quaternion,
-                Radian,
-                Degree
-            };
+            Null,
+            Char,
+            UnsignedChar,
+            Short,
+            UnsignedShort,
+            Int,
+            UnsignedInt,
+            Long,
+            UnsignedLong,
+            LongLong,
+            UnsignedLongLong,
+            Float,
+            Double,
+            LongDouble,
+            Bool,
+            VoidPointer,
+            String,
+            Vector2,
+            Vector3,
+            Vector4,
+            ColourValue,
+            Quaternion,
+            Radian,
+            Degree
         };
 
@@ -174 +171 @@
         {
         public:
-            inline MT_ValueBase(void* data, Type::Enum type) : type_(type), bLastConversionSuccessful(true), data_(data) {}
-            inline virtual ~MT_ValueBase() {}
+            inline MT_ValueBase(void* data, Type type) : type_(type), bLastConversionSuccessful(true), data_(data) {}
+            virtual inline ~MT_ValueBase() {}
 
             virtual MT_ValueBase* clone() const = 0;
@@ -182 +179 @@
 
             /// Returns the type of the current value.
-            inline const Type::Enum& getType() const { return this->type_; }
-            /// Returns true if the type of the stored value is T.
-            template <typename T> inline bool isType() const { return false; }
+            inline const Type& getType() const { return this->type_; }
+
+            /// Returns true if the type of the stored value is T. Note: the actual implementations for all supported types are defined outside of the class.
+            template <typename T> /* for normal classes */ typename std::enable_if<!std::is_enum<T>::value, bool>::type
+            inline /*bool*/ isType() const
+            {
+                // If you reach this code, you used MultiType with an unsupported type T
+                static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
+                return false;
+            }
+            /// Implementation for enum classes: Returns true if the type of the stored value is the underlying type of T.
+            template <typename T> /* for enum classes */ typename std::enable_if<std::is_enum<T>::value, bool>::type
+            inline /*bool*/ isType() const
+            {
+                return this->isType<typename std::underlying_type<T>::type>();
+            }
 
             /// Checks whether the value is a default one.
@@ -215 +225 @@
             virtual bool setValue(const MultiType& other)            = 0;
 
+            template <typename T> /* for normal classes */ typename std::enable_if<!std::is_enum<T>::value, bool>::type
+            inline /*bool*/ setValue(const T& value)
+            {
+                // If you reach this code, you used MultiType with an unsupported type T
+                static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
+                return false;
+            }
+            template <typename T> /* for enum classes */ typename std::enable_if<std::is_enum<T>::value, bool>::type
+            inline /*bool*/ setValue(const T& value)
+            {
+                typedef typename std::underlying_type<T>::type UnderlyingType;
+                return this->setValue(reinterpret_cast<const UnderlyingType&>(value));
+            }
+
             virtual bool getValue(char*                 value) const = 0;
             virtual bool getValue(unsigned char*        value) const = 0;
@@ -239 +263 @@
             virtual bool getValue(orxonox::Degree*      value) const = 0;
 
+            template <typename T> /* for normal classes */ typename std::enable_if<!std::is_enum<T>::value, bool>::type
+            inline /*bool*/ getValue(T* value) const
+            {
+                // If you reach this code, you used MultiType with an unsupported type T
+                static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
+                return false;
+            }
+            template <typename T> /* for enum classes */ typename std::enable_if<std::is_enum<T>::value, bool>::type
+            inline /*bool*/ getValue(T* value) const
+            {
+                typedef typename std::underlying_type<T>::type UnderlyingType;
+                return this->getValue(reinterpret_cast<UnderlyingType*>(value));
+            }
+
             template <typename T> T get() const
             {
@@ -257 +295 @@
             virtual uint8_t getSize() const = 0;
 
-            Type::Enum type_;               ///< The type of the current value
+            Type type_;                     ///< The type of the current value
             bool bLastConversionSuccessful; ///< True if the last conversion was successful
             void* data_;                    ///< For direct access to the value if the type is known
@@ -266 +304 @@
 
             /// Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
-            inline MultiType()                       : value_(0) { }
+            inline MultiType()                       : value_(nullptr) { }
             /// Constructor: Assigns the given value and sets the type.
             template <typename V>
-            inline MultiType(const V& value)         : value_(0) { this->set(value); }
+            inline MultiType(const V& value)         : value_(nullptr) { this->set(value); }
             /// Copyconstructor: Assigns value and type of the other MultiType.
-            inline MultiType(const MultiType& other) : value_(0) { this->set(other); }
+            inline MultiType(const MultiType& other) : value_(nullptr) { this->set(other); }
 
             /// Destructor: Deletes the MT_Value.
@@ -325 +363 @@
                 if (this->value_)
                     delete this->value_;
-                this->value_ = (other.value_) ? other.value_->clone() : 0;
+                this->value_ = (other.value_) ? other.value_->clone() : nullptr;
             }
 
@@ -332 +370 @@
 
             /// Resets value and type. Type will be void afterwards and null() returns true.
-            inline void reset() { if (this->value_) delete this->value_; this->value_ = 0; }
+            inline void reset() { if (this->value_) delete this->value_; this->value_ = nullptr; }
             /// Resets the value and changes the internal type to T.
             template <typename T> inline void reset() { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
@@ -354 +392 @@
             template <typename T> inline bool getValue(T* value) const { if (this->value_) { return this->value_->getValue(value); } return false; }
 
-            /// Returns the current value, converted to the requested type. This base implementation works only for pointers. All other supported types are
-            /// implemented in  specialized functions at the bottom of this file.
-            template <typename T> inline T get() const { return static_cast<T>(this->get<void*>()); }
+            /// Returns the current value, converted to the requested type.
+            template <typename T> /* for normal types */ typename std::enable_if<!std::is_pointer<T>::value, T>::type
+            inline /*T*/ get() const { return (this->value_ ? this->value_->get<T>() : NilValue<T>()); }
+            /// Returns the current value, converted to a pointer of the requested type.
+            template <typename T> /* for pointers */ typename std::enable_if<std::is_pointer<T>::value, T>::type
+            inline /*T*/ get() const { return this->value_ ? static_cast<T>(this->value_->get<void*>()) : nullptr; }
 
 
@@ -365 +406 @@
             inline void exportData(uint8_t*& mem) const
             {
-                assert(sizeof(Type::Enum) <= 8);
-                *static_cast<uint8_t*>(mem) = this->getType();
+                assert(sizeof(Type) <= 8);
+                *static_cast<uint8_t*>(mem) = static_cast<uint8_t>(this->getType());
                 mem += sizeof(uint8_t);
                 this->value_->exportData(mem);
@@ -373 +414 @@
             inline void importData(uint8_t*& mem)
             {
-                assert(sizeof(Type::Enum) <= 8);
-                this->setType(static_cast<Type::Enum>(*static_cast<uint8_t*>(mem)));
+                assert(sizeof(Type) <= 8);
+                this->setType(static_cast<Type>(*static_cast<uint8_t*>(mem)));
                 mem += sizeof(uint8_t);
                 this->value_->importData(mem);
@@ -414 +455 @@
 
             /// Resets the value and changes the internal type to the given type.
-            inline void setType(Type::Enum type) { this->reset(); this->convert(type); this->resetValue(); }
+            inline void setType(Type type) { this->reset(); this->convert(type); this->resetValue(); }
             /// Returns the current type.
-            inline Type::Enum getType() const { return (this->value_) ? this->value_->type_ : Type::Null; }
+            inline Type getType() const { return (this->value_) ? this->value_->type_ : Type::Null; }
             /// Converts the current value to the given type.
-            bool convert(Type::Enum type);
+            bool convert(Type type);
 
             /// Changes the value container.
@@ -428 +469 @@
             }
             /// Creates a new value container (works only with specialized types).
-            template <typename T> inline void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
+            template <typename T> /* for normal classes */ typename std::enable_if<!std::is_enum<T>::value>::type
+            inline /*void*/ createNewValueContainer(const T& value)
+            { 
+                // If you reach this code, you used MultiType with an unsupported type T
+                static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
+            }
+            /// Creates a new value container (implementation for enum classes that must be cast to the underlying type).
+            template <typename T> /* for enum classes */ typename std::enable_if<std::is_enum<T>::value>::type
+            inline /*void*/ createNewValueContainer(const T& value)
+            {
+                typedef typename std::underlying_type<T>::type UnderlyingType;
+                this->createNewValueContainer<UnderlyingType>(reinterpret_cast<const UnderlyingType&>(value));
+            }
 
             MT_ValueBase* value_; //!< A pointer to the value container
@@ -471 +524 @@
     template <> inline bool MultiType::isType<void>() const { return this->null(); }
     template <> inline bool MultiType::convert<void>() { this->reset(); return true; }
-
-    template <> inline char                 MultiType::get() const { return (this->value_ ? this->value_->get<char>()                 : 0); }
-    template <> inline unsigned char        MultiType::get() const { return (this->value_ ? this->value_->get<unsigned char>()        : 0); }
-    template <> inline short                MultiType::get() const { return (this->value_ ? this->value_->get<short>()                : 0); }
-    template <> inline unsigned short       MultiType::get() const { return (this->value_ ? this->value_->get<unsigned short>()       : 0); }
-    template <> inline int                  MultiType::get() const { return (this->value_ ? this->value_->get<int>()                  : 0); }
-    template <> inline unsigned int         MultiType::get() const { return (this->value_ ? this->value_->get<unsigned int>()         : 0); }
-    template <> inline long                 MultiType::get() const { return (this->value_ ? this->value_->get<long>()                 : 0); }
-    template <> inline unsigned long        MultiType::get() const { return (this->value_ ? this->value_->get<unsigned long>()        : 0); }
-    template <> inline long long            MultiType::get() const { return (this->value_ ? this->value_->get<long long>()            : 0); }
-    template <> inline unsigned long long   MultiType::get() const { return (this->value_ ? this->value_->get<unsigned long long>()   : 0); }
-    template <> inline float                MultiType::get() const { return (this->value_ ? this->value_->get<float>()                : 0); }
-    template <> inline double               MultiType::get() const { return (this->value_ ? this->value_->get<double>()               : 0); }
-    template <> inline long double          MultiType::get() const { return (this->value_ ? this->value_->get<long double>()          : 0); }
-    template <> inline bool                 MultiType::get() const { return (this->value_ ? this->value_->get<bool>()                 : 0); }
-    template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : 0); }
-    template <> inline std::string          MultiType::get() const { return (this->value_ ? this->value_->get<std::string>()          : NilValue<std::string>()); }
-    template <> inline orxonox::Vector2     MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Vector2>()     : NilValue<orxonox::Vector2>()); }
-    template <> inline orxonox::Vector3     MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Vector3>()     : NilValue<orxonox::Vector3>()); }
-    template <> inline orxonox::Vector4     MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Vector4>()     : NilValue<orxonox::Vector4>()); }
-    template <> inline orxonox::ColourValue MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::ColourValue>() : NilValue<orxonox::ColourValue>()); }
-    template <> inline orxonox::Quaternion  MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Quaternion>()  : NilValue<orxonox::Quaternion>()); }
-    template <> inline orxonox::Radian      MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Radian>()      : NilValue<orxonox::Radian>()); }
-    template <> inline orxonox::Degree      MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Degree>()      : NilValue<orxonox::Degree>()); }
 
     template <> _UtilExport void MultiType::createNewValueContainer(const char& value);