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

Timestamp:

Jan 17, 2016, 6:41:22 PM (9 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/core/CorePrereqs.h (modified) (1 diff)
• src/libraries/core/XMLPort.h (modified) (3 diffs)
• src/libraries/core/command/ConsoleCommand.h (modified) (4 diffs)
• src/libraries/core/command/Executor.h (modified) (1 diff)
• src/libraries/core/command/Functor.h (modified) (4 diffs)
• src/libraries/core/command/IOConsolePOSIX.cc (modified) (6 diffs)
• src/libraries/core/command/IOConsoleWindows.cc (modified) (4 diffs)
• src/libraries/core/command/Shell.cc (modified) (3 diffs)
• src/libraries/core/command/Shell.h (modified) (2 diffs)
• src/libraries/core/config/ConfigFileSection.h (modified) (1 diff)
• src/libraries/network/Connection.cc (modified) (11 diffs)
• src/libraries/network/Connection.h (modified) (1 diff)
• src/libraries/network/NetworkPrereqs.h (modified) (2 diffs)
• src/libraries/network/packet/Acknowledgement.cc (modified) (2 diffs)
• src/libraries/network/packet/Chat.cc (modified) (2 diffs)
• src/libraries/network/packet/ClassID.cc (modified) (1 diff)
• src/libraries/network/packet/DeleteObjects.cc (modified) (2 diffs)
• src/libraries/network/packet/FunctionCalls.cc (modified) (1 diff)
• src/libraries/network/packet/FunctionIDs.cc (modified) (1 diff)
• src/libraries/network/packet/Gamestate.h (modified) (1 diff)
• src/libraries/network/packet/Packet.cc (modified) (2 diffs)
• src/libraries/network/packet/Packet.h (modified) (2 diffs)
• src/libraries/network/packet/Welcome.cc (modified) (3 diffs)
• src/libraries/network/synchronisable/Synchronisable.h (modified) (4 diffs)
• 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/core/CorePrereqs.h

@@ -38 +38 @@
 #include "OrxonoxConfig.h"
 #include <boost/version.hpp>
+#include <string>
 
 //-----------------------------------------------------------------------

code/branches/cpp11_v3/src/libraries/core/XMLPort.h

@@ -324 +324 @@
     {
     public:
-        enum ParseResult
+        enum class ParseResult
         {
-            PR_not_started,
-            PR_finished,
-            PR_waiting_for_default_values
+            not_started,
+            finished,
+            waiting_for_default_values
         };
 
         public:
             XMLPortParamContainer()
-                { this->parseResult_ = PR_not_started; }
+                { this->parseResult_ = ParseResult::not_started; }
             virtual ~XMLPortParamContainer() = default;
 
@@ -415 +415 @@
                             this->loadexecutor_->parse(object, attributeValue, &error, ",");
                             if (!error || (mode  == XMLPort::ExpandObject))
-                                this->parseResult_ = PR_finished;
+                                this->parseResult_ = ParseResult::finished;
                             else
-                                this->parseResult_ = PR_waiting_for_default_values;
+                                this->parseResult_ = ParseResult::waiting_for_default_values;
                         }
                         else if (mode == XMLPort::ExpandObject)
-                            this->parseResult_ = PR_finished;
+                            this->parseResult_ = ParseResult::finished;
                         else
-                            this->parseResult_ = PR_waiting_for_default_values;
+                            this->parseResult_ = ParseResult::waiting_for_default_values;
                     }
                     catch (ticpp::Exception& ex)
@@ -449 +449 @@
             XMLPortParamContainer& portIfWaitingForDefaultValues(const ParseResult& result, const ParseParams& params)
             {
-                if (result == PR_waiting_for_default_values)
+                if (result == ParseResult::waiting_for_default_values)
                     return this->port(this->owner_, params);
                 else

code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommand.h

@@ -60 +60 @@
     }
 
-    namespace AccessLevel
+    /**
+        @brief Possible access levels: A command can only be executed if the program is in the state which is requested by the access level.
+    */
+    enum class AccessLevel
     {
-        /**
-            @brief Possible access levels: A command can only be executed if the program is in the state which is requested by the access level.
-        */
-        enum Enum
-        {
-            All,
-            Standalone,
-            Master,
-            Server,
-            Client,
-            Online,
-            Offline,
-            None
-        };
-    }
+        All,
+        Standalone,
+        Master,
+        Server,
+        Client,
+        Online,
+        Offline,
+        None
+    };
 
     /**
@@ -249 +246 @@
 
                     /// Changes the access level of the command.
-                    inline ConsoleCommandManipulator& accessLevel(AccessLevel::Enum level)
+                    inline ConsoleCommandManipulator& accessLevel(AccessLevel level)
                         { if (this->command_) { this->command_->accessLevel(level); } return *this; }
 
@@ -332 +329 @@
 
             /// Changes the access level of the command.
-            inline ConsoleCommand& accessLevel(AccessLevel::Enum level)
+            inline ConsoleCommand& accessLevel(AccessLevel level)
                 { this->accessLevel_ = level; return *this; }
             /// Returns the access level of the command.
-            inline AccessLevel::Enum getAccessLevel() const
+            inline AccessLevel getAccessLevel() const
                 { return this->accessLevel_; }
 
@@ -394 +391 @@
             bool bActive_;                                                  ///< True if the command should be active (it can still be inactive, for example if the function is missing)
             bool bHidden_;                                                  ///< True if the command is hidden (it is still executable, but not visible in the list of available commands)
-            AccessLevel::Enum accessLevel_;                                 ///< The access level (the state of the game in which you can access the command)
+            AccessLevel accessLevel_;                                       ///< The access level (the state of the game in which you can access the command)
             std::string baseName_;                                          ///< The name that was first assigned to the command
             std::vector<CommandName> names_;                                ///< All names and aliases of this command

code/branches/cpp11_v3/src/libraries/core/command/Executor.h

@@ -147 +147 @@
                 { return this->functor_->hasReturnvalue(); }
             /// Returns the type of the wrapped function (static or member).
-            inline Functor::Type::Enum getType() const
+            inline Functor::Type getType() const
                 { return this->functor_->getType(); }
             /// Returns the name of the type of a parameter with given index (the first parameter has index 0).

code/branches/cpp11_v3/src/libraries/core/command/Functor.h

@@ -176 +176 @@
     {
         public:
-            struct Type
-            {
-                /// Defines the type of a function (static or member)
-                enum Enum
-                {
-                    Static,
-                    Member
-                };
+            /// Defines the type of a function (static or member)
+            enum class Type
+            {
+                Static,
+                Member
             };
 
@@ -196 +193 @@
 
             /// Returns the type of the function: static or member.
-            virtual Type::Enum getType() const = 0;
+            virtual Type getType() const = 0;
             /// Returns the number of parameters of the function.
             virtual unsigned int getParamCount() const = 0;
@@ -262 +259 @@
 
             // see Functor::getType()
-            virtual inline Functor::Type::Enum getType() const override
+            virtual inline Functor::Type getType() const override
                 { return Functor::Type::Member; }
 
@@ -339 +336 @@
 
             // see Functor::getType()
-            virtual inline Functor::Type::Enum getType() const override
+            virtual inline Functor::Type getType() const override
                 { return Functor::Type::Static; }
 

code/branches/cpp11_v3/src/libraries/core/command/IOConsolePOSIX.cc

@@ -46 +46 @@
     IOConsole* IOConsole::singletonPtr_s = nullptr;
 
-    namespace EscapeMode
-    {
-        enum Value
-        {
-            None,
-            First,
-            Second
-        };
-    }
+    enum class EscapeMode
+    {
+        None,
+        First,
+        Second
+    };
 
     IOConsole::IOConsole()
@@ -90 +87 @@
         std::cout.flush();
         if (!this->origCout_.str().empty())
-            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
         // Erase input and status lines
         this->cout_ << "\033[1G\033[J";
@@ -111 +108 @@
         unsigned char c;
         std::string escapeSequence;
-        EscapeMode::Value escapeMode = EscapeMode::None;
+        EscapeMode escapeMode = EscapeMode::None;
         while (std::cin.good())
         {
@@ -231 +228 @@
         if (!this->origCout_.str().empty())
         {
-            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
             this->origCout_.str("");
         }
@@ -241 +238 @@
         switch (type)
         {
-            case Shell::Message:
-            case Shell::DebugOutput:     this->cout_ << "\033[0m"; break;
-
-            case Shell::UserError:       this->cout_ << "\033[91m"; break;
-            case Shell::UserWarning:     this->cout_ << "\033[93m"; break;
-            case Shell::UserStatus:      this->cout_ << "\033[92m"; break;
-            case Shell::UserInfo:        this->cout_ << "\033[96m"; break;
-
-            case Shell::InternalError:   this->cout_ << "\033[31m"; break;
-            case Shell::InternalWarning: this->cout_ << "\033[33m"; break;
-            case Shell::InternalStatus:  this->cout_ << "\033[32m"; break;
-            case Shell::InternalInfo:    this->cout_ << "\033[36m"; break;
-
-            case Shell::Verbose:         this->cout_ << "\033[94m"; break;
-            case Shell::VerboseMore:     this->cout_ << "\033[34m"; break;
-            case Shell::VerboseUltra:    this->cout_ << "\033[34m"; break;
-
-            case Shell::Command:         this->cout_ << "\033[95m"; break;
-            case Shell::Hint:            this->cout_ << "\033[35m"; break;
-
-            default:                     this->cout_ << "\033[37m"; break;
+            case Shell::LineType::Message:
+            case Shell::LineType::DebugOutput:     this->cout_ << "\033[0m"; break;
+
+            case Shell::LineType::UserError:       this->cout_ << "\033[91m"; break;
+            case Shell::LineType::UserWarning:     this->cout_ << "\033[93m"; break;
+            case Shell::LineType::UserStatus:      this->cout_ << "\033[92m"; break;
+            case Shell::LineType::UserInfo:        this->cout_ << "\033[96m"; break;
+
+            case Shell::LineType::InternalError:   this->cout_ << "\033[31m"; break;
+            case Shell::LineType::InternalWarning: this->cout_ << "\033[33m"; break;
+            case Shell::LineType::InternalStatus:  this->cout_ << "\033[32m"; break;
+            case Shell::LineType::InternalInfo:    this->cout_ << "\033[36m"; break;
+
+            case Shell::LineType::Verbose:         this->cout_ << "\033[94m"; break;
+            case Shell::LineType::VerboseMore:     this->cout_ << "\033[34m"; break;
+            case Shell::LineType::VerboseUltra:    this->cout_ << "\033[34m"; break;
+
+            case Shell::LineType::Command:         this->cout_ << "\033[95m"; break;
+            case Shell::LineType::Hint:            this->cout_ << "\033[35m"; break;
+
+            default:                               this->cout_ << "\033[37m"; break;
         }
 
@@ -384 +381 @@
     void IOConsole::executed()
     {
-        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::LineType::Command);
     }
 

code/branches/cpp11_v3/src/libraries/core/command/IOConsoleWindows.cc

@@ -97 +97 @@
         std::cout.flush();
         if (!this->origCout_.str().empty())
-            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
 
         this->shell_->unregisterListener(this);
@@ -190 +190 @@
         if (!this->origCout_.str().empty())
         {
-            this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
             this->origCout_.str("");
         }
@@ -202 +202 @@
         switch (type)
         {
-            case Shell::Message:
-            case Shell::DebugOutput:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
-
-            case Shell::UserError:       colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | 0              ; break;
-            case Shell::UserWarning:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
-            case Shell::UserStatus:      colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | 0              ; break;
-            case Shell::UserInfo:        colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
-
-            case Shell::InternalError:   colour = 0                    | FOREGROUND_RED | 0                | 0              ; break;
-            case Shell::InternalWarning: colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
-            case Shell::InternalStatus:  colour = 0                    | 0              | FOREGROUND_GREEN | 0              ; break;
-            case Shell::InternalInfo:    colour = 0                    | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
-
-            case Shell::Verbose:         colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
-            case Shell::VerboseMore:     colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
-            case Shell::VerboseUltra:    colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
-
-            case Shell::Command:         colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
-            case Shell::Hint:            colour = 0                    | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
-
-            default:                     colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::LineType::Message:
+            case Shell::LineType::DebugOutput:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+
+            case Shell::LineType::UserError:       colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::LineType::UserWarning:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::UserStatus:      colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::UserInfo:        colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+
+            case Shell::LineType::InternalError:   colour = 0                    | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::LineType::InternalWarning: colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::InternalStatus:  colour = 0                    | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::InternalInfo:    colour = 0                    | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+
+            case Shell::LineType::Verbose:         colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::LineType::VerboseMore:     colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::LineType::VerboseUltra:    colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+
+            case Shell::LineType::Command:         colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+            case Shell::LineType::Hint:            colour = 0                    | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+
+            default:                               colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
         }
 
@@ -331 +331 @@
     void IOConsole::executed()
     {
-        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::LineType::Command);
     }
 

code/branches/cpp11_v3/src/libraries/core/command/Shell.cc

@@ -268 +268 @@
     {
         // yes it was - push the new line to the list
-        this->outputLines_.push_front(std::make_pair(line, static_cast<LineType>(type)));
+        this->outputLines_.push_front(std::make_pair(line, type));
 
         // adjust the scroll position if needed
@@ -381 +381 @@
         const std::string& result = CommandExecutor::query(this->inputBuffer_->get(), &error);
         if (error)
-            this->addOutput("Error: Can't execute \"" + this->inputBuffer_->get() + "\", " + CommandExecutor::getErrorDescription(error) + ". (Shell)", UserError);
+            this->addOutput("Error: Can't execute \"" + this->inputBuffer_->get() + "\", " + CommandExecutor::getErrorDescription(error) + ". (Shell)", LineType::UserError);
         else if (result != "")
-            this->addOutput(result, Result);
+            this->addOutput(result, LineType::Result);
 
         this->clearInput();
@@ -392 +392 @@
     {
         this->inputBuffer_->set(CommandExecutor::evaluate(this->inputBuffer_->get()).complete());
-        this->addOutput(CommandExecutor::evaluate(this->inputBuffer_->get()).hint(), Hint);
+        this->addOutput(CommandExecutor::evaluate(this->inputBuffer_->get()).hint(), LineType::Hint);
 
         this->inputChanged();

code/branches/cpp11_v3/src/libraries/core/command/Shell.h

@@ -88 +88 @@
         public:
             /// Defines the type of a line of text in the Shell - some types depend on the output level, others are of internal use.
-            enum LineType
+            enum class LineType
             {
                 DebugOutput     = debug_output,
@@ -133 +133 @@
             LineList::const_iterator getEndIterator() const;
 
-            void addOutput(const std::string& text, LineType type = DebugOutput);
-            void addLine(const std::string& line, LineType type = DebugOutput);
+            void addOutput(const std::string& text, LineType type = LineType::DebugOutput);
+            void addLine(const std::string& line, LineType type = LineType::DebugOutput);
             void clearOutput();
 

code/branches/cpp11_v3/src/libraries/core/config/ConfigFileSection.h

@@ -39 +39 @@
 #include <string>
 #include <list>
+#include "util/StringUtils.h"
 #include "ConfigFileEntry.h"
 

code/branches/cpp11_v3/src/libraries/network/Connection.cc

@@ -81 +81 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, nullptr, 0 };
+    outgoingEvent outEvent = { peerID, OutgoingEventType::disconnectPeer, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -91 +91 @@
   void Connection::disconnectPeers()
   {
-    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, nullptr, 0 };
+    outgoingEvent outEvent = { 0, OutgoingEventType::disconnectPeers, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -101 +101 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { peerID, outgoingEventType::sendPacket, packet, channelID };
+    outgoingEvent outEvent = { peerID, OutgoingEventType::sendPacket, packet, channelID };
     
     this->outgoingEventsMutex_->lock();
@@ -112 +112 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { 0, outgoingEventType::broadcastPacket, packet, channelID };
+    outgoingEvent outEvent = { 0, OutgoingEventType::broadcastPacket, packet, channelID };
     
     this->outgoingEventsMutex_->lock();
@@ -197 +197 @@
     switch( event.type )
     {
-      case outgoingEventType::sendPacket:
+      case OutgoingEventType::sendPacket:
         // check whether the peer is still/already in the peer list
         if( this->peerMap_.find(event.peerID) != this->peerMap_.end() )
@@ -211 +211 @@
         }
         break;
-      case outgoingEventType::disconnectPeer:
+      case OutgoingEventType::disconnectPeer:
         if( this->peerMap_.find(event.peerID) != this->peerMap_.end() )
         {
@@ -223 +223 @@
         }
         break;
-      case outgoingEventType::disconnectPeers:
+      case OutgoingEventType::disconnectPeers:
         disconnectPeersInternal();
         break;
-      case outgoingEventType::broadcastPacket:
+      case OutgoingEventType::broadcastPacket:
         enet_host_broadcast( this->host_, event.channelID, event.packet );
         break;
@@ -271 +271 @@
       switch( inEvent.type )
       {
-        case incomingEventType::peerConnect:
+        case IncomingEventType::peerConnect:
           addPeer(inEvent.peerID);
           break;
-        case incomingEventType::peerDisconnect:
+        case IncomingEventType::peerDisconnect:
           removePeer(inEvent.peerID);
           break;
-        case incomingEventType::receivePacket:
+        case IncomingEventType::receivePacket:
           processPacket(inEvent.packet);
           break;
@@ -322 +322 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, nullptr };
+    incomingEvent inEvent = { peerID, IncomingEventType::peerConnect, nullptr };
     return inEvent;
   }
@@ -337 +337 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, nullptr };
+    incomingEvent inEvent = { peerID, IncomingEventType::peerDisconnect, nullptr };
     return inEvent;
   }
@@ -351 +351 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::receivePacket, p };
+    incomingEvent inEvent = { peerID, IncomingEventType::receivePacket, p };
     return inEvent;
   }

code/branches/cpp11_v3/src/libraries/network/Connection.h

@@ -60 +60 @@
   const unsigned int NETWORK_MAX_QUEUE_PROCESS_TIME = 5;
   
-  namespace incomingEventType
+  enum class IncomingEventType
   {
-    enum Value
-    {
-      receivePacket   = 1,  // incoming packet
-      peerConnect     = 2,  // incoming connect request
-      peerDisconnect  = 3   // incoming disconnect request
-    };
-    
-  }
+    receivePacket   = 1,  // incoming packet
+    peerConnect     = 2,  // incoming connect request
+    peerDisconnect  = 3   // incoming disconnect request
+  };
   
-  namespace outgoingEventType
+  enum class OutgoingEventType
   {
-    enum Value
-    {
-      sendPacket      = 1,  // outgoing packet
-      broadcastPacket = 2,  // outgoing broadcast packet
-      disconnectPeer  = 3,  // outgoing disconnect request
-      disconnectPeers = 4   // outgoing disconnect request
-    };
-    
-  }
+    sendPacket      = 1,  // outgoing packet
+    broadcastPacket = 2,  // outgoing broadcast packet
+    disconnectPeer  = 3,  // outgoing disconnect request
+    disconnectPeers = 4   // outgoing disconnect request
+  };
   
   struct _NetworkExport incomingEvent
   {
-    uint32_t                  peerID;
-    incomingEventType::Value  type;
-    packet::Packet*           packet;
+    uint32_t          peerID;
+    IncomingEventType type;
+    packet::Packet*   packet;
   };
   
   struct _NetworkExport outgoingEvent
   {
-    uint32_t                  peerID;
-    outgoingEventType::Value  type;
-    ENetPacket*               packet;
-    ENetChannelID             channelID;
+    uint32_t          peerID;
+    OutgoingEventType type;
+    ENetPacket*       packet;
+    ENetChannelID     channelID;
   };
   

code/branches/cpp11_v3/src/libraries/network/NetworkPrereqs.h

@@ -89 +89 @@
     namespace PacketFlag
     {
-      enum Value
-      {
-        Reliable    = 1,
-        Unsequenced = 2,
-        NoAllocate  = 4
-      };
+      static constexpr uint32_t Reliable    = 1;
+      static constexpr uint32_t Unsequenced = 2;
+      static constexpr uint32_t NoAllocate  = 4;
     }
   }
@@ -101 +98 @@
   {
     typedef int Type;
-    static const Type NETWORK_FUNCTION = 6;
+    static constexpr Type NETWORK_FUNCTION = 6;
   }
 }

code/branches/cpp11_v3/src/libraries/network/packet/Acknowledgement.cc

@@ -38 +38 @@
 #define PACKET_FLAGS_ACK    0
 #define _PACKETID           0
-#define _ACKID              _PACKETID + sizeof(packet::Type::Value)
+#define _ACKID              _PACKETID + sizeof(packet::Type)
 
 Acknowledgement::Acknowledgement( unsigned int id, unsigned int peerID )
@@ -45 +45 @@
   flags_ = flags_ | PACKET_FLAGS_ACK;
   data_=new uint8_t[ getSize() ];
-  *(Type::Value *)(data_ + _PACKETID ) = Type::Acknowledgement;
+  *(Type *)(data_ + _PACKETID ) = Type::Acknowledgement;
   *(uint32_t *)(data_ + _ACKID ) = id;
   peerID_=peerID;

code/branches/cpp11_v3/src/libraries/network/packet/Chat.cc

@@ -40 +40 @@
 /* Some lengths */
 #define _PACKETID         0
-#define _SOURCEID         _PACKETID + sizeof(Type::Value)
+#define _SOURCEID         _PACKETID + sizeof(Type)
 #define _TARGETID         _SOURCEID + sizeof(uint32_t)
 #define _MESSAGELENGTH    _TARGETID + sizeof(uint32_t)
@@ -57 +57 @@
   data_=new unsigned char[ getSize() ];
 
-  *(Type::Value *)(data_ + _PACKETID ) = Type::Chat;
+  *(Type *)(data_ + _PACKETID ) = Type::Chat;
   *(unsigned int *)(data_ + _SOURCEID ) = sourceID;
   *(unsigned int *)(data_ + _TARGETID ) = targetID;

code/branches/cpp11_v3/src/libraries/network/packet/ClassID.cc

@@ -70 +70 @@
   //set the appropriate packet id
   assert(this->data_);
-  *(Type::Value *)(this->data_ + _PACKETID ) = Type::ClassID;
+  *(Type *)(this->data_ + _PACKETID ) = Type::ClassID;
 
   uint8_t *temp=data_+sizeof(uint32_t);

code/branches/cpp11_v3/src/libraries/network/packet/DeleteObjects.cc

@@ -39 +39 @@
 #define PACKET_FLAG_DELETE  PacketFlag::Reliable
 #define _PACKETID           0
-#define _QUANTITY           _PACKETID + sizeof(Type::Value)
+#define _QUANTITY           _PACKETID + sizeof(Type)
 #define _OBJECTIDS          _QUANTITY + sizeof(uint32_t)
 
@@ -63 +63 @@
     return false;
   orxout(verbose, context::packets) << "sending DeleteObjects: ";
-  unsigned int size = sizeof(Type::Value) + sizeof(uint32_t)*(number+1);
+  unsigned int size = sizeof(Type) + sizeof(uint32_t)*(number+1);
   data_ = new uint8_t[size];
   uint8_t *tdata = data_;
-  *reinterpret_cast<Type::Value*>(tdata) = Type::DeleteObjects;
-  tdata += sizeof(Type::Value);
+  *reinterpret_cast<Type*>(tdata) = Type::DeleteObjects;
+  tdata += sizeof(Type);
   *(uint32_t *)tdata = number;
   tdata += sizeof(uint32_t);

code/branches/cpp11_v3/src/libraries/network/packet/FunctionCalls.cc

@@ -96 +96 @@
   assert(this->functionCalls_.size());
   data_=new uint8_t[ currentSize_ ];
-  *(Type::Value *)(data_ + _PACKETID ) = Type::FunctionCalls; // Set the Packet ID
+  *(Type *)(data_ + _PACKETID ) = Type::FunctionCalls; // Set the Packet ID
   *(uint32_t*)(data_+sizeof(uint32_t)) = this->functionCalls_.size(); // set nrOfCalls
   *(uint32_t*)(data_+2*sizeof(uint32_t)) = this->minGamestateID_; // set minGamestateID_

code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.cc

@@ -71 +71 @@
   //set the appropriate packet id
   assert(this->data_);
-  *(Type::Value *)(this->data_ + _PACKETID ) = Type::FunctionIDs;
+  *(Type *)(this->data_ + _PACKETID ) = Type::FunctionIDs;
 
   uint8_t *temp=data_+sizeof(uint32_t);

code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.h

@@ -56 +56 @@
     GamestateHeader(){ data_=nullptr; }
     GamestateHeader(uint8_t* data)
-      { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
+      { assert(data); data_ = data; *(Type*)data_ = Type::Gamestate; }
     /*GamestateHeader(uint8_t* data, GamestateHeader* h)
       { assert(data); data_=data; memcpy(data_, h->data_, getSize()); }*/
     void setData(uint8_t* data)
-      { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
+      { assert(data); data_ = data; *(Type*)data_ = Type::Gamestate; }
     static inline uint32_t getSize()
       { return 21; }

code/branches/cpp11_v3/src/libraries/network/packet/Packet.cc

@@ -157 +157 @@
   }
 #ifndef NDEBUG
-  switch( *(Type::Value *)(data_ + _PACKETID) )
+  switch( *(Type *)(data_ + _PACKETID) )
   {
     case Type::Acknowledgement:
@@ -191 +191 @@
 //     peerID = NETWORK_PEER_ID_SERVER;
   Packet *p = nullptr;
-//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
-  switch( *(Type::Value *)(data + _PACKETID) )
+//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type *)&data[_PACKETID] << endl;
+  switch( *(Type *)(data + _PACKETID) )
   {
     case Type::Acknowledgement:

code/branches/cpp11_v3/src/libraries/network/packet/Packet.h

@@ -38 +38 @@
 {
 
-namespace Direction
+enum class Direction
 {
-  enum Value
-  {
-    Incoming,
-    Outgoing,
-    Bidirectional
-  };
-}
-namespace Type
+  Incoming,
+  Outgoing,
+  Bidirectional
+};
+enum class Type : uint8_t
 {
-  enum Value
-  {
-    Acknowledgement,
-    Chat,
-    ClassID,
-    DeleteObjects,
-    FunctionIDs,
-    FunctionCalls,
-    Gamestate,
-    Welcome
-  };
-}
+  Acknowledgement,
+  Chat,
+  ClassID,
+  DeleteObjects,
+  FunctionIDs,
+  FunctionCalls,
+  Gamestate,
+  Welcome
+};
 
 /**
@@ -98 +92 @@
     unsigned int peerID_;
     uint32_t requiredGamestateID_;
-    Direction::Value packetDirection_;
+    Direction packetDirection_;
     /** Pointer to the data. Be careful when deleting it because it might
         point to a location that was allocated by ENet.

code/branches/cpp11_v3/src/libraries/network/packet/Welcome.cc

@@ -41 +41 @@
 #define PACKET_FLAGS_CLASSID  PacketFlag::Reliable
 #define _PACKETID             0
-#define _CLIENTID             _PACKETID + sizeof(Type::Value)
+#define _CLIENTID             _PACKETID + sizeof(Type)
 #define _ENDIANTEST           _CLIENTID + sizeof(uint32_t)
 
@@ -51 +51 @@
   data_=new uint8_t[ getSize() ];
   assert(data_);
-  *(packet::Type::Value *)(data_ + _PACKETID ) = packet::Type::Welcome;
+  *(packet::Type *)(data_ + _PACKETID ) = packet::Type::Welcome;
   *(uint32_t *)(data_ + _CLIENTID ) = static_cast<uint32_t>(clientID);
   *(uint32_t *)(data_ + _ENDIANTEST ) = 0xFEDC4321;
@@ -70 +70 @@
 
 unsigned int Welcome::getSize() const{
-  return sizeof(packet::Type::Value) + 2*sizeof(uint32_t);
+  return sizeof(packet::Type) + 2*sizeof(uint32_t);
 }
 

code/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.h

@@ -38 +38 @@
 #include <queue>
 #include <set>
+#include <type_traits>
 
 #include "util/mbool.h"
@@ -203 +204 @@
   };
 
-  template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
-  {
+  namespace detail
+  {
+    template <class T, bool = std::is_enum<T>::value>
+    struct UnderlyingType;
+    template <class T>
+    struct UnderlyingType<T, true> { typedef typename std::underlying_type<T>::type type; };
+    template <class T>
+    struct UnderlyingType<T, false> { typedef T type; };
+  }
+
+  template <class T>
+  void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     if (bidirectional)
     {
-      syncList_.push_back(new SynchronisableVariableBidirectional<T>(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<T>(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_);
@@ -218 +231 @@
   }
   
-  template <class T> void Synchronisable::unregisterVariable(T& variable)
+  template <class T>
+  void Synchronisable::unregisterVariable(T& variable)
   {
     std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin();
@@ -238 +252 @@
   }
 
-  template <class T> void Synchronisable::registerVariable( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
-  {
+  template <class T>
+  void Synchronisable::registerVariable( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     SynchronisableVariableBase* sv;
     if (bidirectional)
-      sv = new SynchronisableVariableBidirectional<std::set<T>>(variable, mode, cb);
+      sv = new SynchronisableVariableBidirectional<std::set<UnderlyingType>>(reinterpret_cast<std::set<UnderlyingType>&>(variable), mode, cb);
     else
-      sv = new SynchronisableVariable<std::set<T>>(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);

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>
 
 //-----------------------------------------------------------------------