Index: code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.h	(revision 11001)
+++ code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.h	(revision 11002)
@@ -207,9 +207,9 @@
   {
     template <class T, bool = std::is_enum<T>::value>
-    struct RealType;
+    struct UnderlyingType;
     template <class T>
-    struct RealType<T, true> { typedef typename std::underlying_type<T>::type type; };
+    struct UnderlyingType<T, true> { typedef typename std::underlying_type<T>::type type; };
     template <class T>
-    struct RealType<T, false> { typedef T type; };
+    struct UnderlyingType<T, false> { typedef T type; };
   }
 
@@ -217,13 +217,13 @@
   void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
   {
-    typedef typename detail::RealType<T>::type RealType;
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     if (bidirectional)
     {
-      syncList_.push_back(new SynchronisableVariableBidirectional<RealType>(reinterpret_cast<RealType&>(variable), mode, cb));
+      syncList_.push_back(new SynchronisableVariableBidirectional<UnderlyingType>(reinterpret_cast<UnderlyingType&>(variable), mode, cb));
       this->dataSize_ += syncList_.back()->getSize(state_);
     }
     else
     {
-      syncList_.push_back(new SynchronisableVariable<RealType>(reinterpret_cast<RealType&>(variable), mode, cb));
+      syncList_.push_back(new SynchronisableVariable<UnderlyingType>(reinterpret_cast<UnderlyingType&>(variable), mode, cb));
       if ( this->state_ == mode )
         this->dataSize_ += syncList_.back()->getSize(state_);
@@ -255,10 +255,10 @@
   void Synchronisable::registerVariable( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
   {
-    typedef typename detail::RealType<T>::type RealType;
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     SynchronisableVariableBase* sv;
     if (bidirectional)
-      sv = new SynchronisableVariableBidirectional<std::set<RealType>>(reinterpret_cast<std::set<RealType>&>(variable), mode, cb);
+      sv = new SynchronisableVariableBidirectional<std::set<UnderlyingType>>(reinterpret_cast<std::set<UnderlyingType>&>(variable), mode, cb);
     else
-      sv = new SynchronisableVariable<std::set<RealType>>(reinterpret_cast<std::set<RealType>&>(variable), mode, cb);
+      sv = new SynchronisableVariable<std::set<UnderlyingType>>(reinterpret_cast<std::set<UnderlyingType>&>(variable), mode, cb);
     syncList_.push_back(sv);
     stringList_.push_back(sv);
Index: code/branches/cpp11_v2/src/libraries/util/Math.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/util/Math.h	(revision 11001)
+++ code/branches/cpp11_v2/src/libraries/util/Math.h	(revision 11002)
@@ -47,4 +47,5 @@
 #include <cstdlib>
 #include <random>
+#include <type_traits>
 
 #include <OgreMath.h>
@@ -178,9 +179,15 @@
         @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>());
     }
 
Index: code/branches/cpp11_v2/src/libraries/util/MultiType.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/util/MultiType.h	(revision 11001)
+++ code/branches/cpp11_v2/src/libraries/util/MultiType.h	(revision 11002)
@@ -183,6 +183,19 @@
             /// 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; }
+
+            /// 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,4 +228,18 @@
             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,4 +266,18 @@
             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
             {
@@ -431,8 +472,16 @@
             }
             /// 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));
             }
 
Index: code/branches/cpp11_v2/test/util/MultiTypeTest.cc
===================================================================
--- code/branches/cpp11_v2/test/util/MultiTypeTest.cc	(revision 11001)
+++ code/branches/cpp11_v2/test/util/MultiTypeTest.cc	(revision 11002)
@@ -697,3 +697,242 @@
         EXPECT_TRUE(mt.null());
     }
+
+    ///////////////////////////////
+    // Strongly typed enum class //
+    ///////////////////////////////
+    enum class EnumWithChar : unsigned char
+    {
+        ValueA = 'A',
+        ValueB = 'B',
+        ValueC = 'C',
+    };
+    enum class EnumWithInt
+    {
+        Value1 = 50,
+        Value2 = 0,
+        Value3,
+    };
+
+    TEST(MultiType, Enum_Constructor)
+    {
+        // Constructor:
+        {
+            MultiType mt = EnumWithChar::ValueA;
+
+            EXPECT_TRUE(mt.isType<EnumWithChar>());
+            EXPECT_EQ(EnumWithChar::ValueA, mt.get<EnumWithChar>());
+        }
+        {
+            MultiType mt = MultiType(EnumWithInt::Value1);
+
+            EXPECT_TRUE(mt.isType<EnumWithInt>());
+            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
+        }
+    }
+
+    TEST(MultiType, Enum_Assignment)
+    {
+        // operator=:
+        MultiType mt;
+        mt = EnumWithChar::ValueB;
+
+        EXPECT_TRUE(mt.isType<EnumWithChar>());
+        EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
+    }
+
+    TEST(MultiType, Enum_Set)
+    {
+        // set(value):
+        {
+            MultiType mt;
+            mt.set(EnumWithInt::Value2); // assign enum to an empty MultiType
+
+            EXPECT_TRUE(mt.isType<EnumWithInt>());
+            EXPECT_EQ(EnumWithInt::Value2, mt.get<EnumWithInt>());
+        }
+        {
+            MultiType mt = "string";
+            mt.set(EnumWithChar::ValueC); // assign enum to a MultiType with type std::string
+
+            EXPECT_TRUE(mt.isType<std::string>());
+            EXPECT_EQ("C", mt.get<std::string>());
+        }
+        {
+            MultiType mt = EnumWithChar::ValueA;
+            mt.set(EnumWithChar::ValueB); // assign enum to a MultiType with type std::string
+
+            EXPECT_TRUE(mt.isType<EnumWithChar>());
+            EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
+        }
+        {
+            MultiType mt = EnumWithInt::Value3;
+            mt.set("50"); // assign enum to a MultiType with type std::string
+
+            EXPECT_TRUE(mt.isType<EnumWithInt>());
+            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
+        }
+    }
+
+    TEST(MultiType, Enum_Force)
+    {
+        // force(value):
+        {
+            MultiType mt = "string";
+            EXPECT_TRUE(mt.isType<std::string>());
+            EXPECT_EQ("string", mt.get<std::string>());
+
+            mt.force<EnumWithChar>("C");
+
+            EXPECT_TRUE(mt.isType<EnumWithChar>());
+            EXPECT_EQ(EnumWithChar::ValueC, mt.get<EnumWithChar>());
+        }
+        {
+            MultiType mt = EnumWithChar::ValueA;
+            EXPECT_TRUE(mt.isType<EnumWithChar>());
+            EXPECT_EQ(EnumWithChar::ValueA, mt.get<EnumWithChar>());
+
+            mt.force<std::string>(EnumWithChar::ValueB);
+
+            EXPECT_TRUE(mt.isType<std::string>());
+            EXPECT_EQ("B", mt.get<std::string>());
+        }
+    }
+
+    TEST(MultiType, Enum_Convert)
+    {
+        // convert():
+        {
+            MultiType mt = "C";
+            mt.convert<EnumWithChar>();
+
+            EXPECT_TRUE(mt.isType<EnumWithChar>());
+            EXPECT_EQ(EnumWithChar::ValueC, mt.get<EnumWithChar>());
+        }
+        {
+            MultiType mt = EnumWithChar::ValueA;
+            mt.convert<std::string>();
+
+            EXPECT_TRUE(mt.isType<std::string>());
+            EXPECT_EQ("A", mt.get<std::string>());
+        }
+    }
+
+    TEST(MultiType, Enum_Reset)
+    {
+        // reset():
+        {
+            MultiType mt = EnumWithChar::ValueA;
+            mt.reset<EnumWithChar>();
+
+            EXPECT_TRUE(mt.isType<EnumWithChar>());
+            EXPECT_TRUE(mt.isType<unsigned char>());
+            EXPECT_EQ('\0', mt.get<unsigned char>());
+        }
+        {
+            MultiType mt = "string";
+            mt.reset<EnumWithInt>();
+
+            EXPECT_TRUE(mt.isType<EnumWithInt>());
+            EXPECT_TRUE(mt.isType<int>());
+            EXPECT_EQ(0, mt.get<int>());
+        }
+    }
+
+    TEST(MultiType, Enum_IsType)
+    {
+        // isType():
+        {
+            MultiType mt = EnumWithChar::ValueB;
+            EXPECT_TRUE(mt.isType<EnumWithChar>());
+            EXPECT_TRUE(mt.isType<unsigned char>());
+            EXPECT_FALSE(mt.isType<char>());
+            EXPECT_FALSE(mt.isType<int>());
+            EXPECT_FALSE(mt.isType<bool>());
+            EXPECT_FALSE(mt.isType<std::string>());
+        }
+        {
+            MultiType mt = EnumWithInt::Value3;
+            EXPECT_TRUE(mt.isType<EnumWithInt>());
+            EXPECT_TRUE(mt.isType<int>());
+            EXPECT_FALSE(mt.isType<unsigned char>());
+            EXPECT_FALSE(mt.isType<char>());
+            EXPECT_FALSE(mt.isType<bool>());
+            EXPECT_FALSE(mt.isType<std::string>());
+        }
+    }
+
+    TEST(MultiType, Enum_ConversionOperator)
+    {
+        // conversion operator:
+        {
+            MultiType mt = EnumWithChar::ValueA;
+            EnumWithChar value = mt;
+            EXPECT_EQ(EnumWithChar::ValueA, value);
+        }
+        {
+            MultiType mt = 'B';
+            EnumWithChar value = mt;
+            EXPECT_EQ(EnumWithChar::ValueB, value);
+        }
+        {
+            MultiType mt = EnumWithInt::Value1;
+            std::string value = mt;
+            EXPECT_EQ("50", value);
+        }
+    }
+
+    TEST(MultiType, Enum_GetValue)
+    {
+        // getValue():
+        {
+            MultiType mt = EnumWithChar::ValueA;
+            EnumWithChar value;
+            mt.getValue(&value);
+            EXPECT_EQ(EnumWithChar::ValueA, value);
+        }
+        {
+            MultiType mt = 'B';
+            EnumWithChar value;
+            mt.getValue(&value);
+            EXPECT_EQ(EnumWithChar::ValueB, value);
+        }
+        {
+            MultiType mt = EnumWithInt::Value1;
+            std::string value;
+            mt.getValue(&value);
+            EXPECT_EQ("50", value);
+        }
+    }
+
+    TEST(MultiType, Enum_Get)
+    {
+        // get():
+        {
+            MultiType mt = EnumWithChar::ValueB;
+            EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
+
+            EXPECT_EQ('B', mt.get<unsigned char>());
+            EXPECT_EQ("B", mt.get<std::string>());
+            EXPECT_EQ(66, mt.get<int>());
+            EXPECT_TRUE(mt.get<bool>());
+        }
+        {
+            MultiType mt = EnumWithInt::Value1;
+            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
+
+            EXPECT_EQ('2', mt.get<unsigned char>());
+            EXPECT_EQ("50", mt.get<std::string>());
+            EXPECT_EQ(50, mt.get<int>());
+            EXPECT_TRUE(mt.get<bool>());
+        }
+        {
+            MultiType mt = EnumWithInt::Value2;
+            EXPECT_EQ(EnumWithInt::Value2, mt.get<EnumWithInt>());
+
+            EXPECT_EQ('\0', mt.get<unsigned char>());
+            EXPECT_EQ("0", mt.get<std::string>());
+            EXPECT_EQ(0, mt.get<int>());
+            EXPECT_FALSE(mt.get<bool>());
+        }
+    }
 }
