Changeset 11068 for code/branches/cpp11_v3/src/libraries/util

Timestamp:

Jan 17, 2016, 6:41:22 PM (10 years ago)

Author:

landauf

Message:

merged remaining commits from cpp11_v2 to cpp11_v3 (for some reason they were not merged in the first attempt)

Location:

code/branches/cpp11_v3

Files:

• . (modified) (1 prop)
• src/libraries/util/Math.h (modified) (2 diffs)
• src/libraries/util/MultiType.cc (modified) (2 diffs)
• src/libraries/util/MultiType.h (modified) (12 diffs)
• src/libraries/util/MultiTypeValue.h (modified) (1 diff)
• src/libraries/util/SubString.cc (modified) (15 diffs)
• src/libraries/util/SubString.h (modified) (2 diffs)
• src/libraries/util/UtilPrereqs.h (modified) (1 diff)

code/branches/cpp11_v3/src/libraries/util/Math.h

@@ -47 +47 @@
 #include <cstdlib>
 #include <random>
+#include <type_traits>
 
 #include <OgreMath.h>
@@ -178 +179 @@
         @c Vector3 you get <tt>Vector3(0, 0, 0)</tt>.
     */
-    template <typename T>
-    inline T zeroise()
+    template <typename T> /* for normal classes */ typename std::enable_if<!std::is_enum<T>::value, T>::type
+    inline /*T*/ zeroise()
     {
         // If you reach this code, you abused zeroise()!
         static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
+    }
+    /// Implementation for enum classes: uses the underlying type to create a zero value.
+    template <typename T> /* for enum classes */ typename std::enable_if<std::is_enum<T>::value, T>::type
+    inline /*T*/ zeroise()
+    {
+        return static_cast<T>(zeroise<typename std::underlying_type<T>::type>());
     }
 

code/branches/cpp11_v3/src/libraries/util/MultiType.cc

@@ -43 +43 @@
         @param type The type
     */
-    bool MultiType::convert(Type::Enum type)
+    bool MultiType::convert(Type type)
     {
         switch (type)
@@ -106 +106 @@
     std::string MultiType::getTypename() const
     {
-        Type::Enum type = (this->value_) ? this->value_->type_ : Type::Null;
+        Type type = (this->value_) ? this->value_->type_ : Type::Null;
 
         switch (type)

code/branches/cpp11_v3/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 MT_ValueBase(void* data, Type type) : type_(type), bLastConversionSuccessful(true), data_(data) {}
             virtual inline ~MT_ValueBase() {}
 
@@ -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
@@ -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)
+            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));
             }
 
@@ -475 +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*>()                : nullptr); }
-    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);

code/branches/cpp11_v3/src/libraries/util/MultiTypeValue.h

@@ -55 +55 @@
     public:
         /// Constructor: Assigns the value and the type identifier.
-        MT_Value(const T& value, MultiType::Type::Enum type) : MT_ValueBase(&this->value_, type), value_(value) {}
+        MT_Value(const T& value, MultiType::Type type) : MT_ValueBase(&this->value_, type), value_(value) {}
 
         /// Creates a copy of itself.

code/branches/cpp11_v3/src/libraries/util/SubString.cc

@@ -265 +265 @@
         bool inSafemode = false;
 
-        if(start_state != SL_NORMAL && tokens.size() > 0)
+        if(start_state != SPLIT_LINE_STATE::NORMAL && tokens.size() > 0)
         {
             token = tokens[tokens.size()-1];
             tokens.pop_back();
         }
-        if(start_state != SL_NORMAL && bTokenInSafemode.size() > 0)
+        if(start_state != SPLIT_LINE_STATE::NORMAL && bTokenInSafemode.size() > 0)
         {
             inSafemode = bTokenInSafemode[bTokenInSafemode.size()-1];
@@ -280 +280 @@
             switch(state)
             {
-            case SL_NORMAL:
+            case SPLIT_LINE_STATE::NORMAL:
                 if(line[i] == escapeChar)
                 {
-                    state = SL_ESCAPE;
+                    state = SPLIT_LINE_STATE::ESCAPE;
                     if (!bRemoveEscapeChar)
                         token += line[i];
@@ -290 +290 @@
                 else if(line[i] == safemodeChar)
                 {
-                    state = SL_SAFEMODE;
+                    state = SPLIT_LINE_STATE::SAFEMODE;
                     inSafemode = true;
                     if (!bRemoveSafemodeChar)
@@ -298 +298 @@
                 else if(line[i] == openparenthesisChar)
                 {
-                    state = SL_PARENTHESES;
+                    state = SPLIT_LINE_STATE::PARENTHESES;
                     inSafemode = true;
                     if (!bRemoveParenthesisChars)
@@ -318 +318 @@
                     }
                     token += line[i];       // EAT
-                    state = SL_COMMENT;
+                    state = SPLIT_LINE_STATE::COMMENT;
                 }
                 else if(delimiters.find(line[i]) != std::string::npos)
@@ -334 +334 @@
                         inSafemode = false;
                     }
-                    state = SL_NORMAL;
+                    state = SPLIT_LINE_STATE::NORMAL;
                 }
                 else
@@ -353 +353 @@
                 }
                 break;
-            case SL_ESCAPE:
+            case SPLIT_LINE_STATE::ESCAPE:
                 if (!bRemoveSafemodeChar)
                     token += line[i];
@@ -368 +368 @@
                     else token += line[i];  // EAT
                 }
-                state = SL_NORMAL;
-                break;
-            case SL_SAFEMODE:
+                state = SPLIT_LINE_STATE::NORMAL;
+                break;
+            case SPLIT_LINE_STATE::SAFEMODE:
                 if(line[i] == safemodeChar)
                 {
-                    state = SL_NORMAL;
+                    state = SPLIT_LINE_STATE::NORMAL;
                     if (!bRemoveSafemodeChar)
                         token += line[i];
@@ -379 +379 @@
                 else if(line[i] == escapeChar)
                 {
-                    state = SL_SAFEESCAPE;
+                    state = SPLIT_LINE_STATE::SAFEESCAPE;
                 }
                 else
@@ -387 +387 @@
                 break;
 
-            case SL_SAFEESCAPE:
+            case SPLIT_LINE_STATE::SAFEESCAPE:
                 if(line[i] == 'n') token += '\n';
                 else if(line[i] == 't') token += '\t';
@@ -397 +397 @@
                 else if(line[i] == '?') token += '\?';
                 else token += line[i];  // EAT
-                state = SL_SAFEMODE;
-                break;
-
-            case SL_PARENTHESES:
+                state = SPLIT_LINE_STATE::SAFEMODE;
+                break;
+
+            case SPLIT_LINE_STATE::PARENTHESES:
                 if(line[i] == closeparenthesisChar)
                 {
-                    state = SL_NORMAL;
+                    state = SPLIT_LINE_STATE::NORMAL;
                     if (!bRemoveParenthesisChars)
                         token += line[i];
@@ -409 +409 @@
                 else if(line[i] == escapeChar)
                 {
-                    state = SL_PARENTHESESESCAPE;
+                    state = SPLIT_LINE_STATE::PARENTHESESESCAPE;
                 }
                 else
@@ -417 +417 @@
                 break;
 
-            case SL_PARENTHESESESCAPE:
+            case SPLIT_LINE_STATE::PARENTHESESESCAPE:
                 if(line[i] == 'n') token += '\n';
                 else if(line[i] == 't') token += '\t';
@@ -427 +427 @@
                 else if(line[i] == '?') token += '\?';
                 else token += line[i];  // EAT
-                state = SL_PARENTHESES;
-                break;
-
-            case SL_COMMENT:
+                state = SPLIT_LINE_STATE::PARENTHESES;
+                break;
+
+            case SPLIT_LINE_STATE::COMMENT:
                 if(line[i] == '\n')
                 {
@@ -441 +441 @@
                         inSafemode = false;
                     }
-                    state = SL_NORMAL;
+                    state = SPLIT_LINE_STATE::NORMAL;
                 }
                 else

code/branches/cpp11_v3/src/libraries/util/SubString.h

@@ -102 +102 @@
     {
         /// An enumerator for the internal state of the parser
-        enum SPLIT_LINE_STATE
+        enum class SPLIT_LINE_STATE
         {
-            SL_NORMAL,            //!< Normal state
-            SL_ESCAPE,            //!< After an escape character
-            SL_SAFEMODE,          //!< In safe mode (usually between quotation marks).
-            SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
-            SL_COMMENT,           //!< In Comment mode.
-            SL_PARENTHESES,       //!< Between parentheses (usually '{' and '}')
-            SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing parenthesis character.
+            NORMAL,            //!< Normal state
+            ESCAPE,            //!< After an escape character
+            SAFEMODE,          //!< In safe mode (usually between quotation marks).
+            SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
+            COMMENT,           //!< In Comment mode.
+            PARENTHESES,       //!< Between parentheses (usually '{' and '}')
+            PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing parenthesis character.
         };
 
@@ -204 +204 @@
                                           bool bRemoveParenthesisChars = true,
                                           char commentChar = '\0',
-                                          SPLIT_LINE_STATE start_state = SL_NORMAL);
+                                          SPLIT_LINE_STATE start_state = SPLIT_LINE_STATE::NORMAL);
 
         std::vector<std::string>  tokens_;              ///< The tokens after splitting the input line

code/branches/cpp11_v3/src/libraries/util/UtilPrereqs.h

@@ -37 +37 @@
 
 #include "OrxonoxConfig.h"
+#include <string>
 
 //-----------------------------------------------------------------------