Index: code/branches/cpp11_v3/src/libraries/core/ApplicationPaths.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ApplicationPaths.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ApplicationPaths.cc	(revision 11054)
@@ -68,5 +68,5 @@
 
     //! Static pointer to the singleton
-    ApplicationPaths* ApplicationPaths::singletonPtr_s  = 0;
+    ApplicationPaths* ApplicationPaths::singletonPtr_s  = nullptr;
 
     ApplicationPaths::ApplicationPaths()
@@ -84,5 +84,5 @@
         // get executable module
         TCHAR buffer[1024];
-        if (GetModuleFileName(NULL, buffer, 1024) == 0)
+        if (GetModuleFileName(nullptr, buffer, 1024) == 0)
             ThrowException(General, "Could not retrieve executable path.");
 
Index: code/branches/cpp11_v3/src/libraries/core/ApplicationPaths.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ApplicationPaths.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ApplicationPaths.h	(revision 11054)
@@ -104,5 +104,7 @@
 
         private:
-            ApplicationPaths(const ApplicationPaths&); //!< Don't use (undefined symbol)
+            // non-copyable:
+            ApplicationPaths(const ApplicationPaths&) = delete;
+            ApplicationPaths& operator=(const ApplicationPaths&) = delete;
 
             std::vector<std::string> getModuleOrPluginPaths(boost::filesystem::path& directory, const std::string& extension);
Index: code/branches/cpp11_v3/src/libraries/core/BaseObject.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/BaseObject.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/BaseObject.cc	(revision 11054)
@@ -65,7 +65,7 @@
         this->bRegisteredEventStates_ = false;
 
-        this->lastLoadedXMLElement_ = 0;
-
-        this->mainStateFunctor_ = 0;
+        this->lastLoadedXMLElement_ = nullptr;
+
+        this->mainStateFunctor_ = nullptr;
 
         if (context)
@@ -86,5 +86,5 @@
         else
         {
-            this->file_ = 0;
+            this->file_ = nullptr;
             this->sceneID_ = OBJECTID_UNKNOWN;
         }
@@ -132,5 +132,5 @@
         XMLPortObject(BaseObject, BaseObject, "eventlisteners", addEventListener, getEventListener, xmlelement, mode);
 
-        Element* events = 0;
+        Element* events = nullptr;
         if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
             events = xmlelement.FirstChildElement("events", false);
@@ -163,6 +163,6 @@
         this->setName(name);
 
-        for (ObjectList<XMLNameListener>::iterator it = ObjectList<XMLNameListener>::begin(); it != ObjectList<XMLNameListener>::end(); ++it)
-            it->loadedNewXMLName(this);
+        for (XMLNameListener* listener : ObjectList<XMLNameListener>())
+            listener->loadedNewXMLName(this);
     }
 
@@ -205,5 +205,5 @@
             Template* link;
             assert(!(link = Template::getTemplate(temp->getLink())) || !link->isLink());
-            link = NULL;
+            link = nullptr;
         }
         else
@@ -234,11 +234,11 @@
     {
         unsigned int i = 0;
-        for (std::set<Template*>::const_iterator it = this->templates_.begin(); it != this->templates_.end(); ++it)
+        for (Template* temp : this->templates_)
         {
             if (i == index)
-                return (*it);
+                return temp;
             i++;
         }
-        return 0;
+        return nullptr;
     }
 
@@ -269,14 +269,14 @@
     {
         unsigned int i = 0;
-        for (std::map<BaseObject*, std::string>::const_iterator it = this->eventSources_.begin(); it != this->eventSources_.end(); ++it)
-        {
-            if (it->second != state)
+        for (const auto& mapEntry : this->eventSources_)
+        {
+            if (mapEntry.second != state)
                 continue;
 
             if (i == index)
-                return it->first;
+                return mapEntry.first;
             ++i;
         }
-        return 0;
+        return nullptr;
     }
 
@@ -296,11 +296,11 @@
     {
         unsigned int i = 0;
-        for (std::set<BaseObject*>::const_iterator it = this->eventListenersXML_.begin(); it != this->eventListenersXML_.end(); ++it)
+        for (BaseObject* listener : this->eventListenersXML_)
         {
             if (i == index)
-                return *it;
+                return listener;
             ++i;
         }
-        return 0;
+        return nullptr;
     }
 
@@ -331,5 +331,5 @@
             return (it->second);
         else
-            return 0;
+            return nullptr;
     }
 
@@ -358,8 +358,8 @@
         Event event(activate, originator, name);
 
-        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
-        {
-            event.statename_ = (*it)->eventSources_[this];
-            (*it)->processEvent(event);
+        for (BaseObject* listener : this->eventListeners_)
+        {
+            event.statename_ = listener->eventSources_[this];
+            listener->processEvent(event);
         }
     }
@@ -370,6 +370,6 @@
     void BaseObject::fireEvent(Event& event)
     {
-        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
-            (*it)->processEvent(event);
+        for (BaseObject* listener : this->eventListeners_)
+            listener->processEvent(event);
     }
 
@@ -423,5 +423,5 @@
     void BaseObject::changedMainStateName()
     {
-        this->mainStateFunctor_ = 0;
+        this->mainStateFunctor_ = nullptr;
 
         if (!this->mainStateName_.empty())
@@ -474,8 +474,6 @@
 
             // iterate through all states and get the event sources
-            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
-            {
-                const std::string& statename = (*it);
-
+            for (const std::string& statename : eventnames)
+            {
                 // if the event state is already known, continue with the next state
                 orxonox::EventState* eventstate = object->getEventState(statename);
Index: code/branches/cpp11_v3/src/libraries/core/BaseObject.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/BaseObject.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/BaseObject.h	(revision 11054)
@@ -163,5 +163,5 @@
             inline void setScene(const StrongOrWeakPtr<Scene>& scene, uint32_t sceneID) { this->scene_ = scene; this->sceneID_=sceneID; }
             inline Scene* getScene() const { return this->scene_.get(); }
-            inline virtual uint32_t getSceneID() const { return this->sceneID_; }
+            virtual inline uint32_t getSceneID() const { return this->sceneID_; }
 
             inline void setGametype(const StrongOrWeakPtr<Gametype>& gametype) { this->gametype_ = gametype; }
@@ -218,5 +218,5 @@
             bool                       bInitialized_;          //!< True if the object was initialized (passed the object registration)
             const XMLFile*             file_;                  //!< The XMLFile that loaded this object
-            Element*                   lastLoadedXMLElement_;  //!< Non 0 if the TinyXML attributes have already been copied to our own lowercase map
+            Element*                   lastLoadedXMLElement_;  //!< Non nullptr if the TinyXML attributes have already been copied to our own lowercase map
             std::map<std::string, std::string> xmlAttributes_; //!< Lowercase XML attributes
             std::string                loaderIndentation_;     //!< Indentation of the debug output in the Loader
@@ -265,5 +265,5 @@
             return this->weakPtr_;
         else
-            return NULL;
+            return nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/ClassTreeMask.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ClassTreeMask.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ClassTreeMask.cc	(revision 11054)
@@ -207,5 +207,5 @@
             return ((*this->nodes_.top().first) == compare);
         else
-            return (compare == 0);
+            return (compare == nullptr);
     }
 
@@ -218,5 +218,5 @@
             return ((*this->nodes_.top().first) != compare);
         else
-            return (compare != 0);
+            return (compare != nullptr);
     }
 
@@ -293,8 +293,8 @@
         {
             // No it's not: Search for classes inheriting from the given class and add the rules for them
-            for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildren().begin(); it != subclass->getDirectChildren().end(); ++it)
-                if ((*it)->isA(this->root_->getClass()))
-                    if (overwrite || (!this->nodeExists(*it))) // If we don't want to overwrite, only add nodes that don't already exist
-                        this->add(this->root_, *it, bInclude, overwrite);
+            for (const Identifier* directChild : subclass->getDirectChildren())
+                if (directChild->isA(this->root_->getClass()))
+                    if (overwrite || (!this->nodeExists(directChild))) // If we don't want to overwrite, only add nodes that don't already exist
+                        this->add(this->root_, directChild, bInclude, overwrite);
         }
 
@@ -325,10 +325,10 @@
         {
             // Search for an already existing node, containing the subclass we want to add
-            for (std::list<ClassTreeMaskNode*>::iterator it = node->subnodes_.begin(); it != node->subnodes_.end(); ++it)
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
             {
-                if (subclass->isA((*it)->getClass()))
+                if (subclass->isA(subnode->getClass()))
                 {
                     // We've found an existing node -> delegate the work with a recursive function-call and return
-                    this->add(*it, subclass, bInclude, overwrite);
+                    this->add(subnode, subclass, bInclude, overwrite);
                     return;
                 }
@@ -392,6 +392,6 @@
         if (!subclass)
             return;
-        for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildren().begin(); it != subclass->getDirectChildren().end(); ++it)
-            this->add(*it, this->isIncluded(*it), false, false);
+        for (const Identifier* directChild : subclass->getDirectChildren())
+            this->add(directChild, this->isIncluded(directChild), false, false);
 
         this->add(subclass, bInclude, false, clean);
@@ -435,7 +435,7 @@
 
             // Go through the list of subnodes and look for a node containing the searched subclass and delegate the request by a recursive function-call.
-            for (std::list<ClassTreeMaskNode*>::iterator it = node->subnodes_.begin(); it != node->subnodes_.end(); ++it)
-                if (subclass->isA((*it)->getClass()))
-                    return isIncluded(*it, subclass);
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
+                if (subclass->isA(subnode->getClass()))
+                    return isIncluded(subnode, subclass);
 
             // There is no subnode containing our class -> the rule of the current node takes in effect
@@ -851,5 +851,5 @@
             this->objectIterator_ = Context::getRootContext()->getObjectList(this->subclassIterator_->first)->begin();
         else
-            this->objectIterator_ = ObjectList<BaseObject>::end();
+            this->objectIterator_ = ObjectList<BaseObject>().end();
 
         // Check if the iterator points on a valid object. If not, go to the next object by calling ++
@@ -915,8 +915,8 @@
 
             // Iterate through all subnodes
-            for (std::list<ClassTreeMaskNode*>::iterator it1 = node->subnodes_.begin(); it1 != node->subnodes_.end(); ++it1)
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
             {
                 // Recursive call to this function with the subnode
-                this->create(*it1);
+                this->create(subnode);
 
                 // Only execute the following code if the current node is included, meaning some of the subnodes might be included too
@@ -926,22 +926,22 @@
 
                     // Iterate through all direct children
-                    for (std::set<const Identifier*>::iterator it2 = directChildren.begin(); it2 != directChildren.end(); ++it2)
+                    for (std::set<const Identifier*>::iterator it = directChildren.begin(); it != directChildren.end(); ++it)
                     {
                         // Check if the subnode (it1) is a child of the directChild (it2)
-                        if ((*it1)->getClass()->isA(*it2))
+                        if (subnode->getClass()->isA(*it))
                         {
                             // Yes it is - remove the directChild (it2) from the list, because it will already be handled by a recursive call to the create() function
-                            directChildren.erase(it2);
+                            directChildren.erase(it);
 
                             // Check if the removed directChild was exactly the subnode
-                            if (!(*it1)->getClass()->isExactlyA(*it2))
+                            if (!subnode->getClass()->isExactlyA(*it))
                             {
                                 // No, it wasn't exactly the subnode - therefore there are some classes between
 
                                 // Add the previously removed directChild (it2) to the subclass-list
-                                this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(*it2, true));
+                                this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(*it, true));
 
                                 // Insert all directChildren of the directChild
-                                directChildren.insert((*it2)->getDirectChildren().begin(), (*it2)->getDirectChildren().end());
+                                directChildren.insert((*it)->getDirectChildren().begin(), (*it)->getDirectChildren().end());
 
                                 // Restart the scan with the expanded set of directChildren
@@ -957,6 +957,6 @@
             // The bool is "false", meaning they have no subnodes and therefore need no further checks
             if (node->isIncluded())
-                for (std::set<const Identifier*>::iterator it = directChildren.begin(); it != directChildren.end(); ++it)
-                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(*it, false));
+                for (const Identifier* directChild : directChildren)
+                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(directChild, false));
         }
     }
Index: code/branches/cpp11_v3/src/libraries/core/ClassTreeMask.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ClassTreeMask.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ClassTreeMask.h	(revision 11054)
@@ -152,10 +152,10 @@
             ClassTreeMaskNode* operator*() const;
             ClassTreeMaskNode* operator->() const;
-            operator bool() const;
+            explicit operator bool() const;
             bool operator==(ClassTreeMaskNode* compare) const;
             bool operator!=(ClassTreeMaskNode* compare) const;
 
         private:
-            std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator> > nodes_;    ///< A stack to store list-iterators
+            std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator>> nodes_;    ///< A stack to store list-iterators
             std::list<ClassTreeMaskNode*> rootlist_;                                                                            ///< A list for internal use (it only stores the root-node)
     };
@@ -211,5 +211,5 @@
             inline const ClassTreeMask& begin() const { return (*this); }
             /// End of the ClassTreeMaskObjectIterator.
-            inline BaseObject*          end()   const { return 0; }
+            inline BaseObject*          end()   const { return nullptr; }
 
             ClassTreeMask& operator=(const ClassTreeMask& other);
@@ -276,5 +276,5 @@
         public:
             /// Default-constructor: Does nothing.
-            inline ClassTreeMaskObjectIterator() {}
+            inline ClassTreeMaskObjectIterator() = default;
             /// Copy-Constructor: Initializes the iterator from another ClassTreeMask.
             inline ClassTreeMaskObjectIterator(const ClassTreeMask& mask) { (*this) = mask; }
@@ -285,9 +285,9 @@
 
             /// Returns true if the ClassTreeMaskObjectIterator points at the given object.
-            inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == 0); }
+            inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == nullptr); }
             /// Returns true if the ClassTreeMaskObjectIterator doesn't point at the given object.
-            inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != 0); }
+            inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != nullptr); }
             /// Returns true if the ClassTreeMaskObjectIterator hasn't already reached the end.
-            inline operator bool() const { return (this->objectIterator_); }
+            inline explicit operator bool() const { return this->objectIterator_.operator bool(); }
             /// Returns the object the ClassTreeMaskObjectIterator currently points at.
             inline BaseObject* operator*() const { return (*this->objectIterator_); }
@@ -298,7 +298,7 @@
             void create(ClassTreeMaskNode* node);
 
-            std::list<std::pair<const Identifier*, bool> >           subclasses_;       ///< A list of all Identifiers through which objects the iterator should iterate
-            std::list<std::pair<const Identifier*, bool> >::iterator subclassIterator_; ///< The current class of the iterator
-            Iterator<BaseObject>                                     objectIterator_;   ///< The current object of the iterator
+            std::list<std::pair<const Identifier*, bool>>           subclasses_;       ///< A list of all Identifiers through which objects the iterator should iterate
+            std::list<std::pair<const Identifier*, bool>>::iterator subclassIterator_; ///< The current class of the iterator
+            Iterator<BaseObject>                                    objectIterator_;   ///< The current object of the iterator
     };
 }
Index: code/branches/cpp11_v3/src/libraries/core/ConfigurablePaths.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ConfigurablePaths.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ConfigurablePaths.cc	(revision 11054)
@@ -54,4 +54,5 @@
 #include "util/Exception.h"
 #include "commandline/CommandLineIncludes.h"
+#include "core/ApplicationPaths.h"
 
 // Differentiate Boost Filesystem v2 and v3
@@ -67,5 +68,5 @@
 
     //! Static pointer to the singleton
-    ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = 0;
+    ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = nullptr;
 
     SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
@@ -122,5 +123,5 @@
             char* userDataPathPtr(getenv("APPDATA"));
 #endif
-            if (userDataPathPtr == NULL)
+            if (userDataPathPtr == nullptr)
                 ThrowException(General, "Could not retrieve user data path.");
             bf::path userDataPath(userDataPathPtr);
@@ -143,9 +144,9 @@
 
         // Create directories to avoid problems when opening files in non existent folders.
-        std::vector<std::pair<bf::path, std::string> > directories;
-        directories.push_back(std::make_pair(bf::path(configPath_), std::string("config")));
-        directories.push_back(std::make_pair(bf::path(logPath_), std::string("log")));
+        std::vector<std::pair<bf::path, std::string>> directories;
+        directories.emplace_back(bf::path(configPath_), std::string("config"));
+        directories.emplace_back(bf::path(logPath_), std::string("log"));
 
-        for (std::vector<std::pair<bf::path, std::string> >::iterator it = directories.begin();
+        for (std::vector<std::pair<bf::path, std::string>>::iterator it = directories.begin();
             it != directories.end(); ++it)
         {
Index: code/branches/cpp11_v3/src/libraries/core/ConfigurablePaths.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ConfigurablePaths.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ConfigurablePaths.h	(revision 11054)
@@ -93,5 +93,7 @@
 
         private:
-            ConfigurablePaths(const ConfigurablePaths&); //!< Don't use (undefined symbol)
+            // non-copyable:
+            ConfigurablePaths(const ConfigurablePaths&) = delete;
+            ConfigurablePaths& operator=(const ConfigurablePaths&) = delete;
 
             boost::filesystem::path& dataPath_;              //!< Path to the data files folder
Index: code/branches/cpp11_v3/src/libraries/core/Core.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Core.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Core.cc	(revision 11054)
@@ -83,5 +83,5 @@
 {
     //! Static pointer to the singleton
-    Core* Core::singletonPtr_s  = 0;
+    Core* Core::singletonPtr_s  = nullptr;
 
     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
@@ -98,24 +98,24 @@
 
     Core::Core(const std::string& cmdLine)
-        : applicationPaths_(NULL)
-        , configurablePaths_(NULL)
-        , dynLibManager_(NULL)
-        , signalHandler_(NULL)
-        , configFileManager_(NULL)
-        , languageInstance_(NULL)
-        , loaderInstance_(NULL)
-        , ioConsole_(NULL)
-        , tclBind_(NULL)
-        , tclThreadManager_(NULL)
-        , rootScope_(NULL)
-        , graphicsManager_(NULL)
-        , inputManager_(NULL)
-        , guiManager_(NULL)
-        , graphicsScope_(NULL)
+        : applicationPaths_(nullptr)
+        , configurablePaths_(nullptr)
+        , dynLibManager_(nullptr)
+        , signalHandler_(nullptr)
+        , configFileManager_(nullptr)
+        , languageInstance_(nullptr)
+        , loaderInstance_(nullptr)
+        , ioConsole_(nullptr)
+        , tclBind_(nullptr)
+        , tclThreadManager_(nullptr)
+        , rootScope_(nullptr)
+        , graphicsManager_(nullptr)
+        , inputManager_(nullptr)
+        , guiManager_(nullptr)
+        , graphicsScope_(nullptr)
         , bGraphicsLoaded_(false)
-        , staticInitHandler_(NULL)
-        , pluginManager_(NULL)
-        , rootModule_(NULL)
-        , config_(NULL)
+        , staticInitHandler_(nullptr)
+        , pluginManager_(nullptr)
+        , rootModule_(nullptr)
+        , config_(nullptr)
         , destructionHelper_(this)
     {
@@ -179,5 +179,5 @@
 
         // initialize root context
-        Context::setRootContext(new Context(NULL));
+        Context::setRootContext(new Context(nullptr));
 
         // Do this soon after the ConfigFileManager has been created to open up the
@@ -282,7 +282,7 @@
 
         const std::vector<std::string>& modulePaths = ApplicationPaths::getInstance().getModulePaths();
-        for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
-        {
-            ModuleInstance* module = new ModuleInstance(*it);
+        for (const std::string& modulePath : modulePaths)
+        {
+            ModuleInstance* module = new ModuleInstance(modulePath);
             this->loadModule(module);
             this->modules_.push_back(module);
@@ -312,7 +312,6 @@
     void Core::unloadModules()
     {
-        for (std::list<ModuleInstance*>::iterator it = this->modules_.begin(); it != this->modules_.end(); ++it)
-        {
-            ModuleInstance* module = (*it);
+        for (ModuleInstance* module : this->modules_)
+        {
             this->unloadModule(module);
             delete module;
@@ -329,5 +328,5 @@
         module->deleteAllStaticallyInitializedInstances();
         this->dynLibManager_->unload(module->getDynLib());
-        module->setDynLib(NULL);
+        module->setDynLib(nullptr);
     }
 
@@ -464,6 +463,6 @@
     {
         // Update UpdateListeners before general ticking
-        for (ObjectList<UpdateListener>::iterator it = ObjectList<UpdateListener>::begin(); it != ObjectList<UpdateListener>::end(); ++it)
-            it->preUpdate(time);
+        for (UpdateListener* listener : ObjectList<UpdateListener>())
+            listener->preUpdate(time);
         if (this->bGraphicsLoaded_)
         {
@@ -474,5 +473,5 @@
         }
         // Process console events and status line
-        if (this->ioConsole_ != NULL)
+        if (this->ioConsole_ != nullptr)
             this->ioConsole_->preUpdate(time);
         // Process thread commands
@@ -483,6 +482,6 @@
     {
         // Update UpdateListeners just before rendering
-        for (ObjectList<UpdateListener>::iterator it = ObjectList<UpdateListener>::begin(); it != ObjectList<UpdateListener>::end(); ++it)
-            it->postUpdate(time);
+        for (UpdateListener* listener : ObjectList<UpdateListener>())
+            listener->postUpdate(time);
         if (this->bGraphicsLoaded_)
         {
Index: code/branches/cpp11_v3/src/libraries/core/Core.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Core.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Core.h	(revision 11054)
@@ -73,5 +73,5 @@
 
             /// Leave empty and use destroy() instead
-            ~Core() {}
+            ~Core() = default;
             /// Destructor that also executes when the object fails to construct
             void destroy();
@@ -92,5 +92,7 @@
 
         private:
-            Core(const Core&); //!< Don't use (undefined symbol)
+            // non-copyable:
+            Core(const Core&) = delete;
+            Core& operator=(const Core&) = delete;
 
             void setThreadAffinity(int limitToCPU);
Index: code/branches/cpp11_v3/src/libraries/core/CoreConfig.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/CoreConfig.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/CoreConfig.cc	(revision 11054)
@@ -35,4 +35,6 @@
 #include "core/Language.h"
 #include "core/ApplicationPaths.h"
+
+#include <random>
 
 namespace orxonox
@@ -106,7 +108,6 @@
     {
         // Inform listeners
-        ObjectList<DevModeListener>::iterator it = ObjectList<DevModeListener>::begin();
-        for (; it != ObjectList<DevModeListener>::end(); ++it)
-            it->devModeChanged(bDevMode_);
+        for (DevModeListener* listener : ObjectList<DevModeListener>())
+            listener->devModeChanged(bDevMode_);
     }
 
@@ -129,5 +130,8 @@
         if (!bInitialized && this->bInitRandomNumberGenerator_)
         {
-            srand(static_cast<unsigned int>(time(0)));
+            std::random_device rnddev;
+            rndseed(rnddev());
+            //Keep the old seeding around because people will probably still use the old functions
+            srand(rnddev());
             rand();
             bInitialized = true;
@@ -137,10 +141,10 @@
     void CoreConfig::updateLastLevelTimestamp()
     {
-        ModifyConfigValue(lastLevelTimestamp_, set, static_cast<long long>(time(NULL)));
+        ModifyConfigValue(lastLevelTimestamp_, set, static_cast<long long>(time(nullptr)));
     }
 
     void CoreConfig::updateOgreConfigTimestamp()
     {
-        ModifyConfigValue(ogreConfigTimestamp_, set, static_cast<long long>(time(NULL)));
+        ModifyConfigValue(ogreConfigTimestamp_, set, static_cast<long long>(time(nullptr)));
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/CoreConfig.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/CoreConfig.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/CoreConfig.h	(revision 11054)
@@ -76,5 +76,5 @@
     public:
         DevModeListener();
-        virtual ~DevModeListener() {}
+        virtual ~DevModeListener() = default;
         virtual void devModeChanged(bool value) = 0;
     };
Index: code/branches/cpp11_v3/src/libraries/core/CoreIncludes.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/CoreIncludes.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/CoreIncludes.h	(revision 11054)
@@ -120,5 +120,5 @@
 */
 #define RegisterAbstractClass(ClassName) \
-    RegisterClassWithFactory(ClassName, static_cast<ClassFactory<ClassName>*>(NULL), false)
+    RegisterClassWithFactory(ClassName, static_cast<ClassFactory<ClassName>*>(nullptr), false)
 
 /**
@@ -221,5 +221,5 @@
         struct InheritsFromClass : public Identifier::InheritsFrom
         {
-            virtual Identifier* getParent() const { return Class(T); }
+            virtual Identifier* getParent() const override { return Class(T); }
         };
 
@@ -231,10 +231,10 @@
             ~StaticallyInitializedIdentifier() { identifier_->destroy(); }
 
-            virtual void load()
+            virtual void load() override
             {
                 IdentifierManager::getInstance().addIdentifier(this->identifier_);
             }
 
-            virtual void unload()
+            virtual void unload() override
             {
                 IdentifierManager::getInstance().removeIdentifier(this->identifier_);
Index: code/branches/cpp11_v3/src/libraries/core/CorePrecompiledHeaders.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/CorePrecompiledHeaders.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/CorePrecompiledHeaders.h	(revision 11054)
@@ -50,4 +50,5 @@
 #include <sstream>  // 53
 #include <set>      // 50
+#include <memory>
 
 #include "util/Output.h" // 48
@@ -66,5 +67,4 @@
 #include <OgreColourValue.h> // 36
 #include <boost/preprocessor/cat.hpp> // 27
-#include <boost/shared_ptr.hpp> // 21
 
 #ifdef ORXONOX_COMPILER_MSVC
@@ -76,5 +76,4 @@
 #include "util/SubString.h"  // 14
 
-#include <boost/scoped_ptr.hpp> // 13
 #include <stack> // 12
 
Index: code/branches/cpp11_v3/src/libraries/core/CorePrereqs.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/CorePrereqs.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/CorePrereqs.h	(revision 11054)
@@ -68,5 +68,5 @@
 namespace orxonox
 {
-    static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
+    static constexpr uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
 }
 
@@ -82,6 +82,6 @@
 
         //!A list of available scopes for the Scope template.
-        static const Value ROOT = 1;
-        static const Value GRAPHICS = 2;
+        static constexpr Value ROOT = 1;
+        static constexpr Value GRAPHICS = 2;
     }
 
@@ -90,9 +90,9 @@
         typedef int Type;
 
-        static const Type STATIC_INITIALIZATION_HANDLER = 1;
-        static const Type IDENTIFIER = 2;
-        static const Type SCOPED_SINGLETON_WRAPPER = 3;
-        static const Type COMMAND_LINE_ARGUMENT = 4;
-        static const Type CONSOLE_COMMAND = 5;
+        static constexpr Type STATIC_INITIALIZATION_HANDLER = 1;
+        static constexpr Type IDENTIFIER = 2;
+        static constexpr Type SCOPED_SINGLETON_WRAPPER = 3;
+        static constexpr Type COMMAND_LINE_ARGUMENT = 4;
+        static constexpr Type CONSOLE_COMMAND = 5;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/CoreStaticInitializationHandler.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 11054)
@@ -99,6 +99,6 @@
         std::set<Identifier*> identifiers;
         const std::set<StaticallyInitializedInstance*>& instances = module->getInstances(StaticInitialization::IDENTIFIER);
-        for (std::set<StaticallyInitializedInstance*>::const_iterator it = instances.begin(); it != instances.end(); ++it)
-            identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(*it)->getIdentifier());
+        for (StaticallyInitializedInstance* instance : instances)
+            identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(instance)->getIdentifier());
 
         // destroy objects. some objects may survive this at first because they still have strong pointers pointing at them. this is
@@ -106,16 +106,16 @@
         // that objects within one module may reference each other by strong pointers. but it is not allowed that objects from another
         // module (which is not unloaded) uses strong pointers to point at objects inside the unloaded module. this will lead to a crash.
-        for (std::set<Identifier*>::iterator it = identifiers.begin(); it != identifiers.end(); ++it)
-            (*it)->destroyObjects();
+        for (Identifier* identifier : identifiers)
+            identifier->destroyObjects();
 
         // check if all objects were really destroyed. this is not the case if an object is referenced by a strong pointer from another
         // module (or if two objects inside this module reference each other). this will lead to a crash and must be fixed (e.g. by
         // changing object dependencies; or by changing the logic that allows modules to be unloaded).
-        for (std::set<Identifier*>::iterator it = identifiers.begin(); it != identifiers.end(); ++it)
+        for (Identifier* identifier : identifiers)
         {
-            ObjectListBase* objectList = Context::getRootContext()->getObjectList(*it);
+            ObjectListBase* objectList = Context::getRootContext()->getObjectList(identifier);
             if (objectList->size() > 0)
             {
-                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (*it)->getName()
+                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << identifier->getName()
                     << " after unloading the Identifier. This may lead to a crash" << endl;
             }
@@ -123,12 +123,12 @@
 
         // destroy object-lists in all contexts
-        for (std::set<Identifier*>::iterator it_identifier = identifiers.begin(); it_identifier != identifiers.end(); ++it_identifier)
+        for (Identifier* identifier : identifiers)
         {
             // only do this if the Identifier is not a Context itself; otherwise we delete the list we're iterating over
-            if (!(*it_identifier)->isExactlyA(Class(Context)))
+            if (!identifier->isExactlyA(Class(Context)))
             {
                 // iterate over all contexts
-                for (ObjectList<Context>::iterator it_context = ObjectList<Context>::begin(); it_context != ObjectList<Context>::end(); ++it_context)
-                    it_context->destroyObjectList((*it_identifier));
+                for (Context* context : ObjectList<Context>())
+                    context->destroyObjectList(identifier);
             }
         }
Index: code/branches/cpp11_v3/src/libraries/core/CoreStaticInitializationHandler.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/CoreStaticInitializationHandler.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/CoreStaticInitializationHandler.h	(revision 11054)
@@ -43,9 +43,9 @@
             CoreStaticInitializationHandler() : bInitInstances_(false) {}
 
-            virtual void setupHandler();
-            virtual void shutdownHandler();
+            virtual void setupHandler() override;
+            virtual void shutdownHandler() override;
 
-            virtual void loadModule(ModuleInstance* module);
-            virtual void unloadModule(ModuleInstance* module);
+            virtual void loadModule(ModuleInstance* module) override;
+            virtual void unloadModule(ModuleInstance* module) override;
 
             inline void setInitInstances(bool bInitInstances)
Index: code/branches/cpp11_v3/src/libraries/core/EventIncludes.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/EventIncludes.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/EventIncludes.h	(revision 11054)
@@ -86,6 +86,8 @@
 
 #define XMLPortEventStateIntern(name, classname, statename, xmlelement, mode) \
-    static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname> >(); \
-    static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname> >(); \
+    static orxonox::ExecutorPtr xmlsetfunctorbase##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')'); \
+    static orxonox::ExecutorPtr xmlgetfunctorbase##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')'); \
+    static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = std::static_pointer_cast<orxonox::ExecutorMember<classname>>(xmlsetfunctorbase##name); \
+    static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = std::static_pointer_cast<orxonox::ExecutorMember<classname>>(xmlgetfunctorbase##name); \
     xmlsetfunctor##name->setDefaultValue(1, statename); \
     xmlgetfunctor##name->setDefaultValue(1, statename); \
Index: code/branches/cpp11_v3/src/libraries/core/GUIManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/GUIManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/GUIManager.cc	(revision 11054)
@@ -32,5 +32,5 @@
 #include <fstream>
 #include <memory>
-#include <boost/bind.hpp>
+#include <functional>
 #include <OgreRenderQueue.h>
 #include <OgreRenderWindow.h>
@@ -119,4 +119,6 @@
 namespace orxonox
 {
+    namespace arg = std::placeholders;
+
     static void key_esc()
         { GUIManager::getInstance().keyESC(); }
@@ -126,5 +128,5 @@
     {
     public:
-        void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
+        virtual void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard) override
         {
             OutputLevel orxonoxLevel = level::debug_output;
@@ -145,5 +147,5 @@
 
         /// Carbon copy from CEGUIDefaultLogger.cpp with a bugfix for Windows
-        void setLogFilename(const CEGUI::String& filename, bool append = false)
+        virtual void setLogFilename(const CEGUI::String& filename, bool append = false) override
         {
             // Close current log file (if any)
@@ -169,5 +171,5 @@
                 d_caching = false;
 
-                std::vector<std::pair<CEGUI::String, CEGUI::LoggingLevel> >::iterator it = d_cache.begin();
+                std::vector<std::pair<CEGUI::String, CEGUI::LoggingLevel>>::iterator it = d_cache.begin();
 
                 while (it != d_cache.end())
@@ -230,5 +232,5 @@
     public:
         /// Callback from Ogre invoked before other stuff in our target queue is rendered
-        void renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, bool& skipThisQueue)
+        virtual void renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, bool& skipThisQueue) override
         {
             if (id == Ogre::RENDER_QUEUE_OVERLAY && invocation.empty())
@@ -252,5 +254,5 @@
     static CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button);
 
-    GUIManager* GUIManager::singletonPtr_s = 0;
+    GUIManager* GUIManager::singletonPtr_s = nullptr;
     /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen"; //Alternative: Orxonox (not fully complete yet, see the graphics menu)
 
@@ -291,18 +293,18 @@
     */
     GUIManager::GUIManager(const std::pair<int, int>& mousePosition)
-        : guiRenderer_(NULL)
-        , resourceProvider_(NULL)
+        : guiRenderer_(nullptr)
+        , resourceProvider_(nullptr)
 #ifndef ORXONOX_OLD_CEGUI
-        , rqListener_(NULL)
-        , imageCodec_(NULL)
-#endif
-        , luaState_(NULL)
-        , scriptModule_(NULL)
-        , guiSystem_(NULL)
-        , ceguiLogger_(NULL)
-        , rootWindow_(NULL)
-        , hudRootWindow_(NULL)
-        , menuRootWindow_(NULL)
-        , camera_(NULL)
+        , rqListener_(nullptr)
+        , imageCodec_(nullptr)
+#endif
+        , luaState_(nullptr)
+        , scriptModule_(nullptr)
+        , guiSystem_(nullptr)
+        , ceguiLogger_(nullptr)
+        , rootWindow_(nullptr)
+        , hudRootWindow_(nullptr)
+        , menuRootWindow_(nullptr)
+        , camera_(nullptr)
         , destructionHelper_(this)
     {
@@ -353,5 +355,5 @@
 
         // Create our own logger to specify the filepath
-        std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
+        std::unique_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
         ceguiLogger->setLogFilename(ConfigurablePaths::getLogPathString() + "cegui.log");
         ceguiLogger->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
@@ -360,5 +362,5 @@
         // Create the CEGUI system singleton
 #ifdef ORXONOX_OLD_CEGUI
-        guiSystem_ = new System(guiRenderer_, resourceProvider_, 0, scriptModule_);
+        guiSystem_ = new System(guiRenderer_, resourceProvider_, nullptr, scriptModule_);
         // Add functions that have been renamed in newer versions
         luaState_->doString("CEGUI.SchemeManager.create = CEGUI.SchemeManager.loadScheme");
@@ -366,5 +368,5 @@
         luaState_->doString("CEGUI.ImagesetManager.createFromImageFile= CEGUI.ImagesetManager.createImagesetFromImageFile");
 #else
-        guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, 0, imageCodec_, scriptModule_);
+        guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, nullptr, imageCodec_, scriptModule_);
 #endif
 
@@ -474,5 +476,5 @@
     {
         assert(guiSystem_);
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectTimePulse, _1, time.getDeltaTime()));
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectTimePulse, arg::_1, time.getDeltaTime()));
     }
 
@@ -490,12 +492,12 @@
     {
 #ifdef ORXONOX_OLD_CEGUI
-        if (camera == NULL)
-            this->guiRenderer_->setTargetSceneManager(0);
+        if (camera == nullptr)
+            this->guiRenderer_->setTargetSceneManager(nullptr);
         else
             this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
 #else
-        if (camera_ != NULL && camera_->getSceneManager() != NULL)
+        if (camera_ != nullptr && camera_->getSceneManager() != nullptr)
             camera_->getSceneManager()->removeRenderQueueListener(rqListener_);
-        if (camera != NULL && camera->getSceneManager() != NULL)
+        if (camera != nullptr && camera->getSceneManager() != nullptr)
             camera->getSceneManager()->addRenderQueueListener(rqListener_);
 #endif
@@ -672,9 +674,9 @@
     {
 #if CEGUI_VERSION >= 0x000800
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectKeyDown, _1, (CEGUI::Key::Scan) evt.getKeyCode())); // TODO: will this cast always work?
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectChar, _1, evt.getText()));
-#else
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectKeyDown, _1, evt.getKeyCode()));
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectChar, _1, evt.getText()));
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectKeyDown, arg::_1, (CEGUI::Key::Scan) evt.getKeyCode())); // TODO: will this cast always work?
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectChar, arg::_1, evt.getText()));
+#else
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectKeyDown, arg::_1, evt.getKeyCode()));
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectChar, arg::_1, evt.getText()));
 #endif
     }
@@ -683,7 +685,7 @@
     {
 #if CEGUI_VERSION >= 0x000800
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectKeyUp, _1, (CEGUI::Key::Scan) evt.getKeyCode())); // TODO: will this cast always work?
-#else
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectKeyUp, _1, evt.getKeyCode()));
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectKeyUp, arg::_1, (CEGUI::Key::Scan) evt.getKeyCode())); // TODO: will this cast always work?
+#else
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectKeyUp, arg::_1, evt.getKeyCode()));
 #endif
     }
@@ -701,7 +703,7 @@
     {
 #if CEGUI_VERSION >= 0x000800
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectMouseButtonDown, _1, convertButton(id)));
-#else
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectMouseButtonDown, _1, convertButton(id)));
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectMouseButtonDown, arg::_1, convertButton(id)));
+#else
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectMouseButtonDown, arg::_1, convertButton(id)));
 #endif
     }
@@ -719,7 +721,7 @@
     {
 #if CEGUI_VERSION >= 0x000800
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectMouseButtonUp, _1, convertButton(id)));
-#else
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectMouseButtonUp, _1, convertButton(id)));
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectMouseButtonUp, arg::_1, convertButton(id)));
+#else
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectMouseButtonUp, arg::_1, convertButton(id)));
 #endif
     }
@@ -728,7 +730,7 @@
     {
 #if CEGUI_VERSION >= 0x000800
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectMousePosition, _1, (float)abs.x, (float)abs.y));
-#else
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectMousePosition, _1, (float)abs.x, (float)abs.y));
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectMousePosition, arg::_1, (float)abs.x, (float)abs.y));
+#else
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectMousePosition, arg::_1, (float)abs.x, (float)abs.y));
 #endif
     }
@@ -737,7 +739,7 @@
     {
 #if CEGUI_VERSION >= 0x000800
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectMouseWheelChange, _1, (float)sgn(rel) * this->numScrollLines_));
-#else
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectMouseWheelChange, _1, (float)sgn(rel) * this->numScrollLines_));
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectMouseWheelChange, arg::_1, (float)sgn(rel) * this->numScrollLines_));
+#else
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectMouseWheelChange, arg::_1, (float)sgn(rel) * this->numScrollLines_));
 #endif
     }
@@ -749,7 +751,7 @@
     {
 #if CEGUI_VERSION >= 0x000800
-        this->protectedCeguiContextCall(boost::bind(&CEGUI::GUIContext::injectMouseLeaves, _1));
-#else
-        this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectMouseLeaves, _1));
+        this->protectedCeguiContextCall(std::bind(&CEGUI::GUIContext::injectMouseLeaves, arg::_1));
+#else
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectMouseLeaves, arg::_1));
 #endif
     }
@@ -798,5 +800,5 @@
         terminate the whole program...
     @note
-        Your life gets easier if you use boost::bind to create the object/function.
+        Your life gets easier if you use std::bind to create the object/function.
     @param function
         Any callable object/function that takes this->guiSystem_ as its only parameter.
@@ -921,5 +923,5 @@
             return;
 
-        CEGUI::Font* font = NULL;
+        CEGUI::Font* font = nullptr;
         CEGUI::XMLAttributes xmlAttributes;
 
@@ -937,5 +939,5 @@
 
         font = CEGUI::FontManager::getSingleton().createFont("FreeType", xmlAttributes);
-        if(font != NULL)
+        if(font != nullptr)
             font->load();
 #else
Index: code/branches/cpp11_v3/src/libraries/core/GUIManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/GUIManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/GUIManager.h	(revision 11054)
@@ -40,4 +40,5 @@
 #include <map>
 #include <string>
+#include <memory>
 
 #if CEGUI_VERSION >= 0x000800
@@ -48,6 +49,4 @@
 #   include <CEGUIVersion.h>
 #endif
-
-#include <boost/shared_ptr.hpp>
 
 #include "util/DestructionHelper.h"
@@ -98,5 +97,5 @@
 
         //! Leave empty and use cleanup() instead
-        ~GUIManager() {}
+        ~GUIManager() = default;
         /// Destructor that also executes when object fails to construct
         void destroy();
@@ -137,5 +136,5 @@
         inline void setPlayer(const std::string& guiname, PlayerInfo* player)
             { this->players_[guiname] = player; }
-        inline orxonox::PlayerInfo* getPlayer(const std::string& guiname) const { std::map<std::string, PlayerInfo*>::const_iterator it = this->players_.find(guiname); return (it != this->players_.end()) ? it->second : 0; } // tolua_export
+        inline orxonox::PlayerInfo* getPlayer(const std::string& guiname) const { std::map<std::string, PlayerInfo*>::const_iterator it = this->players_.find(guiname); return (it != this->players_.end()) ? it->second : nullptr; } // tolua_export
 
         // TODO: Temporary hack because the tolua exported CEGUI method does not seem to work
@@ -154,5 +153,7 @@
 
     private:
-        GUIManager(const GUIManager& instance); //!< private and undefined copy c'tor (this is a singleton class)
+        // non-copyable:
+        GUIManager(const GUIManager&) = delete;
+        GUIManager& operator=(const GUIManager&) = delete;
 
         void executeCode(const std::string& str);
@@ -172,17 +173,17 @@
 
         // keyHandler functions
-        void buttonPressed (const KeyEvent& evt);
-        void buttonReleased(const KeyEvent& evt);
+        virtual void buttonPressed (const KeyEvent& evt) override;
+        virtual void buttonReleased(const KeyEvent& evt) override;
 
         // mouseHandler functions
-        void buttonPressed (MouseButtonCode::ByEnum id);
-        void buttonReleased(MouseButtonCode::ByEnum id);
-        void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
-        void mouseScrolled (int abs, int rel);
+        virtual void buttonPressed (MouseButtonCode::ByEnum id) override;
+        virtual void buttonReleased(MouseButtonCode::ByEnum id) override;
+        virtual void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) override;
+        virtual void mouseScrolled (int abs, int rel) override;
         void mouseLeft     ();
 
         // window event handler
-        virtual void windowResized(unsigned int newWidth, unsigned int newHeight);
-        virtual void windowFocusChanged(bool bFocus);
+        virtual void windowResized(unsigned int newWidth, unsigned int newHeight) override;
+        virtual void windowFocusChanged(bool bFocus) override;
 
 #ifdef ORXONOX_OLD_CEGUI
@@ -198,5 +199,5 @@
         CEGUI::LuaScriptModule*              scriptModule_;         //!< CEGUI's script module to use Lua
         CEGUI::System*                       guiSystem_;            //!< CEGUI's main system
-        shared_ptr<ResourceInfo>             rootFileInfo_;         //!< Resource information about the root script
+        std::shared_ptr<ResourceInfo>        rootFileInfo_;         //!< Resource information about the root script
         CEGUI::Logger*                       ceguiLogger_;          //!< CEGUI's logger to be able to log CEGUI errors in our log
         int                                  outputLevelCeguiLog_;  //!< CEGUI's log level
Index: code/branches/cpp11_v3/src/libraries/core/Game.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Game.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Game.cc	(revision 11054)
@@ -36,5 +36,4 @@
 
 #include <exception>
-#include <boost/weak_ptr.hpp>
 #include <loki/ScopeGuard.h>
 
@@ -66,5 +65,5 @@
 
     std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;
-    Game* Game::singletonPtr_s = 0;
+    Game* Game::singletonPtr_s = nullptr;
 
     //! Represents one node of the game state tree.
@@ -72,14 +71,14 @@
     {
         std::string name_;
-        weak_ptr<GameStateTreeNode> parent_;
-        std::vector<shared_ptr<GameStateTreeNode> > children_;
+        std::weak_ptr<GameStateTreeNode> parent_;
+        std::vector<std::shared_ptr<GameStateTreeNode>> children_;
     };
 
     Game::Game(const std::string& cmdLine)
-        : gameClock_(NULL)
-        , core_(NULL)
+        : gameClock_(nullptr)
+        , core_(nullptr)
         , bChangingState_(false)
         , bAbort_(false)
-        , config_(NULL)
+        , config_(nullptr)
         , destructionHelper_(this)
     {
@@ -116,13 +115,12 @@
 
         // After the core has been created, we can safely instantiate the GameStates that don't require graphics
-        for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
-            it != gameStateDeclarations_s.end(); ++it)
-        {
-            if (!it->second.bGraphicsMode)
-                constructedStates_[it->second.stateName] = GameStateFactory::fabricate(it->second);
+        for (const auto& mapEntry : gameStateDeclarations_s)
+        {
+            if (!mapEntry.second.bGraphicsMode)
+                constructedStates_[mapEntry.second.stateName] = GameStateFactory::fabricate(mapEntry.second);
         }
 
         // The empty root state is ALWAYS loaded!
-        this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode());
+        this->rootStateNode_ = std::shared_ptr<GameStateTreeNode>(std::make_shared<GameStateTreeNode>());
         this->rootStateNode_->name_ = "emptyRootGameState";
         this->loadedTopStateNode_ = this->rootStateNode_;
@@ -137,5 +135,5 @@
 
         assert(loadedStates_.size() <= 1); // Just empty root GameState
-        // Destroy all GameStates (shared_ptrs take care of actual destruction)
+        // Destroy all GameStates (std::shared_ptrs take care of actual destruction)
         constructedStates_.clear();
 
@@ -235,5 +233,5 @@
         while (this->requestedStateNodes_.size() > 0)
         {
-            shared_ptr<GameStateTreeNode> requestedStateNode = this->requestedStateNodes_.front();
+            std::shared_ptr<GameStateTreeNode> requestedStateNode = this->requestedStateNodes_.front();
             assert(this->loadedTopStateNode_);
             if (!this->loadedTopStateNode_->parent_.expired() && requestedStateNode == this->loadedTopStateNode_->parent_.lock())
@@ -263,6 +261,5 @@
     {
         // Note: The first element is the empty root state, which doesn't need ticking
-        for (GameStateVector::const_iterator it = this->loadedStates_.begin() + 1;
-            it != this->loadedStates_.end(); ++it)
+        for (const std::shared_ptr<GameState>& state : this->loadedStates_)
         {
             try
@@ -270,17 +267,17 @@
                 // Add tick time for most of the states
                 uint64_t timeBeforeTick = 0;
-                if ((*it)->getInfo().bIgnoreTickTime)
+                if (state->getInfo().bIgnoreTickTime)
                     timeBeforeTick = this->gameClock_->getRealMicroseconds();
-                (*it)->update(*this->gameClock_);
-                if ((*it)->getInfo().bIgnoreTickTime)
+                state->update(*this->gameClock_);
+                if (state->getInfo().bIgnoreTickTime)
                     this->subtractTickTime(static_cast<int32_t>(this->gameClock_->getRealMicroseconds() - timeBeforeTick));
             }
             catch (...)
             {
-                orxout(user_error) << "An exception occurred while updating '" << (*it)->getName() << "': " << Exception::handleMessage() << endl;
+                orxout(user_error) << "An exception occurred while updating '" << state->getName() << "': " << Exception::handleMessage() << endl;
                 orxout(user_error) << "This should really never happen!" << endl;
                 orxout(user_error) << "Unloading all GameStates depending on the one that crashed." << endl;
-                shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
-                while (current->name_ != (*it)->getName() && current)
+                std::shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
+                while (current->name_ != state->getName() && current)
                     current = current->parent_.lock();
                 if (current && current->parent_.lock())
@@ -372,5 +369,5 @@
         }
 
-        shared_ptr<GameStateTreeNode> lastRequestedNode;
+        std::shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->loadedTopStateNode_;
@@ -384,5 +381,5 @@
 
         // Check children first
-        std::vector<shared_ptr<GameStateTreeNode> > requestedNodes;
+        std::vector<std::shared_ptr<GameStateTreeNode>> requestedNodes;
         for (unsigned int i = 0; i < lastRequestedNode->children_.size(); ++i)
         {
@@ -397,6 +394,6 @@
         {
             // Check parent and all its grand parents
-            shared_ptr<GameStateTreeNode> currentNode = lastRequestedNode;
-            while (currentNode != NULL)
+            std::shared_ptr<GameStateTreeNode> currentNode = lastRequestedNode;
+            while (currentNode != nullptr)
             {
                 if (currentNode->name_ == name)
@@ -405,5 +402,5 @@
                 requestedNodes.push_back(currentNode);
             }
-            if (currentNode == NULL)
+            if (currentNode == nullptr)
                 requestedNodes.clear();
         }
@@ -424,5 +421,5 @@
     void Game::popState()
     {
-        shared_ptr<GameStateTreeNode> lastRequestedNode;
+        std::shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->loadedTopStateNode_;
@@ -435,5 +432,5 @@
     }
 
-    shared_ptr<GameState> Game::getState(const std::string& name)
+    std::shared_ptr<GameState> Game::getState(const std::string& name)
     {
         GameStateMap::const_iterator it = constructedStates_.find(name);
@@ -447,5 +444,5 @@
             else
                 orxout(internal_error) << "Could not find GameState '" << name << "'." << endl;
-            return shared_ptr<GameState>();
+            return std::shared_ptr<GameState>();
         }
     }
@@ -454,5 +451,5 @@
     {
         // Split string into pieces of the form whitespacesText
-        std::vector<std::pair<std::string, int> > stateStrings;
+        std::vector<std::pair<std::string, int>> stateStrings;
         size_t pos = 0;
         size_t startPos = 0;
@@ -465,13 +462,13 @@
             while (pos < str.size() && str[pos] != ' ')
                 ++pos;
-            stateStrings.push_back(std::make_pair(str.substr(startPos, pos - startPos), indentation));
+            stateStrings.emplace_back(str.substr(startPos, pos - startPos), indentation);
         }
         if (stateStrings.empty())
             ThrowException(GameState, "Emtpy GameState hierarchy provided, terminating.");
         // Add element with large identation to detect the last with just an iterator
-        stateStrings.push_back(std::make_pair(std::string(), -1));
+        stateStrings.emplace_back(std::string(), -1);
 
         // Parse elements recursively
-        std::vector<std::pair<std::string, int> >::const_iterator begin = stateStrings.begin();
+        std::vector<std::pair<std::string, int>>::const_iterator begin = stateStrings.begin();
         parseStates(begin, this->rootStateNode_);
     }
@@ -479,8 +476,8 @@
     /*** Internal ***/
 
-    void Game::parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
+    void Game::parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, std::shared_ptr<GameStateTreeNode> currentNode)
     {
         SubString tokens(it->first, ",");
-        std::vector<std::pair<std::string, int> >::const_iterator startIt = it;
+        std::vector<std::pair<std::string, int>>::const_iterator startIt = it;
 
         for (unsigned int i = 0; i < tokens.size(); ++i)
@@ -491,5 +488,5 @@
             if (tokens[i] == this->rootStateNode_->name_)
                 ThrowException(GameState, "You shouldn't use 'emptyRootGameState' in the hierarchy...");
-            shared_ptr<GameStateTreeNode> node(new GameStateTreeNode());
+            std::shared_ptr<GameStateTreeNode> node(std::make_shared<GameStateTreeNode>());
             node->name_ = tokens[i];
             node->parent_ = currentNode;
@@ -521,13 +518,12 @@
 
             // Construct all the GameStates that require graphics
-            for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
-                it != gameStateDeclarations_s.end(); ++it)
-            {
-                if (it->second.bGraphicsMode)
+            for (const auto& mapEntry : gameStateDeclarations_s)
+            {
+                if (mapEntry.second.bGraphicsMode)
                 {
                     // Game state loading failure is serious --> don't catch
-                    shared_ptr<GameState> gameState = GameStateFactory::fabricate(it->second);
+                    std::shared_ptr<GameState> gameState = GameStateFactory::fabricate(mapEntry.second);
                     if (!constructedStates_.insert(std::make_pair(
-                        it->second.stateName, gameState)).second)
+                        mapEntry.second.stateName, gameState)).second)
                         assert(false); // GameState was already created!
                 }
@@ -582,5 +578,5 @@
             graphicsUnloader.Dismiss();
 
-        shared_ptr<GameState> state = this->getState(name);
+        std::shared_ptr<GameState> state = this->getState(name);
         state->activateInternal();
         if (!this->loadedStates_.empty())
@@ -599,5 +595,5 @@
         try
         {
-            shared_ptr<GameState> state = this->getState(name);
+            std::shared_ptr<GameState> state = this->getState(name);
             state->activity_.topState = false;
             this->loadedStates_.pop_back();
@@ -613,6 +609,6 @@
         // Check if graphics is still required
         bool graphicsRequired = false;
-        for (unsigned i = 0; i < loadedStates_.size(); ++i)
-            graphicsRequired |= loadedStates_[i]->getInfo().bGraphicsMode;
+        for (const std::shared_ptr<GameState>& state : loadedStates_)
+            graphicsRequired |= state->getInfo().bGraphicsMode;
         if (!graphicsRequired)
             this->unloadGraphics(!this->bAbort_); // if abort is false, that means the game is still running while unloading graphics. in this case we load a graphics manager without renderer (to keep all necessary ogre instances alive)
@@ -620,13 +616,13 @@
     }
 
-    /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory> >& Game::GameStateFactory::getFactories()
-    {
-        static std::map<std::string, shared_ptr<GameStateFactory> > factories;
+    /*static*/ std::map<std::string, std::shared_ptr<Game::GameStateFactory>>& Game::GameStateFactory::getFactories()
+    {
+        static std::map<std::string, std::shared_ptr<GameStateFactory>> factories;
         return factories;
     }
 
-    /*static*/ shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
-    {
-        std::map<std::string, shared_ptr<Game::GameStateFactory> >::const_iterator it = getFactories().find(info.className);
+    /*static*/ std::shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
+    {
+        std::map<std::string, std::shared_ptr<Game::GameStateFactory>>::const_iterator it = getFactories().find(info.className);
         assert(it != getFactories().end());
         return it->second->fabricateInternal(info);
Index: code/branches/cpp11_v3/src/libraries/core/Game.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Game.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Game.h	(revision 11054)
@@ -44,5 +44,5 @@
 #include <string>
 #include <vector>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <boost/preprocessor/cat.hpp>
 
@@ -84,7 +84,7 @@
     { // tolua_export
         friend class Singleton<Game>;
-        typedef std::vector<shared_ptr<GameState> > GameStateVector;
-        typedef std::map<std::string, shared_ptr<GameState> > GameStateMap;
-        typedef shared_ptr<GameStateTreeNode> GameStateTreeNodePtr;
+        typedef std::vector<std::shared_ptr<GameState>> GameStateVector;
+        typedef std::map<std::string, std::shared_ptr<GameState>> GameStateMap;
+        typedef std::shared_ptr<GameStateTreeNode> GameStateTreeNodePtr;
 
     public:
@@ -92,10 +92,10 @@
 
         //! Leave empty and use cleanup() instead
-        ~Game() {}
+        ~Game() = default;
         /// Destructor that also executes when object fails to construct
         void destroy();
 
         void setStateHierarchy(const std::string& str);
-        shared_ptr<GameState> getState(const std::string& name);
+        std::shared_ptr<GameState> getState(const std::string& name);
 
         void run();
@@ -122,12 +122,12 @@
         {
         public:
-            virtual ~GameStateFactory() { }
-            static shared_ptr<GameState> fabricate(const GameStateInfo& info);
+            virtual ~GameStateFactory() = default;
+            static std::shared_ptr<GameState> fabricate(const GameStateInfo& info);
             template <class T>
             static void createFactory(const std::string& className)
                 { getFactories()[className].reset(new TemplateGameStateFactory<T>()); }
 
-            virtual shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) = 0;
-            static std::map<std::string, shared_ptr<GameStateFactory> >& getFactories();
+            virtual std::shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) = 0;
+            static std::map<std::string, std::shared_ptr<GameStateFactory>>& getFactories();
         };
         template <class T>
@@ -135,6 +135,6 @@
         {
         public:
-            shared_ptr<GameState> fabricateInternal(const GameStateInfo& info)
-                { return shared_ptr<GameState>(new T(info)); }
+            virtual std::shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) override
+                { return std::shared_ptr<GameState>(std::make_shared<T>(info)); }
         };
 
@@ -145,10 +145,12 @@
         };
 
-        Game(Game&); // don't mess with singletons
+        // non-copyable:
+        Game(const Game&) = delete;
+        Game& operator=(const Game&) = delete;
 
         void loadGraphics();
         void unloadGraphics(bool loadGraphicsManagerWithoutRenderer = true);
 
-        void parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
+        void parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, std::shared_ptr<GameStateTreeNode> currentNode);
         bool checkState(const std::string& name) const;
         void loadState(const std::string& name);
Index: code/branches/cpp11_v3/src/libraries/core/GameMode.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/GameMode.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/GameMode.h	(revision 11054)
@@ -63,7 +63,9 @@
 
         private:
-            GameMode();
-            GameMode(const GameMode& inst);
-            ~GameMode();
+            // static class, no instances allowed:
+            GameMode() = delete;
+            GameMode(const GameMode&) = delete;
+            GameMode& operator=(const GameMode&) = delete;
+            ~GameMode() = delete;
 
             /// Checks if we're in control of the game (either standalone or server).
Index: code/branches/cpp11_v3/src/libraries/core/GraphicsManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/GraphicsManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/GraphicsManager.cc	(revision 11054)
@@ -34,5 +34,4 @@
 #include <sstream>
 #include <boost/filesystem.hpp>
-#include <boost/shared_array.hpp>
 
 #include <OgreFrameListener.h>
@@ -83,15 +82,15 @@
     {
     public:
-        void windowResized     (Ogre::RenderWindow* rw)
+        virtual void windowResized     (Ogre::RenderWindow* rw) override
             { orxonox::WindowEventListener::resizeWindow(rw->getWidth(), rw->getHeight()); }
-        void windowFocusChange (Ogre::RenderWindow* rw)
+        virtual void windowFocusChange (Ogre::RenderWindow* rw) override
             { orxonox::WindowEventListener::changeWindowFocus(rw->isActive()); }
-        void windowClosed      (Ogre::RenderWindow* rw)
+        virtual void windowClosed      (Ogre::RenderWindow* rw) override
             { orxonox::Game::getInstance().stop(); }
-        void windowMoved       (Ogre::RenderWindow* rw)
+        virtual void windowMoved       (Ogre::RenderWindow* rw) override
             { orxonox::WindowEventListener::moveWindow(); }
     };
 
-    GraphicsManager* GraphicsManager::singletonPtr_s = 0;
+    GraphicsManager* GraphicsManager::singletonPtr_s = nullptr;
 
     RegisterAbstractClass(GraphicsManager).inheritsFrom<Configurable>();
@@ -99,6 +98,6 @@
     GraphicsManager::GraphicsManager(bool bLoadRenderer)
         : ogreWindowEventListener_(new OgreWindowEventListener())
-        , renderWindow_(0)
-        , viewport_(0)
+        , renderWindow_(nullptr)
+        , viewport_(nullptr)
         , lastFrameStartTime_(0.0f)
         , lastFrameEndTime_(0.0f)
@@ -178,5 +177,5 @@
     void GraphicsManager::upgradeToGraphics()
     {
-        if (renderWindow_ != NULL)
+        if (renderWindow_ != nullptr)
             return;
 
@@ -304,5 +303,5 @@
         //       But in our case we only have one viewport for now anyway, therefore
         //       no ScopeGuards or anything to handle exceptions.
-        this->viewport_ = this->renderWindow_->addViewport(0, 0);
+        this->viewport_ = this->renderWindow_->addViewport(nullptr, 0);
 
         Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(Ogre::MIP_UNLIMITED);
@@ -312,5 +311,5 @@
         HWND hwnd;
         this->renderWindow_->getCustomAttribute("WINDOW", (void*)&hwnd);
-        LONG iconID = (LONG)LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(101));
+        LONG iconID = (LONG)LoadIcon(GetModuleHandle(nullptr), MAKEINTRESOURCE(101));
         SetClassLong(hwnd, GCL_HICON, iconID);
 #endif
@@ -390,6 +389,6 @@
         GUIManager::getInstance().setCamera(camera);
 
-        for (ObjectList<ViewportEventListener>::iterator it = ObjectList<ViewportEventListener>::begin(); it != ObjectList<ViewportEventListener>::end(); ++it)
-            it->cameraChanged(this->viewport_, oldCamera);
+        for (ViewportEventListener* listener : ObjectList<ViewportEventListener>())
+            listener->cameraChanged(this->viewport_, oldCamera);
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/GraphicsManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/GraphicsManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/GraphicsManager.h	(revision 11054)
@@ -47,6 +47,7 @@
 #include <cassert>
 #include <string>
+#include <memory>
+
 #include <OgreLog.h>
-#include <boost/shared_ptr.hpp>
 
 #include "util/DestructionHelper.h"
@@ -70,5 +71,5 @@
 
         //! Leave empty and use cleanup() instead
-        ~GraphicsManager() {}
+        ~GraphicsManager() = default;
         /// Destructor that also executes when object fails to construct
         void destroy();
@@ -96,10 +97,12 @@
         void loadDebugOverlay();
         void unloadDebugOverlay();
-        bool rendererLoaded() const { return renderWindow_ != NULL; }
+        bool rendererLoaded() const { return renderWindow_ != nullptr; }
 
         void setCamera(Ogre::Camera* camera);
 
     private:
-        GraphicsManager(GraphicsManager&); // don't mess with singletons
+        // non-copyable:
+        GraphicsManager(const GraphicsManager&) = delete;
+        GraphicsManager& operator=(const GraphicsManager&) = delete;
 
         // OGRE initialisation
@@ -110,7 +113,7 @@
         // event from Ogre::LogListener
 #if OGRE_VERSION >= 0x010800
-        void messageLogged(const std::string& message, Ogre::LogMessageLevel lml, bool maskDebug, const std::string& logName, bool& skipThisMessage);
+        virtual void messageLogged(const std::string& message, Ogre::LogMessageLevel lml, bool maskDebug, const std::string& logName, bool& skipThisMessage) override;
 #else
-        void messageLogged(const std::string& message, Ogre::LogMessageLevel lml, bool maskDebug, const std::string& logName);
+        virtual void messageLogged(const std::string& message, Ogre::LogMessageLevel lml, bool maskDebug, const std::string& logName) override;
 #endif
 
@@ -130,7 +133,7 @@
 
         // XML files for the resources and the debug overlay
-        shared_ptr<XMLFile> resources_;                //!< XML with resource locations
-        shared_ptr<XMLFile> extResources_;             //!< XML with resource locations in the external path (only for dev runs)
-        shared_ptr<XMLFile> debugOverlay_;             //!< XML with various debug overlays
+        std::shared_ptr<XMLFile> resources_;           //!< XML with resource locations
+        std::shared_ptr<XMLFile> extResources_;        //!< XML with resource locations in the external path (only for dev runs)
+        std::shared_ptr<XMLFile> debugOverlay_;        //!< XML with various debug overlays
 
         // config values
Index: code/branches/cpp11_v3/src/libraries/core/Language.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Language.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Language.cc	(revision 11054)
@@ -88,5 +88,5 @@
     // ###############################
 
-    Language* Language::singletonPtr_s = 0;
+    Language* Language::singletonPtr_s = nullptr;
 
     /**
@@ -107,6 +107,6 @@
     Language::~Language()
     {
-        for (std::map<std::string, LanguageEntry*>::iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
-            delete (it->second);
+        for (const auto& mapEntry : this->languageEntries_)
+            delete (mapEntry.second);
     }
 
@@ -319,7 +319,7 @@
 
         // Iterate through the list an write the lines into the file
-        for (std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
-        {
-            file << it->second->getLabel() << '=' << it->second->getDefault() << endl;
+        for (const auto& mapEntry : this->languageEntries_)
+        {
+            file << mapEntry.second->getLabel() << '=' << mapEntry.second->getDefault() << endl;
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/Language.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Language.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Language.h	(revision 11054)
@@ -171,5 +171,7 @@
 
         private:
-            Language(const Language&);
+            // non-copyable:
+            Language(const Language&) = delete;
+            Language& operator=(const Language&) = delete;
 
             void readDefaultLanguageFile();
Index: code/branches/cpp11_v3/src/libraries/core/Loader.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Loader.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Loader.cc	(revision 11054)
@@ -31,5 +31,4 @@
 #include <sstream>
 #include <tinyxml/ticpp.h>
-#include <boost/scoped_ptr.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
@@ -48,5 +47,5 @@
 namespace orxonox
 {
-    Loader* Loader::singletonPtr_s = 0;
+    Loader* Loader::singletonPtr_s = nullptr;
 
     /**
@@ -73,5 +72,5 @@
         std::string xmlInput;
 
-        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > lineTrace(new std::vector<std::vector<std::pair<std::string, size_t> > >());
+        std::shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> lineTrace(std::make_shared<std::vector<std::vector<std::pair<std::string, size_t>>>>());
         lineTrace->reserve(1000); //arbitrary number
 
@@ -80,5 +79,5 @@
         {
             // Use the LuaState to replace the XML tags (calls our function)
-            scoped_ptr<LuaState> luaState(new LuaState());
+            const std::unique_ptr<LuaState> luaState(new LuaState());
             luaState->setTraceMap(lineTrace);
             luaState->setIncludeParser(&Loader::replaceLuaTags);
@@ -88,6 +87,6 @@
         else
         {
-            shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename());
-            if (info == NULL)
+            std::shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename());
+            if (info == nullptr)
             {
                 orxout(user_error, context::loader) << "Could not find XML file '" << file->getFilename() << "'." << endl;
@@ -163,10 +162,10 @@
                     if (line <= lineTrace->size())
                     {
-                        std::vector<std::pair<std::string, size_t> > linesources = lineTrace->at(line - 1);
+                        std::vector<std::pair<std::string, size_t>> linesources = lineTrace->at(line - 1);
                         std::ostringstream message;
                         message << "Possible sources of error:" << endl;
-                        for (std::vector<std::pair<std::string, size_t> >::iterator it = linesources.begin(); it != linesources.end(); ++it)
+                        for (const std::pair<std::string, size_t>& pair : linesources)
                         {
-                            message << it->first << ", Line " << it->second << endl;
+                            message << pair.first << ", Line " << pair.second << endl;
                         }
                         orxout(user_error, context::loader) << message.str() << endl;
@@ -208,5 +207,5 @@
         if (!file)
             return;
-        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; )
+        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>().begin(); it; )
         {
             if ((it->getFile() == file) && mask.isIncluded(it->getIdentifier()))
@@ -262,7 +261,7 @@
         {
             bool expectedValue = true;
-            for (std::map<size_t, bool>::iterator it = luaTags.begin(); it != luaTags.end(); ++it)
-            {
-                if (it->second == expectedValue)
+            for (const auto& mapEntry : luaTags)
+            {
+                if (mapEntry.second == expectedValue)
                     expectedValue = !expectedValue;
                 else
Index: code/branches/cpp11_v3/src/libraries/core/Loader.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Loader.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Loader.h	(revision 11054)
@@ -67,5 +67,5 @@
             static bool getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags);
 
-            std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_;
+            std::vector<std::pair<const XMLFile*, ClassTreeMask>> files_;
 
             static Loader* singletonPtr_s;
Index: code/branches/cpp11_v3/src/libraries/core/LuaState.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/LuaState.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/LuaState.cc	(revision 11054)
@@ -48,5 +48,5 @@
     LuaState::LuaState()
         : bIsRunning_(false)
-        , includeParseFunction_(NULL)
+        , includeParseFunction_(nullptr)
     {
         // Create new lua state and configure it
@@ -79,10 +79,10 @@
     }
 
-    shared_ptr<ResourceInfo> LuaState::getFileInfo(const std::string& filename)
+    std::shared_ptr<ResourceInfo> LuaState::getFileInfo(const std::string& filename)
     {
         // Look in the current directory first
-        shared_ptr<ResourceInfo> sourceInfo = Resource::getInfo(sourceFileInfo_->path + filename);
+        std::shared_ptr<ResourceInfo> sourceInfo = Resource::getInfo(sourceFileInfo_->path + filename);
         // Continue search in root directories
-        if (sourceInfo == NULL && !sourceFileInfo_->path.empty())
+        if (sourceInfo == nullptr && !sourceFileInfo_->path.empty())
             sourceInfo = Resource::getInfo(filename);
         return sourceInfo;
@@ -91,6 +91,6 @@
     bool LuaState::includeFile(const std::string& filename)
     {
-        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
-        if (sourceInfo != NULL)
+        std::shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
+        if (sourceInfo != nullptr)
             return this->includeString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
         else
@@ -101,14 +101,14 @@
     }
 
-    bool LuaState::includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
+    bool LuaState::includeString(const std::string& code, const std::shared_ptr<ResourceInfo>& sourceFileInfo)
     {
         // Parse string with provided include parser (otherwise don't preparse at all)
         std::string luaInput;
-        if (includeParseFunction_ != NULL)
+        if (includeParseFunction_ != nullptr)
             luaInput = (*includeParseFunction_)(code);
         else
             luaInput = code;
 
-        if (sourceFileInfo != NULL)
+        if (sourceFileInfo != nullptr)
         {
             // Also fill a map with the actual source code. This is just for the include* commands
@@ -119,8 +119,8 @@
         bool returnValue = this->doString(luaInput, sourceFileInfo);
 
-        if (sourceFileInfo != NULL)
+        if (sourceFileInfo != nullptr)
         {
             // Delete source code entry
-            if (sourceFileInfo != NULL)
+            if (sourceFileInfo != nullptr)
                 this->sourceCodeMap_.erase(sourceFileInfo->filename);
         }
@@ -131,6 +131,6 @@
     bool LuaState::doFile(const std::string& filename)
     {
-        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
-        if (sourceInfo != NULL)
+        std::shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
+        if (sourceInfo != nullptr)
             return this->doString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
         else
@@ -141,14 +141,14 @@
     }
 
-    bool LuaState::doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
+    bool LuaState::doString(const std::string& code, const std::shared_ptr<ResourceInfo>& sourceFileInfo)
     {
         // Save the old source file info
-        shared_ptr<ResourceInfo> oldSourceFileInfo = sourceFileInfo_;
+        std::shared_ptr<ResourceInfo> oldSourceFileInfo = sourceFileInfo_;
         // Only override if sourceFileInfo provides useful information
-        if (sourceFileInfo != NULL)
+        if (sourceFileInfo != nullptr)
             sourceFileInfo_ = sourceFileInfo;
 
         std::string chunkname;
-        if (sourceFileInfo != NULL)
+        if (sourceFileInfo != nullptr)
         {
             // Provide lua_load with the filename for debug purposes
@@ -245,5 +245,5 @@
             //Note: due to newlines etc., it's possible that one line consists of parts of
             //      multiple, different files
-            std::vector<std::vector<std::pair<std::string, size_t> > >::reverse_iterator it = lineTrace_->rbegin();
+            std::vector<std::vector<std::pair<std::string, size_t>>>::reverse_iterator it = lineTrace_->rbegin();
             std::pair<std::string, size_t> temppair = std::make_pair(filename, line);
             //Avoid duplicate entries. This could happen if there were lua blocks on the same line
@@ -259,7 +259,7 @@
             {
                 //Add the new line to the trace map
-                lineTrace_->push_back(std::vector<std::pair<std::string, size_t> >());
+                lineTrace_->emplace_back();
                 //Add the source of the line at the end
-                lineTrace_->rbegin()->push_back(std::make_pair(filename, line + i));
+                lineTrace_->rbegin()->emplace_back(filename, line + i);
             }
         }
@@ -285,6 +285,6 @@
     bool LuaState::fileExists(const std::string& filename)
     {
-        shared_ptr<ResourceInfo> info = this->getFileInfo(filename);
-        if (info == NULL)
+        std::shared_ptr<ResourceInfo> info = this->getFileInfo(filename);
+        if (info == nullptr)
             return false;
         else
@@ -300,6 +300,6 @@
         if (it != this->sourceCodeMap_.end())
             return it->second;
-        shared_ptr<ResourceInfo> info = Resource::getInfo(filename);
-        if (info == NULL)
+        std::shared_ptr<ResourceInfo> info = Resource::getInfo(filename);
+        if (info == nullptr)
             return "";
         else
@@ -326,7 +326,7 @@
     /*static*/ bool LuaState::addToluaInterface(int (*function)(lua_State*), const std::string& name)
     {
-        for (ToluaInterfaceMap::const_iterator it = getToluaInterfaces().begin(); it != getToluaInterfaces().end(); ++it)
-        {
-            if (it->first == name || it->second == function)
+        for (const auto& mapEntry : getToluaInterfaces())
+        {
+            if (mapEntry.first == name || mapEntry.second == function)
             {
                 orxout(internal_warning, context::lua) << "Trying to add a Tolua interface with the same name or function." << endl;
@@ -337,6 +337,6 @@
 
         // Open interface in all LuaStates
-        for (std::vector<LuaState*>::const_iterator it = getInstances().begin(); it != getInstances().end(); ++it)
-            (*function)((*it)->luaState_);
+        for (LuaState* state : getInstances())
+            (*function)(state->luaState_);
 
         // Return dummy bool
@@ -354,8 +354,8 @@
 
         // Close interface in all LuaStates
-        for (std::vector<LuaState*>::const_iterator itState = getInstances().begin(); itState != getInstances().end(); ++itState)
-        {
-            lua_pushnil((*itState)->luaState_);
-            lua_setglobal((*itState)->luaState_, it->first.c_str());
+        for (LuaState* state : getInstances())
+        {
+            lua_pushnil(state->luaState_);
+            lua_setglobal(state->luaState_, it->first.c_str());
         }
 
@@ -369,14 +369,14 @@
     /*static*/ void LuaState::openToluaInterfaces(lua_State* state)
     {
-        for (ToluaInterfaceMap::const_iterator it = getToluaInterfaces().begin(); it != getToluaInterfaces().end(); ++it)
-            (*it->second)(state);
+        for (const auto& mapEntry : getToluaInterfaces())
+            (mapEntry.second)(state);
     }
 
     /*static*/ void LuaState::closeToluaInterfaces(lua_State* state)
     {
-        for (ToluaInterfaceMap::const_iterator it = getToluaInterfaces().begin(); it != getToluaInterfaces().end(); ++it)
+        for (const auto& mapEntry : getToluaInterfaces())
         {
             lua_pushnil(state);
-            lua_setglobal(state, it->first.c_str());
+            lua_setglobal(state, mapEntry.first.c_str());
         }
     }
Index: code/branches/cpp11_v3/src/libraries/core/LuaState.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/LuaState.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/LuaState.h	(revision 11054)
@@ -47,5 +47,5 @@
 #include <string>
 #include <vector>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include "util/Output.h"
@@ -79,8 +79,8 @@
 
         bool doFile(const std::string& filename); // tolua_export
-        bool doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
+        bool doString(const std::string& code, const std::shared_ptr<ResourceInfo>& sourceFileInfo = std::shared_ptr<ResourceInfo>());
 
         bool includeFile(const std::string& filename); // tolua_export
-        bool includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
+        bool includeString(const std::string& code, const std::shared_ptr<ResourceInfo>& sourceFileInfo = std::shared_ptr<ResourceInfo>());
 
         void luaPrint(const std::string& str); // tolua_export
@@ -94,12 +94,12 @@
         void clearOutput() { output_.clear(); } // tolua_export
 
-        void setTraceMap(shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > map)
-            { map->push_back(std::vector<std::pair<std::string, size_t> >()); lineTrace_ = map; }
+        void setTraceMap(std::shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> map)
+            { map->emplace_back(); lineTrace_ = map; }
 
         void setIncludeParser(std::string (*function)(const std::string&)) { includeParseFunction_ = function; }
         lua_State* getInternalLuaState() { return luaState_; }
 
-        void setDefaultResourceInfo(const shared_ptr<ResourceInfo>& sourceFileInfo) { this->sourceFileInfo_ = sourceFileInfo; }
-        const shared_ptr<ResourceInfo>& getDefaultResourceInfo() { return this->sourceFileInfo_; }
+        void setDefaultResourceInfo(const std::shared_ptr<ResourceInfo>& sourceFileInfo) { this->sourceFileInfo_ = sourceFileInfo; }
+        const std::shared_ptr<ResourceInfo>& getDefaultResourceInfo() { return this->sourceFileInfo_; }
 
         LuaFunctor* createLuaFunctor(const std::string& code) { return new LuaFunctor(code, this); } // tolua_export
@@ -115,11 +115,11 @@
 
     private:
-        shared_ptr<ResourceInfo> getFileInfo(const std::string& filename);
-        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > lineTrace_;
+        std::shared_ptr<ResourceInfo> getFileInfo(const std::string& filename);
+        std::shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> lineTrace_;
         
         std::stringstream output_;
         lua_State* luaState_;
         bool bIsRunning_;
-        shared_ptr<ResourceInfo> sourceFileInfo_;
+        std::shared_ptr<ResourceInfo> sourceFileInfo_;
         std::map<std::string, std::string> sourceCodeMap_;
         std::string (*includeParseFunction_)(const std::string&);
Index: code/branches/cpp11_v3/src/libraries/core/Namespace.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Namespace.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Namespace.cc	(revision 11054)
@@ -53,6 +53,6 @@
     {
         if (this->bRoot_)
-            for (std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it)
-                delete (*it);
+            for (NamespaceNode* node : this->representingNamespaces_)
+                delete node;
     }
 
@@ -80,7 +80,7 @@
             for (unsigned int i = 0; i < tokens.size(); i++)
             {
-                for (std::set<NamespaceNode*>::iterator it = this->getNamespace()->representingNamespaces_.begin(); it != this->getNamespace()->representingNamespaces_.end(); ++it)
+                for (NamespaceNode* node : this->getNamespace()->representingNamespaces_)
                 {
-                    std::set<NamespaceNode*> temp = (*it)->getNodeRelative(tokens[i]);
+                    std::set<NamespaceNode*> temp = node->getNodeRelative(tokens[i]);
                     this->representingNamespaces_.insert(temp.begin(), temp.end());
                 }
@@ -93,8 +93,8 @@
         if (this->bAutogeneratedFileRootNamespace_)
         {
-            for (std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it)
+            for (NamespaceNode* node : this->representingNamespaces_)
             {
-                (*it)->setRoot(true);
-                (*it)->setHidden(true);
+                node->setRoot(true);
+                node->setHidden(true);
             }
         }
@@ -109,14 +109,14 @@
     const BaseObject* Namespace::saveObjects(unsigned int index) const
     {
-        return 0; // todo
+        return nullptr; // todo
     }
 
     bool Namespace::includes(const Namespace* ns) const
     {
-        for (std::set<NamespaceNode*>::const_iterator it1 = this->representingNamespaces_.begin(); it1 != this->representingNamespaces_.end(); ++it1)
+        for (NamespaceNode* node1 : this->representingNamespaces_)
         {
-            for (std::set<NamespaceNode*>::const_iterator it2 = ns->representingNamespaces_.begin(); it2 != ns->representingNamespaces_.end(); ++it2)
+            for (NamespaceNode* node2 : ns->representingNamespaces_)
             {
-                if ((*it1)->includes(*it2))
+                if (node1->includes(node2))
                 {
                     if (this->operator_ == "or")
@@ -149,10 +149,11 @@
 
         int i = 0;
-        for (std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it)
+        for (NamespaceNode* node : this->representingNamespaces_)
         {
             if (i > 0)
                 output += " / ";
 
-            output += (*it)->toString();
+            output += node->toString();
+            i++;
         }
 
@@ -165,10 +166,11 @@
 
         int i = 0;
-        for (std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it)
+        for (NamespaceNode* node : this->representingNamespaces_)
         {
             if (i > 0)
                 output += '\n';
 
-            output += (*it)->toString(indentation);
+            output += node->toString(indentation);
+            i++;
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/Namespace.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Namespace.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Namespace.h	(revision 11054)
@@ -50,5 +50,5 @@
             virtual ~Namespace();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
             void loadObjects(BaseObject* object);
Index: code/branches/cpp11_v3/src/libraries/core/NamespaceNode.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/NamespaceNode.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/NamespaceNode.cc	(revision 11054)
@@ -103,9 +103,9 @@
                 bool bFoundMatchingNamespace = false;
 
-                for (std::map<std::string, NamespaceNode*>::iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
+                for (const auto& mapEntry : this->subnodes_)
                 {
-                    if (it->first.find(firstPart) == (it->first.size() - firstPart.size()))
+                    if (mapEntry.first.find(firstPart) == (mapEntry.first.size() - firstPart.size()))
                     {
-                        std::set<NamespaceNode*> temp2 = it->second->getNodeRelative(secondPart);
+                        std::set<NamespaceNode*> temp2 = mapEntry.second->getNodeRelative(secondPart);
                         nodes.insert(temp2.begin(), temp2.end());
                         bFoundMatchingNamespace = true;
@@ -132,6 +132,6 @@
         else
         {
-            for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
-                if (it->second->includes(ns))
+            for (const auto& mapEntry : this->subnodes_)
+                if (mapEntry.second->includes(ns))
                     return true;
         }
@@ -149,10 +149,11 @@
 
             int i = 0;
-            for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); i++, ++it)
+            for (const auto& mapEntry : this->subnodes_)
             {
                 if (i > 0)
                     output += ", ";
 
-                output += it->second->toString();
+                output += mapEntry.second->toString();
+                i++;
             }
 
@@ -167,6 +168,6 @@
         std::string output = (indentation + this->name_ + '\n');
 
-        for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
-            output += it->second->toString(indentation + "  ");
+        for (const auto& mapEntry : this->subnodes_)
+            output += mapEntry.second->toString(indentation + "  ");
 
         return output;
Index: code/branches/cpp11_v3/src/libraries/core/NamespaceNode.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/NamespaceNode.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/NamespaceNode.h	(revision 11054)
@@ -46,5 +46,5 @@
     {
         public:
-            NamespaceNode(const std::string& name, NamespaceNode* parent = 0);
+            NamespaceNode(const std::string& name, NamespaceNode* parent = nullptr);
             ~NamespaceNode();
 
Index: code/branches/cpp11_v3/src/libraries/core/Resource.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Resource.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Resource.cc	(revision 11054)
@@ -58,7 +58,7 @@
         DataStreamListPtr resources(new Ogre::DataStreamList());
         const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        for (const std::string& group : groups)
         {
-            DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, *it);
+            DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
             resources->insert(resources->end(), temp->begin(), temp->end());
         }
@@ -79,5 +79,5 @@
     }
 
-    shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name)
+    std::shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name)
     {
         std::string group;
@@ -88,5 +88,5 @@
         catch (const Ogre::Exception&)
         {
-            return shared_ptr<ResourceInfo>();
+            return std::shared_ptr<ResourceInfo>();
         }
         Ogre::FileInfoListPtr infos = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(group, name);
@@ -95,5 +95,5 @@
             if (it->filename == name)
             {
-                shared_ptr<ResourceInfo> ptr(new ResourceInfo());
+                std::shared_ptr<ResourceInfo> ptr(std::make_shared<ResourceInfo>());
                 ptr->filename = name;
                 ptr->path = it->path;
@@ -102,7 +102,7 @@
                 ptr->size = it->uncompressedSize;
 #if OGRE_VERSION >= 0x010800
-                if (dynamic_cast<const Ogre::FileSystemArchive*>(it->archive) != NULL)
+                if (dynamic_cast<const Ogre::FileSystemArchive*>(it->archive) != nullptr)
 #else
-                if (dynamic_cast<Ogre::FileSystemArchive*>(it->archive) != NULL)
+                if (dynamic_cast<Ogre::FileSystemArchive*>(it->archive) != nullptr)
 #endif
                 {
@@ -114,5 +114,5 @@
             }
         }
-        return shared_ptr<ResourceInfo>();
+        return std::shared_ptr<ResourceInfo>();
     }
 
@@ -121,7 +121,7 @@
         StringVectorPtr resourceNames(new Ogre::StringVector());
         const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        for (const std::string& group : groups)
         {
-            StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(*it, pattern);
+            StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(group, pattern);
             resourceNames->insert(resourceNames->end(), temp->begin(), temp->end());
         }
Index: code/branches/cpp11_v3/src/libraries/core/Resource.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Resource.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Resource.h	(revision 11054)
@@ -42,5 +42,6 @@
 #include "CorePrereqs.h"
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
+
 #include <OgreDataStream.h>
 #include <OgreStringVector.h>
@@ -93,5 +94,5 @@
 
         //! Similar to open(string, string, bool), but with a fileInfo struct
-        static DataStreamPtr open(shared_ptr<ResourceInfo> fileInfo)
+        static DataStreamPtr open(std::shared_ptr<ResourceInfo> fileInfo)
         {
             return open(fileInfo->filename);
@@ -125,5 +126,5 @@
             Fully qualified name of the file to test for
         */
-        static shared_ptr<ResourceInfo> getInfo(const std::string& name);
+        static std::shared_ptr<ResourceInfo> getInfo(const std::string& name);
 
         /**
@@ -140,7 +141,9 @@
 
     private:
-        Resource();
-        ~Resource();
-        Resource(const Resource& instance);
+        // static class, no instances allowed:
+        Resource() = delete;
+        Resource(const Resource&) = delete;
+        Resource& operator=(const Resource&) = delete;
+        ~Resource() = delete;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/core/Template.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Template.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Template.cc	(revision 11054)
@@ -49,5 +49,5 @@
         this->bLoadDefaults_ = true;
         this->bIsReturningXMLElement_ = false;
-        this->baseclassIdentifier_ = 0;
+        this->baseclassIdentifier_ = nullptr;
     }
 
@@ -176,5 +176,5 @@
         {
             orxout(internal_warning, context::templates) << "Template with name " << name << " doesn't exist." << endl;
-            return 0;
+            return nullptr;
         }
     }
Index: code/branches/cpp11_v3/src/libraries/core/Template.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Template.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Template.h	(revision 11054)
@@ -54,6 +54,6 @@
             virtual ~Template();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            virtual void changedName();
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void changedName() override;
 
             inline void setLink(const std::string& link)
Index: code/branches/cpp11_v3/src/libraries/core/Thread.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/Thread.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/Thread.cc	(revision 11054)
@@ -34,6 +34,6 @@
 
 #include <cassert>
+#include <functional>
 #include <boost/thread/thread.hpp>
-#include <boost/bind.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread_time.hpp>
@@ -48,5 +48,5 @@
 
     Thread::Thread():
-        executor_(0),
+        executor_(nullptr),
         isWorking_(false),
         stopThread_(false)
@@ -55,5 +55,5 @@
         this->isWorkingMutex_ = new boost::mutex;
         this->stopThreadMutex_ = new boost::mutex;
-        this->workerThread_ = new boost::thread( boost::bind(&Thread::threadLoop, this) );
+        this->workerThread_ = new boost::thread( std::bind(&Thread::threadLoop, this) );
     }
 
@@ -102,5 +102,5 @@
                 (*executor)();
                 this->executorMutex_->lock();
-                this->executor_ = 0;
+                this->executor_ = nullptr;
                 this->executorMutex_->unlock();
                 this->isWorkingMutex_->lock();
Index: code/branches/cpp11_v3/src/libraries/core/ThreadPool.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ThreadPool.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ThreadPool.cc	(revision 11054)
@@ -83,11 +83,10 @@
     bool ThreadPool::passFunction( const ExecutorPtr& executor, bool addThread )
     {
-        std::vector<Thread*>::iterator it;
-        for ( it=this->threadPool_.begin(); it!=this->threadPool_.end(); ++it )
+        for ( Thread* thread : threadPool_ )
         {
-            if ( ! (*it)->isWorking() )
+            if ( ! thread->isWorking() )
             {
                 // If that fails, then there is some code error
-                OrxVerify( (*it)->evaluateExecutor( executor ), "ERROR: could not evaluate Executor" );
+                OrxVerify( thread->evaluateExecutor( executor ), "ERROR: could not evaluate Executor" );
                 return true;
             }
@@ -105,8 +104,7 @@
     void ThreadPool::synchronise()
     {
-        std::vector<Thread*>::iterator it;
-        for ( it=this->threadPool_.begin(); it!=this->threadPool_.end(); ++it )
+        for ( Thread* thread : this->threadPool_ )
         {
-            (*it)->waitUntilFinished();
+            thread->waitUntilFinished();
         }
     }
Index: code/branches/cpp11_v3/src/libraries/core/ThreadWin.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ThreadWin.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ThreadWin.cc	(revision 11054)
@@ -31,6 +31,6 @@
 
 #include <cassert>
+// #include <functional>
 // #include <boost/thread/thread.hpp>
-// #include <boost/bind.hpp>
 // #include <boost/thread/mutex.hpp>
 // #include <boost/thread/thread_time.hpp>
@@ -45,5 +45,5 @@
 
     Thread::Thread():
-        executor_(0),
+        executor_(nullptr),
         isWorking_(false),
         stopThread_(false)
@@ -52,5 +52,5 @@
 //         this->isWorkingMutex_ = new boost::mutex;
 //         this->stopThreadMutex_ = new boost::mutex;
-//         this->workerThread_ = new boost::thread( boost::bind(&Thread::threadLoop, this) );
+//         this->workerThread_ = new boost::thread( std::bind(&Thread::threadLoop, this) );
     }
 
@@ -101,5 +101,5 @@
 //                 (*executor)();
 //                 this->executorMutex_->lock();
-//                 this->executor_ = 0;
+//                 this->executor_ = nullptr;
 //                 this->executorMutex_->unlock();
 //                 this->isWorkingMutex_->lock();
Index: code/branches/cpp11_v3/src/libraries/core/ViewportEventListener.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/ViewportEventListener.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/ViewportEventListener.h	(revision 11054)
@@ -44,5 +44,5 @@
         protected:
             ViewportEventListener();
-            virtual ~ViewportEventListener() {}
+            virtual ~ViewportEventListener() = default;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/core/WindowEventListener.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/WindowEventListener.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/WindowEventListener.cc	(revision 11054)
@@ -45,6 +45,6 @@
     /*static*/ void WindowEventListener::moveWindow()
     {
-        for (ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it)
-            it->windowMoved();
+        for (WindowEventListener* listener : ObjectList<WindowEventListener>())
+            listener->windowMoved();
     }
 
@@ -54,6 +54,6 @@
         windowWidth_s = newWidth;
         windowHeight_s = newHeight;
-        for (ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it)
-            it->windowResized(newWidth, newHeight);
+        for (WindowEventListener* listener : ObjectList<WindowEventListener>())
+            listener->windowResized(newWidth, newHeight);
     }
 
@@ -61,6 +61,6 @@
     /*static*/ void WindowEventListener::changeWindowFocus(bool bFocus)
     {
-        for (ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it)
-            it->windowFocusChanged(bFocus);
+        for (WindowEventListener* listener : ObjectList<WindowEventListener>())
+            listener->windowFocusChanged(bFocus);
     }
 }
Index: code/branches/cpp11_v3/src/libraries/core/WindowEventListener.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/WindowEventListener.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/WindowEventListener.h	(revision 11054)
@@ -47,5 +47,5 @@
         protected:
             WindowEventListener();
-            virtual ~WindowEventListener() { }
+            virtual ~WindowEventListener() = default;
 
             //! Returns the current render window width
Index: code/branches/cpp11_v3/src/libraries/core/XMLNameListener.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/XMLNameListener.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/XMLNameListener.h	(revision 11054)
@@ -44,5 +44,5 @@
         public:
             XMLNameListener();
-            virtual ~XMLNameListener() {}
+            virtual ~XMLNameListener() = default;
 
             virtual void loadedNewXMLName(BaseObject* object) = 0;
Index: code/branches/cpp11_v3/src/libraries/core/XMLPort.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/XMLPort.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/XMLPort.h	(revision 11054)
@@ -245,5 +245,5 @@
             return my_added_objects[index];
           else
-            return 0;
+            return nullptr;
         }
       @endcode
@@ -334,5 +334,5 @@
             XMLPortParamContainer()
                 { this->parseResult_ = PR_not_started; }
-            virtual ~XMLPortParamContainer() {}
+            virtual ~XMLPortParamContainer() = default;
 
             inline const std::string& getName() const
@@ -378,8 +378,4 @@
             }
 
-            ~XMLPortClassParamContainer()
-            {
-            }
-
             XMLPortParamContainer& port(BaseObject* owner, T* object, Element& xmlelement, XMLPort::Mode mode)
             {
@@ -399,5 +395,5 @@
                             // Iterate through the attributes manually in order to make them case insensitive
                             ticpp::Attribute* attribute = xmlelement.FirstAttribute(false);
-                            while (attribute != 0)
+                            while (attribute != nullptr)
                             {
                                 this->owner_->xmlAttributes_[getLowercase(attribute->Name())] = attribute->Value();
@@ -459,5 +455,5 @@
             }
 
-            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param)
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param) override
             {
                 if (!this->loadexecutor_->defaultValueSet(index))
@@ -465,5 +461,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiType& param1)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1) override
             {
                 if (!this->loadexecutor_->defaultValueSet(0))
@@ -471,5 +467,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2) override
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)))
@@ -477,5 +473,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3) override
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)))
@@ -483,5 +479,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) override
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)))
@@ -489,5 +485,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) override
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)) || (!this->loadexecutor_->defaultValueSet(4)))
@@ -511,5 +507,5 @@
             XMLPortObjectContainer()
                 { this->bApplyLoaderMask_ = false; }
-            virtual ~XMLPortObjectContainer() {}
+            virtual ~XMLPortObjectContainer() = default;
 
             XMLPortObjectContainer& port(BaseObject* object, Element& xmlelement, XMLPort::Mode mode);
@@ -552,9 +548,5 @@
             }
 
-            ~XMLPortClassObjectContainer()
-            {
-            }
-
-            void callLoadExecutor(BaseObject* object, BaseObject* newObject)
+            virtual void callLoadExecutor(BaseObject* object, BaseObject* newObject) override
             {
                 T* castObject = orxonox_cast<T*>(object);
Index: code/branches/cpp11_v3/src/libraries/core/class/Identifiable.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/Identifiable.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/Identifiable.cc	(revision 11054)
@@ -48,5 +48,5 @@
     Identifiable::Identifiable()
     {
-        this->identifier_ = 0;
+        this->identifier_ = nullptr;
         this->objectPointers_.reserve(6); // Optimisation
 
Index: code/branches/cpp11_v3/src/libraries/core/class/Identifiable.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/Identifiable.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/Identifiable.h	(revision 11054)
@@ -98,5 +98,5 @@
                 registered in the class hierarchy.
             @return
-                Returns NULL if the no pointer was found.
+                Returns nullptr if the no pointer was found.
             */
             ORX_FORCEINLINE void* getDerivedPointer(unsigned int classID)
@@ -107,5 +107,5 @@
                         return this->objectPointers_[i].second;
                 }
-                return NULL;
+                return nullptr;
             }
 
@@ -121,5 +121,5 @@
 
             /// 'Fast map' that holds this-pointers of all derived types
-            std::vector<std::pair<unsigned int, void*> > objectPointers_;
+            std::vector<std::pair<unsigned int, void*>> objectPointers_;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/core/class/Identifier.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/Identifier.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/Identifier.cc	(revision 11054)
@@ -79,23 +79,23 @@
             delete this->factory_;
 
-        for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
-            delete (*it);
+        for (const InheritsFrom* manualDirectParent : this->manualDirectParents_)
+            delete manualDirectParent;
 
         // erase this Identifier from all related identifiers
-        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-            const_cast<Identifier*>(*it)->children_.erase(this);
-        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-            const_cast<Identifier*>(*it)->directChildren_.erase(this);
-        for (std::set<const Identifier*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
-            const_cast<Identifier*>(*it)->parents_.remove(this);
-        for (std::set<const Identifier*>::const_iterator it = this->directChildren_.begin(); it != this->directChildren_.end(); ++it)
-            const_cast<Identifier*>(*it)->directParents_.remove(this);
-
-        for (std::map<std::string, ConfigValueContainer*>::iterator it = this->configValues_.begin(); it != this->configValues_.end(); ++it)
-            delete (it->second);
-        for (std::map<std::string, XMLPortParamContainer*>::iterator it = this->xmlportParamContainers_.begin(); it != this->xmlportParamContainers_.end(); ++it)
-            delete (it->second);
-        for (std::map<std::string, XMLPortObjectContainer*>::iterator it = this->xmlportObjectContainers_.begin(); it != this->xmlportObjectContainers_.end(); ++it)
-            delete (it->second);
+        for (const Identifier* parent : this->parents_)
+            const_cast<Identifier*>(parent)->children_.erase(this);
+        for (const Identifier* directParent : this->directParents_)
+            const_cast<Identifier*>(directParent)->directChildren_.erase(this);
+        for (const Identifier* child : this->children_)
+            const_cast<Identifier*>(child)->parents_.remove(this);
+        for (const Identifier* directChild : this->directChildren_)
+            const_cast<Identifier*>(directChild)->directParents_.remove(this);
+
+        for (const auto& mapEntry : this->configValues_)
+            delete (mapEntry.second);
+        for (const auto& mapEntry : this->xmlportParamContainers_)
+            delete (mapEntry.second);
+        for (const auto& mapEntry : this->xmlportObjectContainers_)
+            delete (mapEntry.second);
     }
 
@@ -117,5 +117,5 @@
             orxout(user_error) << "Aborting..." << endl;
             abort();
-            return 0;
+            return nullptr;
         }
     }
@@ -157,7 +157,7 @@
         if (this->directParents_.empty())
         {
-            for (std::list<const Identifier*>::const_iterator it = initializationTrace.begin(); it != initializationTrace.end(); ++it)
-                if (*it != this)
-                    this->parents_.push_back(*it);
+            for (const Identifier* identifier : initializationTrace)
+                if (identifier != this)
+                    this->parents_.push_back(identifier);
         }
         else
@@ -184,12 +184,12 @@
 
             // initialize all parents
-            for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-                const_cast<Identifier*>(*it)->finishInitialization(); // initialize parent
+            for (const Identifier* parent : this->parents_)
+                const_cast<Identifier*>(parent)->finishInitialization(); // initialize parent
 
             // parents of parents are no direct parents of this identifier
             this->directParents_ = this->parents_;
-            for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
-                    this->directParents_.remove(*it_parent_parent);
+            for (const Identifier* parent : this->parents_)
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->directParents_.remove(parent_parent);
 
             this->verifyIdentifierTrace();
@@ -200,7 +200,7 @@
 
             // initialize all direct parents
-            for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
+            for (const InheritsFrom* manualDirectParent : this->manualDirectParents_)
             {
-                Identifier* directParent = (*it)->getParent();
+                Identifier* directParent = manualDirectParent->getParent();
                 this->directParents_.push_back(directParent);
                 directParent->finishInitialization(); // initialize parent
@@ -208,9 +208,9 @@
 
             // direct parents and their parents are also parents of this identifier (but only add them once)
-            for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
+            for (const Identifier* parent : this->directParents_)
             {
-                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
-                    this->addIfNotExists(this->parents_, *it_parent_parent);
-                this->addIfNotExists(this->parents_, *it_parent);
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->addIfNotExists(this->parents_, parent_parent);
+                this->addIfNotExists(this->parents_, parent);
             }
         }
@@ -224,14 +224,14 @@
 
         // tell all parents that this identifier is a child
-        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-            const_cast<Identifier*>(*it)->children_.insert(this);
+        for (const Identifier* parent : this->parents_)
+            const_cast<Identifier*>(parent)->children_.insert(this);
 
         // tell all direct parents that this identifier is a direct child
-        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-        {
-            const_cast<Identifier*>(*it)->directChildren_.insert(this);
+        for (const Identifier* directChild : this->directParents_)
+        {
+            const_cast<Identifier*>(directChild)->directChildren_.insert(this);
 
             // Create the super-function dependencies
-            (*it)->createSuperFunctionCaller();
+            directChild->createSuperFunctionCaller();
         }
 
@@ -261,20 +261,20 @@
 
         // if any parent class is virtual, it will be instantiated first, so we need to add them first.
-        for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-        {
-            if ((*it_parent)->isVirtualBase())
+        for (const Identifier* parent : this->parents_)
+        {
+            if (parent->isVirtualBase())
             {
-                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
-                    this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-                this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->addIfNotExists(expectedIdentifierTrace, parent_parent);
+                this->addIfNotExists(expectedIdentifierTrace, parent);
             }
         }
 
         // now all direct parents get created recursively. already added identifiers (e.g. virtual base classes) are not added again.
-        for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
-        {
-            for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
-                this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-            this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+        for (const Identifier* directParent : this->directParents_)
+        {
+            for (const Identifier* parent_parent : const_cast<Identifier*>(directParent)->parents_)
+                this->addIfNotExists(expectedIdentifierTrace, parent_parent);
+            this->addIfNotExists(expectedIdentifierTrace, directParent);
         }
 
@@ -285,16 +285,16 @@
 
             orxout(internal_warning) << "  Actual trace (after creating a sample instance):" << endl << "    ";
-            for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-                orxout(internal_warning) << " " << (*it_parent)->getName();
+            for (const Identifier* parent : this->parents_)
+                orxout(internal_warning) << " " << parent->getName();
             orxout(internal_warning) << endl;
 
             orxout(internal_warning) << "  Expected trace (according to class hierarchy definitions):" << endl << "    ";
-            for (std::list<const Identifier*>::const_iterator it_parent = expectedIdentifierTrace.begin(); it_parent != expectedIdentifierTrace.end(); ++it_parent)
-                orxout(internal_warning) << " " << (*it_parent)->getName();
+            for (const Identifier* parent : expectedIdentifierTrace)
+                orxout(internal_warning) << " " << parent->getName();
             orxout(internal_warning) << endl;
 
             orxout(internal_warning) << "  Direct parents (according to class hierarchy definitions):" << endl << "    ";
-            for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
-                orxout(internal_warning) << " " << (*it_parent)->getName();
+            for (const Identifier* directParent : this->directParents_)
+                orxout(internal_warning) << " " << directParent->getName();
             orxout(internal_warning) << endl;
         }
@@ -393,5 +393,5 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -407,5 +407,5 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -438,5 +438,5 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/class/Identifier.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/Identifier.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/Identifier.h	(revision 11054)
@@ -56,5 +56,5 @@
     object->getIdentifier()->getName();                                         // returns "MyClass"
 
-    Identifiable* other = object->getIdentifier()->fabricate(0);                // fabricates a new instance of MyClass
+    Identifiable* other = object->getIdentifier()->fabricate(nullptr);                // fabricates a new instance of MyClass
 
 
@@ -80,6 +80,4 @@
 #include <typeinfo>
 #include <loki/TypeTraits.h>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 
 #include "util/Output.h"
@@ -120,6 +118,9 @@
         public:
             Identifier(const std::string& name, Factory* factory, bool bLoadable);
-            Identifier(const Identifier& identifier); // don't copy
             virtual ~Identifier();
+
+            // non-copyable:
+            Identifier(const Identifier&) = delete;
+            Identifier& operator=(const Identifier&) = delete;
 
             /// Returns the name of the class the Identifier belongs to.
@@ -137,5 +138,5 @@
 
             /// Returns true if the Identifier has a Factory.
-            inline bool hasFactory() const { return (this->factory_ != 0); }
+            inline bool hasFactory() const { return (this->factory_ != nullptr); }
 
             Identifiable* fabricate(Context* context);
@@ -269,5 +270,5 @@
     class ClassIdentifier : public Identifier
     {
-        BOOST_STATIC_ASSERT((boost::is_base_of<Identifiable, T>::value));
+        static_assert(std::is_base_of<Identifiable, T>::value, "ClassIdentifier can only be used with Identifiables");
 
         #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -279,5 +280,5 @@
             ClassIdentifier(const std::string& name, Factory* factory, bool bLoadable) : Identifier(name, factory, bLoadable)
             {
-                OrxVerify(ClassIdentifier<T>::classIdentifier_s == NULL, "Assertion failed in ClassIdentifier of type " << typeid(T).name());
+                OrxVerify(ClassIdentifier<T>::classIdentifier_s == nullptr, "Assertion failed in ClassIdentifier of type " << typeid(T).name());
                 ClassIdentifier<T>::classIdentifier_s = this;
 
@@ -291,18 +292,20 @@
             bool initializeObject(T* object);
 
-            virtual void updateConfigValues(bool updateChildren = true) const;
-
-            virtual const std::type_info& getTypeInfo()
+            virtual void updateConfigValues(bool updateChildren = true) const override;
+
+            virtual const std::type_info& getTypeInfo() override
                 { return typeid(T); }
 
-            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const
-                { return dynamic_cast<T*>(object) != 0; }
-
-            virtual void destroyObjects();
+            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const override
+                { return dynamic_cast<T*>(object) != nullptr; }
+
+            virtual void destroyObjects() override;
 
             static ClassIdentifier<T>* getIdentifier();
 
         private:
-            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
+            // non-copyable:
+            ClassIdentifier(const ClassIdentifier<T>&) = delete;
+            ClassIdentifier& operator=(const ClassIdentifier<T>&) = delete;
 
             void setConfigValues(T* object, Configurable*) const;
@@ -321,9 +324,9 @@
             void updateConfigValues(bool updateChildren, Identifiable*) const;
 
-            static WeakPtr<ClassIdentifier<T> > classIdentifier_s;
+            static WeakPtr<ClassIdentifier<T>> classIdentifier_s;
     };
 
     template <class T>
-    WeakPtr<ClassIdentifier<T> > ClassIdentifier<T>::classIdentifier_s;
+    WeakPtr<ClassIdentifier<T>> ClassIdentifier<T>::classIdentifier_s;
 
     /**
@@ -334,8 +337,8 @@
     /*static*/ inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
     {
-        if (ClassIdentifier<T>::classIdentifier_s == NULL)
+        if (ClassIdentifier<T>::classIdentifier_s == nullptr)
             ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*) IdentifierManager::getInstance().getIdentifierByTypeInfo(typeid(T));
 
-        OrxVerify(ClassIdentifier<T>::classIdentifier_s != NULL, "Did you forget to register the class of type " << typeid(T).name() << "?");
+        OrxVerify(ClassIdentifier<T>::classIdentifier_s != nullptr, "Did you forget to register the class of type " << typeid(T).name() << "?");
         return ClassIdentifier<T>::classIdentifier_s;
     }
@@ -365,5 +368,5 @@
 
             // Add pointer of type T to the map in the Identifiable instance that enables "dynamic_casts"
-            object->objectPointers_.push_back(std::make_pair(this->getClassID(), static_cast<void*>(object)));
+            object->objectPointers_.emplace_back(this->getClassID(), static_cast<void*>(object));
             return false;
         }
@@ -408,5 +411,5 @@
     void ClassIdentifier<T>::destroyObjects()
     {
-        this->destroyObjects((T*)0);
+        this->destroyObjects((T*)nullptr);
     }
 
@@ -417,8 +420,6 @@
     void ClassIdentifier<T>::destroyObjects(Listable*)
     {
-        ObjectListBase* objectList = Context::getRootContext()->getObjectList(this);
-        ObjectListElement<T>* begin = static_cast<ObjectListElement<T>*>(objectList->begin());
-        ObjectListElement<T>* end = static_cast<ObjectListElement<T>*>(objectList->end());
-        for (typename ObjectList<T>::iterator it = begin; it != end; )
+        ObjectList<T> list(Context::getRootContext()->getObjectList(this));
+        for (typename ObjectList<T>::iterator it = list.begin(); it != list.end(); )
             this->destroyObject(*(it++));
     }
@@ -451,5 +452,5 @@
     void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
     {
-        this->updateConfigValues(updateChildren, static_cast<T*>(NULL));
+        this->updateConfigValues(updateChildren, static_cast<T*>(nullptr));
     }
 
@@ -460,10 +461,10 @@
             return;
 
-        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
-            this->setConfigValues(*it, *it);
+        for (T* object : ObjectList<T>())
+            this->setConfigValues(object, object);
 
         if (updateChildren)
-            for (std::set<const Identifier*>::const_iterator it = this->getChildren().begin(); it != this->getChildren().end(); ++it)
-                (*it)->updateConfigValues(false);
+            for (const Identifier* child : this->getChildren())
+                child->updateConfigValues(false);
     }
 
@@ -483,7 +484,7 @@
         registered in the class hierarchy.
     @return
-        Returns NULL if the cast is not possible
+        Returns nullptr if the cast is not possible
     @note
-        In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
+        In case of nullptr return (and using MSVC), a dynamic_cast might still be possible if
         a class forgot to register its objects.
         Also note that the function is implemented differently for GCC/MSVC.
@@ -494,8 +495,8 @@
 #ifdef ORXONOX_COMPILER_MSVC
         typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
-        if (source != NULL)
+        if (source != nullptr)
             return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
         else
-            return NULL;
+            return nullptr;
 #else
         return dynamic_cast<T>(source);
Index: code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.cc	(revision 11054)
@@ -44,10 +44,10 @@
 namespace orxonox
 {
-    IdentifierManager* IdentifierManager::singletonPtr_s = 0;
+    IdentifierManager* IdentifierManager::singletonPtr_s = nullptr;
 
     IdentifierManager::IdentifierManager()
     {
         this->hierarchyCreatingCounter_s = 0;
-        this->recordTraceForIdentifier_ = NULL;
+        this->recordTraceForIdentifier_ = nullptr;
     }
 
@@ -60,4 +60,5 @@
 
         this->identifiers_.insert(identifier);
+        this->identifierByTypeIndex_[identifier->getTypeInfo()] = identifier;
         this->identifierByString_[identifier->getName()] = identifier;
         this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
@@ -71,4 +72,5 @@
     {
         this->identifiers_.erase(identifier);
+        this->identifierByTypeIndex_.erase(identifier->getTypeInfo());
         this->identifierByString_.erase(identifier->getName());
         this->identifierByLowercaseString_.erase(getLowercase(identifier->getName()));
@@ -92,8 +94,7 @@
         // iterate over all identifiers, create one instance of each class and initialize the identifiers
         {
-            Context temporaryContext(NULL);
-            for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            Context temporaryContext(nullptr);
+            for (Identifier* identifier : this->identifiers_)
             {
-                Identifier* identifier = (*it);
                 if (identifier->isInitialized())
                     continue;
@@ -108,5 +109,5 @@
                     Identifiable* temp = identifier->fabricate(&temporaryContext);
 
-                    this->recordTraceForIdentifier_ = NULL;
+                    this->recordTraceForIdentifier_ = nullptr;
 
                     if (temp->getIdentifier() != identifier)
@@ -127,6 +128,6 @@
 
         // finish the initialization of all identifiers
-        for (std::set<Identifier*>::const_iterator it = initializedIdentifiers.begin(); it != initializedIdentifiers.end(); ++it)
-            (*it)->finishInitialization();
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
+            initializedIdentifier->finishInitialization();
 
         // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
@@ -144,26 +145,26 @@
     {
         // check if there are any uninitialized identifiers remaining
-        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
-            if (!(*it)->isInitialized())
-                orxout(internal_error) << "Identifier was registered late and is not initialized: " << (*it)->getName() << " / " << (*it)->getTypeInfo().name() << endl;
+        for (Identifier* identifier : this->identifiers_)
+            if (!identifier->isInitialized())
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << identifier->getName() << " / " << identifier->getTypeInfo().name() << endl;
 
         // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
-        Context temporaryContext(NULL);
-        for (std::set<Identifier*>::const_iterator it1 = initializedIdentifiers.begin(); it1 != initializedIdentifiers.end(); ++it1)
+        Context temporaryContext(nullptr);
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
         {
-            if (!(*it1)->hasFactory())
+            if (!initializedIdentifier->hasFactory())
                 continue;
 
-            Identifiable* temp = (*it1)->fabricate(&temporaryContext);
-
-            for (std::set<Identifier*>::const_iterator it2 = this->identifiers_.begin(); it2 != this->identifiers_.end(); ++it2)
+            Identifiable* temp = initializedIdentifier->fabricate(&temporaryContext);
+
+            for (Identifier* identifier : this->identifiers_)
             {
-                bool isA_AccordingToRtti = (*it2)->canDynamicCastObjectToIdentifierClass(temp);
-                bool isA_AccordingToClassHierarchy = temp->isA((*it2));
+                bool isA_AccordingToRtti = identifier->canDynamicCastObjectToIdentifierClass(temp);
+                bool isA_AccordingToClassHierarchy = temp->isA(identifier);
 
                 if (isA_AccordingToRtti != isA_AccordingToClassHierarchy)
                 {
-                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << (*it1)->getName() <<
-                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << (*it2)->getName() << " but RTTI says the opposite." << endl;
+                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << initializedIdentifier->getName() <<
+                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << identifier->getName() << " but RTTI says the opposite." << endl;
                 }
             }
@@ -184,6 +185,6 @@
     {
         orxout(internal_status) << "Destroy class-hierarchy" << endl;
-        for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
-            (*it)->reset();
+        for (Identifier* identifier : this->identifiers_)
+            identifier->reset();
     }
 
@@ -221,5 +222,5 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -235,5 +236,5 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -249,5 +250,5 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
@@ -259,9 +260,9 @@
     Identifier* IdentifierManager::getIdentifierByTypeInfo(const std::type_info& typeInfo)
     {
-        // TODO: use std::type_index and a map to find identifiers by type_info (only with c++11)
-        for (std::set<Identifier*>::iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
-            if ((*it)->getTypeInfo() == typeInfo)
-                return (*it);
-        return 0;
+        auto it = this->identifierByTypeIndex_.find(typeInfo);
+        if (it != this->identifierByTypeIndex_.end())
+            return it->second;
+        else
+            return nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.h	(revision 11054)
@@ -37,5 +37,7 @@
 #include "core/CorePrereqs.h"
 
+#include <typeindex>
 #include <map>
+#include <unordered_map>
 #include <set>
 #include <list>
@@ -52,5 +54,5 @@
         public:
             IdentifierManager();
-            ~IdentifierManager() {}
+            ~IdentifierManager() = default;
 
             void addIdentifier(Identifier* identifier);
@@ -93,5 +95,7 @@
 
         private:
-            IdentifierManager(const IdentifierManager&); // not implemented
+            // non-copyable:
+            IdentifierManager(const IdentifierManager&) = delete;
+            IdentifierManager& operator=(const IdentifierManager&) = delete;
 
             /// Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
@@ -102,8 +106,9 @@
                 { hierarchyCreatingCounter_s--; }
 
-            std::set<Identifier*> identifiers_;                              //!< All identifiers. This is only used internally.
-            std::map<std::string, Identifier*> identifierByString_;          //!< Map that stores all Identifiers with their names.
-            std::map<std::string, Identifier*> identifierByLowercaseString_; //!< Map that stores all Identifiers with their names in lowercase.
-            std::map<uint32_t, Identifier*> identifierByNetworkId_;          //!< Returns the map that stores all Identifiers with their network IDs.
+            std::set<Identifier*> identifiers_;                                      //!< All identifiers. This is only used internally.
+            std::unordered_map<std::type_index, Identifier*> identifierByTypeIndex_; //!< Map that stores all Identifiers with their type_index.
+            std::map<std::string, Identifier*> identifierByString_;                  //!< Map that stores all Identifiers with their names.
+            std::map<std::string, Identifier*> identifierByLowercaseString_;         //!< Map that stores all Identifiers with their names in lowercase.
+            std::map<uint32_t, Identifier*> identifierByNetworkId_;                  //!< Returns the map that stores all Identifiers with their network IDs.
 
             int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
@@ -111,5 +116,5 @@
             /// Used while creating the object hierarchy to keep track of the identifiers of a newly created object (and all other objects that get created as
             /// a consequence of this, e.g. nested member objects).
-            std::map<Identifiable*, std::list<const Identifier*> > identifierTraceOfNewObject_;
+            std::map<Identifiable*, std::list<const Identifier*>> identifierTraceOfNewObject_;
             Identifier* recordTraceForIdentifier_; //!< The identifier for which we want to record the trace of identifiers during object creation. If null, no trace is recorded.
 
Index: code/branches/cpp11_v3/src/libraries/core/class/SubclassIdentifier.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/SubclassIdentifier.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/SubclassIdentifier.h	(revision 11054)
@@ -127,5 +127,5 @@
                     else
                     {
-                        orxout(internal_error) << "Can't assign NULL identifier" << endl;
+                        orxout(internal_error) << "Can't assign nullptr identifier" << endl;
                     }
                 }
@@ -189,5 +189,5 @@
                     orxout(user_error) << "Aborting..." << endl;
                     abort();
-                    return 0;
+                    return nullptr;
                 }
             }
Index: code/branches/cpp11_v3/src/libraries/core/class/Super.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/class/Super.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/class/Super.h	(revision 11054)
@@ -94,5 +94,5 @@
             static void superCheck() \
             { \
-                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0)); \
+                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr)); \
                 SuperFunctionCondition<functionnumber + 1, T, 0, templatehack2>::superCheck(); \
             } \
@@ -103,20 +103,20 @@
             { \
                 ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier(); \
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it) \
+                for (const Identifier* child : identifier->getDirectChildren()) \
                 { \
-                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
+                    if (((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_) \
                     { \
-                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_; \
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0; \
-                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
+                        delete ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_; \
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = nullptr; \
+                        ((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
                     } \
                     \
-                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
+                    if (!((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_) \
                     { \
-                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << endl; \
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
+                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)child)->getName() << endl; \
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
                     } \
-                    else if (((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier()) \
-                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)(*it))->getName() << " calls function of " << ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl; \
+                    else if (((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier()) \
+                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)child)->getName() << " calls function of " << ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl; \
                 } \
             } \
@@ -154,5 +154,5 @@
                 // This call to the apply-function is the whole check. By calling the function with
                 // a T* pointer, the right function get's called.
-                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0));
+                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr));
 
                 // Go go the superCheck for of next super-function (functionnumber + 1)
@@ -171,26 +171,26 @@
 
                 // Iterate through all children
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it)
+                for (const Identifier* child : identifier->getDirectChildren())
                 {
                     // Check if the caller is a fallback-caller
-                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
+                    if (((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_)
                     {
                         // Delete the fallback caller an prepare to get a real caller
-                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_;
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0;
-                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false;
+                        delete ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_;
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = nullptr;
+                        ((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ = false;
                     }
 
                     // Check if there's not already a caller
-                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
+                    if (!((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_)
                     {
                         // Add the SuperFunctionCaller
-                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << endl;
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
+                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)child)->getName() << endl;
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
                     }
 
                     // If there is already a caller, but for another parent, print a warning
-                    else if (((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier())
-                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)(*it))->getName() << " calls function of " << ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl;
+                    else if (((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier())
+                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)child)->getName() << " calls function of " << ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl;
                 }
             }
@@ -584,5 +584,5 @@
         // Creates the super-function-callers by calling the first SuperFunctionCondition check
         // This get's called within the initialization of an Identifier
-        virtual void createSuperFunctionCaller() const
+        virtual void createSuperFunctionCaller() const override
         {
             SuperFunctionCondition<0, T, 0, 0>::superCheck();
Index: code/branches/cpp11_v3/src/libraries/core/command/ArgumentCompletionFunctions.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 11054)
@@ -77,6 +77,6 @@
             bool groupIsVisible(const std::map<std::string, ConsoleCommand*>& group, bool bOnlyShowHidden)
             {
-                for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = group.begin(); it_command != group.end(); ++it_command)
-                    if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden)
+                for (const auto& mapEntry : group)
+                    if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden)
                         return true;
 
@@ -99,21 +99,21 @@
 
                 // get all the groups that are visible (except the shortcut group "")
-                const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommandManager::getInstance().getCommands();
-                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
-                    if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find(fragmentLC) == 0))
-                        groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
+                const std::map<std::string, std::map<std::string, ConsoleCommand*>>& commands = ConsoleCommandManager::getInstance().getCommands();
+                for (const auto& mapEntry : commands)
+                    if (groupIsVisible(mapEntry.second, bOnlyShowHidden) && mapEntry.first != "" && (fragmentLC == "" || getLowercase(mapEntry.first).find(fragmentLC) == 0))
+                        groupList.emplace_back(mapEntry.first, getLowercase(mapEntry.first));
 
                 // now add all shortcuts (in group "")
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.find("");
+                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = commands.find("");
                 if (it_group != commands.end())
                 {
                     // add a line-break if the list isn't empty
                     if (!groupList.empty())
-                        groupList.push_back(ArgumentCompletionListElement("", "", "\n"));
+                        groupList.emplace_back("", "", "\n");
 
                     // add the shortcuts
-                    for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
-                        if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(it_command->first).find(fragmentLC) == 0))
-                            groupList.push_back(ArgumentCompletionListElement(it_command->first, getLowercase(it_command->first)));
+                    for (const auto& mapEntry : it_group->second)
+                        if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(mapEntry.first).find(fragmentLC) == 0))
+                            groupList.emplace_back(mapEntry.first, getLowercase(mapEntry.first));
                 }
 
@@ -138,5 +138,5 @@
 
                 // find the iterator of the given group
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
+                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
                 for ( ; it_group != ConsoleCommandManager::getInstance().getCommands().end(); ++it_group)
                     if (getLowercase(it_group->first) == groupLC)
@@ -146,7 +146,7 @@
                 if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                 {
-                    for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
-                        if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden)
-                            commandList.push_back(ArgumentCompletionListElement(it_command->first, getLowercase(it_command->first)));
+                    for (const auto& mapEntry : it_group->second)
+                        if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden)
+                            commandList.emplace_back(mapEntry.first, getLowercase(mapEntry.first));
                 }
 
@@ -188,5 +188,5 @@
             {
                 ArgumentCompletionList list;
-                list.push_back(ArgumentCompletionListElement("", "", hint));
+                list.emplace_back("", "", hint);
                 return list;
             }
@@ -212,5 +212,5 @@
             if (tokens.size() == 1)
             {
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
+                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
                 if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                     return detail::_subcommands(fragment, tokens[0], true);
@@ -261,7 +261,7 @@
                 {
                     if (boost::filesystem::is_directory(*file))
-                        dirlist.push_back(ArgumentCompletionListElement(file->BF_DICTIONARY_ENTRY_NAME() + '/', getLowercase(file->BF_DICTIONARY_ENTRY_NAME()) + '/', file->BF_LEAF() + '/'));
+                        dirlist.emplace_back(file->BF_DICTIONARY_ENTRY_NAME() + '/', getLowercase(file->BF_DICTIONARY_ENTRY_NAME()) + '/', file->BF_LEAF() + '/');
                     else
-                        filelist.push_back(ArgumentCompletionListElement(file->BF_DICTIONARY_ENTRY_NAME(), getLowercase(file->BF_DICTIONARY_ENTRY_NAME()), file->BF_LEAF()));
+                        filelist.emplace_back(file->BF_DICTIONARY_ENTRY_NAME(), getLowercase(file->BF_DICTIONARY_ENTRY_NAME()), file->BF_LEAF());
                     ++file;
                 }
@@ -281,6 +281,6 @@
 
             const std::set<std::string>& names = SettingsConfigFile::getInstance().getSectionNames();
-            for (std::set<std::string>::const_iterator it = names.begin(); it != names.end(); ++it)
-                sectionList.push_back(ArgumentCompletionListElement(*it, getLowercase(*it)));
+            for (const std::string& name : names)
+                sectionList.emplace_back(name, getLowercase(name));
 
             return sectionList;
@@ -298,5 +298,5 @@
             SettingsConfigFile::ContainerMap::const_iterator upper = settings.getContainerUpperBound(sectionLC);
             for (SettingsConfigFile::ContainerMap::const_iterator it = settings.getContainerLowerBound(sectionLC); it != upper; ++it)
-                entryList.push_back(ArgumentCompletionListElement(it->second.second->getName(), it->second.first));
+                entryList.emplace_back(it->second.second->getName(), it->second.first);
 
             return entryList;
@@ -319,5 +319,5 @@
                 {
                     const std::string& valuestring = it->second.second->toString();
-                    oldValue.push_back(ArgumentCompletionListElement(valuestring, getLowercase(valuestring), "Old value: " + valuestring));
+                    oldValue.emplace_back(valuestring, getLowercase(valuestring), "Old value: " + valuestring);
                 }
             }
@@ -334,6 +334,6 @@
             ArgumentCompletionList threads;
 
-            for (std::list<unsigned int>::const_iterator it = threadnumbers.begin(); it != threadnumbers.end(); ++it)
-                threads.push_back(ArgumentCompletionListElement(multi_cast<std::string>(*it)));
+            for (unsigned int threadnumber : threadnumbers)
+                threads.emplace_back(multi_cast<std::string>(threadnumber));
 
             return threads;
Index: code/branches/cpp11_v3/src/libraries/core/command/ArgumentCompletionFunctions.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ArgumentCompletionFunctions.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ArgumentCompletionFunctions.h	(revision 11054)
@@ -86,20 +86,20 @@
         {
             for (int month = 1; month <= 12; ++month)
-                list.push_back(ArgumentCompletionListElement(multi_cast<std::string>(month)));
+                list.emplace_back(multi_cast<std::string>(month));
         }
         else
         {
-            list.push_back(ArgumentCompletionListElement("January",   "january"));
-            list.push_back(ArgumentCompletionListElement("February",  "february"));
-            list.push_back(ArgumentCompletionListElement("March",     "march"));
-            list.push_back(ArgumentCompletionListElement("April",     "april"));
-            list.push_back(ArgumentCompletionListElement("May",       "may"));
-            list.push_back(ArgumentCompletionListElement("June",      "june"));
-            list.push_back(ArgumentCompletionListElement("July",      "july"));
-            list.push_back(ArgumentCompletionListElement("August",    "august"));
-            list.push_back(ArgumentCompletionListElement("September", "september"));
-            list.push_back(ArgumentCompletionListElement("October",   "october"));
-            list.push_back(ArgumentCompletionListElement("November",  "november"));
-            list.push_back(ArgumentCompletionListElement("December",  "december"));
+            list.emplace_back("January",   "january");
+            list.emplace_back("February",  "february");
+            list.emplace_back("March",     "march");
+            list.emplace_back("April",     "april");
+            list.emplace_back("May",       "may");
+            list.emplace_back("June",      "june");
+            list.emplace_back("July",      "july");
+            list.emplace_back("August",    "august");
+            list.emplace_back("September", "september");
+            list.emplace_back("October",   "october");
+            list.emplace_back("November",  "november");
+            list.emplace_back("December",  "december");
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/command/CommandEvaluation.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/CommandEvaluation.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/CommandEvaluation.cc	(revision 11054)
@@ -54,6 +54,6 @@
     void CommandEvaluation::initialize(const std::string& command)
     {
-        this->execCommand_ = 0;
-        this->hintCommand_ = 0;
+        this->execCommand_ = nullptr;
+        this->hintCommand_ = nullptr;
         this->string_ = command;
         this->execArgumentsOffset_ = 0;
@@ -119,5 +119,5 @@
     /**
         @brief Executes the command which was evaluated by this object and returns its return-value.
-        @param error A pointer to an integer (or NULL) which will be used to write error codes to (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param error A pointer to an integer (or nullptr) which will be used to write error codes to (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
         @return Returns the result of the command (or MultiType::Null if there is no return value)
     */
@@ -306,6 +306,6 @@
                 // the user typed 1-2 arguments, check what he tried to type and print a suitable error
                 std::string groupLC = getLowercase(this->getToken(0));
-                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
-                    if (it_group->first == groupLC)
+                for (const auto& mapEntry : ConsoleCommandManager::getInstance().getCommandsLC())
+                    if (mapEntry.first == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
 
@@ -328,11 +328,11 @@
 
         // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
-        {
-            if (it_group->first != "")
-            {
-                for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); ++it_name)
-                {
-                    std::string command = it_group->first + " " + it_name->first;
+        for (const auto& mapEntryGroup : ConsoleCommandManager::getInstance().getCommandsLC())
+        {
+            if (mapEntryGroup.first != "")
+            {
+                for (const auto& mapEntryName : mapEntryGroup.second)
+                {
+                    std::string command = mapEntryGroup.first + " " + mapEntryName.first;
                     unsigned int distance = getLevenshteinDistance(command, token0_LC + " " + token1_LC);
                     if (distance < nearestDistance)
@@ -346,10 +346,10 @@
 
         // now also iterate through all shortcuts and keep the best if it's better than the one found above.
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
+        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
         if (it_group !=  ConsoleCommandManager::getInstance().getCommandsLC().end())
         {
-            for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); ++it_name)
-            {
-                std::string command = it_name->first;
+            for (const auto& mapEntry : it_group->second)
+            {
+                std::string command = mapEntry.first;
                 unsigned int distance = getLevenshteinDistance(command, token0_LC);
                 if (distance < nearestDistance)
@@ -429,6 +429,6 @@
     {
         size_t count = 0;
-        for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
-            if (it->getComparable() != "")
+        for (const ArgumentCompletionListElement& element : list)
+            if (element.getComparable() != "")
                 ++count;
         return count;
@@ -495,13 +495,13 @@
         {
             // only one (non-empty) value in the list - search it and return it
-            for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
-            {
-                if (it->getComparable() != "")
+            for (const ArgumentCompletionListElement& element : list)
+            {
+                if (element.getComparable() != "")
                 {
                     // arguments that have a separate string to be displayed need a little more care - just return them without modification. add a space character to the others.
-                    if (it->hasDisplay())
-                        return (it->getString());
+                    if (element.hasDisplay())
+                        return (element.getString());
                     else
-                        return (it->getString() + ' ');
+                        return (element.getString() + ' ');
                 }
             }
@@ -517,8 +517,8 @@
                 char tempComparable = '\0';
                 char temp = '\0';
-                for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
-                {
-                    const std::string& argumentComparable = it->getComparable();
-                    const std::string& argument = it->getString();
+                for (const ArgumentCompletionListElement& element : list)
+                {
+                    const std::string& argumentComparable = element.getComparable();
+                    const std::string& argument = element.getString();
 
                     // ignore empty arguments
@@ -560,10 +560,10 @@
     {
         std::string output;
-        for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            output += it->getDisplay();
+        for (const ArgumentCompletionListElement& element : list)
+        {
+            output += element.getDisplay();
 
             // add a space character between two elements for all non-empty arguments
-            if (it->getComparable() != "")
+            if (element.getComparable() != "")
                 output += ' ';
         }
Index: code/branches/cpp11_v3/src/libraries/core/command/CommandEvaluation.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/CommandEvaluation.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/CommandEvaluation.h	(revision 11054)
@@ -86,5 +86,5 @@
 
             int execute();
-            MultiType query(int* error = 0);
+            MultiType query(int* error = nullptr);
 
             std::string complete();
@@ -97,5 +97,5 @@
             /// Returns true if the command evaluation contains a valid command that can be executed.
             inline bool isValid() const
-                { return (this->execCommand_ != 0); }
+                { return (this->execCommand_ != nullptr); }
 
             /// Returns the console command that was evaluated by this object.
@@ -137,5 +137,5 @@
             static std::string getCommonBegin(const ArgumentCompletionList& list);
 
-            const ConsoleCommand* execCommand_;             ///< The command that will be executed (can be NULL if the command is not valid)
+            const ConsoleCommand* execCommand_;             ///< The command that will be executed (can be nullptr if the command is not valid)
             const ConsoleCommand* hintCommand_;             ///< The command that is used to display hints and argument lists (can be different to execCommand_ in some cases)
             SubString tokens_;                              ///< The single words of the command string, split into tokens
Index: code/branches/cpp11_v3/src/libraries/core/command/CommandExecutor.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/CommandExecutor.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/CommandExecutor.cc	(revision 11054)
@@ -81,5 +81,5 @@
         @brief Executes a command and returns its return-value.
         @param command A string containing the command
-        @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
+        @param error A pointer to a value (or nullptr) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
         @param useTcl If true, the command is passed to tcl (see TclBind)
         @return Returns the return-value of the command (if any - MultiType::Null otherwise)
@@ -127,5 +127,5 @@
         @brief Executes a command and returns its return-value as string.
         @param command A string containing the command
-        @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
+        @param error A pointer to a value (or nullptr) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
         @param useTcl If true, the command is passed to tcl (see TclBind)
         @return Returns the return-value of the command converted to a string (or "" if there's no return value)
@@ -275,5 +275,5 @@
         {
             // it is valid - copy the executor of this command
-            ExecutorPtr executor = new Executor(*evaluation.getConsoleCommand()->getExecutor().get());
+            ExecutorPtr executor = std::make_shared<Executor>(*evaluation.getConsoleCommand()->getExecutor().get());
 
             // evaluate the arguments and if this returns no error, store them as default values
Index: code/branches/cpp11_v3/src/libraries/core/command/CommandExecutor.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/CommandExecutor.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/CommandExecutor.h	(revision 11054)
@@ -113,15 +113,15 @@
             static int execute(const std::string& command, bool useTcl = true, bool printErrors = true); // tolua_export
 
-            static MultiType queryMT(const std::string& command, int* error = 0, bool useTcl = true);
-            static std::string query(const std::string& command, int* error = 0, bool useTcl = true); // tolua_export
+            static MultiType queryMT(const std::string& command, int* error = nullptr, bool useTcl = true);
+            static std::string query(const std::string& command, int* error = NULL, bool useTcl = true); // tolua_export
 
             static CommandEvaluation evaluate(const std::string& command);
 
-            static const int Success = 0;       ///< Error code for "success" (or no error)
-            static const int Inexistent = 1;    ///< Error code if the command doesn't exist
-            static const int Incomplete = 2;    ///< Error code if the command needs more arguments
-            static const int Deactivated = 3;   ///< Error code if the command is not active
-            static const int Denied = 4;        ///< Error code if the command needs a different access level
-            static const int Error = 5;         ///< Error code if the command returned an error
+            static constexpr int Success = 0;       ///< Error code for "success" (or no error)
+            static constexpr int Inexistent = 1;    ///< Error code if the command doesn't exist
+            static constexpr int Incomplete = 2;    ///< Error code if the command needs more arguments
+            static constexpr int Deactivated = 3;   ///< Error code if the command is not active
+            static constexpr int Denied = 4;        ///< Error code if the command needs a different access level
+            static constexpr int Error = 5;         ///< Error code if the command returned an error
 
             static std::string getErrorDescription(int error);
@@ -132,7 +132,10 @@
 
         private:
-            CommandExecutor() {}                            ///< Empty constructor
-            CommandExecutor(const CommandExecutor& other);  ///< Not implemented copy-constructor
-            ~CommandExecutor() {}                           ///< Empty destructor
+            CommandExecutor() = default;                      ///< Empty constructor
+            ~CommandExecutor() = default;                     ///< Empty destructor
+
+            // non-copyable:
+            CommandExecutor(const CommandExecutor&) = delete;
+            CommandExecutor& operator=(const CommandExecutor&) = delete;
 
             static CommandExecutor& getInstance();
Index: code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommand.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommand.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommand.cc	(revision 11054)
@@ -50,6 +50,6 @@
     */
     ConsoleCommand::ConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized)
-    {
-        this->init("", name, executor, bInitialized);
+        : ConsoleCommand("", name, executor, bInitialized)
+    {
     }
 
@@ -75,6 +75,6 @@
         this->baseFunctor_ = executor->getFunctor();
 
-        for (size_t i = 0; i < MAX_FUNCTOR_ARGUMENTS; ++i)
-            this->argumentCompleter_[i] = 0;
+        for (ArgumentCompleter*& completer : this->argumentCompleter_)
+            completer = nullptr;
 
         this->keybindMode_ = KeybindMode::OnPress;
@@ -84,5 +84,5 @@
             this->executor_ = executor;
 
-        this->names_.push_back(CommandName(group, name));
+        this->names_.emplace_back(group, name);
     }
 
@@ -99,5 +99,5 @@
     ConsoleCommand& ConsoleCommand::addShortcut()
     {
-        this->names_.push_back(CommandName("", this->baseName_));
+        this->names_.emplace_back("", this->baseName_);
         return *this;
     }
@@ -108,5 +108,5 @@
     ConsoleCommand& ConsoleCommand::addShortcut(const std::string&  name)
     {
-        this->names_.push_back(CommandName("", name));
+        this->names_.emplace_back("", name);
         return *this;
     }
@@ -117,5 +117,5 @@
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group)
     {
-        this->names_.push_back(CommandName(group, this->baseName_));
+        this->names_.emplace_back(group, this->baseName_);
         return *this;
     }
@@ -126,5 +126,5 @@
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group, const std::string&  name)
     {
-        this->names_.push_back(CommandName(group, name));
+        this->names_.emplace_back(group, name);
         return *this;
     }
@@ -320,5 +320,5 @@
     {
         if (this->executor_)
-            this->pushFunction(new Executor(*this->executor_.get()));
+            this->pushFunction(std::make_shared<Executor>(*this->executor_.get()));
         else
             orxout(internal_error, context::commands) << "Couldn't push copy of executor in console command \"" << this->baseName_ << "\", no executor set." << endl;
@@ -348,10 +348,10 @@
 
     /**
-        @brief Sets the functor to NULL (which also deactivates the command).
+        @brief Sets the functor to nullptr (which also deactivates the command).
     */
     void ConsoleCommand::resetFunction()
     {
         if (this->executor_)
-            this->executor_->setFunctor(0);
+            this->executor_->setFunctor(nullptr);
         this->objectStack_.clear();
     }
@@ -405,5 +405,5 @@
     void ConsoleCommand::popObject()
     {
-        void* newobject = 0;
+        void* newobject = nullptr;
         if (!this->objectStack_.empty())
         {
@@ -422,5 +422,5 @@
             return this->executor_->getFunctor()->getRawObjectPointer();
         else
-            return 0;
+            return nullptr;
     }
 
@@ -528,5 +528,5 @@
             return this->argumentCompleter_[index];
         else
-            return 0;
+            return nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommand.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommand.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommand.h	(revision 11054)
@@ -195,5 +195,5 @@
                         { if (this->command_) { this->command_->popFunction(); } return *this; }
 
-                    /// Sets the current function-pointer to NULL, which also deactivates the command.
+                    /// Sets the current function-pointer to nullptr, which also deactivates the command.
                     inline ConsoleCommandManipulator& resetFunction()
                         { if (this->command_) { this->command_->resetFunction(); } return *this; }
@@ -205,5 +205,5 @@
                     inline ConsoleCommandManipulator& pushObject(void* object)
                         { if (this->command_) { this->command_->pushObject(object); } return *this; }
-                    /// Removes the current object from the object-stack and restores the old object (or NULL if there's no object left on the stack).
+                    /// Removes the current object from the object-stack and restores the old object (or nullptr if there's no object left on the stack).
                     inline ConsoleCommandManipulator& popObject()
                         { if (this->command_) { this->command_->popObject(); } return *this; }
Index: code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandIncludes.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandIncludes.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandIncludes.h	(revision 11054)
@@ -316,6 +316,6 @@
             ~StaticallyInitializedConsoleCommand() { delete command_; }
 
-            virtual void load();
-            virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
 
             inline ConsoleCommand& getCommand()
@@ -331,5 +331,5 @@
         @brief Returns a manipulator for a command with the given name.
 
-        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
+        @note If the command doesn't exist, the manipulator contains a nullptr to the command,
         but it can still be used without checks, because all functions of ConsoleCommandManipulator
         check internally if the command exists.
@@ -340,5 +340,5 @@
         @brief Returns a manipulator for a command with the given group and name.
 
-        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
+        @note If the command doesn't exist, the manipulator contains a nullptr to the command,
         but it can still be used without checks, because all functions of ConsoleCommandManipulator
         check internally if the command exists.
Index: code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandManager.cc	(revision 11054)
@@ -39,5 +39,5 @@
 namespace orxonox
 {
-    ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = 0;
+    ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = nullptr;
 
     /**
@@ -50,5 +50,5 @@
     {
         // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMap_.find(group);
+        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMap_.find(group);
         if (it_group != this->commandMap_.end())
         {
@@ -68,5 +68,5 @@
                 orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
         }
-        return 0;
+        return nullptr;
     }
 
@@ -83,5 +83,5 @@
 
         // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMapLC_.find(groupLC);
+        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMapLC_.find(groupLC);
         if (it_group != this->commandMapLC_.end())
         {
@@ -101,5 +101,5 @@
                 orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
         }
-        return 0;
+        return nullptr;
     }
 
@@ -125,5 +125,5 @@
 
         // check if a command with this name already exists
-        if (this->getCommand(group, name) != 0)
+        if (this->getCommand(group, name) != nullptr)
         {
             if (group == "")
@@ -146,5 +146,5 @@
     {
         // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
         {
             // iterate through all commands of each group
@@ -168,5 +168,5 @@
 
         // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
         {
             // iterate through all commands of each group
Index: code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ConsoleCommandManager.h	(revision 11054)
@@ -39,4 +39,6 @@
 #include "util/Singleton.h"
 
+#include <map>
+
 namespace orxonox
 {
@@ -54,8 +56,8 @@
 
             /// Returns the map with all groups and commands.
-            inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
+            inline const std::map<std::string, std::map<std::string, ConsoleCommand*>>& getCommands()
                 { return this->commandMap_; }
             /// Returns the map with all groups and commands in lowercase.
-            inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
+            inline const std::map<std::string, std::map<std::string, ConsoleCommand*>>& getCommandsLC()
                 { return this->commandMapLC_; }
 
@@ -71,6 +73,6 @@
 
         private:
-            std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMap_;
-            std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMapLC_;
+            std::map<std::string, std::map<std::string, ConsoleCommand*>> commandMap_;
+            std::map<std::string, std::map<std::string, ConsoleCommand*>> commandMapLC_;
 
             static ConsoleCommandManager* singletonPtr_s;
Index: code/branches/cpp11_v3/src/libraries/core/command/Executor.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/Executor.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/Executor.cc	(revision 11054)
@@ -67,14 +67,7 @@
 
     /**
-        @brief Destructor
-    */
-    Executor::~Executor()
-    {
-    }
-
-    /**
         @brief Calls the wrapped function with arguments that are passed in a string.
         @param arguments The arguments that should be passed to the function, separated by @a delimiter
-        @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
         @param delimiter The delimiter that is used to separate the arguments in the string @a arguments
         @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
@@ -89,5 +82,5 @@
         @brief Calls the wrapped function with arguments that are passed as tokens in a SubString
         @param arguments The arguments that should be passed to the function
-        @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
         @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
         @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
@@ -127,5 +120,5 @@
         @param arguments The arguments that should be converted
         @param arg An array of MultiType where the converted arguments will be stored
-        @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
         @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
         @return Returns the number of evaluated arguments
Index: code/branches/cpp11_v3/src/libraries/core/command/Executor.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/Executor.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/Executor.h	(revision 11054)
@@ -42,6 +42,6 @@
     orxonox::Executor is used to wrap an orxonox::Functor and to store default values for
     its parameters. Usually one uses the function createExecutor() to create a new executor.
-    This function returns an orxonox::ExecutorPtr which is a typedef of @ref orxonox::SharedPtr
-    "SharedPtr<Executor>", used to manage the pointer to the executor.
+    This function returns an orxonox::ExecutorPtr which is a typedef of "std::shared_ptr<Executor>",
+    used to manage the pointer to the executor.
 
     Executors are mostly used to execute callbacks. Because some callback functions need arguments,
@@ -74,6 +74,6 @@
     @endcode
 
-    Because executors that were created with createExecutor() are managed by an orxonox::SharedPtr,
-    they don't need to be deleted after usage.
+    Executors don't need to be deleted after usage normally because they are managed by an
+    std::shared_ptr when they were created with createExecutor().
 */
 
@@ -100,5 +100,5 @@
             Executor(const FunctorPtr& functor, const std::string& name = "");
             Executor(const Executor& other);
-            virtual ~Executor();
+            virtual ~Executor() = default;
 
             /// Calls the wrapped function with 0 arguments. If the function needs more arguments, the executor's default values are used.
@@ -121,8 +121,8 @@
                 { return (*this->functor_)(arg1, arg2, arg3, arg4, arg5); }
 
-            MultiType parse(const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
-            MultiType parse(const SubString& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
-
-            int evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error = 0, const std::string& delimiter = " ") const;
+            MultiType parse(const std::string& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const;
+            MultiType parse(const SubString& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const;
+
+            int evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error = nullptr, const std::string& delimiter = " ") const;
 
             /// Changes the functor.
@@ -249,5 +249,5 @@
 
             /// Overloads Executor::parse() with an additional object-pointer.
-            MultiType parse(T* object, const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const
+            MultiType parse(T* object, const std::string& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const
             {
                 T* oldobject = this->functorMember_->getObject();
@@ -267,5 +267,5 @@
     inline ExecutorPtr createExecutor(const FunctorPtr& functor, const std::string& name = "")
     {
-        return new Executor(functor, name);
+        return std::make_shared<Executor>(functor, name);
     }
 
@@ -274,5 +274,5 @@
     inline ExecutorMemberPtr<T> createExecutor(const FunctorMemberPtr<T>& functor, const std::string& name = "")
     {
-        return new ExecutorMember<T>(functor, name);
+        return std::make_shared<ExecutorMember<T>>(functor, name);
     }
 
@@ -280,5 +280,5 @@
     inline ExecutorStaticPtr createExecutor(const FunctorStaticPtr& functor, const std::string& name = "")
     {
-        return new ExecutorStatic(functor, name);
+        return std::make_shared<ExecutorStatic>(functor, name);
     }
 }
Index: code/branches/cpp11_v3/src/libraries/core/command/ExecutorPtr.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/ExecutorPtr.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/ExecutorPtr.h	(revision 11054)
@@ -32,7 +32,7 @@
     @brief Typedefs and definitions of ExecutorPtr, ExecutorStaticPtr, and ExecutorMemberPtr
 
-    Instances of orxonox::Executor are usually managed by an orxonox::SharedPtr. This ensures
+    Instances of orxonox::Executor are usually managed by an std::shared_ptr. This ensures
     that Executors will be destroyed after usage. To make things easier, there's a typedef
-    that defines ExecutorPtr as SharedPtr<Executor>.
+    that defines ExecutorPtr as std::shared_ptr<Executor>.
 
     Because there's not only orxonox::Executor, but also orxonox::ExecutorStatic, and
@@ -49,23 +49,12 @@
 
 #include "core/CorePrereqs.h"
-#include "util/SharedPtr.h"
+#include <memory>
 
 namespace orxonox
 {
-    /// ExecutorPtr is just a typedef of SharedPtr
-    typedef SharedPtr<Executor> ExecutorPtr;
-
-    /// ExecutorStaticPtr is just a typedef of SharedChildPtr
-    typedef SharedChildPtr<ExecutorStatic, ExecutorPtr> ExecutorStaticPtr;
-
-    /// It's not possible to use a typedef for ExecutorMemberPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
+    using ExecutorPtr = std::shared_ptr<Executor>;
+    using ExecutorStaticPtr = std::shared_ptr<ExecutorStatic>;
     template <class T>
-    class ExecutorMemberPtr : public SharedChildPtr<ExecutorMember<T>, ExecutorPtr>
-    {
-        public:
-            inline ExecutorMemberPtr() : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>() {}
-            inline ExecutorMemberPtr(ExecutorMember<T>* pointer) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(pointer) {}
-            inline ExecutorMemberPtr(const SharedPtr<ExecutorMember<T> >& other) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(other) {}
-    };
+    using ExecutorMemberPtr = std::shared_ptr<ExecutorMember<T>>;
 }
 
Index: code/branches/cpp11_v3/src/libraries/core/command/Functor.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/Functor.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/Functor.h	(revision 11054)
@@ -40,7 +40,7 @@
 
     To create a Functor, the helper function createFunctor() is used. It returns an instance
-    of orxonox::FunctorPtr which is simply a typedef of @ref orxonox::SharedPtr "SharedPtr<Functor>".
-    This means you don't have to delete the Functor after using it, because it is managed
-    by the SharedPtr.
+    of orxonox::FunctorPtr which is simply a typedef of "std::shared_ptr<Functor>". This
+    means you don't have to delete the Functor after using it, because it is managed
+    by the std::shared_ptr.
 
     Example:
@@ -187,5 +187,5 @@
 
         public:
-            virtual ~Functor() {}
+            virtual ~Functor() = default;
 
             /// Calls the function-pointer with up to five arguments. In case of a member-function, the assigned object-pointer is used to call the function. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
@@ -215,5 +215,5 @@
             virtual void* getRawObjectPointer() const = 0;
 
-            /// Enables or disables the safe mode which causes the functor to change the object pointer to NULL if the object is deleted (only member functors).
+            /// Enables or disables the safe mode which causes the functor to change the object pointer to nullptr if the object is deleted (only member functors).
             virtual void setSafeMode(bool bSafeMode) = 0;
 
@@ -242,12 +242,12 @@
         public:
             /// Constructor: Stores the object-pointer.
-            FunctorMember(O* object = 0) : object_(object), bSafeMode_(false) {}
+            FunctorMember(O* object = nullptr) : object_(object), bSafeMode_(false) {}
             virtual ~FunctorMember() { if (this->bSafeMode_) { this->unregisterObject(this->object_); } }
 
-            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be nullptr. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
             virtual MultiType operator()(O* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             // see Functor::operator()()
-            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
+            virtual MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) override
             {
                 // call the function if an object was assigned
@@ -262,5 +262,5 @@
 
             // see Functor::getType()
-            inline Functor::Type::Enum getType() const
+            virtual inline Functor::Type::Enum getType() const override
                 { return Functor::Type::Member; }
 
@@ -280,12 +280,12 @@
 
             // see Functor::setRawObjectPointer()
-            inline void setRawObjectPointer(void* object)
+            virtual inline void setRawObjectPointer(void* object) override
                 { this->setObject((O*)object); }
             // see Functor::getRawObjectPointer()
-            inline void* getRawObjectPointer() const
+            virtual inline void* getRawObjectPointer() const override
                 { return this->object_; }
 
             // see Functor::setSafeMode()
-            inline void setSafeMode(bool bSafeMode)
+            virtual inline void setSafeMode(bool bSafeMode) override
             {
                 if (bSafeMode == this->bSafeMode_)
@@ -301,17 +301,22 @@
 
         protected:
-            /// Casts the object and registers as destruction listener.
-            inline void registerObject(O* object)
-                { Destroyable* base = dynamic_cast<Destroyable*>(object); if (base) { this->registerAsDestructionListener(base); } }
-            /// Casts the object and unregisters as destruction listener.
-            inline void unregisterObject(O* object)
-                { Destroyable* base = dynamic_cast<Destroyable*>(object); if (base) { this->unregisterAsDestructionListener(base); } }
-
-            /// Will be called by Destroyable::~Destroyable() if the stored object is deleted and the Functor is in safe mode.
-            inline void objectDeleted()
-                { this->object_ = 0; }
-
-            O* object_;     ///< The stored object-pointer, used to execute a member-function (or NULL for static functions)
-            bool bSafeMode_; ///< If true, the functor is in safe mode and registers itself as listener at the object and changes the pointer to NULL if the object is deleted
+            /// Casts the object and registers as destruction listener if the object is a Destroyable.
+            inline void registerObject(Destroyable* object)
+                { this->registerAsDestructionListener(object); }
+
+            inline void registerObject(void* object) {}
+
+            /// Casts the object and unregisters as destruction listener if the object is a Destroyable.
+            inline void unregisterObject(Destroyable* object)
+                { this->unregisterAsDestructionListener(object); }
+
+            inline void unregisterObject(void* object) {}
+
+            /// Will be called by Destroyable::~Destroyable() if the stored object is a Destroyable and deleted and the Functor is in safe mode.
+            virtual inline void objectDeleted() override
+                { this->object_ = nullptr; }
+
+            O* object_;     ///< The stored object-pointer, used to execute a member-function (or nullptr for static functions)
+            bool bSafeMode_; ///< If true, the functor is in safe mode and registers itself as listener at the object and changes the pointer to nullptr if the object is deleted
     };
 
@@ -322,28 +327,28 @@
         public:
             /// Constructor: Stores the object-pointer.
-            FunctorMember(void* object = 0) {}
-
-            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            FunctorMember(void* object = nullptr) {}
+
+            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be nullptr. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
             virtual MultiType operator()(void* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             // see Functor::operator()()
-            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
-            {
-                return (*this)((void*)0, param1, param2, param3, param4, param5);
+            virtual MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) override
+            {
+                return (*this)((void*)nullptr, param1, param2, param3, param4, param5);
             }
 
             // see Functor::getType()
-            inline Functor::Type::Enum getType() const
+            virtual inline Functor::Type::Enum getType() const override
                 { return Functor::Type::Static; }
 
             // see Functor::setRawObjectPointer()
-            inline void setRawObjectPointer(void*)
+            virtual inline void setRawObjectPointer(void*) override
                 { orxout(internal_warning) << "Can't assign an object pointer to a static functor" << endl; }
             // see Functor::getRawObjectPointer()
-            inline void* getRawObjectPointer() const
-                { return 0; }
+            virtual inline void* getRawObjectPointer() const override
+                { return nullptr; }
 
             // see Functor::setSafeMode()
-            inline void setSafeMode(bool) {}
+            virtual inline void setSafeMode(bool) override {}
     };
 
@@ -352,12 +357,12 @@
 
     /**
-        @brief FunctorPointer is a child class of FunctorMember and expands it with a function-pointer.
-        @param F The type of the function-pointer
-        @param O The type of the function's class (or void if it's a static function)
+        @brief FunctorPointer is a child class of FunctorMember and extends it with a function-pointer (or a function-object).
+        @param F The type of the function-pointer (or the function-object)
+        @param O The type of the function's class (or void if it's a static function or a function-object)
 
         The template FunctorPointer has an additional template parameter that defines the type
-        of the function-pointer. This can be handy if you want to get or set the function-pointer.
-        You can then use a static_cast to cast a Functor to FunctorPointer if you know the type
-        of the function-pointer.
+        of the function-pointer (or the function-object). This can be handy if you want to get
+        or set the function-pointer (or the function-object). You can then use a static_cast
+        to cast a Functor to FunctorPointer if you know the type of the function.
 
         However FunctorPointer is not aware of the types of the different parameters or the
@@ -369,5 +374,5 @@
         public:
             /// Constructor: Initializes the base class and stores the function-pointer.
-            FunctorPointer(F functionPointer, O* object = 0) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
+            FunctorPointer(F functionPointer, O* object = nullptr) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
 
             /// Changes the function-pointer.
@@ -378,8 +383,4 @@
                 { return this->functionPointer_; }
 
-            // see Functor::getFullIdentifier()
-            const std::type_info& getFullIdentifier() const
-                { return typeid(F); }
-
         protected:
             F functionPointer_;     ///< The stored function-pointer
@@ -388,55 +389,19 @@
     namespace detail
     {
-        // Helper class to get the type of the function pointer with the given class, parameters, return-value, and constness
-        template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer                                            { typedef R (O::*Type)(P1, P2, P3, P4, P5); };
-        template <class R, class O, class P1, class P2, class P3, class P4, class P5>               struct FunctionPointer<R, O, false, P1, P2, P3, P4, P5>           { typedef R (O::*Type)(P1, P2, P3, P4, P5); };
-        template <class R, class O, class P1, class P2, class P3, class P4>                         struct FunctionPointer<R, O, false, P1, P2, P3, P4, void>         { typedef R (O::*Type)(P1, P2, P3, P4); };
-        template <class R, class O, class P1, class P2, class P3>                                   struct FunctionPointer<R, O, false, P1, P2, P3, void, void>       { typedef R (O::*Type)(P1, P2, P3); };
-        template <class R, class O, class P1, class P2>                                             struct FunctionPointer<R, O, false, P1, P2, void, void, void>     { typedef R (O::*Type)(P1, P2); };
-        template <class R, class O, class P1>                                                       struct FunctionPointer<R, O, false, P1, void, void, void, void>   { typedef R (O::*Type)(P1); };
-        template <class R, class O>                                                                 struct FunctionPointer<R, O, false, void, void, void, void, void> { typedef R (O::*Type)(); };
-        template <class R, class O, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer<R, O, true, P1, P2, P3, P4, P5>           { typedef R (O::*Type)(P1, P2, P3, P4, P5) const; };
-        template <class R, class O, class P1, class P2, class P3, class P4>           struct FunctionPointer<R, O, true, P1, P2, P3, P4, void>         { typedef R (O::*Type)(P1, P2, P3, P4) const; };
-        template <class R, class O, class P1, class P2, class P3>                     struct FunctionPointer<R, O, true, P1, P2, P3, void, void>       { typedef R (O::*Type)(P1, P2, P3) const; };
-        template <class R, class O, class P1, class P2>                               struct FunctionPointer<R, O, true, P1, P2, void, void, void>     { typedef R (O::*Type)(P1, P2) const; };
-        template <class R, class O, class P1>                                         struct FunctionPointer<R, O, true, P1, void, void, void, void>   { typedef R (O::*Type)(P1) const; };
-        template <class R, class O>                                                   struct FunctionPointer<R, O, true, void, void, void, void, void> { typedef R (O::*Type)() const; };
-        template <class R, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer<R, void, false, P1, P2, P3, P4, P5>           { typedef R (*Type)(P1, P2, P3, P4, P5); };
-        template <class R, class P1, class P2, class P3, class P4>           struct FunctionPointer<R, void, false, P1, P2, P3, P4, void>         { typedef R (*Type)(P1, P2, P3, P4); };
-        template <class R, class P1, class P2, class P3>                     struct FunctionPointer<R, void, false, P1, P2, P3, void, void>       { typedef R (*Type)(P1, P2, P3); };
-        template <class R, class P1, class P2>                               struct FunctionPointer<R, void, false, P1, P2, void, void, void>     { typedef R (*Type)(P1, P2); };
-        template <class R, class P1>                                         struct FunctionPointer<R, void, false, P1, void, void, void, void>   { typedef R (*Type)(P1); };
-        template <class R>                                                   struct FunctionPointer<R, void, false, void, void, void, void, void> { typedef R (*Type)(); };
-
-        // Helper class, used to call a function-pointer with a given object and parameters and to return its return-value (if available)
-        template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller                                              { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3, param4, param5); } };
-        template <class R, class O, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<R, O, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { return (object->*functionPointer)(param1, param2, param3, param4); } };
-        template <class R, class O, bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<R, O, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1, param2, param3); } };
-        template <class R, class O, bool isconst, class P1, class P2>                               struct FunctorCaller<R, O, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1, param2); } };
-        template <class R, class O, bool isconst, class P1>                                         struct FunctorCaller<R, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1); } };
-        template <class R, class O, bool isconst>                                                   struct FunctorCaller<R, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(); } };
-        template <class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4, param5); return MultiType::Null; } };
-        template <class O, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (object->*functionPointer)(param1, param2, param3, param4); return MultiType::Null; } };
-        template <class O, bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2, param3); return MultiType::Null; } };
-        template <class O, bool isconst, class P1, class P2>                               struct FunctorCaller<void, O, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2); return MultiType::Null; } };
-        template <class O, bool isconst, class P1>                                         struct FunctorCaller<void, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1); return MultiType::Null; } };
-        template <class O, bool isconst>                                                   struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(); return MultiType::Null; } };
-        template <class R, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1, param2, param3, param4, param5); } };
-        template <class R, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { return (*functionPointer)(param1, param2, param3, param4); } };
-        template <class R, bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<R, void, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { return (*functionPointer)(param1, param2, param3); } };
-        template <class R, bool isconst, class P1, class P2>                               struct FunctorCaller<R, void, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(param1, param2); } };
-        template <class R, bool isconst, class P1>                                         struct FunctorCaller<R, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(param1); } };
-        template <class R, bool isconst>                                                   struct FunctorCaller<R, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(); } };
-        template <bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3, param4, param5); return MultiType::Null; } };
-        template <bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (*functionPointer)(param1, param2, param3, param4); return MultiType::Null; } };
-        template <bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2, param3); return MultiType::Null; } };
-        template <bool isconst, class P1, class P2>                               struct FunctorCaller<void, void, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2); return MultiType::Null; } };
-        template <bool isconst, class P1>                                         struct FunctorCaller<void, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1); return MultiType::Null; } };
-        template <bool isconst>                                                   struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(); return MultiType::Null; } };
-
-        // Helper class, used to identify the header of a function-pointer (independent of its class)
-        template <class R, class P1, class P2, class P3, class P4, class P5>
-        struct FunctorHeaderIdentifier
-        {};
+        // Helper class to get the type of the function-pointer (or the function-object) with the given class, parameters, return-value, and constness
+        template <class F, class R, class O, bool isconst, class... Params> struct FunctionType /* generic type is undefined */;
+        template <         class R, class O,               class... Params> struct FunctionType<void, R, O,    false, Params...> { typedef R (O::*Type)(Params...); };       // spezialization: non-const member function
+        template <         class R, class O,               class... Params> struct FunctionType<void, R, O,    true,  Params...> { typedef R (O::*Type)(Params...) const; }; // spezialization: const member function
+        template <         class R,                        class... Params> struct FunctionType<void, R, void, false, Params...> { typedef R (*Type)(Params...); };          // spezialization: static function
+        template <class F, class R,                        class... Params> struct FunctionType<F,    R, void, false, Params...> { typedef F Type; };                        // spezialization: function object
+
+        // Helper class, used to call a function with a given object and parameters and to return its return-value (if available)
+        template <class F, class R, class O, bool isconst, class... Params> struct FunctorCaller /* generic type is undefined */;
+        template <         class R, class O, bool isconst, class... Params> struct FunctorCaller<void, R,    O,    isconst, Params...> { template <class... UnusedParams> static inline MultiType call(typename detail::FunctionType<void, R,    O,    isconst, Params...>::Type functionPointer, O* object, const Params&... parameters, const UnusedParams&...) { return (object->*functionPointer)(parameters...); } };                  // spezialization: member function with return value
+        template <                  class O, bool isconst, class... Params> struct FunctorCaller<void, void, O,    isconst, Params...> { template <class... UnusedParams> static inline MultiType call(typename detail::FunctionType<void, void, O,    isconst, Params...>::Type functionPointer, O* object, const Params&... parameters, const UnusedParams&...) { (object->*functionPointer)(parameters...); return MultiType::Null; } }; // spezialization: member function without return value
+        template <         class R,                        class... Params> struct FunctorCaller<void, R,    void, false,   Params...> { template <class... UnusedParams> static inline MultiType call(typename detail::FunctionType<void, R,    void, false,   Params...>::Type functionPointer, void*,     const Params&... parameters, const UnusedParams&...) { return (*functionPointer)(parameters...); } };                          // spezialization: static function with return value
+        template <                                         class... Params> struct FunctorCaller<void, void, void, false,   Params...> { template <class... UnusedParams> static inline MultiType call(typename detail::FunctionType<void, void, void, false,   Params...>::Type functionPointer, void*,     const Params&... parameters, const UnusedParams&...) { (*functionPointer)(parameters...); return MultiType::Null; } };         // spezialization: static function without return value
+        template <class F, class R,                        class... Params> struct FunctorCaller<F,    R,    void, false,   Params...> { template <class... UnusedParams> static inline MultiType call(typename detail::FunctionType<F,    R,    void, false,   Params...>::Type functor,         void*,     const Params&... parameters, const UnusedParams&...) { return functor(parameters...); } };                                     // spezialization: function object with return value
+        template <class F,                                 class... Params> struct FunctorCaller<F,    void, void, false,   Params...> { template <class... UnusedParams> static inline MultiType call(typename detail::FunctionType<F,    void, void, false,   Params...>::Type functor,         void*,     const Params&... parameters, const UnusedParams&...) { functor(parameters...); return MultiType::Null; } };                    // spezialization: function object without return value
 
         // Helper class to determine if a function has a returnvalue
@@ -448,23 +413,43 @@
         { enum { result = false }; };
 
-        // Helper class to count the number of parameters
-        template <class P1, class P2, class P3, class P4, class P5>
-        struct FunctorParamCount
-        { enum { result = 5 }; };
-        template <class P1, class P2, class P3, class P4>
-        struct FunctorParamCount<P1, P2, P3, P4, void>
-        { enum { result = 4 }; };
-        template <class P1, class P2, class P3>
-        struct FunctorParamCount<P1, P2, P3, void, void>
-        { enum { result = 3 }; };
-        template <class P1, class P2>
-        struct FunctorParamCount<P1, P2, void, void, void>
-        { enum { result = 2 }; };
-        template <class P1>
-        struct FunctorParamCount<P1, void, void, void, void>
-        { enum { result = 1 }; };
+        // Helper class to determine the N-th parameter of a variadic template (with 0 being the index of the first parameter)
+        template <int n, typename T = void, typename... Other>
+        struct GetNthParamType
+        { typedef typename GetNthParamType<n - 1, Other...>::Type Type; };
+        template <typename T, typename... Other>
+        struct GetNthParamType<0, T, Other...>
+        { typedef T Type; };
+
+        // Helper structs to deduce the first N types of a parameter pack
+        template<class... Types> struct type_list {};
+
+        template <class T1, class... AllTypes>
+        struct make_type_list_helper
+        {
+            template <std::size_t N, class... Types>
+            struct make_type_list_impl : make_type_list_helper<AllTypes...>::template make_type_list_impl<N - 1, Types..., T1> {};
+
+            template <class... Types>
+            struct make_type_list_impl<1u, Types...> : type_list<Types..., T1> {};
+        };
+
+        template <class T1>
+        struct make_type_list_helper<T1>
+        {
+            template <std::size_t N, class... Types>
+            struct make_type_list_impl : type_list<Types..., T1> {};
+        };
+
+        template <std::size_t N, class... Types>
+        struct make_type_list : make_type_list_helper<Types...>::template make_type_list_impl<N> {};
+
+        template <class... Types>
+        struct make_type_list<0u, Types...> : type_list<> {};
+
+        template <std::size_t N>
+        struct make_type_list<N> : type_list<> {};
+
         template <>
-        struct FunctorParamCount<void, void, void, void, void>
-        { enum { result = 0 }; };
+        struct make_type_list<0u> : type_list<> {};
     }
 
@@ -473,12 +458,9 @@
         that need to know the exact types of the parameters, return-value, and class.
 
+        @param F the type of the function-object (or void if a function-pointer is used).
         @param R The type of the return-value of the function
         @param O The class of the function
         @param isconst True if the function is a const member-function
-        @param P1 The type of the first parameter
-        @param P2 The type of the second parameter
-        @param P3 The type of the third parameter
-        @param P4 The type of the fourth parameter
-        @param P5 The type of the fifth parameter
+        @param Params The types of the parameters
 
         This template has many parameters and is usually not used directly. It is created by
@@ -489,44 +471,46 @@
         All template arguments can be void.
     */
-    template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5>
-    class FunctorTemplate : public FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>
-    {
+    template <class F, class R, class O, bool isconst, class... Params>
+    class FunctorTemplate : public FunctorPointer<typename detail::FunctionType<F, R, O, isconst, Params...>::Type, O>
+    {
+        static_assert(sizeof...(Params) <= 5, "Only up to 5 parameters are supported");
+
         public:
             /// Constructor: Initializes the base class.
-            FunctorTemplate(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object = 0) : FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>(functionPointer, object) {}
+            FunctorTemplate(typename detail::FunctionType<F, R, O, isconst, Params...>::Type functionPointer, O* object = nullptr) : FunctorPointer<typename detail::FunctionType<F, R, O, isconst, Params...>::Type, O>(functionPointer, object) {}
 
             // see FunctorMember::operator()()
-            MultiType operator()(O* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
-            {
-                return detail::FunctorCaller<R, O, isconst, P1, P2, P3, P4, P5>::call(this->functionPointer_, object, param1, param2, param3, param4, param5);
+            virtual MultiType operator()(O* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) override
+            {
+                return detail::FunctorCaller<F, R, O, isconst, Params...>::call(this->functionPointer_, object, param1, param2, param3, param4, param5);
             }
 
             // see Functor::clone()
-            FunctorPtr clone()
-            {
-                return new FunctorTemplate(*this);
+            virtual FunctorPtr clone() override
+            {
+                return std::make_shared<FunctorTemplate>(*this);
             }
 
             // see Functor::evaluateArgument()
-            void evaluateArgument(unsigned int index, MultiType& argument) const
+            virtual void evaluateArgument(unsigned int index, MultiType& argument) const override
             {
                 switch (index)
                 {
-                    case 0: argument.convert<P1>(); break;
-                    case 1: argument.convert<P2>(); break;
-                    case 2: argument.convert<P3>(); break;
-                    case 3: argument.convert<P4>(); break;
-                    case 4: argument.convert<P5>(); break;
+                    case 0: argument.convert<typename detail::GetNthParamType<0, Params...>::Type>(); break;
+                    case 1: argument.convert<typename detail::GetNthParamType<1, Params...>::Type>(); break;
+                    case 2: argument.convert<typename detail::GetNthParamType<2, Params...>::Type>(); break;
+                    case 3: argument.convert<typename detail::GetNthParamType<3, Params...>::Type>(); break;
+                    case 4: argument.convert<typename detail::GetNthParamType<4, Params...>::Type>(); break;
                 }
             }
 
             // see Functor::getParamCount()
-            unsigned int getParamCount() const
-            {
-                return detail::FunctorParamCount<P1, P2, P3, P4, P5>::result;
+            virtual unsigned int getParamCount() const override
+            {
+                return sizeof...(Params);
             }
 
             // see Functor::hasReturnvalue()
-            bool hasReturnvalue() const
+            virtual bool hasReturnvalue() const override
             {
                 return detail::FunctorHasReturnvalue<R>::result;
@@ -534,13 +518,13 @@
 
             // see Functor::getTypenameParam()
-            std::string getTypenameParam(unsigned int index) const
+            virtual std::string getTypenameParam(unsigned int index) const override
             {
                 switch (index)
                 {
-                    case 0:  return typeToString<P1>();
-                    case 1:  return typeToString<P2>();
-                    case 2:  return typeToString<P3>();
-                    case 3:  return typeToString<P4>();
-                    case 4:  return typeToString<P5>();
+                    case 0:  return typeToString<typename detail::GetNthParamType<0, Params...>::Type>();
+                    case 1:  return typeToString<typename detail::GetNthParamType<1, Params...>::Type>();
+                    case 2:  return typeToString<typename detail::GetNthParamType<2, Params...>::Type>();
+                    case 3:  return typeToString<typename detail::GetNthParamType<3, Params...>::Type>();
+                    case 4:  return typeToString<typename detail::GetNthParamType<4, Params...>::Type>();
                     default: return "";
                 }
@@ -548,62 +532,66 @@
 
             // see Functor::getTypenameReturnvalue()
-            std::string getTypenameReturnvalue() const
+            virtual std::string getTypenameReturnvalue() const override
             {
                 return typeToString<R>();
             }
 
+            // see Functor::getFullIdentifier()
+            virtual const std::type_info& getFullIdentifier() const override
+            {
+                return typeid(typename detail::FunctionType<void, R, O, isconst, Params...>::Type);
+            }
+
             // see Functor::getHeaderIdentifier()
-            const std::type_info& getHeaderIdentifier() const
-            {
-                return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, P4, P5>);
+            virtual const std::type_info& getHeaderIdentifier() const override
+            {
+                return typeid(typename detail::FunctionType<void, R, void, false, Params...>::Type);
             }
 
             // see Functor::getHeaderIdentifier(unsigned int)
-            const std::type_info& getHeaderIdentifier(unsigned int params) const
+            virtual const std::type_info& getHeaderIdentifier(unsigned int params) const override
             {
                 switch (params)
                 {
-                    case 0:  return typeid(detail::FunctorHeaderIdentifier<R, void, void, void, void, void>);
-                    case 1:  return typeid(detail::FunctorHeaderIdentifier<R, P1, void, void, void, void>);
-                    case 2:  return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, void, void, void>);
-                    case 3:  return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, void, void>);
-                    case 4:  return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, P4, void>);
-                    default: return typeid(detail::FunctorHeaderIdentifier<R, P1, P2, P3, P4, P5>);
+                    case 0:  return this->getTypelistIdentifier(detail::make_type_list<0, Params...>{});
+                    case 1:  return this->getTypelistIdentifier(detail::make_type_list<1, Params...>{});
+                    case 2:  return this->getTypelistIdentifier(detail::make_type_list<2, Params...>{});
+                    case 3:  return this->getTypelistIdentifier(detail::make_type_list<3, Params...>{});
+                    case 4:  return this->getTypelistIdentifier(detail::make_type_list<4, Params...>{});
+                    default: return this->getTypelistIdentifier(detail::make_type_list<5, Params...>{});
                 }
             }
+
+    private:
+            /// Helper function that deduces a parameter pack of types and returns the corresponding identifier
+            template<class... Types>
+            const std::type_info& getTypelistIdentifier(detail::type_list<Types...>) const
+            {
+                return typeid(typename detail::FunctionType<void, R, void, false, Types...>::Type);
+            }
     };
 
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5), OO* object) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4), OO* object)     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3), OO* object)         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2), OO* object)             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1), OO* object)                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(), OO* object)                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const, OO* object) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const, OO* object)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const, OO* object)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const, OO* object)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const, OO* object)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const, OO* object)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
-
-    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2))             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1))                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)())                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
-
-    template <class R, class P1, class P2, class P3, class P4, class P5> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1, class P2, class P3, class P4>           inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1, class P2, class P3>                     inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, void, false, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1, class P2>                               inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2))             { return new FunctorTemplate<R, void, false, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R, class P1>                                         inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1))                 { return new FunctorTemplate<R, void, false, P1, void, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
-    template <class R>                                                   inline FunctorStaticPtr createFunctor(R (*functionPointer)())                   { return new FunctorTemplate<R, void, false, void, void, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+
+    namespace detail
+    {
+        // Helper functions to deduce types and constness of operator() and return the correct FunctorTemplate
+        template <class F>
+        struct CallableHelper
+        {
+            template <class R, class... Params> static inline FunctorStaticPtr create(const F& functionObject, R(F::*)(Params...))       { return std::make_shared<FunctorTemplate<F, R, void, false, Params...>>(functionObject); }
+            template <class R, class... Params> static inline FunctorStaticPtr create(const F& functionObject, R(F::*)(Params...) const) { return std::make_shared<FunctorTemplate<F, R, void, false, Params...>>(functionObject); } // note: both const and non-const function-objects are treated as static functors with isconst=false.
+        };
+    }
+
+    template <class R, class O, class OO, class... Params> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(Params...),       OO* object) { return std::make_shared<FunctorTemplate<void, R, O, false, Params...>>(functionPointer, object); } ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class... Params> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(Params...) const, OO* object) { return std::make_shared<FunctorTemplate<void, R, O, true,  Params...>>(functionPointer, object); } ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+
+    template <class R, class O, class... Params> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(Params...))       { return std::make_shared<FunctorTemplate<void, R, O, false, Params...>>(functionPointer); } ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class... Params> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(Params...) const) { return std::make_shared<FunctorTemplate<void, R, O, true,  Params...>>(functionPointer); } ///< Creates a new FunctorMember with the given function-pointer
+
+    template <class R, class... Params> inline FunctorStaticPtr createFunctor(R (*functionPointer)(Params...)) { return std::make_shared<FunctorTemplate<void, R, void, false, Params...>>(functionPointer); } ///< Creates a new FunctorStatic with the given function-pointer
+
+    /** Take care that this functor does not outlive objects that have been captured by reference in a lambda. */
+    template <class F> inline FunctorStaticPtr createFunctor(const F& functionObject) { return detail::CallableHelper<F>::create(functionObject, &F::operator()); } ///< Creates a new Functor with a callable object
 }
 
Index: code/branches/cpp11_v3/src/libraries/core/command/FunctorPtr.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/FunctorPtr.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/FunctorPtr.h	(revision 11054)
@@ -32,7 +32,7 @@
     @brief Typedefs and definitions of FunctorPtr, FunctorMemberPtr, FunctorStaticPtr, and FunctorPointerPtr
 
-    Instances of orxonox::Functor are usually managed by an orxonox::SharedPtr. This ensures
+    Instances of orxonox::Functor are usually managed by an std::shared_ptr. This ensures
     that Functors will be destroyed after usage. To make things easier, there's a typedef
-    that defines FunctorPtr as SharedPtr<Functor>.
+    that defines FunctorPtr as std::shared_ptr<Functor>.
 
     Because there's not only orxonox::Functor, but also orxonox::FunctorStatic, and
@@ -51,33 +51,14 @@
 
 #include "core/CorePrereqs.h"
-#include "util/SharedPtr.h"
+#include <memory>
 
 namespace orxonox
 {
-    /// FunctorPtr is just a typedef of SharedPtr
-    typedef SharedPtr<Functor> FunctorPtr;
-
-    /// It's not possible to use a typedef for FunctorMemberPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
+    using FunctorPtr = std::shared_ptr<Functor>;
     template <class T>
-    class FunctorMemberPtr : public SharedChildPtr<FunctorMember<T>, FunctorPtr>
-    {
-        public:
-            inline FunctorMemberPtr() : SharedChildPtr<FunctorMember<T>, FunctorPtr>() {}
-            inline FunctorMemberPtr(FunctorMember<T>* pointer) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(pointer) {}
-            inline FunctorMemberPtr(const SharedPtr<FunctorMember<T> >& other) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(other) {}
-    };
-
-    /// FunctorStaticPtr is just FunctorMemberPtr with @a T = void
-    typedef FunctorMemberPtr<void> FunctorStaticPtr;
-
-    /// It's not possible to use a typedef for FunctorPointerPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
+    using FunctorMemberPtr = std::shared_ptr<FunctorMember<T>>;
+    using FunctorStaticPtr = std::shared_ptr<FunctorMember<void>>;
     template <class F, class T>
-    class FunctorPointerPtr : public SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >
-    {
-        public:
-            inline FunctorPointerPtr() : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >() {}
-            inline FunctorPointerPtr(FunctorPointer<F, T>* pointer) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(pointer) {}
-            inline FunctorPointerPtr(const SharedPtr<FunctorPointer<F, T> >& other) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(other) {}
-    };
+    using FunctorPointerPtr = std::shared_ptr<FunctorPointer<F, T>>;
 }
 
Index: code/branches/cpp11_v3/src/libraries/core/command/IOConsolePOSIX.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/IOConsolePOSIX.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/IOConsolePOSIX.cc	(revision 11054)
@@ -44,5 +44,5 @@
 namespace orxonox
 {
-    IOConsole* IOConsole::singletonPtr_s = NULL;
+    IOConsole* IOConsole::singletonPtr_s = nullptr;
 
     namespace EscapeMode
@@ -62,5 +62,5 @@
         , promptString_("orxonox # ")
         , bStatusPrinted_(false)
-        , originalTerminalSettings_(0)
+        , originalTerminalSettings_(nullptr)
     {
         this->setTerminalMode();
@@ -326,5 +326,5 @@
             tcsetattr(0, TCSANOW, IOConsole::singletonPtr_s->originalTerminalSettings_);
             delete IOConsole::singletonPtr_s->originalTerminalSettings_;
-            IOConsole::singletonPtr_s->originalTerminalSettings_ = 0;
+            IOConsole::singletonPtr_s->originalTerminalSettings_ = nullptr;
         }
     }
@@ -353,9 +353,9 @@
         const char* s;
         if (!this->terminalWidth_ && (s = getenv("COLUMNS")))
-            this->terminalWidth_  = strtol(s, NULL, 10);
+            this->terminalWidth_  = strtol(s, nullptr, 10);
         if (!this->terminalWidth_)
             this->terminalWidth_ = 80;
         if (!this->terminalHeight_ && (s = getenv("LINES")))
-            this->terminalHeight_ = strtol(s, NULL, 10);
+            this->terminalHeight_ = strtol(s, nullptr, 10);
         if (!this->terminalHeight_)
             this->terminalHeight_ = 24;
Index: code/branches/cpp11_v3/src/libraries/core/command/IOConsolePOSIX.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/IOConsolePOSIX.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/IOConsolePOSIX.h	(revision 11054)
@@ -65,10 +65,10 @@
 
         // Methods from ShellListener
-        void linesChanged();
-        void lineAdded();
-        void inputChanged();
-        void cursorChanged();
-        void executed();
-        void exit();
+        virtual void linesChanged() override;
+        virtual void lineAdded() override;
+        virtual void inputChanged() override;
+        virtual void cursorChanged() override;
+        virtual void executed() override;
+        virtual void exit() override;
 
         bool willPrintStatusLines();
Index: code/branches/cpp11_v3/src/libraries/core/command/IOConsoleWindows.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/IOConsoleWindows.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/IOConsoleWindows.cc	(revision 11054)
@@ -41,5 +41,5 @@
 namespace orxonox
 {
-    IOConsole* IOConsole::singletonPtr_s = NULL;
+    IOConsole* IOConsole::singletonPtr_s = nullptr;
 
     //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
@@ -300,5 +300,5 @@
                 this->terminalWidth_ - 1, this->inputLineRow_ + this->inputLineHeight_ + this->statusLines_ - 1);
             this->inputLineRow_ += linesDown;
-            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, this->inputLineRow_), &fillChar);
+            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, nullptr, makeCOORD(0, this->inputLineRow_), &fillChar);
             // Move cursor down to the new bottom so the user can see the status lines
             COORD pos = makeCOORD(0, this->inputLineRow_ + this->inputLineHeight_ - 1 + this->statusLines_);
@@ -312,5 +312,5 @@
             // Scroll output up
             SMALL_RECT oldRect = makeSMALL_RECT(0, lines - linesDown, this->terminalWidth_ - 1, this->inputLineRow_ - 1);
-            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, 0), &fillChar);
+            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, nullptr, makeCOORD(0, 0), &fillChar);
         }
     }
@@ -360,5 +360,5 @@
             SMALL_RECT oldRect = makeSMALL_RECT(0, statusLineRow, this->terminalWidth_ - 1, statusLineRow + this->statusLines_);
             CHAR_INFO fillChar = {{' '}, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED};
-            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, statusLineRow + newLines), &fillChar);
+            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, nullptr, makeCOORD(0, statusLineRow + newLines), &fillChar);
             // Clear potential leftovers
             if (-newLines - this->statusLines_ > 0)
Index: code/branches/cpp11_v3/src/libraries/core/command/IOConsoleWindows.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/IOConsoleWindows.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/IOConsoleWindows.h	(revision 11054)
@@ -67,10 +67,10 @@
 
         // Methods from ShellListener
-        void linesChanged();
-        void lineAdded();
-        void inputChanged();
-        void cursorChanged();
-        void executed();
-        void exit();
+        virtual void linesChanged() override;
+        virtual void lineAdded() override;
+        virtual void inputChanged() override;
+        virtual void cursorChanged() override;
+        virtual void executed() override;
+        virtual void exit() override;
 
         void resetTerminalMode();
Index: code/branches/cpp11_v3/src/libraries/core/command/IRC.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/IRC.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/IRC.cc	(revision 11054)
@@ -44,5 +44,5 @@
 namespace orxonox
 {
-    static const unsigned int IRC_TCL_THREADID  = 1421421421;   ///< The ID of the thread in TclThreadManager that is used for the IRC connection
+    static constexpr unsigned int IRC_TCL_THREADID  = 1421421421;   ///< The ID of the thread in TclThreadManager that is used for the IRC connection
 
     SetConsoleCommand("IRC", "say",  &IRC::say);
@@ -66,5 +66,5 @@
     IRC::IRC()
     {
-        this->interpreter_ = 0;
+        this->interpreter_ = nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/command/IRC.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/IRC.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/IRC.h	(revision 11054)
@@ -65,6 +65,9 @@
 
             IRC();
-            IRC(const IRC& other);              ///< Copy-constructor: Not implemented
-            ~IRC() {}                           ///< Destructor
+            ~IRC() = default;
+
+            // non-copyable:
+            IRC(const IRC&) = delete;
+            IRC& operator=(const IRC&) = delete;
 
             Tcl::interpreter* interpreter_;     ///< The Tcl interpreter that is used for the IRC connection
Index: code/branches/cpp11_v3/src/libraries/core/command/Shell.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/Shell.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/Shell.cc	(revision 11054)
@@ -258,6 +258,6 @@
         vectorize(text, '\n', &lines);
 
-        for (size_t i = 0; i < lines.size(); ++i)
-            this->addLine(lines[i], type);
+        for (const std::string& line : lines)
+            this->addLine(line, type);
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/command/Shell.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/Shell.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/Shell.h	(revision 11054)
@@ -61,5 +61,6 @@
 
         public:
-            virtual ~ShellListener() {}
+            ShellListener() = default;
+            virtual ~ShellListener() = default;
 
         private:
@@ -128,5 +129,5 @@
             const std::string& getInput() const;
 
-            typedef std::list<std::pair<std::string, LineType> > LineList;
+            typedef std::list<std::pair<std::string, LineType>> LineList;
             LineList::const_iterator getNewestLineIterator() const;
             LineList::const_iterator getEndIterator() const;
@@ -148,8 +149,10 @@
 
         private:
-            Shell(const Shell& other);
+            // non-copyable:
+            Shell(const Shell&) = delete;
+            Shell& operator=(const Shell&) = delete;
 
             // DevModeListener
-            void devModeChanged(bool value);
+            virtual void devModeChanged(bool value) override;
 
             void addToHistory(const std::string& command);
@@ -157,5 +160,5 @@
             void clearInput();
             // BaseWriter
-            virtual void printLine(const std::string& line, OutputLevel level);
+            virtual void printLine(const std::string& line, OutputLevel level) override;
 
             void configureInputBuffer();
Index: code/branches/cpp11_v3/src/libraries/core/command/TclBind.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/TclBind.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/TclBind.cc	(revision 11054)
@@ -47,5 +47,5 @@
     SetConsoleCommand("bgerror", &TclBind::bgerror).hide();
 
-    TclBind* TclBind::singletonPtr_s = 0;
+    TclBind* TclBind::singletonPtr_s = nullptr;
 
     /**
@@ -55,5 +55,5 @@
     TclBind::TclBind(const std::string& datapath)
     {
-        this->interpreter_ = 0;
+        this->interpreter_ = nullptr;
         this->bSetTclDataPath_ = false;
         this->setDataPath(datapath);
@@ -228,5 +228,5 @@
         @brief Executes Tcl-code and returns the return-value.
         @param tclcode A string that contains Tcl-code
-        @param error A pointer to an integer (or NULL) that is used to write an error-code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param error A pointer to an integer (or nullptr) that is used to write an error-code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
         @return Returns the return-value of the executed code (or an empty string if there's no return-value)
     */
Index: code/branches/cpp11_v3/src/libraries/core/command/TclBind.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/TclBind.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/TclBind.h	(revision 11054)
@@ -121,8 +121,10 @@
             static void tcl_execute(Tcl::object const &args);
 
-            static std::string eval(const std::string& tclcode, int* error = 0);
+            static std::string eval(const std::string& tclcode, int* error = nullptr);
 
         private:
-            TclBind(const TclBind& other);      ///< Copy-constructor, not implemented
+            // non-copyable:
+            TclBind(const TclBind&) = delete;
+            TclBind& operator=(const TclBind&) = delete;
 
             static std::string tcl_helper(Tcl::object const &args, bool bQuery);
Index: code/branches/cpp11_v3/src/libraries/core/command/TclThreadList.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/TclThreadList.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/TclThreadList.h	(revision 11054)
@@ -262,6 +262,6 @@
         boost::shared_lock<boost::shared_mutex> lock(this->mutex_);
 
-        for (typename std::list<T>::const_iterator it = this->list_.begin(); it != this->list_.end(); ++it)
-            if (*it == value)
+        for (const T& element : this->list_)
+            if (element == value)
                 return true;
 
Index: code/branches/cpp11_v3/src/libraries/core/command/TclThreadManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/command/TclThreadManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/command/TclThreadManager.cc	(revision 11054)
@@ -34,5 +34,5 @@
 #include "TclThreadManager.h"
 
-#include <boost/bind.hpp>
+#include <functional>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/locks.hpp>
@@ -86,5 +86,5 @@
     };
 
-    TclThreadManager* TclThreadManager::singletonPtr_s = 0;
+    TclThreadManager* TclThreadManager::singletonPtr_s = nullptr;
 
     /**
@@ -145,10 +145,10 @@
             {
                 boost::shared_lock<boost::shared_mutex> lock(*this->interpreterBundlesMutex_);
-                for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
+                for (const auto& mapEntry : this->interpreterBundles_)
                 {
-                    if (it->first == 0)
+                    if (mapEntry.first == 0)
                         continue; // We'll handle the default interpreter later (and without threads of course)
 
-                    TclInterpreterBundle* bundle = it->second;
+                    TclInterpreterBundle* bundle = mapEntry.second;
                     if (!bundle->queue_.empty())
                     {
@@ -163,5 +163,5 @@
                                 {
                                     // Start a thread to execute the command
-                                    boost::thread(boost::bind(&tclThread, bundle, command));
+                                    boost::thread(std::bind(&tclThread, bundle, command));
                                 }
                                 else
@@ -289,5 +289,5 @@
         catch (const Tcl::tcl_error& e)
         {
-            bundle->interpreter_ = 0;
+            bundle->interpreter_ = nullptr;
             orxout(user_error, context::tcl) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << endl;
         }
@@ -488,5 +488,5 @@
     void TclThreadManager::source(const std::string& file)
     {
-        boost::thread(boost::bind(&sourceThread, file));
+        boost::thread(std::bind(&sourceThread, file));
     }
 
@@ -521,5 +521,5 @@
         {
             TclThreadManager::error("No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
-            return 0;
+            return nullptr;
         }
     }
@@ -551,7 +551,7 @@
 
         std::list<unsigned int> threads;
-        for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
-            if (it->first > 0 && it->first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
-                threads.push_back(it->first);
+        for (const auto& mapEntry : this->interpreterBundles_)
+            if (mapEntry.first > 0 && mapEntry.first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
+                threads.push_back(mapEntry.first);
         return threads;
     }
Index: code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineIncludes.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineIncludes.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineIncludes.h	(revision 11054)
@@ -64,8 +64,8 @@
             ~StaticallyInitializedCommandLineArgument() { delete argument_; }
 
-            virtual void load()
+            virtual void load() override
                 { CommandLineParser::addArgument(this->argument_); }
 
-            virtual void unload()
+            virtual void unload() override
                 { CommandLineParser::removeArgument(this->argument_); }
 
Index: code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.cc	(revision 11054)
@@ -40,5 +40,5 @@
 namespace orxonox
 {
-    CommandLineParser* CommandLineParser::singletonPtr_s = 0;
+    CommandLineParser* CommandLineParser::singletonPtr_s = nullptr;
 
     /**
@@ -110,11 +110,10 @@
             {
                 // first shove all the shortcuts in a map
-                for (std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
-                    it != cmdLineArgs_.end(); ++it)
+                for (const auto& mapEntry : cmdLineArgs_)
                 {
-                    OrxAssert(cmdLineArgsShortcut_.find(it->second->getShortcut()) == cmdLineArgsShortcut_.end(),
+                    OrxAssert(cmdLineArgsShortcut_.find(mapEntry.second->getShortcut()) == cmdLineArgsShortcut_.end(),
                         "Cannot have two command line shortcut with the same name.");
-                    if (!it->second->getShortcut().empty())
-                        cmdLineArgsShortcut_[it->second->getShortcut()] = it->second;
+                    if (!mapEntry.second->getShortcut().empty())
+                        cmdLineArgsShortcut_[mapEntry.second->getShortcut()] = mapEntry.second;
                 }
                 bFirstTimeParse_ = false;
@@ -124,21 +123,21 @@
             std::string shortcut;
             std::string value;
-            for (unsigned int i = 0; i < arguments.size(); ++i)
-            {
-                if (arguments[i].size() != 0)
+            for (const std::string& argument : arguments)
+            {
+                if (argument.size() != 0)
                 {
                     // sure not ""
-                    if (arguments[i][0] == '-')
+                    if (argument[0] == '-')
                     {
                         // start with "-"
-                        if (arguments[i].size() == 1)
+                        if (argument.size() == 1)
                         {
                             // argument[i] is "-", probably a minus sign
                             value += "- ";
                         }
-                        else if (arguments[i][1] <= 57 && arguments[i][1] >= 48)
+                        else if (argument[1] <= 57 && argument[1] >= 48)
                         {
                             // negative number as a value
-                            value += arguments[i] + ' ';
+                            value += argument + ' ';
                         }
                         else
@@ -161,13 +160,13 @@
                             }
 
-                            if (arguments[i][1] == '-')
+                            if (argument[1] == '-')
                             {
                                 // full name argument with "--name"
-                                name = arguments[i].substr(2);
+                                name = argument.substr(2);
                             }
                             else
                             {
                                 // shortcut with "-s"
-                                shortcut = arguments[i].substr(1);
+                                shortcut = argument.substr(1);
                             }
 
@@ -186,5 +185,5 @@
 
                         // Concatenate strings as long as there's no new argument by "-" or "--"
-                        value += arguments[i] + ' ';
+                        value += argument + ' ';
                     }
                 }
@@ -257,8 +256,7 @@
         // determine maximum name size
         size_t maxNameSize = 0;
-        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
-            it != inst.cmdLineArgs_.end(); ++it)
-        {
-            maxNameSize = std::max(it->second->getName().size(), maxNameSize);
+        for (const auto& mapEntry : inst.cmdLineArgs_)
+        {
+            maxNameSize = std::max(mapEntry.second->getName().size(), maxNameSize);
         }
 
@@ -267,19 +265,18 @@
         infoStr << "Available options:" << endl;
 
-        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
-            it != inst.cmdLineArgs_.end(); ++it)
-        {
-            if (!it->second->getShortcut().empty())
-                infoStr << " [-" << it->second->getShortcut() << "] ";
+        for (const auto& mapEntry : inst.cmdLineArgs_)
+        {
+            if (!mapEntry.second->getShortcut().empty())
+                infoStr << " [-" << mapEntry.second->getShortcut() << "] ";
             else
                 infoStr << "      ";
-            infoStr << "--" << it->second->getName() << ' ';
-            if (it->second->getValue().isType<bool>())
+            infoStr << "--" << mapEntry.second->getName() << ' ';
+            if (mapEntry.second->getValue().isType<bool>())
                 infoStr << "    ";
             else
                 infoStr << "ARG ";
             // fill with the necessary amount of blanks
-            infoStr << std::string(maxNameSize - it->second->getName().size(), ' ');
-            infoStr << ": " << it->second->getInformation();
+            infoStr << std::string(maxNameSize - mapEntry.second->getName().size(), ' ');
+            infoStr << ": " << mapEntry.second->getInformation();
             infoStr << endl;
         }
Index: code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.h	(revision 11054)
@@ -107,6 +107,7 @@
 
     private:
-        //! Undefined copy constructor
-        CommandLineArgument(const CommandLineArgument& instance);
+        // non-copyable:
+        CommandLineArgument(const CommandLineArgument&) = delete;
+        CommandLineArgument& operator=(const CommandLineArgument&) = delete;
 
         //! Parses the value string of a command line argument.
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFile.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFile.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFile.cc	(revision 11054)
@@ -35,4 +35,8 @@
 
 #include <boost/filesystem.hpp>
+
+#include <iterator>
+#include <algorithm>
+#include <fstream>
 
 #include "util/Convert.h"
@@ -93,5 +97,7 @@
                         try
                         {
-                            boost::filesystem::copy_file(defaultFilepath, filepath);
+                            std::ifstream input(defaultFilepath.string().c_str(), std::ifstream::in | std::ifstream::binary);
+                            std::ofstream output(filepath.string().c_str(), std::ofstream::out | std::ofstream::binary);
+                            copy(std::istreambuf_iterator<char>(input), std::istreambuf_iterator<char>(), std::ostream_iterator<char>(output));
                             orxout(internal_info, context::config) << "Copied " << this->filename_ << " from the default config folder." << endl;
                         }
@@ -108,5 +114,5 @@
         if (file.is_open())
         {
-            ConfigFileSection* newsection = 0;
+            ConfigFileSection* newsection = nullptr;
 
             while (file.good() && !file.eof())
@@ -135,5 +141,5 @@
                 }
 
-                if (newsection != 0)
+                if (newsection != nullptr)
                 {
                     if (isComment(line))
@@ -228,9 +234,9 @@
         }
 
-        for (std::list<ConfigFileSection*>::const_iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
-        {
-            file << (*it)->getFileEntry() << endl;
-
-            for (std::list<ConfigFileEntry*>::const_iterator it_entries = (*it)->getEntriesBegin(); it_entries != (*it)->getEntriesEnd(); ++it_entries)
+        for (ConfigFileSection* section : this->sections_)
+        {
+            file << section->getFileEntry() << endl;
+
+            for (std::list<ConfigFileEntry*>::const_iterator it_entries = section->getEntriesBegin(); it_entries != section->getEntriesEnd(); ++it_entries)
                 file << (*it_entries)->getFileEntry() << endl;
 
@@ -270,12 +276,12 @@
 
     /**
-        @brief Returns a pointer to the section with given name (or NULL if the section doesn't exist).
-    */
-    ConfigFileSection* ConfigFile::getSection(const std::string& section) const
-    {
-        for (std::list<ConfigFileSection*>::const_iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
-            if ((*it)->getName() == section)
-                return (*it);
-        return NULL;
+        @brief Returns a pointer to the section with given name (or nullptr if the section doesn't exist).
+    */
+    ConfigFileSection* ConfigFile::getSection(const std::string& sectionName) const
+    {
+        for (ConfigFileSection* section : this->sections_)
+            if (section->getName() == sectionName)
+                return section;
+        return nullptr;
     }
 
@@ -283,13 +289,13 @@
         @brief Returns a pointer to the section with given name. If it doesn't exist, the section is created.
     */
-    ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& section)
-    {
-        for (std::list<ConfigFileSection*>::iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
-            if ((*it)->getName() == section)
-                return (*it);
+    ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& sectionName)
+    {
+        for (ConfigFileSection* section : this->sections_)
+            if (section->getName() == sectionName)
+                return section;
 
         this->bUpdated_ = true;
 
-        return (*this->sections_.insert(this->sections_.end(), new ConfigFileSection(section)));
+        return (*this->sections_.insert(this->sections_.end(), new ConfigFileSection(sectionName)));
     }
 
@@ -301,10 +307,10 @@
         bool sectionsUpdated = false;
 
-        for (std::list<ConfigFileSection*>::iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
-        {
-            if ((*it)->bUpdated_)
+        for (ConfigFileSection* section : this->sections_)
+        {
+            if (section->bUpdated_)
             {
                 sectionsUpdated = true;
-                (*it)->bUpdated_ = false;
+                section->bUpdated_ = false;
             }
         }
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntry.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntry.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntry.h	(revision 11054)
@@ -51,5 +51,5 @@
         public:
             /// Destructor
-            virtual ~ConfigFileEntry() {};
+            virtual ~ConfigFileEntry() = default;
 
             /// Changes the value of the entry.
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryComment.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryComment.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryComment.h	(revision 11054)
@@ -54,21 +54,21 @@
 
             /// Destructor
-            inline virtual ~ConfigFileEntryComment() {}
+            virtual inline ~ConfigFileEntryComment() = default;
 
-            inline virtual const std::string& getName() const
+            virtual inline const std::string& getName() const override
                 { return this->comment_; }
 
-            inline virtual void setComment(const std::string& comment)
+            virtual inline void setComment(const std::string& comment) override
                 { this->comment_ = comment; }
 
-            inline virtual void setValue(const std::string& value)
+            virtual inline void setValue(const std::string& value) override
                 {}
-            inline virtual const std::string& getValue() const
+            virtual inline const std::string& getValue() const override
                 { return BLANKSTRING; }
 
-            inline void setString(bool bString)
+            virtual inline void setString(bool bString) override
                 {}
 
-            inline virtual const std::string& getFileEntry() const
+            virtual inline const std::string& getFileEntry() const override
                 { return this->comment_; }
 
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryValue.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryValue.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryValue.h	(revision 11054)
@@ -67,25 +67,25 @@
 
             /// Destructor
-            inline virtual ~ConfigFileEntryValue() {}
+            virtual inline ~ConfigFileEntryValue() = default;
 
-            inline virtual const std::string& getName() const
+            virtual inline const std::string& getName() const override
                 { return this->name_; }
 
-            inline virtual void setComment(const std::string& comment)
+            virtual inline void setComment(const std::string& comment) override
                 { this->additionalComment_ = comment; this->update(); }
 
-            inline virtual void setValue(const std::string& value)
+            virtual inline void setValue(const std::string& value) override
                 { this->value_ = value; this->update(); }
-            inline virtual const std::string& getValue() const
+            virtual inline const std::string& getValue() const override
                 { return this->value_; }
 
-            inline void virtual setString(bool bString)
+            virtual inline void setString(bool bString) override
                 { this->bString_ = bString; this->update(); }
 
-            inline virtual const std::string& getFileEntry() const
+            virtual inline const std::string& getFileEntry() const override
                 { return this->fileEntry_; }
 
             /// Returns the "key" of the value (in this case it's just the name of the entry, but for vectors it's different)
-            inline virtual const std::string& getKeyString() const
+            virtual inline const std::string& getKeyString() const
                 { return this->name_; }
 
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryVectorValue.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryVectorValue.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFileEntryVectorValue.h	(revision 11054)
@@ -65,15 +65,15 @@
 
             /// Destructor
-            inline ~ConfigFileEntryVectorValue() {}
+            inline ~ConfigFileEntryVectorValue() = default;
 
-            inline unsigned int getIndex() const
+            virtual inline unsigned int getIndex() const override
                 { return this->index_; }
 
             /// Returns the "key" of the value (the name of the vector plus the index of the element)
-            inline const std::string& getKeyString() const
+            virtual inline const std::string& getKeyString() const override
                 { return this->keyString_; }
 
         private:
-            void update();
+            virtual void update() override;
 
             unsigned int index_;        ///< The index of the element in the vector
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFileManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFileManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFileManager.cc	(revision 11054)
@@ -42,10 +42,10 @@
     ///////////////////////
 
-    ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
+    ConfigFileManager* ConfigFileManager::singletonPtr_s = nullptr;
 
-    /// Constructor: Initializes the array of config files with NULL.
+    /// Constructor: Initializes the array of config files with nullptr.
     ConfigFileManager::ConfigFileManager()
     {
-        this->configFiles_.assign(NULL);
+        this->configFiles_.fill(nullptr);
     }
 
@@ -53,7 +53,7 @@
     ConfigFileManager::~ConfigFileManager()
     {
-        for (boost::array<ConfigFile*, 3>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); ++it)
-            if (*it)
-                delete (*it);
+        for (ConfigFile* configFile : this->configFiles_)
+            if (configFile)
+                delete configFile;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFileManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFileManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFileManager.h	(revision 11054)
@@ -38,5 +38,5 @@
 #include "core/CorePrereqs.h"
 
-#include <boost/array.hpp>
+#include <array>
 
 #include "util/Singleton.h"
@@ -67,7 +67,9 @@
 
         private:
-            ConfigFileManager(const ConfigFileManager&);    ///< Copy-constructor: not implemented
+            // non-copyable:
+            ConfigFileManager(const ConfigFileManager&) = delete;
+            ConfigFileManager& operator=(const ConfigFileManager&) = delete;
 
-            boost::array<ConfigFile*, 3> configFiles_;      ///< Stores the config files for each type in an array (must have the same size like ConfigFileType::Value)
+            std::array<ConfigFile*, 3> configFiles_;        ///< Stores the config files for each type in an array (must have the same size like ConfigFileType::Value)
             static ConfigFileManager* singletonPtr_s;       ///< Stores the singleton-pointer
     };
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigFileSection.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigFileSection.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigFileSection.cc	(revision 11054)
@@ -80,8 +80,8 @@
     {
         unsigned int size = 0;
-        for (std::list<ConfigFileEntry*>::const_iterator it = this->entries_.begin(); it != this->entries_.end(); ++it)
-            if ((*it)->getName() == name)
-                if ((*it)->getIndex() >= size)
-                    size = (*it)->getIndex() + 1;
+        for (ConfigFileEntry* entry : this->entries_)
+            if (entry->getName() == name)
+                if (entry->getIndex() >= size)
+                    size = entry->getIndex() + 1;
         return size;
     }
@@ -99,5 +99,5 @@
 
     /**
-        @brief Returns the entry with given name (or NULL if it doesn't exist).
+        @brief Returns the entry with given name (or nullptr if it doesn't exist).
 
         @param name     The name of the entry
@@ -105,14 +105,14 @@
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name) const
     {
-        for (std::list<ConfigFileEntry*>::const_iterator it = this->entries_.begin(); it != this->entries_.end(); ++it)
+        for (ConfigFileEntry* entry : this->entries_)
         {
-            if ((*it)->getName() == name)
-                return *it;
+            if (entry->getName() == name)
+                return entry;
         }
-        return NULL;
+        return nullptr;
     }
 
     /**
-        @brief Returns the entry of a vector element with given name and index (or NULL if it doesn't exist).
+        @brief Returns the entry of a vector element with given name and index (or nullptr if it doesn't exist).
 
         @param name     The name of the vector
@@ -121,10 +121,10 @@
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name, unsigned int index) const
     {
-        for (std::list<ConfigFileEntry*>::const_iterator it = this->entries_.begin(); it != this->entries_.end(); ++it)
+        for (ConfigFileEntry* entry : this->entries_)
         {
-            if (((*it)->getName() == name) && ((*it)->getIndex() == index))
-                return *it;
+            if ((entry->getName() == name) && (entry->getIndex() == index))
+                return entry;
         }
-        return NULL;
+        return nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigValueContainer.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigValueContainer.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigValueContainer.cc	(revision 11054)
@@ -53,5 +53,5 @@
         this->sectionname_ = sectionname;
         this->varname_ = varname;
-        this->callback_ = 0;
+        this->callback_ = nullptr;
         this->bContainerIsNew_ = true;
         this->bDoInitialCallback_ = false;
@@ -191,5 +191,5 @@
                 for (unsigned int i = this->valueVector_.size(); i <= index; i++)
                 {
-                    this->valueVector_.push_back(MultiType());
+                    this->valueVector_.emplace_back();
                 }
             }
Index: code/branches/cpp11_v3/src/libraries/core/config/ConfigValueContainer.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/ConfigValueContainer.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/ConfigValueContainer.h	(revision 11054)
@@ -59,5 +59,5 @@
         public:
             virtual void call(void* object) = 0;
-            inline virtual ~ConfigValueCallbackBase() {}
+            virtual inline ~ConfigValueCallbackBase() {}
     };
 
@@ -67,6 +67,6 @@
         public:
             inline ConfigValueCallback(void (T::*function) (void)) : function_(function) {}
-            inline virtual ~ConfigValueCallback() {}
-            inline virtual void call(void* object)
+            virtual inline ~ConfigValueCallback() = default;
+            virtual inline void call(void* object) override
             {
                 if (!IdentifierManager::getInstance().isCreatingHierarchy())
@@ -130,6 +130,6 @@
 
                 this->value_ = V();
-                for (unsigned int i = 0; i < defvalue.size(); i++)
-                    this->valueVector_.push_back(MultiType(defvalue[i]));
+                for (const D& defvalueElement : defvalue)
+                    this->valueVector_.emplace_back(defvalueElement);
 
                 this->initVector();
@@ -183,6 +183,6 @@
                     std::vector<T> temp = *value;
                     value->clear();
-                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
-                        value->push_back(this->valueVector_[i]);
+                    for (const MultiType& vectorEntry : this->valueVector_)
+                        value->push_back(vectorEntry);
 
                     if (value->size() != temp.size())
@@ -211,6 +211,6 @@
                 {
                     value->clear();
-                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
-                        value->push_back(this->valueVector_[i]);
+                    for (const MultiType& vectorEntry : this->valueVector_)
+                        value->push_back(vectorEntry);
                 }
                 return *this;
@@ -223,5 +223,5 @@
             inline const std::string& getSectionName() const
                 { return this->sectionname_; }
-            /// Returns the associated identifier (can be NULL).
+            /// Returns the associated identifier (can be nullptr).
             inline Identifier* getIdentifier() const
                 { return this->identifier_; }
Index: code/branches/cpp11_v3/src/libraries/core/config/SettingsConfigFile.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/SettingsConfigFile.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/SettingsConfigFile.cc	(revision 11054)
@@ -57,5 +57,5 @@
     SetConsoleCommand(__CC_getConfig_name,       &SettingsConfigFile::getConfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries());
 
-    SettingsConfigFile* SettingsConfigFile::singletonPtr_s = 0;
+    SettingsConfigFile* SettingsConfigFile::singletonPtr_s = nullptr;
 
     /**
@@ -77,9 +77,9 @@
     SettingsConfigFile::~SettingsConfigFile()
     {
-        ModifyConsoleCommand(__CC_load_name).setObject(0);
-        ModifyConsoleCommand(__CC_setFilename_name).setObject(0);
-        ModifyConsoleCommand(__CC_config_name).setObject(0);
-        ModifyConsoleCommand(__CC_tconfig_name).setObject(0);
-        ModifyConsoleCommand(__CC_getConfig_name).setObject(0);
+        ModifyConsoleCommand(__CC_load_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_setFilename_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_config_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_tconfig_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_getConfig_name).setObject(nullptr);
     }
 
@@ -106,5 +106,5 @@
     void SettingsConfigFile::addConfigValueContainer(ConfigValueContainer* container)
     {
-        if (container == NULL)
+        if (container == nullptr)
             return;
         std::pair<std::string, ConfigValueContainer*> second(getLowercase(container->getName()), container);
@@ -118,5 +118,5 @@
     void SettingsConfigFile::removeConfigValueContainer(ConfigValueContainer* container)
     {
-        if (container == NULL)
+        if (container == nullptr)
             return;
         const std::string& sectionLC = getLowercase(container->getSectionName());
@@ -142,8 +142,8 @@
         // todo: can this be done more efficiently? looks like some identifiers will be updated multiple times.
 
-        for (ContainerMap::const_iterator it = this->containers_.begin(); it != this->containers_.end(); ++it)
-        {
-            it->second.second->update();
-            it->second.second->getIdentifier()->updateConfigValues();
+        for (const auto& mapEntry : this->containers_)
+        {
+            mapEntry.second.second->update();
+            mapEntry.second.second->getIdentifier()->updateConfigValues();
         }
     }
@@ -269,5 +269,5 @@
             {
                 std::string value;
-                it->second.second->getValue<std::string, void>(&value, NULL);
+                it->second.second->getValue<std::string, void>(&value, nullptr);
                 return value;
             }
Index: code/branches/cpp11_v3/src/libraries/core/config/SettingsConfigFile.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/config/SettingsConfigFile.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/config/SettingsConfigFile.h	(revision 11054)
@@ -63,10 +63,10 @@
 
         public:
-            typedef std::multimap<std::string, std::pair<std::string, ConfigValueContainer*> > ContainerMap;
+            typedef std::multimap<std::string, std::pair<std::string, ConfigValueContainer*>> ContainerMap;
 
             SettingsConfigFile(const std::string& filename);
             ~SettingsConfigFile();
 
-            void load(); // tolua_export
+            virtual void load() override; // tolua_export
             void setFilename(const std::string& filename); // tolua_export
             void clean(bool bCleanComments = false); // tolua_export
Index: code/branches/cpp11_v3/src/libraries/core/input/Button.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/Button.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/Button.cc	(revision 11054)
@@ -53,5 +53,5 @@
     Button::Button()
         : bButtonThresholdUser_(false)
-        , paramCommandBuffer_(0)
+        , paramCommandBuffer_(nullptr)
     {
         nCommands_[0]=0;
@@ -75,5 +75,5 @@
                     delete commands_[j][i];
                 delete[] commands_[j];
-                commands_[j] = 0;
+                commands_[j] = nullptr;
                 nCommands_[j] = 0;
             }
@@ -196,15 +196,15 @@
 
                     // add command to the buffer if not yet existing
-                    for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer_->size(); iParamCmd++)
-                    {
-                        if ((*paramCommandBuffer_)[iParamCmd]->evaluation_.getConsoleCommand()
+                    for (BufferedParamCommand* command : *paramCommandBuffer_)
+                    {
+                        if (command->evaluation_.getConsoleCommand()
                             == eval.getConsoleCommand())
                         {
                             // already in list
-                            cmd->paramCommand_ = (*paramCommandBuffer_)[iParamCmd];
+                            cmd->paramCommand_ = command;
                             break;
                         }
                     }
-                    if (cmd->paramCommand_ == 0)
+                    if (cmd->paramCommand_ == nullptr)
                     {
                         cmd->paramCommand_ = new BufferedParamCommand();
@@ -239,5 +239,5 @@
             }
             else
-                commands_[j] = 0;
+                commands_[j] = nullptr;
         }
     }
Index: code/branches/cpp11_v3/src/libraries/core/input/HalfAxis.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/HalfAxis.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/HalfAxis.h	(revision 11054)
@@ -49,5 +49,5 @@
             : relVal_(0.0f)
             , absVal_(0.0f)
-            , paramCommands_(0)
+            , paramCommands_(nullptr)
             , nParamCommands_(0)
             , pressed_(false)
@@ -56,6 +56,6 @@
         using Button::execute;
         bool execute();
-        bool addParamCommand(ParamCommand* command);
-        void clear();
+        virtual bool addParamCommand(ParamCommand* command) override;
+        virtual void clear() override;
         void reset();
 
Index: code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.cc	(revision 11054)
@@ -75,7 +75,6 @@
     InputBuffer::~InputBuffer()
     {
-        for (std::list<BaseInputBufferListenerTuple*>::const_iterator it = this->listeners_.begin();
-            it != this->listeners_.end(); ++it)
-            delete *it;
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+            delete listener;
     }
 
@@ -110,10 +109,10 @@
     void InputBuffer::insert(const std::string& input, bool update)
     {
-        for (unsigned int i = 0; i < input.size(); ++i)
-        {
-            this->insert(input[i], false);
+        for (const char& inputChar : input)
+        {
+            this->insert(inputChar, false);
 
             if (update)
-                this->updated(input[i], false);
+                this->updated(inputChar, false);
         }
 
@@ -170,8 +169,8 @@
     void InputBuffer::updated()
     {
-        for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-        {
-            if ((*it)->bListenToAllChanges_)
-                (*it)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if (listener->bListenToAllChanges_)
+                listener->callFunction();
         }
     }
@@ -179,8 +178,8 @@
     void InputBuffer::updated(const char& update, bool bSingleInput)
     {
-        for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-        {
-            if ((!(*it)->trueKeyFalseChar_) && ((*it)->bListenToAllChanges_ || ((*it)->char_ == update)) && (!(*it)->bOnlySingleInput_ || bSingleInput))
-                (*it)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if ((!listener->trueKeyFalseChar_) && (listener->bListenToAllChanges_ || (listener->char_ == update)) && (!listener->bOnlySingleInput_ || bSingleInput))
+                listener->callFunction();
         }
     }
@@ -201,8 +200,8 @@
             return;
 
-        for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-        {
-            if ((*it)->trueKeyFalseChar_ && ((*it)->key_ == evt.getKeyCode()))
-                (*it)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if (listener->trueKeyFalseChar_ && (listener->key_ == evt.getKeyCode()))
+                listener->callFunction();
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.h	(revision 11054)
@@ -47,5 +47,5 @@
               trueKeyFalseChar_(trueKeyFalseChar), char_(_char), key_(key)
         { }
-        virtual ~BaseInputBufferListenerTuple() { }
+        virtual ~BaseInputBufferListenerTuple() = default;
         virtual void callFunction() = 0;
         bool bListenToAllChanges_;
@@ -65,6 +65,6 @@
               listener_(listener), function_(function)
         { }
-        virtual ~InputBufferListenerTuple() { }
-        void callFunction()
+        virtual ~InputBufferListenerTuple() = default;
+        virtual void callFunction() override
         {
             (listener_->*function_)();
@@ -165,13 +165,13 @@
                 { if (this->cursor_ > 0) { --this->cursor_; } }
 
-            void buttonPressed(const KeyEvent& evt);
+            virtual void buttonPressed(const KeyEvent& evt) override;
 
         private:
             bool charIsAllowed(const char& input);
 
-            void buttonHeld   (const KeyEvent& evt);
-            void processKey   (const KeyEvent& evt);
+            virtual void buttonHeld (const KeyEvent& evt) override;
+            void processKey (const KeyEvent& evt);
 
-            void keyboardUpdated(float dt);
+            virtual void keyboardUpdated(float dt) override;
 
             std::string buffer_;
Index: code/branches/cpp11_v3/src/libraries/core/input/InputCommands.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputCommands.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputCommands.h	(revision 11054)
@@ -57,5 +57,5 @@
     public:
         BaseCommand() : bFixedKeybindMode_(false) {}
-        virtual ~BaseCommand() { }
+        virtual ~BaseCommand() = default;
 
         virtual bool execute(float abs = 1.0f, float rel = 1.0f) = 0;
@@ -76,7 +76,7 @@
     {
     public:
-        bool execute(float abs = 1.0f, float rel = 1.0f);
-        CommandEvaluation* getEvaluation();
-        virtual SimpleCommand* clone() { return new SimpleCommand(*this); }
+        virtual bool execute(float abs = 1.0f, float rel = 1.0f) override;
+        virtual CommandEvaluation* getEvaluation() override;
+        virtual SimpleCommand* clone() override { return new SimpleCommand(*this); }
 
         CommandEvaluation evaluation_;
@@ -103,8 +103,8 @@
     {
     public:
-        ParamCommand() : scale_(1.0f), paramCommand_(0) { }
-        bool execute(float abs = 1.0f, float rel = 1.0f);
-        CommandEvaluation* getEvaluation();
-        virtual ParamCommand* clone() { return new ParamCommand(*this); }
+        ParamCommand() : scale_(1.0f), paramCommand_(nullptr) { }
+        virtual bool execute(float abs = 1.0f, float rel = 1.0f) override;
+        virtual CommandEvaluation* getEvaluation() override;
+        virtual ParamCommand* clone() override { return new ParamCommand(*this); }
 
         float scale_;
@@ -118,5 +118,5 @@
             return &this->paramCommand_->evaluation_;
         else
-            return 0;
+            return nullptr;
     }
 }
Index: code/branches/cpp11_v3/src/libraries/core/input/InputDevice.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputDevice.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputDevice.h	(revision 11054)
@@ -60,5 +60,5 @@
         //! Only resets the members
         InputDevice(unsigned int id) : bCalibrating_(false), deviceID_(id) { }
-        virtual ~InputDevice() { }
+        virtual ~InputDevice() = default;
         //! Returns the device class (derived) name as string
         virtual std::string getClassName() const = 0;
@@ -99,5 +99,7 @@
 
     private:
-        InputDevice(const InputDevice& rhs); //!< Don't use!
+        // non-copyable:
+        InputDevice(const InputDevice&) = delete;
+        InputDevice& operator=(const InputDevice&) = delete;
 
         bool bCalibrating_;                  //!< Whether the device is in calibration mode
@@ -153,17 +155,17 @@
 
         //! Captures OIS events (which then get distributed to the derived class) and creates the button held events
-        void update(const Clock& time)
+        virtual void update(const Clock& time) override
         {
             oisDevice_->capture();
 
             // Call all the states with the held button event
-            for (unsigned int iB = 0; iB < pressedButtons_.size(); ++iB)
-                for (unsigned int iS = 0; iS < inputStates_.size(); ++iS)
-                    inputStates_[iS]->buttonEvent<ButtonEvent::THold, typename Traits::ButtonTypeParam>(
-                        this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(pressedButtons_[iB]));
+            for (ButtonType& button : pressedButtons_)
+                for (InputState* state : inputStates_)
+                    state->template buttonEvent<ButtonEvent::THold, typename Traits::ButtonTypeParam>(
+                        this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
 
             // Call states with device update events
-            for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->update(time.getDeltaTime(), this->getDeviceID());
+            for (InputState* state : inputStates_)
+                state->update(time.getDeltaTime(), this->getDeviceID());
 
             static_cast<DeviceClass*>(this)->updateImpl(time);
@@ -171,5 +173,5 @@
 
         //! Clears the list of pressed buttons and calls the derived class's method
-        void clearBuffers()
+        virtual void clearBuffers() override
         {
             pressedButtons_.clear();
@@ -180,5 +182,5 @@
         OISDeviceClass* getOISDevice()   { return this->oisDevice_; }
         // Returns the name of the derived class as string
-        std::string getClassName() const { return DeviceClass::getClassNameImpl(); }
+        virtual std::string getClassName() const override { return DeviceClass::getClassNameImpl(); }
 
     protected:
@@ -196,6 +198,6 @@
 
             // Call states
-            for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (InputState* state : inputStates_)
+                state->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 
@@ -218,6 +220,6 @@
 
             // Call states
-            for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (InputState* state : inputStates_)
+                state->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/input/InputHandler.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputHandler.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputHandler.h	(revision 11054)
@@ -119,5 +119,5 @@
     {
     public:
-        virtual ~InputHandler() { }
+        virtual ~InputHandler() = default;
 
         template<class T> void buttonEvent(unsigned int device, T button, ButtonEvent::TPress)
Index: code/branches/cpp11_v3/src/libraries/core/input/InputManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputManager.cc	(revision 11054)
@@ -39,5 +39,4 @@
 #include <ois/OISException.h>
 #include <ois/OISInputManager.h>
-#include <boost/foreach.hpp>
 #include <loki/ScopeGuard.h>
 
@@ -72,5 +71,5 @@
     InputHandler InputHandler::EMPTY;
 
-    InputManager* InputManager::singletonPtr_s = 0;
+    InputManager* InputManager::singletonPtr_s = nullptr;
 
     //! Defines the |= operator for easier use.
@@ -94,9 +93,9 @@
     InputManager::InputManager()
         : internalState_(Bad)
-        , oisInputManager_(0)
+        , oisInputManager_(nullptr)
         , devices_(2)
         , exclusiveMouse_(false)
-        , emptyState_(0)
-        , calibratorCallbackHandler_(0)
+        , emptyState_(nullptr)
+        , calibratorCallbackHandler_(nullptr)
     {
         RegisterObject(InputManager);
@@ -149,6 +148,6 @@
         // When loading the devices they should not already be loaded
         assert(internalState_ & Bad);
-        assert(devices_[InputDeviceEnumerator::Mouse] == 0);
-        assert(devices_[InputDeviceEnumerator::Keyboard] == 0);
+        assert(devices_[InputDeviceEnumerator::Mouse] == nullptr);
+        assert(devices_[InputDeviceEnumerator::Keyboard] == nullptr);
         assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
 
@@ -210,5 +209,5 @@
         catch (const std::exception& ex)
         {
-            oisInputManager_ = NULL;
+            oisInputManager_ = nullptr;
             internalState_ |= Bad;
             ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
@@ -294,6 +293,6 @@
 
         // Reset console commands
-        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(0);
-        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
+        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(nullptr);
 
         orxout(internal_status, context::input) << "InputManager: Destruction complete." << endl;
@@ -310,16 +309,16 @@
         orxout(verbose, context::input) << "InputManager: Destroying devices..." << endl;
 
-        BOOST_FOREACH(InputDevice*& device, devices_)
-        {
-            if (device == NULL)
+        for (InputDevice*& device : devices_)
+        {
+            if (device == nullptr)
                 continue;
             const std::string& className = device->getClassName();
             delete device;
-            device = 0;
+            device = nullptr;
             orxout(verbose, context::input) << className << " destroyed." << endl;
         }
         devices_.resize(InputDeviceEnumerator::FirstJoyStick);
 
-        assert(oisInputManager_ != NULL);
+        assert(oisInputManager_ != nullptr);
         try
         {
@@ -331,5 +330,5 @@
                                                    << "Potential resource leak!" << endl;
         }
-        oisInputManager_ = NULL;
+        oisInputManager_ = nullptr;
 
         internalState_ |= Bad;
@@ -374,9 +373,9 @@
         // check whether a state has changed its EMPTY situation
         bool bUpdateRequired = false;
-        for (std::map<int, InputState*>::iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
-        {
-            if (it->second->hasExpired())
-            {
-                it->second->resetExpiration();
+        for (const auto& mapEntry : activeStates_)
+        {
+            if (mapEntry.second->hasExpired())
+            {
+                mapEntry.second->resetExpiration();
                 bUpdateRequired = true;
             }
@@ -387,11 +386,11 @@
         // Capture all the input and collect the function calls
         // No event gets triggered here yet!
-        BOOST_FOREACH(InputDevice* device, devices_)
-            if (device != NULL)
+        for  (InputDevice* device : devices_)
+            if (device != nullptr)
                 device->update(time);
 
         // Collect function calls for the update
-        for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
-            activeStatesTicked_[i]->update(time.getDeltaTime());
+        for (InputState* state : activeStatesTicked_)
+            state->update(time.getDeltaTime());
 
         // Execute all cached function calls in order
@@ -402,6 +401,6 @@
         // If we delay the calls, then OIS and and the InputStates are not anymore
         // in the call stack and can therefore be edited.
-        for (size_t i = 0; i < this->callBuffer_.size(); ++i)
-            this->callBuffer_[i]();
+        for (auto& function : this->callBuffer_)
+            function();
 
         this->callBuffer_.clear();
@@ -419,5 +418,5 @@
         for (unsigned int i = 0; i < devices_.size(); ++i)
         {
-            if (devices_[i] == NULL)
+            if (devices_[i] == nullptr)
                 continue;
             std::vector<InputState*>& states = devices_[i]->getStateListRef();
@@ -438,13 +437,13 @@
         // Using an std::set to avoid duplicates
         std::set<InputState*> tempSet;
-        for (unsigned int i = 0; i < devices_.size(); ++i)
-            if (devices_[i] != NULL)
-                for (unsigned int iState = 0; iState < devices_[i]->getStateListRef().size(); ++iState)
-                    tempSet.insert(devices_[i]->getStateListRef()[iState]);
+        for (InputDevice* device : devices_)
+            if (device != nullptr)
+                for (unsigned int iState = 0; iState < device->getStateListRef().size(); ++iState)
+                    tempSet.insert(device->getStateListRef()[iState]);
 
         // Copy the content of the std::set back to the actual vector
         activeStatesTicked_.clear();
-        for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
-            activeStatesTicked_.push_back(*it);
+        for (InputState* state : tempSet)
+            activeStatesTicked_.push_back(state);
 
         // Check whether we have to change the mouse mode
@@ -466,6 +465,6 @@
     void InputManager::clearBuffers()
     {
-        BOOST_FOREACH(InputDevice* device, devices_)
-            if (device != NULL)
+        for (InputDevice* device : devices_)
+            if (device != nullptr)
                 device->clearBuffers();
     }
@@ -476,6 +475,6 @@
                         << "When done, put the axex in the middle position and press enter." << endl;
 
-        BOOST_FOREACH(InputDevice* device, devices_)
-            if (device != NULL)
+        for (InputDevice* device : devices_)
+            if (device != nullptr)
                 device->startCalibration();
 
@@ -487,6 +486,6 @@
     void InputManager::stopCalibration()
     {
-        BOOST_FOREACH(InputDevice* device, devices_)
-            if (device != NULL)
+        for (InputDevice* device : devices_)
+            if (device != nullptr)
                 device->stopCalibration();
 
@@ -509,5 +508,5 @@
     {
         Mouse* mouse = static_cast<Mouse*>(devices_[InputDeviceEnumerator::Mouse]);
-        if (mouse != NULL)
+        if (mouse != nullptr)
         {
             const OIS::MouseState state = mouse->getOISDevice()->getMouseState();
@@ -526,5 +525,5 @@
     {
         if (name.empty())
-            return 0;
+            return nullptr;
         if (statesByName_.find(name) == statesByName_.end())
         {
@@ -532,12 +531,11 @@
             {
                 // Make sure we don't add two high priority states with the same priority
-                for (std::map<std::string, InputState*>::const_iterator it = this->statesByName_.begin();
-                    it != this->statesByName_.end(); ++it)
+                for (const auto& mapEntry : this->statesByName_)
                 {
-                    if (it->second->getPriority() == priority)
+                    if (mapEntry.second->getPriority() == priority)
                     {
                         orxout(internal_warning, context::input) << "Could not add an InputState with the same priority '"
                             << static_cast<int>(priority) << "' != 0." << endl;
-                        return 0;
+                        return nullptr;
                     }
                 }
@@ -551,5 +549,5 @@
         {
             orxout(internal_warning, context::input) << "Could not add an InputState with the same name '" << name << "'." << endl;
-            return 0;
+            return nullptr;
         }
     }
@@ -561,5 +559,5 @@
             return it->second;
         else
-            return 0;
+            return nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/input/InputManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputManager.h	(revision 11054)
@@ -35,5 +35,5 @@
 #include <string>
 #include <vector>
-#include <boost/function.hpp>
+#include <functional>
 
 #include "util/Singleton.h"
@@ -134,5 +134,5 @@
             Returns a pointer to a InputState referenced by name.
         @return
-            Returns NULL if state was not found.
+            Returns nullptr if state was not found.
         */
         InputState* getState(const std::string& name);
@@ -186,5 +186,5 @@
         // Function call caching
         //-------------------------------
-        void pushCall(const boost::function<void ()>& function)
+        void pushCall(const std::function<void ()>& function)
             { this->callBuffer_.push_back(function); }
 
@@ -192,6 +192,7 @@
 
     private: // functions
-        // don't mess with a Singleton
-        InputManager(const InputManager&);
+        // non-copyable:
+        InputManager(const InputManager&) = delete;
+        InputManager& operator=(const InputManager&) = delete;
 
         // Internal methods
@@ -208,5 +209,5 @@
 
         // From WindowEventListener
-        void windowFocusChanged(bool bFocus);
+        virtual void windowFocusChanged(bool bFocus) override;
 
     private: // variables
@@ -225,5 +226,5 @@
         std::vector<InputState*>            activeStatesTicked_;   //!< Like activeStates_, but only contains the ones that currently receive events
 
-        std::vector<boost::function<void ()> > callBuffer_;        //!< Caches all calls from InputStates to be executed afterwards (see preUpdate)
+        std::vector<std::function<void ()>> callBuffer_;        //!< Caches all calls from InputStates to be executed afterwards (see preUpdate)
 
         static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton
Index: code/branches/cpp11_v3/src/libraries/core/input/InputPrereqs.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputPrereqs.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputPrereqs.h	(revision 11054)
@@ -454,11 +454,11 @@
         OrxEnumConstructors(InputStatePriority);
 
-        static const int Empty        = -1;
-        static const int Dynamic      = 0;
-
-        static const int HighPriority = 1000;
-        static const int Console      = HighPriority + 0;
-        static const int Calibrator   = HighPriority + 1;
-        static const int Detector     = HighPriority + 2;
+        static constexpr int Empty        = -1;
+        static constexpr int Dynamic      = 0;
+
+        static constexpr int HighPriority = 1000;
+        static constexpr int Console      = HighPriority + 0;
+        static constexpr int Calibrator   = HighPriority + 1;
+        static constexpr int Detector     = HighPriority + 2;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/core/input/InputState.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputState.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputState.cc	(revision 11054)
@@ -40,7 +40,7 @@
         , bExpired_(true)
         , handlers_(2)
-        , joyStickHandlerAll_(0)
-        , enterFunctor_(0)
-        , leaveFunctor_(0)
+        , joyStickHandlerAll_(nullptr)
+        , enterFunctor_(nullptr)
+        , leaveFunctor_(nullptr)
     {
         if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)
@@ -49,5 +49,5 @@
             priority_ = 0;
 
-        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + this->getJoyStickList().size(), NULL);
+        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + this->getJoyStickList().size(), nullptr);
     }
 
@@ -55,5 +55,5 @@
     {
         if (device < handlers_.size())
-            return handlers_[device] != NULL;
+            return handlers_[device] != nullptr;
         else
             return false;
@@ -64,5 +64,5 @@
     {
         unsigned int oldSize = handlers_.size();
-        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + joyStickList.size(), NULL);
+        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + joyStickList.size(), nullptr);
 
         for (unsigned int i = oldSize; i < handlers_.size(); ++i)
Index: code/branches/cpp11_v3/src/libraries/core/input/InputState.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/InputState.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/InputState.h	(revision 11054)
@@ -35,6 +35,5 @@
 #include <string>
 #include <vector>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
+#include <functional>
 
 #include "util/tribool.h"
@@ -44,5 +43,5 @@
 
 #define INPUT_STATE_PUSH_CALL(deviceIndex, functionName, ...) \
-    InputManager::getInstance().pushCall(boost::function<void ()>(boost::bind(&InputHandler::functionName, handlers_[deviceIndex], __VA_ARGS__)))
+    InputManager::getInstance().pushCall(std::function<void ()>(std::bind(&InputHandler::functionName, handlers_[deviceIndex], __VA_ARGS__)))
 
 namespace orxonox
@@ -156,7 +155,7 @@
     private:
         InputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority);
-        ~InputState() { }
-
-        void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
+        ~InputState() = default;
+
+        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList) override;
 
         //! Sets the priority (only to be used by the InputManager!)
@@ -179,5 +178,5 @@
     {
         for (unsigned int i = 0; i < handlers_.size(); ++i)
-            if (handlers_[i] != NULL)
+            if (handlers_[i] != nullptr)
                 INPUT_STATE_PUSH_CALL(i, allDevicesUpdated, dt);
     }
@@ -188,15 +187,15 @@
         {
         case InputDeviceEnumerator::Keyboard:
-            if (handlers_[keyboardIndex_s] != NULL)
+            if (handlers_[keyboardIndex_s] != nullptr)
                 INPUT_STATE_PUSH_CALL(keyboardIndex_s, keyboardUpdated, dt);
             break;
 
         case InputDeviceEnumerator::Mouse:
-            if (handlers_[mouseIndex_s] != NULL)
+            if (handlers_[mouseIndex_s] != nullptr)
                 INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseUpdated, dt);
             break;
 
         default: // joy sticks
-            if (handlers_[device] != NULL)
+            if (handlers_[device] != nullptr)
                 INPUT_STATE_PUSH_CALL(device, joyStickUpdated, device - firstJoyStickIndex_s, dt);
             break;
@@ -208,9 +207,9 @@
     {
         assert(device < handlers_.size());
-        if (handlers_[device] != NULL)
+        if (handlers_[device] != nullptr)
         {
             // We have to store the function pointer to tell the compiler about its actual type because of overloading
             void (InputHandler::*function)(unsigned int, ButtonTypeParam, EventType) = &InputHandler::buttonEvent<ButtonTypeParam>;
-            InputManager::getInstance().pushCall(boost::function<void ()>(boost::bind(function, handlers_[device], device, button, EventType())));
+            InputManager::getInstance().pushCall(std::function<void ()>(std::bind(function, handlers_[device], device, button, EventType())));
         }
     }
@@ -218,5 +217,5 @@
     ORX_FORCEINLINE void InputState::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
     {
-        if (handlers_[mouseIndex_s] != NULL)
+        if (handlers_[mouseIndex_s] != nullptr)
             INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseMoved, abs, rel, clippingSize);
     }
@@ -224,5 +223,5 @@
     ORX_FORCEINLINE void InputState::mouseScrolled(int abs, int rel)
     {
-        if (handlers_[mouseIndex_s] != NULL)
+        if (handlers_[mouseIndex_s] != nullptr)
             INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseScrolled, abs, rel);
     }
@@ -231,5 +230,5 @@
     {
         assert(device < handlers_.size());
-        if (handlers_[device] != NULL)
+        if (handlers_[device] != nullptr)
             INPUT_STATE_PUSH_CALL(device, axisMoved, device - firstJoyStickIndex_s, axis, value);
     }
Index: code/branches/cpp11_v3/src/libraries/core/input/JoyStick.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/JoyStick.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/JoyStick.cc	(revision 11054)
@@ -31,5 +31,4 @@
 #include <climits>
 #include <ois/OISJoyStick.h>
-#include <boost/foreach.hpp>
 
 #include "util/StringUtils.h"
@@ -73,5 +72,5 @@
         //deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Vector3));
 
-        BOOST_FOREACH(std::string& idString, deviceNames_s)
+        for (const std::string& idString : deviceNames_s)
         {
             if (deviceName_ == idString)
@@ -128,9 +127,9 @@
     {
         // Set initial values
-        BOOST_FOREACH(int& minVal, configMinValues_)
+        for (int& minVal : configMinValues_)
             minVal = INT_MAX;
-        BOOST_FOREACH(int& minVal, configMaxValues_)
+        for (int& minVal : configMaxValues_)
             minVal = INT_MIN;
-        BOOST_FOREACH(int& zeroVal, configZeroValues_)
+        for (int& zeroVal : configZeroValues_)
             zeroVal = 0;
     }
@@ -187,6 +186,6 @@
     void JoyStick::clearBuffersImpl()
     {
-        for (int j = 0; j < 4; ++j)
-            povStates_[j] = 0;
+        for (int& state : povStates_)
+            state = 0;
     }
 
@@ -209,5 +208,5 @@
                 fValue *= negativeCoeffs_[axis];
 
-            BOOST_FOREACH(InputState* state, inputStates_)
+            for (InputState* state : inputStates_)
                 state->joyStickAxisMoved(this->getDeviceID(), axis, fValue);
         }
Index: code/branches/cpp11_v3/src/libraries/core/input/JoyStick.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/JoyStick.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/JoyStick.h	(revision 11054)
@@ -70,5 +70,5 @@
         //! Assigns a generated ID string and loads the calibration (if present)
         JoyStick(unsigned int id, OIS::InputManager* oisInputManager);
-        ~JoyStick() { }
+        ~JoyStick() = default;
         void setConfigValues();
 
@@ -77,6 +77,6 @@
 
     private:
-        void calibrationStarted();
-        void calibrationStopped();
+        virtual void calibrationStarted() override;
+        virtual void calibrationStopped() override;
         void evaluateCalibration();
 
@@ -86,5 +86,5 @@
 
         //! OIS event handler
-        bool buttonPressed (const OIS::JoyStickEvent &arg, int button)
+        virtual bool buttonPressed (const OIS::JoyStickEvent &arg, int button) override
         {
             super::buttonPressed(static_cast<JoyStickButtonCode::ByEnum>(button));
@@ -93,5 +93,5 @@
 
         //! OIS event handler
-        bool buttonReleased(const OIS::JoyStickEvent &arg, int button)
+        virtual bool buttonReleased(const OIS::JoyStickEvent &arg, int button) override
         {
             super::buttonReleased(static_cast<JoyStickButtonCode::ByEnum>(button));
@@ -99,9 +99,9 @@
         }
 
-        bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
-        bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
-        bool povMoved      (const OIS::JoyStickEvent &arg, int id);
+        virtual bool axisMoved     (const OIS::JoyStickEvent &arg, int axis) override;
+        virtual bool sliderMoved   (const OIS::JoyStickEvent &arg, int id) override;
+        virtual bool povMoved      (const OIS::JoyStickEvent &arg, int id) override;
         //! OIS event handler (don't remove that because of OIS version issues!)
-        bool vector3Moved  (const OIS::JoyStickEvent &arg, int id) { return true; }
+        virtual bool vector3Moved  (const OIS::JoyStickEvent &arg, int id) override { return true; }
 
         //! Returns the class name as string
Index: code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.cc	(revision 11054)
@@ -47,6 +47,6 @@
     {
         joyStickList_s = joyStickList;
-        for (ObjectList<JoyStickQuantityListener>::iterator it = ObjectList<JoyStickQuantityListener>::begin(); it; ++it)
-            it->JoyStickQuantityChanged(joyStickList);
+        for (JoyStickQuantityListener* listener : ObjectList<JoyStickQuantityListener>())
+            listener->JoyStickQuantityChanged(joyStickList);
     }
 }
Index: code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.h	(revision 11054)
@@ -48,5 +48,5 @@
     protected:
         JoyStickQuantityListener();
-        virtual ~JoyStickQuantityListener() { }
+        virtual ~JoyStickQuantityListener() = default;
 
         //! Returns a list with all JoySticks currently loaded
Index: code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.cc	(revision 11054)
@@ -53,6 +53,6 @@
         : deriveTime_(0.0f)
         , filename_(filename)
-        , configFile_(NULL)
-        , fallbackConfigFile_(NULL)
+        , configFile_(nullptr)
+        , fallbackConfigFile_(nullptr)
     {
         mouseRelative_[0] = 0;
@@ -153,7 +153,7 @@
     void KeyBinder::buttonThresholdChanged()
     {
-        for (unsigned int i = 0; i < allHalfAxes_.size(); i++)
-            if (!allHalfAxes_[i]->bButtonThresholdUser_)
-                allHalfAxes_[i]->buttonThreshold_ = this->buttonThreshold_;
+        for (HalfAxis* halfAxis : allHalfAxes_)
+            if (!halfAxis->bButtonThresholdUser_)
+                halfAxis->buttonThreshold_ = this->buttonThreshold_;
     }
 
@@ -170,5 +170,5 @@
 
         // load the bindings if required
-        if (configFile_ != NULL)
+        if (configFile_ != nullptr)
         {
             for (unsigned int iDev = oldValue; iDev < joySticks_.size(); ++iDev)
@@ -188,7 +188,7 @@
     {
         while (joyStickAxes_.size() < joySticks_.size())
-            joyStickAxes_.push_back(shared_ptr<JoyStickAxisVector>(new JoyStickAxisVector()));
+            joyStickAxes_.push_back(std::make_shared<JoyStickAxisVector>());
         while (joyStickButtons_.size() < joySticks_.size())
-            joyStickButtons_.push_back(shared_ptr<JoyStickButtonVector>(new JoyStickButtonVector()));
+            joyStickButtons_.push_back(std::make_shared<JoyStickButtonVector>());
         // For the case the new size is smaller
         this->joyStickAxes_.resize(joySticks_.size());
@@ -274,8 +274,8 @@
 
         // Parse bindings and create the ConfigValueContainers if necessary
-        for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
-        {
-            it->second->readBinding(this->configFile_, this->fallbackConfigFile_);
-            addButtonToCommand(it->second->bindingString_, it->second);
+        for (const auto& mapEntry : allButtons_)
+        {
+            mapEntry.second->readBinding(this->configFile_, this->fallbackConfigFile_);
+            addButtonToCommand(mapEntry.second->bindingString_, mapEntry.second);
         }
 
@@ -420,9 +420,9 @@
     void KeyBinder::clearBindings()
     {
-        for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
-            it->second->clear();
-
-        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
-            delete paramCommandBuffer_[i];
+        for (const auto& mapEntry : allButtons_)
+            mapEntry.second->clear();
+
+        for (BufferedParamCommand* command : paramCommandBuffer_)
+            delete command;
         paramCommandBuffer_.clear();
     }
@@ -434,7 +434,7 @@
     {
         // iterate over all buttons
-        for (std::map<std::string, Button*>::iterator it = this->allButtons_.begin(); it != this->allButtons_.end(); ++it)
-        {
-            Button* button = it->second;
+        for (const auto& mapEntry : this->allButtons_)
+        {
+            Button* button = mapEntry.second;
 
             // iterate over all modes
@@ -479,5 +479,5 @@
                         {
                             delete[] button->commands_[mode_index];
-                            button->commands_[mode_index] = 0;
+                            button->commands_[mode_index] = nullptr;
                         }
 
@@ -505,6 +505,6 @@
         this->mousePosition_[1] = 0.0f;
 
-        for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
-            mouseAxes_[i].reset();
+        for (HalfAxis& axis : mouseAxes_)
+            axis.reset();
     }
 
@@ -545,5 +545,5 @@
         }
 
-        for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
+        for (HalfAxis& axis : mouseAxes_)
         {
             // Why dividing relative value by dt? The reason lies in the simple fact, that when you
@@ -555,8 +555,8 @@
             {
                 // just ignore if dt == 0.0 because we have multiplied by 0.0 anyway..
-                mouseAxes_[i].relVal_ /= dt;
-            }
-
-            tickHalfAxis(mouseAxes_[i]);
+                axis.relVal_ /= dt;
+            }
+
+            tickHalfAxis(axis);
         }
     }
Index: code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.h	(revision 11054)
@@ -36,5 +36,5 @@
 #include <vector>
 #include <map>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include "InputHandler.h"
@@ -85,26 +85,26 @@
         void compilePointerLists();
         // from JoyStickQuantityListener interface
-        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
-
-        void allDevicesUpdated(float dt);
-        void mouseUpdated(float dt);
-        void joyStickUpdated(unsigned int joyStick, float dt);
+        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList) override;
+
+        virtual void allDevicesUpdated(float dt) override;
+        virtual void mouseUpdated(float dt) override;
+        virtual void joyStickUpdated(unsigned int joyStick, float dt) override;
         // internal
         void tickHalfAxis(HalfAxis& halfAxis);
 
-        void buttonPressed (const KeyEvent& evt);
-        void buttonReleased(const KeyEvent& evt);
-        void buttonHeld    (const KeyEvent& evt);
-
-        void buttonPressed (MouseButtonCode::ByEnum button);
-        void buttonReleased(MouseButtonCode::ByEnum button);
-        void buttonHeld    (MouseButtonCode::ByEnum button);
-        void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
-        void mouseScrolled (int abs, int rel);
-
-        void buttonPressed (unsigned int device, JoyStickButtonCode::ByEnum button);
-        void buttonReleased(unsigned int device, JoyStickButtonCode::ByEnum button);
-        void buttonHeld    (unsigned int device, JoyStickButtonCode::ByEnum button);
-        void axisMoved     (unsigned int device, unsigned int axis, float value);
+        virtual void buttonPressed (const KeyEvent& evt) override;
+        virtual void buttonReleased(const KeyEvent& evt) override;
+        virtual void buttonHeld    (const KeyEvent& evt) override;
+
+        virtual void buttonPressed (MouseButtonCode::ByEnum button) override;
+        virtual void buttonReleased(MouseButtonCode::ByEnum button) override;
+        virtual void buttonHeld    (MouseButtonCode::ByEnum button) override;
+        virtual void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) override;
+        virtual void mouseScrolled (int abs, int rel) override;
+
+        virtual void buttonPressed (unsigned int device, JoyStickButtonCode::ByEnum button) override;
+        virtual void buttonReleased(unsigned int device, JoyStickButtonCode::ByEnum button) override;
+        virtual void buttonHeld    (unsigned int device, JoyStickButtonCode::ByEnum button) override;
+        virtual void axisMoved     (unsigned int device, unsigned int axis, float value) override;
 
     protected: // variables
@@ -128,5 +128,5 @@
         };
         //! Actual key bindings for joy stick buttons
-        std::vector<shared_ptr<JoyStickButtonVector> > joyStickButtons_;
+        std::vector<std::shared_ptr<JoyStickButtonVector>> joyStickButtons_;
         //! Helper class to use something like std:vector<HalfAxis[48]>
         struct JoyStickAxisVector
@@ -136,5 +136,5 @@
         };
         //! Actual key bindings for joy stick axes (and sliders)
-        std::vector<shared_ptr<JoyStickAxisVector> > joyStickAxes_;
+        std::vector<std::shared_ptr<JoyStickAxisVector>> joyStickAxes_;
 
         //! Pointer map with all Buttons, including half axes
@@ -143,5 +143,5 @@
         std::vector<HalfAxis*> allHalfAxes_;
         //! Maps input commands to all Button names, including half axes
-        std::map< std::string, std::vector<std::string> > allCommands_;
+        std::map< std::string, std::vector<std::string>> allCommands_;
 
         /**
@@ -160,5 +160,5 @@
         //! Name of the file used in this KeyBinder (constant!)
         const std::string filename_;
-        //! Config file used. NULL in case of KeyDetector. Also indicates whether we've already loaded.
+        //! Config file used. nullptr in case of KeyDetector. Also indicates whether we've already loaded.
         ConfigFile* configFile_;
         //! Config file from the data directory that only serves as fallback
@@ -227,13 +227,13 @@
     {
         // execute all buffered bindings (additional parameter)
-        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+        for (BufferedParamCommand* command : paramCommandBuffer_)
         {
-            paramCommandBuffer_[i]->rel_ *= dt;
-            paramCommandBuffer_[i]->execute();
+            command->rel_ *= dt;
+            command->execute();
         }
 
         // always reset the relative movement of the mouse
-        for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
-            mouseAxes_[i].relVal_ = 0.0f;
+        for (HalfAxis& axis : mouseAxes_)
+            axis.relVal_ = 0.0f;
     }
 }// tolua_export
Index: code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.cc	(revision 11054)
@@ -56,5 +56,5 @@
 
     KeyBinderManager::KeyBinderManager()
-        : currentBinder_(NULL)
+        : currentBinder_(nullptr)
         , bDefaultFileLoaded_(true)
         , bBinding_(false)
@@ -76,12 +76,12 @@
     {
         // Delete all remaining KeyBinders
-        for (std::map<std::string, KeyBinder*>::const_iterator it = this->binders_.begin(); it != this->binders_.end(); ++it)
-            delete it->second;
+        for (const auto& mapEntry : this->binders_)
+            delete mapEntry.second;
 
         // Reset console commands
-        ModifyConsoleCommand(__CC_keybind_name ).setObject(0);
-        ModifyConsoleCommand(__CC_tkeybind_name).setObject(0);
-        ModifyConsoleCommand(__CC_unbind_name  ).setObject(0);
-        ModifyConsoleCommand(__CC_tunbind_name ).setObject(0);
+        ModifyConsoleCommand(__CC_keybind_name ).setObject(nullptr);
+        ModifyConsoleCommand(__CC_tkeybind_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_unbind_name  ).setObject(nullptr);
+        ModifyConsoleCommand(__CC_tunbind_name ).setObject(nullptr);
     }
 
@@ -205,5 +205,5 @@
     void KeyBinderManager::registerKeybindCallback(LuaFunctor* function)
     {
-        this->callbackFunction_ = function;
+        this->callbackFunction_.reset(function);
     }
 }
Index: code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.h	(revision 11054)
@@ -34,4 +34,5 @@
 #include <map>
 #include <string>
+#include <memory>
 
 #include "util/Singleton.h"
@@ -101,5 +102,8 @@
 
     private:
-        KeyBinderManager(const KeyBinderManager&);
+        // non-copyable:
+        KeyBinderManager(const KeyBinderManager&) = delete;
+        KeyBinderManager& operator=(const KeyBinderManager&) = delete;
+
         void keybindInternal(const std::string& command, bool bTemporary);
         void keybindKeyPressed(const std::string& keyName);
@@ -107,14 +111,14 @@
 
         // KeyBinder management
-        KeyBinder* currentBinder_;                   //! Currently selected KeyBinder (never NULL!)
-        std::map<std::string, KeyBinder*> binders_;  //! All loaded KeyBinders
-        bool bDefaultFileLoaded_;                    //! Tells whether the default one is loaded
-        std::string defaultFilename_;                //! Name of the file with the default key bindings
+        KeyBinder* currentBinder_;                      //! Currently selected KeyBinder (never nullptr!)
+        std::map<std::string, KeyBinder*> binders_;     //! All loaded KeyBinders
+        bool bDefaultFileLoaded_;                       //! Tells whether the default one is loaded
+        std::string defaultFilename_;                   //! Name of the file with the default key bindings
 
         // keybind command related
-        SharedPtr<LuaFunctor> callbackFunction_;     //! Function to be called when key was pressed after "keybind" command
-        bool bBinding_;                              //! Tells whether a key binding process is active
-        bool bTemporary_;                            //! Stores tkeybind/keybind value
-        std::string command_;                        //! Stores the command received by (t)keybind
+        std::shared_ptr<LuaFunctor> callbackFunction_;  //! Function to be called when key was pressed after "keybind" command
+        bool bBinding_;                                 //! Tells whether a key binding process is active
+        bool bTemporary_;                               //! Stores tkeybind/keybind value
+        std::string command_;                           //! Stores the command received by (t)keybind
 
         static KeyBinderManager* singletonPtr_s;
Index: code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.cc	(revision 11054)
@@ -62,5 +62,5 @@
     KeyDetector::~KeyDetector()
     {
-        inputState_->setHandler(NULL);
+        inputState_->setHandler(nullptr);
         InputManager::getInstance().destroyState("detector");
         ModifyConsoleCommand(__CC_KeyDetector_callback_name).resetFunction();
@@ -70,6 +70,6 @@
     {
         // Assign every button/axis the same command, but with its name as argument
-        for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
-            it->second->parse(__CC_KeyDetector_callback_name + ' ' + it->second->groupName_ + "." + it->second->name_);
+        for (const auto& mapEntry : allButtons_)
+            mapEntry.second->parse(__CC_KeyDetector_callback_name + ' ' + mapEntry.second->groupName_ + "." + mapEntry.second->name_);
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.h	(revision 11054)
@@ -48,8 +48,10 @@
 
     private:
-        KeyDetector(const KeyDetector&);
+        // non-copyable:
+        KeyDetector(const KeyDetector&) = delete;
+        KeyDetector& operator=(const KeyDetector&) = delete;
 
         void callback(const std::string& name);
-        void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
+        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList) override;
         void assignCommands();
 
Index: code/branches/cpp11_v3/src/libraries/core/input/Keyboard.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/Keyboard.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/Keyboard.h	(revision 11054)
@@ -63,5 +63,5 @@
         //! Only resets the keyboard modifiers. Initialising is done in the base class.
         Keyboard(unsigned int id, OIS::InputManager* oisInputManager) : super(id, oisInputManager), modifiers_(0) { }
-        ~Keyboard() { }
+        ~Keyboard() = default;
 
     private:
@@ -75,6 +75,6 @@
         }
 
-        bool keyPressed(const OIS::KeyEvent& arg);
-        bool keyReleased(const OIS::KeyEvent& arg);
+        virtual bool keyPressed(const OIS::KeyEvent& arg) override;
+        virtual bool keyReleased(const OIS::KeyEvent& arg) override;
 
         //! Returns the class name as string
Index: code/branches/cpp11_v3/src/libraries/core/input/Mouse.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/Mouse.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/Mouse.cc	(revision 11054)
@@ -68,6 +68,6 @@
     {
 #ifdef ORXONOX_PLATFORM_LINUX
-        ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(0);
-        ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(0);
+        ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(nullptr);
 #endif
     }
@@ -82,6 +82,6 @@
             IntVector2 rel(e.state.X.rel, e.state.Y.rel);
             IntVector2 clippingSize(e.state.width, e.state.height);
-            for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->mouseMoved(abs, rel, clippingSize);
+            for (InputState* state : inputStates_)
+                state->mouseMoved(abs, rel, clippingSize);
         }
 
@@ -89,6 +89,6 @@
         if (e.state.Z.rel != 0)
         {
-            for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+            for (InputState* state : inputStates_)
+                state->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/input/Mouse.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/input/Mouse.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/input/Mouse.h	(revision 11054)
@@ -74,5 +74,5 @@
     private:
         //! OIS event handler
-        bool mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
+        virtual bool mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id) override
         {
             super::buttonPressed(static_cast<MouseButtonCode::ByEnum>(id));
@@ -81,5 +81,5 @@
 
         //! OIS event handler
-        bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
+        virtual bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id) override
         {
             super::buttonReleased(static_cast<MouseButtonCode::ByEnum>(id));
@@ -87,7 +87,7 @@
         }
 
-        bool mouseMoved(const OIS::MouseEvent &arg);
+        virtual bool mouseMoved(const OIS::MouseEvent &arg) override;
 
-        void windowResized(unsigned int newWidth, unsigned int newHeight);
+        virtual void windowResized(unsigned int newWidth, unsigned int newHeight) override;
 
         // Returns the class name as string
Index: code/branches/cpp11_v3/src/libraries/core/module/DynLib.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/DynLib.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/DynLib.cc	(revision 11054)
@@ -56,5 +56,5 @@
     {
         mName = name;
-        m_hInst = NULL;
+        m_hInst = nullptr;
     }
 
@@ -127,10 +127,10 @@
             FORMAT_MESSAGE_FROM_SYSTEM |
             FORMAT_MESSAGE_IGNORE_INSERTS,
-            NULL,
+            nullptr,
             GetLastError(),
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
             (LPTSTR) &lpMsgBuf,
             0,
-            NULL
+            nullptr
             );
         std::string ret = (char*)lpMsgBuf;
Index: code/branches/cpp11_v3/src/libraries/core/module/DynLib.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/DynLib.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/DynLib.h	(revision 11054)
@@ -45,5 +45,5 @@
 #if defined(ORXONOX_PLATFORM_WINDOWS)
 #    define DYNLIB_HANDLE hInstance
-#    define DYNLIB_LOAD( a ) LoadLibraryEx( a, NULL, LOAD_WITH_ALTERED_SEARCH_PATH )
+#    define DYNLIB_LOAD( a ) LoadLibraryEx( a, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH )
 #    define DYNLIB_GETSYM( a, b ) GetProcAddress( a, b )
 #    define DYNLIB_UNLOAD( a ) !FreeLibrary( a )
@@ -104,5 +104,5 @@
                 the symbol.
             @par
-                If the function fails, the returned value is <b>NULL</b>.
+                If the function fails, the returned value is <b>nullptr</b>.
 
         */
Index: code/branches/cpp11_v3/src/libraries/core/module/DynLibManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/DynLibManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/DynLibManager.cc	(revision 11054)
@@ -38,5 +38,5 @@
     //-----------------------------------------------------------------------
     //! Static pointer to the singleton
-    DynLibManager* DynLibManager::singletonPtr_s  = 0;
+    DynLibManager* DynLibManager::singletonPtr_s  = nullptr;
 
     //-----------------------------------------------------------------------
@@ -75,8 +75,8 @@
     {
         // Unload & delete resources in turn
-        for (DynLibList::iterator it = mLibList.begin(); it != mLibList.end(); ++it)
+        for (const auto& mapEntry : mLibList)
         {
-            it->second->unload();
-            delete it->second;
+            mapEntry.second->unload();
+            delete mapEntry.second;
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.cc	(revision 11054)
@@ -33,9 +33,9 @@
 namespace orxonox
 {
-    ModuleInstance* ModuleInstance::currentModuleInstance_s = NULL;
+    ModuleInstance* ModuleInstance::currentModuleInstance_s = nullptr;
 
     ModuleInstance::ModuleInstance(const std::string& libraryName)
         : libraryName_(libraryName)
-        , dynLib_(NULL)
+        , dynLib_(nullptr)
     {
     }
@@ -59,6 +59,6 @@
     {
         const std::set<StaticallyInitializedInstance*>& instances = this->staticallyInitializedInstancesByType_[type];
-        for (std::set<StaticallyInitializedInstance*>::iterator it = instances.begin(); it != instances.end(); ++it)
-            (*it)->load();
+        for (StaticallyInitializedInstance* instance : instances)
+            instance->load();
     }
 
@@ -73,9 +73,9 @@
     void ModuleInstance::deleteAllStaticallyInitializedInstances()
     {
-        std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > copy(this->staticallyInitializedInstancesByType_);
+        std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
         this->staticallyInitializedInstancesByType_.clear();
-        for (std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> >::iterator it1 = copy.begin(); it1 != copy.end(); ++it1)
-            for (std::set<StaticallyInitializedInstance*>::iterator it2 = it1->second.begin(); it2 != it1->second.end(); ++it2)
-                delete (*it2);
+        for (const auto& mapEntry : copy)
+            for (StaticallyInitializedInstance* instance : mapEntry.second)
+                delete instance;
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.h	(revision 11054)
@@ -69,5 +69,5 @@
 
         private:
-            std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > staticallyInitializedInstancesByType_;
+            std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> staticallyInitializedInstancesByType_;
             std::string libraryName_;
             DynLib* dynLib_;
Index: code/branches/cpp11_v3/src/libraries/core/module/Plugin.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/Plugin.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/Plugin.cc	(revision 11054)
@@ -39,5 +39,5 @@
     {
         this->referenceCounter_ = 0;
-        this->moduleInstance_ = NULL;
+        this->moduleInstance_ = nullptr;
     }
 
@@ -45,5 +45,5 @@
     {
         // force unloading of the module when the plugin is destroyed
-        if (this->moduleInstance_ != NULL)
+        if (this->moduleInstance_ != nullptr)
             this->unloadModule();
     }
Index: code/branches/cpp11_v3/src/libraries/core/module/PluginManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/PluginManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/PluginManager.cc	(revision 11054)
@@ -54,5 +54,5 @@
     SetConsoleCommand("PluginManager", __CC_PluginManager_unload_name, &PluginManager::unloadPlugin);
 
-    PluginManager* PluginManager::singletonPtr_s  = 0;
+    PluginManager* PluginManager::singletonPtr_s  = nullptr;
 
     RegisterAbstractClass(PluginManager).inheritsFrom<Configurable>();
@@ -70,11 +70,11 @@
     PluginManager::~PluginManager()
     {
-        ModifyConsoleCommand("PluginManager", __CC_PluginManager_load_name).setObject(NULL);
-        ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(NULL);
+        ModifyConsoleCommand("PluginManager", __CC_PluginManager_load_name).setObject(nullptr);
+        ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(nullptr);
 
-        for (std::map<std::string, PluginReference*>::iterator it = this->references_.begin(); it != this->references_.end(); ++it)
-            delete it->second;
-        for (std::map<std::string, Plugin*>::iterator it = this->plugins_.begin(); it != this->plugins_.end(); ++it)
-            delete it->second;
+        for (const auto& mapEntry : this->references_)
+            delete mapEntry.second;
+        for (const auto& mapEntry : this->plugins_)
+            delete mapEntry.second;
     }
 
@@ -96,8 +96,7 @@
     {
         const std::vector<std::string>& pluginPaths = ApplicationPaths::getInstance().getPluginPaths();
-        for (std::vector<std::string>::const_iterator it = pluginPaths.begin(); it != pluginPaths.end(); ++it)
+        for (const std::string& libraryName : pluginPaths)
         {
             std::string name;
-            std::string libraryName = (*it);
             std::string filename = libraryName +  + specialConfig::pluginExtension;
             std::ifstream infile(filename.c_str());
@@ -117,5 +116,5 @@
     {
         Plugin* plugin = this->plugins_[name];
-        if (plugin != NULL)
+        if (plugin != nullptr)
             plugin->reference();
         else
@@ -126,5 +125,5 @@
     {
         Plugin* plugin = this->plugins_[name];
-        if (plugin != NULL)
+        if (plugin != nullptr)
             plugin->dereference(this->bMerelyDeactivatePlugins_);
         else
@@ -137,5 +136,5 @@
     void PluginManager::loadPlugin(const std::string& name)
     {
-        if (this->references_[name] == NULL)
+        if (this->references_[name] == nullptr)
         {
             this->references_[name] = new PluginReference(name);
@@ -152,7 +151,7 @@
     {
         PluginReference* reference = this->references_[name];
-        if (reference != NULL)
+        if (reference != nullptr)
         {
-            this->references_[name] = NULL;
+            this->references_[name] = nullptr;
             delete reference;
         }
Index: code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandler.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandler.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandler.h	(revision 11054)
@@ -37,6 +37,6 @@
     {
         public:
-            StaticInitializationHandler() {}
-            virtual ~StaticInitializationHandler() {}
+            StaticInitializationHandler() = default;
+            virtual ~StaticInitializationHandler() = default;
 
             virtual void setupHandler() = 0;
Index: code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandlerIncludes.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandlerIncludes.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandlerIncludes.h	(revision 11054)
@@ -53,6 +53,6 @@
             ~StaticallyInitializedStaticInitializationHandler() { delete handler_; }
 
-            virtual void load();
-            virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
 
             inline StaticInitializationHandler& getHandler()
Index: code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.cc	(revision 11054)
@@ -33,5 +33,5 @@
 namespace orxonox
 {
-    StaticInitializationManager* StaticInitializationManager::singletonPtr_s = 0;
+    StaticInitializationManager* StaticInitializationManager::singletonPtr_s = nullptr;
 
     void StaticInitializationManager::addHandler(StaticInitializationHandler* handler)
@@ -50,6 +50,6 @@
     {
         // attention: loading a module may add new handlers to the list
-        for (std::list<StaticInitializationHandler*>::iterator it = this->handlers_.begin(); it != this->handlers_.end(); ++it)
-            (*it)->loadModule(module);
+        for (StaticInitializationHandler* handler : this->handlers_)
+            handler->loadModule(module);
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.h	(revision 11054)
@@ -43,6 +43,6 @@
 
         public:
-            StaticInitializationManager() {}
-            virtual ~StaticInitializationManager() {}
+            StaticInitializationManager() = default;
+            virtual ~StaticInitializationManager() = default;
 
             void addHandler(StaticInitializationHandler* handler);
Index: code/branches/cpp11_v3/src/libraries/core/object/ClassFactory.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/ClassFactory.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/ClassFactory.h	(revision 11054)
@@ -53,5 +53,6 @@
     {
         public:
-            virtual ~Factory() {}
+            Factory() = default;
+            virtual ~Factory() = default;
             virtual Identifiable* fabricate(Context* context) = 0;
     };
Index: code/branches/cpp11_v3/src/libraries/core/object/Context.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/Context.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/Context.cc	(revision 11054)
@@ -40,5 +40,5 @@
     RegisterClass(Context);
 
-    Context* Context::rootContext_s = 0;
+    Context* Context::rootContext_s = nullptr;
 
     Context* getContextForInitializationOfOtherContexts()
@@ -46,11 +46,11 @@
         static size_t count = 0;
         // the first time this is called, ++count returns 1 and the context is created
-        // the second time this is called, ++count returns 2 and NULL is returned because we're in the constructor of the context itself
+        // the second time this is called, ++count returns 2 and nullptr is returned because we're in the constructor of the context itself
         // for each future call the context (now completely created) is returned
         if (++count == 2)
-            return NULL;
+            return nullptr;
         else
         {
-            static Context context(NULL);
+            static Context context(nullptr);
             return &context;
         }
@@ -70,6 +70,6 @@
         // unregister context from object lists before object lists are destroyed
         this->unregisterObject();
-        for (size_t i = 0; i < this->objectLists_.size(); ++i)
-            delete this->objectLists_[i];
+        for (ObjectListBase* objectList : this->objectLists_)
+            delete objectList;
     }
 
@@ -82,10 +82,10 @@
     {
         delete Context::rootContext_s;
-        Context::rootContext_s = NULL;
+        Context::rootContext_s = nullptr;
     }
 
     /*static*/ Context* Context::getRootContext()
     {
-        OrxVerify(Context::rootContext_s != NULL, "Root Context is undefined");
+        OrxVerify(Context::rootContext_s != nullptr, "Root Context is undefined");
         return Context::rootContext_s;
     }
@@ -105,5 +105,5 @@
         ObjectListBase* objectList = this->getObjectList(identifier);
         delete objectList;
-        this->objectLists_[identifier->getClassID()] = NULL;
+        this->objectLists_[identifier->getClassID()] = nullptr;
     }
 }
Index: code/branches/cpp11_v3/src/libraries/core/object/DestroyLaterManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/DestroyLaterManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/DestroyLaterManager.h	(revision 11054)
@@ -45,6 +45,6 @@
             virtual ~DestroyLaterManager();
 
-            virtual void preUpdate(const Clock& time) { /*no action*/ }
-            virtual void postUpdate(const Clock& time);
+            virtual void preUpdate(const Clock& time) override { /*no action*/ }
+            virtual void postUpdate(const Clock& time) override;
 
             void retain(Destroyable* instance)
@@ -52,5 +52,5 @@
 
         private:
-            std::vector<StrongPtr<Destroyable> > retainedInstances_;
+            std::vector<StrongPtr<Destroyable>> retainedInstances_;
 
             static DestroyLaterManager* singletonPtr_s;
Index: code/branches/cpp11_v3/src/libraries/core/object/Destroyable.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/Destroyable.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/Destroyable.cc	(revision 11054)
@@ -70,5 +70,5 @@
     void Destroyable::destroy()
     {
-        assert(this); // Just in case someone tries to delete a NULL pointer
+        assert(this); // Just in case someone tries to delete a nullptr
         this->requestedDestruction_ = true;
         if (this->referenceCount_ == 0)
Index: code/branches/cpp11_v3/src/libraries/core/object/Iterator.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/Iterator.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/Iterator.h	(revision 11054)
@@ -70,5 +70,5 @@
     */
     template <class T>
-    class Iterator : public IteratorBase<T, Iterator<T> >
+    class Iterator : public IteratorBase<T, Iterator<T>>
     {
         public:
@@ -76,11 +76,5 @@
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
-            inline Iterator() : IteratorBase<T, Iterator<T> >() {}
-
-            /**
-                @brief Constructor: Sets this element to a given element
-                @param element The element
-            */
-            inline Iterator(ObjectListBaseElement* element) : IteratorBase<T, Iterator<T> >(element) {}
+            inline Iterator() : IteratorBase<T, Iterator<T>>() {}
 
             /**
@@ -88,5 +82,6 @@
                 @param other The other Iterator
             */
-            inline Iterator(const IteratorBase<T, Iterator<T> >& other) : IteratorBase<T, Iterator<T> >(other) {}
+            template <class OT, class OI>
+            inline Iterator(const IteratorBase<OT, OI>& other) : IteratorBase<T, Iterator<T>>(other) {}
 
             /**
Index: code/branches/cpp11_v3/src/libraries/core/object/IteratorBase.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/IteratorBase.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/IteratorBase.h	(revision 11054)
@@ -37,7 +37,4 @@
 
 #include "core/CorePrereqs.h"
-
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 
 #include "ObjectListBase.h"
@@ -52,12 +49,11 @@
     class IteratorBase : public ObjectListElementRemovalListener
     {
-        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
-
-        protected:
+        static_assert(std::is_base_of<Listable, T>::value, "IteratorBase can only be used with Listables");
+
+        public:
             /**
                 @brief Constructor: Sets the element, whereon the iterator points, to the given element.
-                This constructor is protected and only for internal usage (don't mess with the BaseElements directly).
-            */
-            inline IteratorBase(ObjectListBaseElement* element = NULL)
+            */
+            inline IteratorBase(ObjectListElement<T>* element = nullptr)
             {
                 this->element_ = element;
@@ -65,34 +61,12 @@
             }
 
-
-        public:
-            /**
-                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
-            */
-            inline IteratorBase(ObjectListElement<T>* element)
-            {
-                this->element_ = element;
-                this->registerIterator();
-            }
-
             /**
                 @brief Constructor: Sets the element, whereon the iterator points, to the given element of another type.
                 The element's type O must be a derivative of the Iterator's type T.
             */
-            template <class O>
-            inline IteratorBase(ObjectListElement<O>* element)
-            {
-                (void)static_cast<T*>((O*)NULL); // Check type: The element's type O must be a derivative of the Iterator's type T.
-                this->element_ = element;
-                this->registerIterator();
-            }
-
-            /**
-                @brief Constructor: Sets this element to the element of another Iterator.
-                @param other The other Iterator
-            */
-            inline IteratorBase(const IteratorBase& other)
-            {
-                this->element_ = other.element_;
+            template <class OT, class OI>
+            inline IteratorBase(const IteratorBase<OT, OI>& other)
+            {
+                this->element_ = other.getElement();
                 this->registerIterator();
             }
@@ -172,7 +146,7 @@
                 @return True if the Iterator points to an existing object.
             */
-            inline operator bool() const
-            {
-                return (this->element_ != NULL);
+            inline explicit operator bool() const
+            {
+                return (this->element_ != nullptr);
             }
 
@@ -201,8 +175,13 @@
                 @param object The object to compare with
             */
-            virtual void removedElement(ObjectListBaseElement* element)
+            virtual void removedElement(ObjectListBaseElement* element) override
             {
                 if (this->element_ == element)
                     this->operator++();
+            }
+
+            inline ObjectListBaseElement* getElement() const
+            {
+                return this->element_;
             }
 
@@ -226,5 +205,5 @@
                 }
                 else
-                    this->list_ = NULL;
+                    this->list_ = nullptr;
             }
 
Index: code/branches/cpp11_v3/src/libraries/core/object/Listable.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/Listable.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/Listable.cc	(revision 11054)
@@ -44,10 +44,6 @@
         @brief Constructor: Allocates space in the element list.
     */
-    Listable::Listable()
+    Listable::Listable() : Listable(Context::getRootContext())
     {
-        this->context_ = Context::getRootContext();
-        this->elements_.reserve(6);
-
-        RegisterObject(Listable);
     }
 
@@ -76,6 +72,6 @@
     void Listable::unregisterObject()
     {
-        for (size_t i = 0; i < this->elements_.size(); ++i)
-            Listable::deleteObjectListElement(this->elements_[i]);
+        for (ObjectListBaseElement* element : this->elements_)
+            Listable::deleteObjectListElement(element);
         this->elements_.clear();
     }
@@ -91,8 +87,8 @@
         this->elements_.clear();
 
-        for (size_t i = 0; i < copy.size(); ++i)
+        for (ObjectListBaseElement* element : copy)
         {
-            copy[i]->changeContext(this->context_, context);
-            Listable::deleteObjectListElement(copy[i]);
+            element->changeContext(this->context_, context);
+            Listable::deleteObjectListElement(element);
         }
 
Index: code/branches/cpp11_v3/src/libraries/core/object/Listable.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/Listable.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/Listable.h	(revision 11054)
@@ -40,4 +40,5 @@
 #include <vector>
 
+#include "util/SmallObjectAllocator.h"
 #include "core/class/Identifiable.h"
 
Index: code/branches/cpp11_v3/src/libraries/core/object/ObjectList.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/ObjectList.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/ObjectList.h	(revision 11054)
@@ -47,7 +47,4 @@
 #include "core/CorePrereqs.h"
 
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-
 #include "ObjectListBase.h"
 #include "ObjectListIterator.h"
@@ -69,57 +66,33 @@
     class ObjectList
     {
-        BOOST_STATIC_ASSERT((boost::is_base_of<Listable, T>::value));
+        static_assert(std::is_base_of<Listable, T>::value, "ObjectList can only be used with Listables");
 
         public:
             typedef ObjectListIterator<T> iterator;
 
-            /// Returns the size of the list (for the root context)
-            inline static size_t size()
-            {   return size(Context::getRootContext());   }
+            ObjectList() : ObjectList(Context::getRootContext()) {}
+            ObjectList(Context* context) : ObjectList(context->getObjectList<T>()) {}
+            ObjectList(ObjectListBase* list) : list_(list) {}
+
             /// Returns the size of the list
-            inline static size_t size(Context* context)
-            {
-                return context->getObjectList<T>()->size();
-            }
+            inline size_t size()
+            {   return this->list_->size();   }
 
-            /// Returns an Iterator to the first element in the list (for the root context).
-            inline static ObjectListElement<T>* begin()
-            {   return begin(Context::getRootContext());   }
             /// Returns an Iterator to the first element in the list.
-            inline static ObjectListElement<T>* begin(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->begin());
-            }
+            inline ObjectListIterator<T> begin()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->begin());   }
+            /// Returns an Iterator to the element after the last element in the list.
+            inline ObjectListIterator<T> end()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->end());   }
 
-            /// Returns an Iterator to the element after the last element in the list (for the root context).
-            inline static ObjectListElement<T>* end()
-            {   return end(Context::getRootContext());   }
-            /// Returns an Iterator to the element after the last element in the list.
-            inline static ObjectListElement<T>* end(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->end());
-            }
+            /// Returns an Iterator to the last element in the list.
+            inline ObjectListIterator<T> rbegin()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->rbegin());   }
+            /// Returns an Iterator to the element before the first element in the list.
+            inline ObjectListIterator<T> rend()
+            {   return static_cast<ObjectListElement<T>*>(this->list_->rend());   }
 
-            /// Returns an Iterator to the last element in the list (for the root context).
-            inline static ObjectListElement<T>* rbegin()
-            {   return rbegin(Context::getRootContext());   }
-            /// Returns an Iterator to the last element in the list.
-            inline static ObjectListElement<T>* rbegin(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->rbegin());
-            }
-
-            /// Returns an Iterator to the element before the first element in the list (for the root context).
-            inline static ObjectListElement<T>* rend()
-            {   return rend(Context::getRootContext());   }
-            /// Returns an Iterator to the element before the first element in the list.
-            inline static ObjectListElement<T>* rend(Context* context)
-            {
-                ObjectListBase* list = context->getObjectList<T>();
-                return static_cast<ObjectListElement<T>*>(list->rend());
-            }
+        private:
+            ObjectListBase* list_;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.cc	(revision 11054)
@@ -58,6 +58,6 @@
     ObjectListBase::ObjectListBase()
     {
-        this->first_ = 0;
-        this->last_ = 0;
+        this->first_ = nullptr;
+        this->last_ = nullptr;
         this->size_ = 0;
     }
@@ -73,7 +73,7 @@
             ObjectListBaseElement* next = current->next_;
 
-            current->list_ = 0;
-            current->next_ = 0;
-            current->prev_ = 0;
+            current->list_ = nullptr;
+            current->next_ = nullptr;
+            current->prev_ = nullptr;
 
             current = next;
@@ -92,6 +92,6 @@
     void ObjectListBase::notifyRemovalListeners(ObjectListBaseElement* element) const
     {
-        for (std::vector<ObjectListElementRemovalListener*>::const_iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-            (*it)->removedElement(element);
+        for (ObjectListElementRemovalListener* listener : this->listeners_)
+            listener->removedElement(element);
     }
 
@@ -155,7 +155,7 @@
             this->first_ = element->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
 
-        element->list_ = 0;
-        element->next_ = 0;
-        element->prev_ = 0;
+        element->list_ = nullptr;
+        element->next_ = nullptr;
+        element->prev_ = nullptr;
         --this->size_;
     }
Index: code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.h	(revision 11054)
@@ -57,5 +57,5 @@
                 @param objectBase The object to store
             */
-            ObjectListBaseElement(Listable* object) : next_(0), prev_(0), objectBase_(object), list_(0) {}
+            ObjectListBaseElement(Listable* object) : next_(nullptr), prev_(nullptr), objectBase_(object), list_(nullptr) {}
             virtual ~ObjectListBaseElement() { this->removeFromList(); }
 
@@ -82,5 +82,5 @@
             ObjectListElement(T* object) : ObjectListBaseElement(static_cast<Listable*>(object)), object_(object) {}
 
-            virtual void changeContext(Context* oldContext, Context* newContext)
+            virtual void changeContext(Context* oldContext, Context* newContext) override
             {
                 // add object to new context, but only if this element belongs exactly to the old context (and not to a sub-context to avoid re-adding objects
@@ -104,5 +104,6 @@
     {
         public:
-            virtual ~ObjectListElementRemovalListener() {}
+            ObjectListElementRemovalListener() = default;
+            virtual ~ObjectListElementRemovalListener() = default;
             virtual void removedElement(ObjectListBaseElement* element) = 0;
     };
@@ -136,9 +137,9 @@
             inline ObjectListBaseElement* begin() const { return this->first_; }
             /// Returns a pointer to the element after the last element in the list. Works only with Iterator.
-            inline ObjectListBaseElement* end() const { return 0; }
+            inline ObjectListBaseElement* end() const { return nullptr; }
             /// Returns a pointer to the last element in the list. Works only with Iterator.
             inline ObjectListBaseElement* rbegin() const { return this->last_; }
             /// Returns a pointer to the element in front of the first element in the list. Works only with Iterator.
-            inline ObjectListBaseElement* rend() const { return 0; }
+            inline ObjectListBaseElement* rend() const { return nullptr; }
 
             inline void registerRemovalListener(ObjectListElementRemovalListener* listener) { this->listeners_.push_back(listener); }
Index: code/branches/cpp11_v3/src/libraries/core/object/ObjectListIterator.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/ObjectListIterator.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/ObjectListIterator.h	(revision 11054)
@@ -41,5 +41,6 @@
     Usage:
     @code
-    for (ObjectListIterator<myClass> it = ObjectList<myClass>::begin(); it != ObjectList<myClass>::end(); ++it)
+    ObjectList<myClass> list;
+    for (ObjectListIterator<myClass> it = list.begin(); it != list.end(); ++it)
     {
         it->someFunction(...);
@@ -68,5 +69,5 @@
     */
     template <class T>
-    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T> >
+    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T>>
     {
         public:
@@ -74,5 +75,5 @@
                 @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
             */
-            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >() {}
+            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T>>() {}
 
             /**
@@ -80,5 +81,5 @@
                 @param element The element to start with
             */
-            inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T> >(element) {}
+            inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T>>(element) {}
 
             /**
@@ -86,5 +87,6 @@
                 @param other The other ObjectListIterator
             */
-            inline ObjectListIterator(const IteratorBase<T, ObjectListIterator<T> >& other) : IteratorBase<T, ObjectListIterator<T> >(other) {}
+            template <class OI>
+            inline ObjectListIterator(const IteratorBase<T, OI>& other) : IteratorBase<T, ObjectListIterator<T>>(other) {}
 
             /**
Index: code/branches/cpp11_v3/src/libraries/core/object/StrongPtr.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/StrongPtr.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/StrongPtr.h	(revision 11054)
@@ -43,5 +43,5 @@
     orxonox::StrongPtr is an implementation of a smart pointer - it wraps a pointer to an
     object  and keeps this object alive until no StrongPtr points to this object anymore.
-    In contrast to orxonox::SharedPtr, StrongPtr works only with classes that are derived
+    In contrast to std::shared_ptr, StrongPtr works only with classes that are derived
     from orxonox::Destroyable, because it's an intrusive implementation, meaning the
     reference counter is stored in the object itself.
@@ -51,5 +51,5 @@
     at any time and also convert it back to a normal pointer if you like. This is possible
     because the reference counter is stored in the object itself and not in StrongPtr (in
-    contrast to SharedPtr).
+    contrast to std::shared_ptr).
 
     @b Important: If you want to delete an object, you must not use @c delete @c object but
@@ -138,5 +138,5 @@
         public:
             /// Constructor: Initializes the strong pointer with a null pointer.
-            inline StrongPtr() : pointer_(0), base_(0)
+            inline StrongPtr() : pointer_(nullptr), base_(nullptr)
             {
             }
@@ -158,5 +158,5 @@
             /// Copy-constructor for strong pointers to objects of another class.
             template <class O>
-            inline StrongPtr(const StrongPtr<O>& other) : pointer_(other.get()), base_(other.base_)
+            inline StrongPtr(const StrongPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
             {
                 if (this->base_)
@@ -172,4 +172,11 @@
             }
 
+            /// Move-constructor
+            inline StrongPtr(StrongPtr&& other) : pointer_(other.pointer_), base_(other.base_)
+            {
+                other.pointer_ = nullptr;
+                other.base_ = nullptr;
+            }
+
             /// Destructor: Decrements the reference counter.
             inline ~StrongPtr()
@@ -187,7 +194,7 @@
 
             /// Assigns the wrapped pointer of another StrongPtr.
-            inline StrongPtr& operator=(const StrongPtr& other)
-            {
-                StrongPtr(other).swap(*this);
+            inline StrongPtr& operator=(StrongPtr other)
+            {
+                other.swap(*this);
                 return *this;
             }
@@ -230,5 +237,5 @@
             inline T* operator->() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return this->pointer_;
             }
@@ -237,12 +244,12 @@
             inline T& operator*() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return *this->pointer_;
             }
 
-            /// Returns true if the wrapped pointer is NULL.
-            inline bool operator!() const
-            {
-                return (this->pointer_ == 0);
+            /// Returns true if the pointer is not nullptr.
+            inline explicit operator bool() const
+            {
+                return (this->pointer_ != nullptr);
             }
 
@@ -262,5 +269,5 @@
             }
 
-            /// Resets the strong pointer (equivalent to assigning a NULL pointer).
+            /// Resets the strong pointer (equivalent to assigning a nullptr).
             inline void reset()
             {
Index: code/branches/cpp11_v3/src/libraries/core/object/WeakPtr.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/object/WeakPtr.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/object/WeakPtr.h	(revision 11054)
@@ -37,5 +37,5 @@
 
     A WeakPtr wraps a pointer to an object. If the object gets deleted, the WeakPtr becomes
-    NULL. This can be used to store pointers to objects without knowing when they will be
+    nullptr. This can be used to store pointers to objects without knowing when they will be
     destroyed.
 
@@ -50,10 +50,10 @@
     WeakPtr<MyClass> pointer = object;                  // create a WeakPtr and assign the object
 
-    if (pointer)                                        // checks if pointer is not NULL (which is true)
+    if (pointer)                                        // checks if pointer is not nullptr (which is true)
         pointer->someFunction();                        // calls MyClass::someFunction()
 
     object->destroy();                                  // calls destroy() which deletes the object
 
-    if (pointer)                                        // checks if pointer is not NULL (which is now false)
+    if (pointer)                                        // checks if pointer is not nullptr (which is now false)
         pointer->someFunction();                        // this will not be executed
     @endcode
@@ -91,5 +91,5 @@
 {
     /**
-        @brief WeakPtr wraps a pointer to an object, which becomes NULL if the object is deleted.
+        @brief WeakPtr wraps a pointer to an object, which becomes nullptr if the object is deleted.
 
         @see See @ref WeakPtrExample "this description" for more information and an example.
@@ -100,10 +100,10 @@
         public:
             /// Constructor: Initializes the weak pointer with a null pointer.
-            inline WeakPtr() : pointer_(0), base_(0), callback_(0)
+            inline WeakPtr() : pointer_(nullptr), base_(nullptr), callback_(nullptr)
             {
             }
 
             /// Constructor: Initializes the weak pointer with a pointer to an object.
-            inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
+            inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(nullptr)
             {
                 this->registerAsDestructionListener(this->base_);
@@ -111,5 +111,5 @@
 
             /// Copy-constructor
-            inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(0)
+            inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(nullptr)
             {
                 this->registerAsDestructionListener(this->base_);
@@ -118,5 +118,5 @@
             /// Copy-constructor for weak pointers to objects of another class.
             template <class O>
-            inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.base_), callback_(0)
+            inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase()), callback_(nullptr)
             {
                 this->registerAsDestructionListener(this->base_);
@@ -124,5 +124,5 @@
 
             /// Destructor
-            inline virtual ~WeakPtr()
+            virtual inline ~WeakPtr()
             {
                 this->unregisterAsDestructionListener(this->base_);
@@ -137,7 +137,7 @@
 
             /// Assigns the wrapped pointer of another WeakPtr.
-            inline WeakPtr& operator=(const WeakPtr& other)
-            {
-                WeakPtr(other).swap(*this);
+            inline WeakPtr& operator=(WeakPtr other)
+            {
+                other.swap(*this);
                 return *this;
             }
@@ -172,5 +172,5 @@
             inline T* operator->() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return this->pointer_;
             }
@@ -179,12 +179,12 @@
             inline T& operator*() const
             {
-                assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return *this->pointer_;
             }
 
-            /// Returns true if the wrapped pointer is NULL.
-            inline bool operator!() const
-            {
-                return (this->pointer_ == 0);
+            /// Returns true if the pointer is not nullptr.
+            inline explicit operator bool() const
+            {
+                return (this->pointer_ != nullptr);
             }
 
@@ -210,5 +210,5 @@
             }
 
-            /// Resets the weak pointer (equivalent to assigning a NULL pointer).
+            /// Resets the weak pointer (equivalent to assigning a nullptr).
             inline void reset()
             {
@@ -230,8 +230,8 @@
         private:
             /// Will be called by Destroyable::~Destroyable() if the stored object is deleted. Resets the wrapped pointer and executes the callback.
-            inline void objectDeleted()
-            {
-                this->base_ = 0;
-                this->pointer_ = 0;
+            virtual inline void objectDeleted() override
+            {
+                this->base_ = nullptr;
+                this->pointer_ = nullptr;
                 if (this->callback_)
                     (*this->callback_)();
Index: code/branches/cpp11_v3/src/libraries/core/singleton/Scope.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/singleton/Scope.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/singleton/Scope.h	(revision 11054)
@@ -72,5 +72,5 @@
         protected:
             ScopeListener() : bActivated_(false) { }
-            virtual ~ScopeListener() { }
+            virtual ~ScopeListener() = default;
 
             //! Gets called if the scope is activated
Index: code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.cc	(revision 11054)
@@ -38,5 +38,5 @@
 namespace orxonox
 {
-    ScopeManager* ScopeManager::singletonPtr_s = 0;
+    ScopeManager* ScopeManager::singletonPtr_s = nullptr;
 
     void ScopeManager::addScope(ScopeID::Value scope)
@@ -73,12 +73,12 @@
     void ScopeManager::activateListenersForScope(ScopeID::Value scope)
     {
-        for (std::set<ScopeListener*>::iterator it = this->listeners_[scope].begin(); it != this->listeners_[scope].end(); ++it)
-            this->activateListener(*it);
+        for (ScopeListener* listener : this->listeners_[scope])
+            this->activateListener(listener);
     }
 
     void ScopeManager::deactivateListenersForScope(ScopeID::Value scope)
     {
-        for (std::set<ScopeListener*>::iterator it = this->listeners_[scope].begin(); it != this->listeners_[scope].end(); ++it)
-            this->deactivateListener(*it);
+        for (ScopeListener* listener : this->listeners_[scope])
+            this->deactivateListener(listener);
     }
 
Index: code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.h	(revision 11054)
@@ -83,5 +83,5 @@
 
             std::set<ScopeID::Value> activeScopes_;
-            std::map<ScopeID::Value, std::set<ScopeListener*> > listeners_; //!< Stores all listeners for a scope
+            std::map<ScopeID::Value, std::set<ScopeListener*>> listeners_; //!< Stores all listeners for a scope
 
             static ScopeManager* singletonPtr_s;
Index: code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonIncludes.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonIncludes.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonIncludes.h	(revision 11054)
@@ -71,5 +71,5 @@
 */
 #define ManageScopedSingleton(className, scope, allowedToFail) \
-    className* className::singletonPtr_s = NULL; \
+    className* className::singletonPtr_s = nullptr; \
     static ScopedSingletonWrapper& className##ScopedSingletonWrapper \
         = (new orxonox::SI_SSW(new ClassScopedSingletonWrapper<className, allowedToFail>(#className), scope))->getWrapper()
@@ -87,6 +87,6 @@
             ~StaticallyInitializedScopedSingletonWrapper() { delete wrapper_; }
 
-            virtual void load();
-            virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
 
             inline ScopedSingletonWrapper& getWrapper()
Index: code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonWrapper.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonWrapper.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonWrapper.h	(revision 11054)
@@ -64,5 +64,5 @@
                 : className_(className)
             { }
-            virtual ~ScopedSingletonWrapper() { }
+            virtual ~ScopedSingletonWrapper() = default;
 
         protected:
@@ -91,5 +91,5 @@
         ClassScopedSingletonWrapper(const std::string& className)
             : ScopedSingletonWrapper(className)
-            , singletonPtr_(NULL)
+            , singletonPtr_(nullptr)
         {
         }
@@ -102,16 +102,16 @@
 
         //! Called if the Scope of the Singleton gets active (creates the instance)
-        void activated()
+        virtual void activated() override
         {
-            assert(singletonPtr_ == NULL);
+            assert(singletonPtr_ == nullptr);
             singletonPtr_ = new T();
         }
 
         //! Called if the Scope of this Singleton gets deactivated (destroys the instance)
-        void deactivated()
+        virtual void deactivated() override
         {
-            assert(singletonPtr_ != NULL);
+            assert(singletonPtr_ != nullptr);
             this->destroy(singletonPtr_);
-            singletonPtr_ = NULL;
+            singletonPtr_ = nullptr;
         }
 
@@ -146,5 +146,5 @@
         ClassScopedSingletonWrapper(const std::string& className)
             : ScopedSingletonWrapper(className)
-            , singletonPtr_(NULL)
+            , singletonPtr_(nullptr)
         {
         }
@@ -157,7 +157,7 @@
 
         //! Called if the Scope of the Singleton gets active (creates the instance)
-        void activated()
+        virtual void activated() override
         {
-            assert(singletonPtr_ == NULL);
+            assert(singletonPtr_ == nullptr);
             try
                 { singletonPtr_ = new T(); }
@@ -169,10 +169,10 @@
 
         //! Called if the Scope of this Singleton gets deactivated (destroys the instance)
-        void deactivated()
+        virtual void deactivated() override
         {
-            if (singletonPtr_ != NULL)
+            if (singletonPtr_ != nullptr)
             {
                 this->destroy(singletonPtr_);
-                singletonPtr_ = NULL;
+                singletonPtr_ = nullptr;
             }
         }
Index: code/branches/cpp11_v3/src/libraries/network/Client.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/Client.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/Client.cc	(revision 11054)
@@ -161,8 +161,7 @@
         {
           std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-          std::vector<packet::Gamestate*>::iterator it;
-          for( it = gamestates.begin(); it != gamestates.end(); ++it )
+          for( packet::Gamestate* gamestate : gamestates )
           {
-            (*it)->send( static_cast<Host*>(this) );
+            gamestate->send( static_cast<Host*>(this) );
           }
         }
Index: code/branches/cpp11_v3/src/libraries/network/Client.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/Client.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/Client.h	(revision 11054)
@@ -76,20 +76,20 @@
     static Client* getInstance(){ return singletonPtr_s; } // tolua_export
 
-    bool establishConnection();
+    virtual bool establishConnection() override;
     void setDestination( const std::string& serverAddress, unsigned int port ); // tolua_export
-    bool closeConnection();
-    void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID);
-    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
-    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void printRTT();
+    virtual bool closeConnection() override;
+    virtual void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID) override;
+    virtual bool sendPacket( packet::Packet* packet ) override{ return packet->send( static_cast<Host*>(this) ); }
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void printRTT() override;
 
     void update(const Clock& time);
   protected:
-    virtual void connectionClosed();
+    virtual void connectionClosed() override;
   private:
     Client(const Client& copy); // not used
-    virtual bool isServer_(){return false;}
-    void processPacket(packet::Packet* packet);
+    virtual bool isServer_() override{return false;}
+    virtual void processPacket(packet::Packet* packet) override;
 
     static Client* singletonPtr_s;
Index: code/branches/cpp11_v3/src/libraries/network/ClientConnection.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/ClientConnection.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/ClientConnection.cc	(revision 11054)
@@ -44,5 +44,5 @@
     Connection(NETWORK_PEER_ID_SERVER),
     established_(false),
-    server_(NULL)
+    server_(nullptr)
   {
     this->serverAddress_ = new ENetAddress();
@@ -72,9 +72,9 @@
 
     // create host
-    this->host_ = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
+    this->host_ = enet_host_create(nullptr, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     
-    if ( this->host_ == NULL )
+    if ( this->host_ == nullptr )
     {
-      orxout(internal_error, context::network) << "ClientConnection: host_ == NULL" << endl;
+      orxout(internal_error, context::network) << "ClientConnection: host_ == nullptr" << endl;
       // error handling
       return false;
@@ -93,7 +93,7 @@
 
     this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CHANNEL_COUNT, 0);
-    if ( this->server_==NULL )
+    if ( this->server_==nullptr )
     {
-      orxout(internal_error, context::network) << "ClientConnection: server_ == NULL" << endl;
+      orxout(internal_error, context::network) << "ClientConnection: server_ == nullptr" << endl;
       // error handling
       return false;
Index: code/branches/cpp11_v3/src/libraries/network/ClientConnection.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/ClientConnection.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/ClientConnection.h	(revision 11054)
@@ -57,6 +57,6 @@
     uint32_t getRTT();
   private:
-    virtual void addPeer(uint32_t peerID);
-    virtual void removePeer(uint32_t peerID);
+    virtual void addPeer(uint32_t peerID) override;
+    virtual void removePeer(uint32_t peerID) override;
 
     bool disconnectConnection();
Index: code/branches/cpp11_v3/src/libraries/network/ClientConnectionListener.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/ClientConnectionListener.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/ClientConnectionListener.cc	(revision 11054)
@@ -44,12 +44,12 @@
     void ClientConnectionListener::broadcastClientConnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientConnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientConnected(clientID);
     }
 
     void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientDisconnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientDisconnected(clientID);
     }
 
Index: code/branches/cpp11_v3/src/libraries/network/Connection.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/Connection.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/Connection.cc	(revision 11054)
@@ -46,5 +46,5 @@
 
   Connection::Connection(uint32_t firstPeerID):
-    host_(0), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
+    host_(nullptr), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
   {
     enet_initialize();
@@ -81,5 +81,5 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, 0, 0 };
+    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -91,5 +91,5 @@
   void Connection::disconnectPeers()
   {
-    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, 0, 0 };
+    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -237,8 +237,7 @@
   void Connection::disconnectPeersInternal()
   {
-    std::map<uint32_t, ENetPeer*>::iterator it;
-    for( it=this->peerMap_.begin(); it!=this->peerMap_.end(); ++it )
-    {
-      enet_peer_disconnect(it->second, 0);
+    for( const auto& mapEntry : this->peerMap_ )
+    {
+      enet_peer_disconnect(mapEntry.second, 0);
     }
     uint32_t iterations = NETWORK_DISCONNECT_TIMEOUT/NETWORK_WAIT_TIMEOUT;
@@ -323,5 +322,5 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, 0 };
+    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, nullptr };
     return inEvent;
   }
@@ -338,5 +337,5 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, 0 };
+    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, nullptr };
     return inEvent;
   }
Index: code/branches/cpp11_v3/src/libraries/network/Connection.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/Connection.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/Connection.h	(revision 11054)
@@ -46,5 +46,4 @@
 #include <map>
 #include <enet/enet.h>
-#include <boost/concept_check.hpp>
 
 namespace boost
Index: code/branches/cpp11_v3/src/libraries/network/FunctionCall.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/FunctionCall.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/FunctionCall.cc	(revision 11054)
@@ -48,5 +48,5 @@
 bool FunctionCall::execute(){
   NetworkFunctionBase* fct = NetworkFunctionManager::getInstance().getFunctionByNetworkId( this->functionID_ );
-  assert( fct != NULL );
+  assert( fct != nullptr );
   assert( this->nrOfArguments_==this->arguments_.size() );
   switch(this->nrOfArguments_)
@@ -119,5 +119,5 @@
   for( unsigned int i=0; i<this->nrOfArguments_; ++i )
   {
-    this->arguments_.push_back(MultiType());
+    this->arguments_.emplace_back();
     this->arguments_.back().importData(mem);
   }
@@ -131,7 +131,7 @@
   *(uint32_t*)(mem+2*sizeof(uint32_t)) = this->objectID_;
   mem += 3*sizeof(uint32_t);
-  for( std::vector<MultiType>::iterator it = this->arguments_.begin(); it!=this->arguments_.end(); ++it )
+  for(const MultiType& argument : this->arguments_)
   {
-    it->exportData( mem );
+    argument.exportData( mem );
   }
 }
Index: code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.cc	(revision 11054)
@@ -37,5 +37,5 @@
 
 std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sPeerMap_;
-std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > > FunctionCallManager::sIncomingFunctionCallBuffer_;
+std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>> FunctionCallManager::sIncomingFunctionCallBuffer_;
 
 
@@ -54,9 +54,8 @@
 void FunctionCallManager::sendCalls(orxonox::Host* host)
 {
-  std::map<uint32_t, packet::FunctionCalls*>::iterator it;
-  for (it = FunctionCallManager::sPeerMap_.begin(); it != FunctionCallManager::sPeerMap_.end(); ++it )
+  for (const auto& mapEntry : FunctionCallManager::sPeerMap_ )
   {
     assert(!FunctionCallManager::sPeerMap_.empty());
-    it->second->send(host);
+    mapEntry.second->send(host);
   }
   FunctionCallManager::sPeerMap_.clear();
@@ -65,10 +64,10 @@
 void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall, uint32_t minGamestateID, uint32_t peerID)
 {
-  FunctionCallManager::sIncomingFunctionCallBuffer_.push_back( std::make_pair(fctCall, std::make_pair(minGamestateID, peerID)));
+  FunctionCallManager::sIncomingFunctionCallBuffer_.emplace_back(fctCall, std::make_pair(minGamestateID, peerID));
 }
 
 void FunctionCallManager::processBufferedFunctionCalls()
 {
-  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > >::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
+  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
   while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
   {
Index: code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/FunctionCallManager.h	(revision 11054)
@@ -54,5 +54,5 @@
 
   static std::map<uint32_t, packet::FunctionCalls*>                           sPeerMap_;
-  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t> > > sIncomingFunctionCallBuffer_;
+  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t>>> sIncomingFunctionCallBuffer_;
 protected:
   FunctionCallManager();
Index: code/branches/cpp11_v3/src/libraries/network/GamestateHandler.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/GamestateHandler.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/GamestateHandler.cc	(revision 11054)
@@ -32,5 +32,5 @@
 namespace orxonox {
 
-// GamestateHandler *GamestateHandler::instance_=0;
+// GamestateHandler *GamestateHandler::instance_=nullptr;
 
 GamestateHandler::GamestateHandler()
Index: code/branches/cpp11_v3/src/libraries/network/GamestateManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/GamestateManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/GamestateManager.cc	(revision 11054)
@@ -60,5 +60,5 @@
 { 
   GamestateManager::GamestateManager() :
-  currentGamestate_(0), id_(0)
+  currentGamestate_(nullptr), id_(0)
   {
 //     trafficControl_ = new TrafficControl();
@@ -70,13 +70,11 @@
   {
     if( this->currentGamestate_ )
-        delete this->currentGamestate_;std::map<unsigned int, packet::Gamestate*>::iterator it;
-    for( it = gamestateQueue.begin(); it != gamestateQueue.end(); ++it )
-      delete it->second;
-    std::map<uint32_t, peerInfo>::iterator peerIt;
-    std::map<uint32_t, packet::Gamestate*>::iterator gamestateIt;
-    for( peerIt = peerMap_.begin(); peerIt != peerMap_.end(); ++peerIt )
-    {
-      for( gamestateIt = peerIt->second.gamestates.begin(); gamestateIt != peerIt->second.gamestates.end(); ++gamestateIt )
-        delete gamestateIt->second;
+        delete this->currentGamestate_;
+    for( const auto& mapEntry : gamestateQueue )
+      delete mapEntry.second;
+    for( const auto& mapEntryPeer : peerMap_ )
+    {
+      for( const auto& mapEntryGamestate : mapEntryPeer.second.gamestates )
+        delete mapEntryGamestate.second;
     }
 //     this->trafficControl_->destroy();
@@ -107,11 +105,10 @@
     if( this->gamestateQueue.empty() )
         return true;
-    std::map<unsigned int, packet::Gamestate*>::iterator it;
     // now push only the most recent gamestates we received (ignore obsolete ones)
-    for(it = gamestateQueue.begin(); it!=gamestateQueue.end(); it++)
-    {
-      OrxVerify(processGamestate(it->second), "ERROR: could not process Gamestate");
-      sendAck( it->second->getID(), it->second->getPeerID() );
-      delete it->second;
+    for(const auto& mapEntry : gamestateQueue)
+    {
+      OrxVerify(processGamestate(mapEntry.second), "ERROR: could not process Gamestate");
+      sendAck( mapEntry.second->getID(), mapEntry.second->getPeerID() );
+      delete mapEntry.second;
     }
     // now clear the queue
@@ -140,5 +137,5 @@
 
   bool GamestateManager::getSnapshot(){
-    if ( currentGamestate_ != 0 )
+    if ( currentGamestate_ != nullptr )
       delete currentGamestate_;
     uint8_t gsMode;
@@ -165,5 +162,5 @@
     { //we have no data to send
       delete currentGamestate_;
-      currentGamestate_=0;
+      currentGamestate_=nullptr;
       return false;
     }
@@ -177,19 +174,18 @@
     std::vector<packet::Gamestate*> peerGamestates;
     
-    std::map<uint32_t, peerInfo>::iterator peerIt;
-    for( peerIt=peerMap_.begin(); peerIt!=peerMap_.end(); ++peerIt )
-    {
-      if( !peerIt->second.isSynched )
+    for( const auto& mapEntry : peerMap_ )
+    {
+      if( !mapEntry.second.isSynched )
       {
         orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
         continue;
       }
-      orxout(verbose_more, context::network) << "client id: " << peerIt->first << endl;
+      orxout(verbose_more, context::network) << "client id: " << mapEntry.first << endl;
       orxout(verbose_more, context::network) << "Server: doing gamestate gamestate preparation" << endl;
-      int peerID = peerIt->first; //get client id
-
-      unsigned int lastAckedGamestateID = peerIt->second.lastAckedGamestateID;
-
-      packet::Gamestate* baseGamestate=0;
+      int peerID = mapEntry.first; //get client id
+
+      unsigned int lastAckedGamestateID = mapEntry.second.lastAckedGamestateID;
+
+      packet::Gamestate* baseGamestate=nullptr;
       if(lastAckedGamestateID != GAMESTATEID_INITIAL)
       {
@@ -200,7 +196,7 @@
       }
 
-      peerGamestates.push_back(0);  // insert an empty gamestate* to be changed
+      peerGamestates.push_back(nullptr);  // insert an empty gamestate* to be changed
       finishGamestate( peerID, peerGamestates.back(), baseGamestate, currentGamestate_ );
-      if( peerGamestates.back()==0 )
+      if( peerGamestates.back()==nullptr )
         // nothing to send to remove pointer from vector
         peerGamestates.pop_back();
@@ -243,5 +239,5 @@
       {
         delete diffed1;
-        destgamestate = 0;
+        destgamestate = nullptr;
         return;
       }
@@ -340,8 +336,7 @@
   {
     assert(peerMap_.find(peerID)!=peerMap_.end());
-    std::map<uint32_t, packet::Gamestate*>::iterator peerIt;
-    for( peerIt = peerMap_[peerID].gamestates.begin(); peerIt!=peerMap_[peerID].gamestates.end(); ++peerIt )
-    {
-      delete peerIt->second;
+    for( const auto& mapEntry : peerMap_[peerID].gamestates )
+    {
+      delete mapEntry.second;
     }
     peerMap_.erase(peerMap_.find(peerID));
@@ -351,5 +346,5 @@
 //   void GamestateManager::removeClient(ClientInformation* client){
 //     assert(client);
-//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>>::iterator clientMap = gamestateMap_.find(client->getID());
 //     // first delete all remained gamestates
 //     std::map<unsigned int, packet::Gamestate*>::iterator it;
Index: code/branches/cpp11_v3/src/libraries/network/GamestateManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/GamestateManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/GamestateManager.h	(revision 11054)
@@ -47,5 +47,4 @@
 #include "core/CorePrereqs.h"
 #include "packet/Gamestate.h"
-#include <boost/concept_check.hpp>
 
 namespace orxonox
@@ -84,8 +83,8 @@
     ~GamestateManager();
 
-    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int peerID);
-    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int peerID);
-    virtual uint32_t  getLastReceivedGamestateID( unsigned int peerID );
-    virtual uint32_t  getCurrentGamestateID(){ if( currentGamestate_) return currentGamestate_->getID(); else return GAMESTATEID_INITIAL; }
+    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int peerID) override;
+    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int peerID) override;
+    virtual uint32_t  getLastReceivedGamestateID( unsigned int peerID ) override;
+    virtual uint32_t  getCurrentGamestateID() override{ if( currentGamestate_) return currentGamestate_->getID(); else return GAMESTATEID_INITIAL; }
 
     bool processGamestates();
@@ -108,5 +107,5 @@
     bool processGamestate(packet::Gamestate *gs);
 
-//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> > gamestateMap_;
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>> gamestateMap_;
     std::map<unsigned int, packet::Gamestate*> gamestateQueue;
 //     std::map<unsigned int, uint32_t> lastProcessedGamestateID_;
Index: code/branches/cpp11_v3/src/libraries/network/Host.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/Host.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/Host.cc	(revision 11054)
@@ -44,5 +44,5 @@
   SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
 
-  // Host*               Host::instance_=0;
+  // Host*               Host::instance_=nullptr;
   uint32_t            Host::clientID_s=0;
 //   uint32_t            Host::shipID_s=-1;
@@ -54,5 +54,5 @@
   Host::Host()
   {
-  //   assert(instance_==0);
+  //   assert(instance_==nullptr);
     instances_s.push_back(this);
     ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
@@ -62,5 +62,5 @@
 
   /**
-  * @brief Destructor: resets the instance pointer to 0
+  * @brief Destructor: resets the instance pointer to nullptr
   */
   Host::~Host()
@@ -68,5 +68,5 @@
     assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
     instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
-    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
+    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(nullptr);
   }
 
@@ -80,9 +80,9 @@
   void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
   {
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+    for(Host* host : instances_s)
     {
-      if( (*it)->isActive() )
+      if( host->isActive() )
       {
-        (*it)->queuePacket(packet, clientID, channelID);
+        host->queuePacket(packet, clientID, channelID);
       }
     }
@@ -97,7 +97,7 @@
   void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
-      if( (*it)->isActive() )
-        (*it)->doSendChat(message, sourceID, targetID);
+    for(Host* host : instances_s)
+      if( host->isActive() )
+        host->doSendChat(message, sourceID, targetID);
   }
 
@@ -107,6 +107,6 @@
   void Host::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for (ObjectList<NetworkChatListener>::iterator it = ObjectList<NetworkChatListener>::begin(); it != ObjectList<NetworkChatListener>::end(); ++it)
-      it->incomingChat(message, sourceID);
+    for (NetworkChatListener* listener : ObjectList<NetworkChatListener>())
+      listener->incomingChat(message, sourceID);
   }
 
@@ -114,9 +114,9 @@
   bool Host::isServer()
   {
-    for (std::vector<Host*>::iterator it=instances_s.begin(); it!=instances_s.end(); ++it )
+    for (Host* host : instances_s)
     {
-      if( (*it)->isActive() )
+      if( host->isActive() )
       {
-        if( (*it)->isServer_() )
+        if( host->isServer_() )
           return true;
       }
@@ -135,5 +135,5 @@
         ++it;
     }
-    return 0;
+    return nullptr;
   }
 
Index: code/branches/cpp11_v3/src/libraries/network/LANDiscoverable.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/LANDiscoverable.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/LANDiscoverable.cc	(revision 11054)
@@ -46,5 +46,5 @@
   RegisterClassNoArgs(LANDiscoverable);
 
-  LANDiscoverable::LANDiscoverable() : bActive_(false), host_(0)
+  LANDiscoverable::LANDiscoverable() : bActive_(false), host_(nullptr)
   {
     /* register object in orxonox */
@@ -82,13 +82,13 @@
       bindAddress.host = ENET_HOST_ANY;
       bindAddress.port = LAN_DISCOVERY_PORT;
-      assert( this->host_ == 0 );
+      assert( this->host_ == nullptr );
       this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
-      if ( this->host_ == NULL )
-          orxout(internal_error, context::network) << "LANDiscoverable: host_ == NULL" << endl;
+      if ( this->host_ == nullptr )
+          orxout(internal_error, context::network) << "LANDiscoverable: host_ == nullptr" << endl;
     }
     else
     {
       enet_host_destroy( this->host_ );
-      this->host_ = 0;
+      this->host_ = nullptr;
     }
       this->bActive_ = bActive;
Index: code/branches/cpp11_v3/src/libraries/network/LANDiscovery.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/LANDiscovery.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/LANDiscovery.cc	(revision 11054)
@@ -42,12 +42,12 @@
   LANDiscovery::LANDiscovery()
   {
-    this->host_ = enet_host_create(NULL, 10, 0, 0, 0 );
-    if ( this->host_ == NULL )
-        orxout(internal_error, context::network) << "LANDiscovery: host_ == NULL" << endl;
+    this->host_ = enet_host_create(nullptr, 10, 0, 0, 0 );
+    if ( this->host_ == nullptr )
+        orxout(internal_error, context::network) << "LANDiscovery: host_ == nullptr" << endl;
   }
 
   LANDiscovery::~LANDiscovery()
   {
-    if (this->host_ != NULL)
+    if (this->host_ != nullptr)
       enet_host_destroy(this->host_);
   }
@@ -65,5 +65,5 @@
     address.host = ENET_HOST_BROADCAST;
     peer = enet_host_connect(this->host_, &address, 0, 0);
-    if (peer == NULL)
+    if (peer == nullptr)
         orxout(internal_error, context::network) << "Could not send LAN discovery to IPv4 Broadcast." << endl;
 
@@ -71,5 +71,5 @@
     enet_address_set_host(&address, "ff02::1"); // TODO: use a multicast group
     peer = enet_host_connect(this->host_, &address, 0, 0);
-    if (peer == NULL)
+    if (peer == nullptr)
         orxout(internal_error, context::network) << "Could not send LAN discovery to IPv6 Multicast." << endl;
 
Index: code/branches/cpp11_v3/src/libraries/network/MasterServer.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/MasterServer.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/MasterServer.cc	(revision 11054)
@@ -43,5 +43,5 @@
 
   /* forward declaration so the linker doesn't complain */
-  MasterServer *MasterServer::instance = NULL;
+  MasterServer *MasterServer::instance = nullptr;
 
   /* command: list servers */
@@ -49,15 +49,11 @@
   MasterServer::listServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* print list header */
     orxout(user_info) << "List of connected servers" << std::endl;
 
     /* loop through list elements */
-    for( i = MasterServer::getInstance()->mainlist.serverlist.begin();
-      i != MasterServer::getInstance()->mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : MasterServer::getInstance()->mainlist.serverlist )
     {
-      orxout(user_info) << "  " << (*i).ServerInfo.getServerIP() << std::endl;
+      orxout(user_info) << "  " << elem.ServerInfo.getServerIP() << std::endl;
     }
 
@@ -112,17 +108,13 @@
   MasterServer::helper_sendlist( ENetEvent *event )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* packet holder */
     ENetPacket *reply;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     {
       /* send this particular server */
       /* build reply string */
-      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + (*i).ServerInfo.getServerIP().length() + 1 + (*i).ServerInfo.getServerName().length() + 1 + sizeof((*i).ServerInfo.getClientNumber()) + 1;
+      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + elem.ServerInfo.getServerIP().length() + 1 + elem.ServerInfo.getServerName().length() + 1 + sizeof(elem.ServerInfo.getClientNumber()) + 1;
       char *tosend = (char *)calloc(packetlen ,1 );
       if( !tosend )
@@ -131,5 +123,5 @@
       }
       sprintf( tosend, "%s %s %s %u", MSPROTO_SERVERLIST_ITEM,
-          (*i).ServerInfo.getServerIP().c_str(), (*i).ServerInfo.getServerName().c_str(), (*i).ServerInfo.getClientNumber());
+          elem.ServerInfo.getServerIP().c_str(), elem.ServerInfo.getServerName().c_str(), elem.ServerInfo.getClientNumber());
 
       /* create packet from it */
@@ -167,21 +159,17 @@
   MasterServer::helper_cleanupServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     if( mainlist.serverlist.size() == 0 )
       return;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     { /* see if we have a disconnected peer */
-      if( (*i).peer &&
-         ((*i).peer->state == ENET_PEER_STATE_DISCONNECTED ||
-          (*i).peer->state == ENET_PEER_STATE_ZOMBIE ))
+      if( elem.peer &&
+         (elem.peer->state == ENET_PEER_STATE_DISCONNECTED ||
+          elem.peer->state == ENET_PEER_STATE_ZOMBIE ))
       {
         /* Remove it from the list */
-        orxout(internal_warning) << (char*)(*i).peer->data << " timed out.\n";
-        mainlist.delServerByName( (*i).ServerInfo.getServerName() );
+        orxout(internal_warning) << (char*)elem.peer->data << " timed out.\n";
+        mainlist.delServerByName( elem.ServerInfo.getServerName() );
 
         /* stop iterating, we manipulated the list */
@@ -345,5 +333,5 @@
     /***** ENTER MAIN LOOP *****/
     ENetEvent *event = (ENetEvent *)calloc(sizeof(ENetEvent), sizeof(char));
-    if( event == NULL )
+    if( event == nullptr )
     {
       orxout(user_error, context::master_server) << "Could not create ENetEvent structure, exiting." << endl;
Index: code/branches/cpp11_v3/src/libraries/network/MasterServerComm.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/MasterServerComm.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/MasterServerComm.cc	(revision 11054)
@@ -54,5 +54,5 @@
 
     /* initiate the client */
-    this->client = enet_host_create( NULL /* create a client host */,
+    this->client = enet_host_create( nullptr /* create a client host */,
         1,
         2, /* allow up 2 channels to be used, 0 and 1 */
@@ -61,5 +61,5 @@
 
     /* see if it worked */
-    if (this->client == NULL)
+    if (this->client == nullptr)
     { orxout(internal_error, context::master_server) << "An error occurred while trying to create an " 
         << "ENet client host." << endl;
@@ -85,5 +85,5 @@
     this->peer = enet_host_connect(this->client, &this->address, 2, 0);    
 
-    if( this->peer == NULL )
+    if( this->peer == nullptr )
     { orxout(internal_error, context::master_server) << "No available peers for initiating an ENet"
         << " connection." << endl;
@@ -157,5 +157,5 @@
 
     /* address buffer */
-    char *addrconv = NULL;
+    char *addrconv = nullptr;
     int retval = 0;
 
@@ -193,5 +193,5 @@
 
           /* call the supplied callback, if any. */
-          if( listener != NULL )
+          if( listener != nullptr )
             retval = listener->rhandler( addrconv, &(this->event) );
 
Index: code/branches/cpp11_v3/src/libraries/network/NetworkFunction.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/NetworkFunction.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/NetworkFunction.h	(revision 11054)
@@ -45,9 +45,9 @@
 
 #if defined(ORXONOX_COMPILER_GCC) && defined(ORXONOX_ARCH_32)
-static const unsigned int MAX_FUNCTION_POINTER_SIZE = 8;
+static constexpr unsigned int MAX_FUNCTION_POINTER_SIZE = 8;
 #else
-static const unsigned int MAX_FUNCTION_POINTER_SIZE = 16;
+static constexpr unsigned int MAX_FUNCTION_POINTER_SIZE = 16;
 #endif //ORXONOX_COMPILER_GCC
-static const unsigned int MAX_FUNCTION_POINTER_INTS = (MAX_FUNCTION_POINTER_SIZE-1)/4+1;
+static constexpr unsigned int MAX_FUNCTION_POINTER_INTS = (MAX_FUNCTION_POINTER_SIZE-1)/4+1;
 
 struct _NetworkExport NetworkFunctionPointer {
@@ -114,10 +114,10 @@
 
     // ignore the objectID because its a static function
-    virtual bool call(uint32_t objectID){ (*this->functor_)(); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1){ (*this->functor_)(mt1); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2){ (*this->functor_)(mt1, mt2); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3){ (*this->functor_)(mt1, mt2, mt3); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4){ (*this->functor_)(mt1, mt2, mt3, mt4); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5){ (*this->functor_)(mt1, mt2, mt3, mt4, mt5); return true; }
+    virtual bool call(uint32_t objectID) override{ (*this->functor_)(); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1) override{ (*this->functor_)(mt1); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2) override{ (*this->functor_)(mt1, mt2); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3) override{ (*this->functor_)(mt1, mt2, mt3); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4) override{ (*this->functor_)(mt1, mt2, mt3, mt4); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5) override{ (*this->functor_)(mt1, mt2, mt3, mt4, mt5); return true; }
 
   private:
@@ -142,7 +142,7 @@
     { }
 
-    inline bool call(uint32_t objectID)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)));
@@ -152,7 +152,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1);
@@ -162,7 +162,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2);
@@ -172,7 +172,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3);
@@ -182,7 +182,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4);
@@ -192,7 +192,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);
Index: code/branches/cpp11_v3/src/libraries/network/NetworkFunctionIncludes.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/NetworkFunctionIncludes.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/NetworkFunctionIncludes.h	(revision 11054)
@@ -33,5 +33,4 @@
 
 #include <boost/preprocessor/cat.hpp>
-#include <boost/static_assert.hpp>
 
 #include "NetworkFunction.h"
@@ -57,6 +56,6 @@
             ~StaticallyInitializedNetworkFunction() { delete function_; }
 
-            virtual void load();
-            virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
 
             inline NetworkFunctionBase& getFunction()
@@ -72,5 +71,5 @@
     inline NetworkFunctionBase* registerStaticNetworkFunctionFct(PT ptr, const std::string& name)
     {
-        BOOST_STATIC_ASSERT(sizeof(PT) <= sizeof(NetworkFunctionPointer)); // if this fails your compiler uses bigger pointers for static functions than defined above
+        static_assert(sizeof(PT) <= sizeof(NetworkFunctionPointer), "check pointer size"); // if this fails your compiler uses bigger pointers for static functions than defined above
         NetworkFunctionPointer destptr;
         copyPtr(ptr, destptr);
@@ -81,5 +80,5 @@
     inline NetworkFunctionBase* registerMemberNetworkFunctionFct(PT ptr, const std::string& name)
     {
-        BOOST_STATIC_ASSERT(sizeof(PT) <= sizeof(NetworkFunctionPointer)); // if this fails your compiler uses bigger pointers for a specific kind of member functions than defined above
+        static_assert(sizeof(PT) <= sizeof(NetworkFunctionPointer), "check pointer size"); // if this fails your compiler uses bigger pointers for a specific kind of member functions than defined above
         NetworkFunctionPointer destptr;
         copyPtr(ptr, destptr);
Index: code/branches/cpp11_v3/src/libraries/network/NetworkFunctionManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/NetworkFunctionManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/NetworkFunctionManager.cc	(revision 11054)
@@ -32,5 +32,5 @@
 namespace orxonox
 {
-    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = 0;
+    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = nullptr;
 
     void NetworkFunctionManager::registerFunction(NetworkFunctionBase* function)
@@ -71,5 +71,5 @@
             return it->second;
         else
-            return NULL;
+            return nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/network/NetworkPrereqs.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/NetworkPrereqs.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/NetworkPrereqs.h	(revision 11054)
@@ -67,14 +67,14 @@
 namespace orxonox
 {
-  static const unsigned int GAMESTATEID_INITIAL       = static_cast<unsigned int>(-1);
+  static constexpr unsigned int GAMESTATEID_INITIAL       = static_cast<unsigned int>(-1);
   extern const char* LAN_DISCOVERY_MESSAGE;
   extern const char* LAN_DISCOVERY_ACK;
-  static const unsigned int LAN_DISCOVERY_PORT          = 55558;
-  static const unsigned int NETWORK_PEER_ID_SERVER      = 0;
-  static const unsigned int NETWORK_PEER_ID_BROADCAST   = static_cast<unsigned int>(-1);
-  static const unsigned int NETWORK_PEER_ID_UNKNOWN     = static_cast<unsigned int>(-2);
-  static const unsigned int NETWORK_CHANNEL_DEFAULT     = 0;
-  static const unsigned int NETWORK_CHANNEL_UNRELIABLE  = 1;
-  static const unsigned int NETWORK_CHANNEL_COUNT       = 2;
+  static constexpr unsigned int LAN_DISCOVERY_PORT          = 55558;
+  static constexpr unsigned int NETWORK_PEER_ID_SERVER      = 0;
+  static constexpr unsigned int NETWORK_PEER_ID_BROADCAST   = static_cast<unsigned int>(-1);
+  static constexpr unsigned int NETWORK_PEER_ID_UNKNOWN     = static_cast<unsigned int>(-2);
+  static constexpr unsigned int NETWORK_CHANNEL_DEFAULT     = 0;
+  static constexpr unsigned int NETWORK_CHANNEL_UNRELIABLE  = 1;
+  static constexpr unsigned int NETWORK_CHANNEL_COUNT       = 2;
 }
 
Index: code/branches/cpp11_v3/src/libraries/network/NetworkStaticInitializationHandler.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/NetworkStaticInitializationHandler.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/NetworkStaticInitializationHandler.h	(revision 11054)
@@ -39,9 +39,9 @@
     {
         public:
-            virtual void setupHandler();
-            virtual void shutdownHandler();
+            virtual void setupHandler() override;
+            virtual void shutdownHandler() override;
 
-            virtual void loadModule(ModuleInstance* module);
-            virtual void unloadModule(ModuleInstance* module);
+            virtual void loadModule(ModuleInstance* module) override;
+            virtual void unloadModule(ModuleInstance* module) override;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/network/PeerList.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/PeerList.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/PeerList.cc	(revision 11054)
@@ -41,5 +41,5 @@
   PeerList::addPeer( ENetPeer *toadd )
   { /* error correction */
-    if( toadd == NULL )
+    if( toadd == nullptr )
     { orxout(internal_error, context::master_server) << "PeerList::addPeer: empty peer given." << endl;
       return -1;
@@ -65,12 +65,10 @@
   bool
   PeerList::remPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
       { /* found this name, remove and quit */
-        this->peerlist.remove( *i );
+        this->peerlist.remove( peer );
         return true;
       }
@@ -82,15 +80,13 @@
   ENetPeer *
   PeerList::findPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
         /* found this name, remove and quit */
-        return *i;
+        return peer;
 
     /* not found */
-    return NULL;
+    return nullptr;
   }
 
Index: code/branches/cpp11_v3/src/libraries/network/Server.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/Server.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/Server.cc	(revision 11054)
@@ -194,5 +194,5 @@
   void Server::printRTT()
   {
-//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
+//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=nullptr; temp=temp->next() )
 //       orxout(message) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
   }
@@ -232,8 +232,7 @@
   {
     std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-    std::vector<packet::Gamestate*>::iterator it;
-    for( it = gamestates.begin(); it != gamestates.end(); ++it )
+    for( packet::Gamestate* gamestate : gamestates )
     {
-      (*it)->send(static_cast<Host*>(this));
+      gamestate->send(static_cast<Host*>(this));
     }
     return true;
@@ -244,5 +243,5 @@
   {
 //     ClientInformation *temp = ClientInformation::getBegin();
-//     if( temp == NULL )
+//     if( temp == nullptr )
       //no client connected
     if( this->clientIDs_.size()==0 )
@@ -255,5 +254,5 @@
     }
 //     orxout(verbose, context::network) << "sending DeleteObjects" << endl;
-//     while(temp != NULL){
+//     while(temp != nullptr){
 //       if( !(temp->getSynched()) )
 //       {
@@ -434,7 +433,6 @@
       return true;
 
-    std::vector<uint32_t>::iterator it;
-    for( it=this->clientIDs_.begin(); it!=this->clientIDs_.end(); ++it )
-      if( *it == targetID )
+    for( uint32_t id : this->clientIDs_ )
+      if( id == targetID )
         return true;
 
Index: code/branches/cpp11_v3/src/libraries/network/Server.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/Server.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/Server.h	(revision 11054)
@@ -61,9 +61,9 @@
     void open();
     void close();
-    void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID);
-    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
+    virtual void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID) override;
+    virtual bool sendPacket( packet::Packet* packet ) override{ return packet->send( static_cast<Host*>(this) ); }
     void update(const Clock& time);
     unsigned int getRTT(unsigned int clientID);
-    virtual void printRTT();
+    virtual void printRTT() override;
     float getPacketLoss(unsigned int clientID);
     int getClientCount() { return this->clientIDs_.size();}
@@ -73,10 +73,10 @@
     void updateGamestate();
   private:
-    virtual bool isServer_(){return true;}
+    virtual bool isServer_() override{return true;}
     unsigned int playerID(){return 0;}
 
-    void addPeer(uint32_t peerID);
-    void removePeer(uint32_t peerID);
-    void processPacket(packet::Packet* packet);
+    virtual void addPeer(uint32_t peerID) override;
+    virtual void removePeer(uint32_t peerID) override;
+    virtual void processPacket(packet::Packet* packet) override;
 
     bool createClient(int clientID);
@@ -85,6 +85,6 @@
     bool sendObjectDeletes();
     bool isValidTarget(unsigned int targetID);
-    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
     void syncClassid(unsigned int clientID);
 
Index: code/branches/cpp11_v3/src/libraries/network/ServerConnection.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/ServerConnection.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/ServerConnection.cc	(revision 11054)
@@ -73,7 +73,7 @@
     this->host_ = enet_host_create(this->bindAddress_, NETWORK_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     
-    if ( this->host_ == NULL )
+    if ( this->host_ == nullptr )
     {
-        orxout(internal_error, context::network) << "ServerConnection: host_ == NULL" << endl;
+        orxout(internal_error, context::network) << "ServerConnection: host_ == nullptr" << endl;
         return false;
     }
Index: code/branches/cpp11_v3/src/libraries/network/TrafficControl.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/TrafficControl.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/TrafficControl.cc	(revision 11054)
@@ -30,5 +30,5 @@
 
 #include <cassert>
-#include <boost/bind.hpp>
+#include <functional>
 
 #include "core/CoreIncludes.h"
@@ -38,5 +38,6 @@
 namespace orxonox {
 
-  static const unsigned int SCHED_PRIORITY_OFFSET = static_cast<unsigned int>(-1);
+  static constexpr unsigned int SCHED_PRIORITY_OFFSET = static_cast<unsigned int>(-1);
+  namespace arg = std::placeholders;
 
   objInfo::objInfo(uint32_t ID, uint32_t creatorID, int32_t curGsID, int32_t diffGsID, uint32_t size, unsigned int prioperm, unsigned int priosched)
@@ -64,5 +65,5 @@
 *Initializing protected members
 */
-    TrafficControl *TrafficControl::instance_=0;
+    TrafficControl *TrafficControl::instance_=nullptr;
 
     /**
@@ -72,5 +73,5 @@
     {
     RegisterObject(TrafficControl);
-      assert(instance_==0);
+      assert(instance_==nullptr);
       instance_=this;
     this->setConfigValues();
@@ -78,9 +79,9 @@
 
     /**
-    * @brief Destructor: resets the instance pointer to 0
+    * @brief Destructor: resets the instance pointer to nullptr
     */
     TrafficControl::~TrafficControl()
     {
-      instance_=0;
+      instance_=nullptr;
     }
 
@@ -148,5 +149,5 @@
     // shortcut for maps
     std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
-    std::map<unsigned int, std::list<obj> >& objectListTemp = clientListTemp_[clientID];
+    std::map<unsigned int, std::list<obj>>& objectListTemp = clientListTemp_[clientID];
 
     for(itvec = objectListTemp[gamestateID].begin(); itvec != objectListTemp[gamestateID].end(); itvec++)
@@ -180,5 +181,5 @@
     void TrafficControl::insertinClientListPerm(unsigned int clientID, obj objinf)
     {
-      std::map<unsigned int,std::map<unsigned int, objInfo> >::iterator itperm;//iterator clientListPerm over clientIDs
+      std::map<unsigned int,std::map<unsigned int, objInfo>>::iterator itperm;//iterator clientListPerm over clientIDs
     unsigned int gsid=GAMESTATEID_INITIAL, gsdiff=currentGamestateID, prioperm=Synchronisable::getSynchronisable(objinf.objID)->getPriority(), priomom=0;
     clientListPerm_[clientID][objinf.objID] = objInfo(objinf.objID, objinf.objCreatorID,gsid,gsdiff, objinf.objSize,prioperm,priomom);
@@ -258,9 +259,9 @@
 
       //sort copied list according to priorities
-      // use boost bind here because we need to pass a memberfunction to stl sort
-//       sort( list.begin(), list.end(), boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
-      list.sort( boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
-
-//       list.sort(boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
+      // use std::bind here because we need to pass a memberfunction to stl sort
+//       sort( list.begin(), list.end(), std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
+      list.sort( std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
+
+//       list.sort(std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
 
       //now we check, that the creator of an object always exists on a client
@@ -275,6 +276,6 @@
       cut(list, targetSize);
       //now sort again after objDataOffset
-//       sort(list.begin(), list.end(), boost::bind(&TrafficControl::dataSort, this, _1, _2) );
-      list.sort( boost::bind(&TrafficControl::dataSort, this, _1, _2) );
+//       sort(list.begin(), list.end(), std::bind(&TrafficControl::dataSort, this, arg::_1, arg::_2) );
+      list.sort( std::bind(&TrafficControl::dataSort, this, arg::_1, arg::_2) );
 
       //diese Funktion updateClientList muss noch gemacht werden
Index: code/branches/cpp11_v3/src/libraries/network/TrafficControl.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/TrafficControl.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/TrafficControl.h	(revision 11054)
@@ -82,5 +82,5 @@
     *permanent client list: contains client ids, object ids and objectInfos (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, objInfo > > clientListPerm_;
+    std::map<unsigned int, std::map<unsigned int, objInfo >> clientListPerm_;
     //has to be created with constructor and then needs to be updated by evaluateList().
 
@@ -88,5 +88,5 @@
     *temporary client list: contains client ids, gamestate ids and object ids (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, std::list<obj> > > clientListTemp_;
+    std::map<unsigned int, std::map<unsigned int, std::list<obj>>> clientListTemp_;
 
     /**updateReferenceList
@@ -109,6 +109,6 @@
 
     //ClientConnectionListener functions
-    virtual void clientConnected(unsigned int clientID){};
-    virtual void clientDisconnected(unsigned int clientID);
+    virtual void clientConnected(unsigned int clientID) override{};
+    virtual void clientDisconnected(unsigned int clientID) override;
 
 
Index: code/branches/cpp11_v3/src/libraries/network/packet/Acknowledgement.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/Acknowledgement.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/Acknowledgement.h	(revision 11054)
@@ -46,6 +46,6 @@
   ~Acknowledgement();
 
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
   unsigned int getAckID();
Index: code/branches/cpp11_v3/src/libraries/network/packet/Chat.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/Chat.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/Chat.h	(revision 11054)
@@ -49,8 +49,8 @@
 
   /* get size of packet */
-  inline unsigned int getSize() const;
+  virtual inline unsigned int getSize() const override;
 
   /* process chat message packet and remove it afterwards */
-  virtual bool process(orxonox::Host* host);
+  virtual bool process(orxonox::Host* host) override;
 
   /* Get the length of the message (not the full size of the packet) */
Index: code/branches/cpp11_v3/src/libraries/network/packet/ClassID.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/ClassID.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/ClassID.cc	(revision 11054)
@@ -52,11 +52,10 @@
   uint32_t network_id;
   flags_ = flags_ | PACKET_FLAGS_CLASSID;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)
-  std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getInstance().getIdentifierByStringMap().begin();
-  for(;it != IdentifierManager::getInstance().getIdentifierByStringMap().end();++it){
-    id = it->second;
-    if(id == NULL || !id->hasFactory())
+  for(const auto& mapEntry : IdentifierManager::getInstance().getIdentifierByStringMap()){
+    id = mapEntry.second;
+    if(id == nullptr || !id->hasFactory())
       continue;
     const std::string& classname = id->getName();
@@ -144,5 +143,5 @@
     id=ClassByString( std::string((const char*)classname) );
     orxout(internal_info, context::packets) << "processing classid: " << networkID << " name: " << classname << " id: " << id << endl;
-    if(id==NULL){
+    if(id==nullptr){
       orxout(user_error, context::packets) << "Received a bad classname" << endl;
       abort();
Index: code/branches/cpp11_v3/src/libraries/network/packet/ClassID.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/ClassID.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/ClassID.h	(revision 11054)
@@ -47,6 +47,6 @@
   ~ClassID();
 
-  uint32_t getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint32_t getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/branches/cpp11_v3/src/libraries/network/packet/DeleteObjects.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/DeleteObjects.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/DeleteObjects.h	(revision 11054)
@@ -48,6 +48,6 @@
   bool fetchIDs();
 
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/branches/cpp11_v3/src/libraries/network/packet/FunctionCalls.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/FunctionCalls.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/FunctionCalls.h	(revision 11054)
@@ -52,10 +52,10 @@
   ~FunctionCalls();
 
-  inline unsigned int getSize() const
+  virtual inline unsigned int getSize() const override
     { assert(!this->isDataENetAllocated()); return currentSize_; }
-  virtual bool process(orxonox::Host* host);
+  virtual bool process(orxonox::Host* host) override;
 
   void addCall( uint32_t networkID, uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
-  virtual bool send(orxonox::Host* host);
+  virtual bool send(orxonox::Host* host) override;
 private:
   std::queue<orxonox::FunctionCall> functionCalls_;
Index: code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.cc	(revision 11054)
@@ -53,5 +53,5 @@
   uint32_t networkID;
   flags_ = flags_ | PACKET_FLAGS_FUNCTIONIDS;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)
Index: code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/FunctionIDs.h	(revision 11054)
@@ -47,6 +47,6 @@
   ~FunctionIDs();
 
-  virtual uint32_t getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint32_t getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.cc	(revision 11054)
@@ -106,5 +106,5 @@
 {
   uint32_t tempsize=0, currentsize=0;
-  assert(data_==0);
+  assert(data_==nullptr);
   uint32_t size = calcGamestateSize(id, mode);
 
@@ -126,5 +126,5 @@
   mem += GamestateHeader::getSize();
   ObjectList<Synchronisable>::iterator it;
-  for(it = ObjectList<Synchronisable>::begin(); it; ++it)
+  for(it = ObjectList<Synchronisable>().begin(); it; ++it)
   {
 
@@ -133,5 +133,5 @@
     tempsize = it->getData(mem, this->sizes_, id, mode);
     if ( tempsize != 0 )
-      dataVector_.push_back( obj(it->getObjectID(), it->getContextID(), tempsize, mem-data_) );
+      dataVector_.emplace_back(it->getObjectID(), it->getContextID(), tempsize, mem-data_);
 
 #ifndef NDEBUG
@@ -213,14 +213,13 @@
   {
     std::list<uint32_t> v1;
-    ObjectList<Synchronisable>::iterator it;
-    for (it = ObjectList<Synchronisable>::begin(); it != ObjectList<Synchronisable>::end(); ++it)
-    {
-      if (it->getObjectID() == OBJECTID_UNKNOWN)
-      {
-        if (it->objectMode_ != 0x0)
+    for (Synchronisable* synchronisable : ObjectList<Synchronisable>())
+    {
+      if (synchronisable->getObjectID() == OBJECTID_UNKNOWN)
+      {
+        if (synchronisable->objectMode_ != 0x0)
         {
           orxout(user_error, context::packets) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << endl;
           orxout(user_error, context::packets) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << endl;
-          orxout(user_error, context::packets) << "Objects class: " << it->getIdentifier()->getName() << endl;
+          orxout(user_error, context::packets) << "Objects class: " << synchronisable->getIdentifier()->getName() << endl;
           assert(false);
         }
@@ -228,8 +227,7 @@
       else
       {
-        std::list<uint32_t>::iterator it2;
-        for (it2 = v1.begin(); it2 != v1.end(); ++it2)
+        for (uint32_t id : v1)
         {
-          if (it->getObjectID() == *it2)
+          if (synchronisable->getObjectID() == id)
           {
             orxout(user_error, context::packets) << "Found duplicate objectIDs on the client!" << endl
@@ -239,5 +237,5 @@
           }
         }
-        v1.push_back(it->getObjectID());
+        v1.push_back(synchronisable->getObjectID());
       }
     }
@@ -608,5 +606,5 @@
 
   if(dest_length==0)
-    return NULL;
+    return nullptr;
 
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
@@ -645,5 +643,5 @@
 
   if(dest_length==0)
-    return NULL;
+    return nullptr;
 
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
@@ -762,10 +760,8 @@
   uint32_t size = 0;
   uint32_t nrOfVariables = 0;
-    // get the start of the Synchronisable list
-  ObjectList<Synchronisable>::iterator it;
     // get total size of gamestate
-  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
-    size+=it->getSize(id, mode); // size of the actual data of the synchronisable
-    nrOfVariables += it->getNrOfVariables();
+  for(Synchronisable* synchronisable : ObjectList<Synchronisable>()){
+    size+=synchronisable->getSize(id, mode); // size of the actual data of the synchronisable
+    nrOfVariables += synchronisable->getNrOfVariables();
   }
 //   orxout() << "allocating " << nrOfVariables << " ints" << endl;
Index: code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/Gamestate.h	(revision 11054)
@@ -48,11 +48,11 @@
 {
     
-static const uint8_t GAMESTATE_MODE_SERVER = 0x1;
-static const uint8_t GAMESTATE_MODE_CLIENT = 0x2;
+static constexpr uint8_t GAMESTATE_MODE_SERVER = 0x1;
+static constexpr uint8_t GAMESTATE_MODE_CLIENT = 0x2;
 
 class _NetworkExport GamestateHeader
 {
   public:
-    GamestateHeader(){ data_=0; }
+    GamestateHeader(){ data_=nullptr; }
     GamestateHeader(uint8_t* data)
       { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
@@ -138,6 +138,6 @@
 //     void rawDiff( uint8_t* newdata, uint8_t* data, uint8_t* basedata, uint32_t datalength, uint32_t baselength);
 //     inline uint32_t findObject( const SynchronisableHeader& header, uint8_t* mem, uint32_t dataLength, uint32_t startPosition = 0 );
-    virtual uint32_t getSize() const;
-    virtual bool process(orxonox::Host* host);
+    virtual uint32_t getSize() const override;
+    virtual bool process(orxonox::Host* host) override;
     uint32_t calcGamestateSize(uint32_t id, uint8_t mode=0x0);
 //     inline void diffObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes );
Index: code/branches/cpp11_v3/src/libraries/network/packet/Packet.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/Packet.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/Packet.cc	(revision 11054)
@@ -34,5 +34,4 @@
 #define WIN32_LEAN_AND_MEAN
 #include <enet/enet.h>
-#include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
 
@@ -54,7 +53,7 @@
 
 // Make sure we assume the right values
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Reliable)    == static_cast<int>(ENET_PACKET_FLAG_RELIABLE));
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED));
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE));
+static_assert(static_cast<int>(PacketFlag::Reliable)    == static_cast<int>(ENET_PACKET_FLAG_RELIABLE),    "check enum");
+static_assert(static_cast<int>(PacketFlag::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED), "check enum");
+static_assert(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE), "check enum");
 
 #define PACKET_FLAG_DEFAULT PacketFlag::NoAllocate
@@ -69,6 +68,6 @@
   packetDirection_ = Direction::Outgoing;
   peerID_=0;
-  data_=0;
-  enetPacket_=0;
+  data_=nullptr;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
 }
@@ -80,5 +79,5 @@
   peerID_=peerID;
   data_=data;
-  enetPacket_=0;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
 }
@@ -95,5 +94,5 @@
     memcpy(data_, p.data_, p.getSize());
   }else
-    data_=0;
+    data_=nullptr;
   bDataENetAllocated_ = p.bDataENetAllocated_;
 }
@@ -122,5 +121,5 @@
   // Destroy the ENetPacket if necessary.
   // Note: For the case ENet used the callback to destroy the packet, we have already set
-  // enetPacket_ to NULL to avoid destroying it again.
+  // enetPacket_ to nullptr to avoid destroying it again.
   if (this->enetPacket_)
   {
@@ -175,5 +174,5 @@
 #endif
 //  ENetPacket *temp = enetPacket_;
-//  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
+//  enetPacket_ = nullptr; // otherwise we have a double free because enet already handles the deallocation of the packet
   if( this->flags_ & PacketFlag::Reliable )
     host->addPacket( enetPacket_, peerID_, NETWORK_CHANNEL_DEFAULT);
@@ -191,5 +190,5 @@
 //   if( peerID==static_cast<unsigned int>(-2))
 //     peerID = NETWORK_PEER_ID_SERVER;
-  Packet *p = 0;
+  Packet *p = nullptr;
 //   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
   switch( *(Type::Value *)(data + _PACKETID) )
@@ -251,5 +250,5 @@
   assert(it != packetMap_.end());
   // Make sure we don't delete it again in the destructor
-  it->second->enetPacket_ = 0;
+  it->second->enetPacket_ = nullptr;
   delete it->second;
   packetMap_.erase(it);
Index: code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.cc	(revision 11054)
@@ -87,10 +87,11 @@
   } // namespace packet
 
-  std::ostream& operator<<(std::ostream& out, const ENetAddress& address)
-  {
-      char addr[64];
-      if (!enet_address_get_host_ip(&address, addr, 64))
-          out << addr;
-      return out;
-  }
 } // namespace orxonox
+
+std::ostream& operator<<(std::ostream& out, const ENetAddress& address)
+{
+    char addr[64];
+    if (!enet_address_get_host_ip(&address, addr, 64))
+        out << addr;
+    return out;
+}
Index: code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/ServerInformation.h	(revision 11054)
@@ -50,10 +50,10 @@
         void          send( ENetPeer* peer );
         void          setServerName(std::string name) { this->serverName_ = name; }
-        std::string   getServerName() { return this->serverName_; }
+        std::string   getServerName() const { return this->serverName_; }
         void          setServerIP( std::string IP ) { this->serverIP_ = IP; }
-        std::string   getServerIP() { return this->serverIP_; }
+        std::string   getServerIP() const { return this->serverIP_; }
         void          setClientNumber( int clientNumber ) { this->clientNumber_ = clientNumber; }
-        int           getClientNumber() { return this->clientNumber_; }
-        uint32_t      getServerRTT() { return this->serverRTT_; }
+        int           getClientNumber() const { return this->clientNumber_; }
+        uint32_t      getServerRTT() const { return this->serverRTT_; }
 
       private:
@@ -66,6 +66,7 @@
   }
 
-  _NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
 }
 
+_NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
+
 #endif // SERVERINFORMATION_H
Index: code/branches/cpp11_v3/src/libraries/network/packet/Welcome.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/packet/Welcome.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/packet/Welcome.h	(revision 11054)
@@ -45,7 +45,7 @@
   virtual ~Welcome();
 
-  uint8_t *getData();
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint8_t *getData() override;
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/branches/cpp11_v3/src/libraries/network/synchronisable/NetworkCallback.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/synchronisable/NetworkCallback.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/synchronisable/NetworkCallback.h	(revision 11054)
@@ -53,5 +53,5 @@
       NetworkCallback(T* object, void (T::*function) (void)) : object_(object), function_(function) {}
       virtual ~NetworkCallback() {}
-      virtual void call()
+      virtual void call() override
         { (this->object_->*function_)(); }
 
@@ -68,5 +68,5 @@
       NetworkCallbackNotify() {}
       virtual ~NetworkCallbackNotify() {}
-      virtual void call()
+      virtual void call() override
         { (this->object_->*function_)( this->oldValue_ ); }
       void setOldValue(const U& value){ this->oldValue_ = value; }
Index: code/branches/cpp11_v3/src/libraries/network/synchronisable/Serialise.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/synchronisable/Serialise.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/synchronisable/Serialise.h	(revision 11054)
@@ -90,5 +90,5 @@
     {
 //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<StrongPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
@@ -125,5 +125,5 @@
     {
         //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<WeakPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<WeakPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
Index: code/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.cc	(revision 11054)
@@ -88,6 +88,6 @@
     }
     // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ )
-    for(std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin(); it!=syncList_.end(); it++)
-      delete (*it);
+    for(SynchronisableVariableBase* variable : syncList_)
+      delete variable;
     syncList_.clear();
     stringList_.clear();
@@ -105,9 +105,9 @@
   uint32_t Synchronisable::findContextID(Context* context)
   {
-      if (context == NULL)
+      if (context == nullptr)
           return OBJECTID_UNKNOWN;
 
       Synchronisable* synchronisableContext = orxonox_cast<Synchronisable*>(context);
-      if (synchronisableContext != NULL)
+      if (synchronisableContext != nullptr)
           return synchronisableContext->getObjectID();
       else
@@ -140,5 +140,5 @@
     {
       mem += header.getDataSize() + header.getSize();
-      return 0;
+      return nullptr;
     }
 //     assert( !header.isDiffed() );
@@ -156,5 +156,5 @@
     }
     assert(id);
-    Context* context = 0;
+    Context* context = nullptr;
     if (header.getContextID() != OBJECTID_UNKNOWN)
     {
@@ -164,5 +164,5 @@
         mem += header.getDataSize()+SynchronisableHeader::getSize(); //.TODO: this suckz.... remove size from header
         assert(0); // TODO: uncomment this if we have a clean objecthierarchy (with destruction of children of objects) ^^
-        return 0;
+        return nullptr;
       }
       else
@@ -172,5 +172,5 @@
       context = Context::getRootContext();
 
-    assert(getSynchronisable(header.getObjectID())==0);   //make sure no object with this id exists
+    assert(getSynchronisable(header.getObjectID())==nullptr);   //make sure no object with this id exists
     BaseObject *bo = orxonox_cast<BaseObject*>(id->fabricate(context));
     assert(bo);
@@ -226,5 +226,5 @@
       return it1->second;
     // if the objects not in the map it should'nt exist at all anymore
-    return NULL;
+    return nullptr;
   }
 
@@ -266,5 +266,4 @@
     assert(this->classID_==this->getIdentifier()->getNetworkID());
     assert(this->objectID_!=OBJECTID_UNKNOWN);
-    std::vector<SynchronisableVariableBase*>::iterator i;
 
     // start copy header
@@ -276,7 +275,7 @@
 //     orxout(verbose, context::network) << "objectid: " << this->objectID_ << ":";
     // copy to location
-    for(i=syncList_.begin(); i!=syncList_.end(); ++i)
-    {
-      uint32_t varsize = (*i)->getData( mem, mode );
+    for(SynchronisableVariableBase* variable : syncList_)
+    {
+      uint32_t varsize = variable->getData( mem, mode );
 //       orxout(verbose, context::network) << " " << varsize;
       tempsize += varsize;
@@ -348,9 +347,8 @@
       assert( this->getContextID() == syncHeader2.getContextID() );
       mem += SynchronisableHeader::getSize();
-      std::vector<SynchronisableVariableBase *>::iterator i;
-      for(i=syncList_.begin(); i!=syncList_.end(); ++i)
+      for(SynchronisableVariableBase* variable : syncList_)
       {
         assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream
-        (*i)->putData( mem, mode, forceCallback );
+        variable->putData( mem, mode, forceCallback );
       }
       assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeader::getSize() );
@@ -388,8 +386,7 @@
     assert( mode==state_ );
     tsize += this->dataSize_;
-    std::vector<SynchronisableVariableBase*>::iterator i;
-    for(i=stringList_.begin(); i!=stringList_.end(); ++i)
-    {
-      tsize += (*i)->getSize( mode );
+    for(SynchronisableVariableBase* variable : stringList_)
+    {
+      tsize += variable->getSize( mode );
     }
     return tsize;
Index: code/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/synchronisable/Synchronisable.h	(revision 11054)
@@ -171,6 +171,6 @@
   protected:
     Synchronisable(Context* context);
-    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
-    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
+    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
+    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
     template <class T> void unregisterVariable(T& var);
 
@@ -242,7 +242,7 @@
     SynchronisableVariableBase* sv;
     if (bidirectional)
-      sv = new SynchronisableVariableBidirectional<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariableBidirectional<std::set<T>>(variable, mode, cb);
     else
-      sv = new SynchronisableVariable<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariable<std::set<T>>(variable, mode, cb);
     syncList_.push_back(sv);
     stringList_.push_back(sv);
@@ -250,5 +250,5 @@
 
   template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
-//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T> >( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
+//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T>>( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::unregisterVariable( std::string& variable );
 
Index: code/branches/cpp11_v3/src/libraries/network/synchronisable/SynchronisableVariable.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/network/synchronisable/SynchronisableVariable.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/network/synchronisable/SynchronisableVariable.h	(revision 11054)
@@ -71,12 +71,12 @@
   {
     public:
-      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=0);
+      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=nullptr);
       virtual ~SynchronisableVariable();
 
-      virtual inline uint8_t getMode(){ return mode_; }
-      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
-      virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
-      virtual inline uint32_t getSize(uint8_t mode);
-      virtual inline void* getReference(){ return static_cast<void*>(const_cast<typename Loki::TypeTraits<T>::UnqualifiedType*>(&this->variable_)); }
+      virtual inline uint8_t getMode() override{ return mode_; }
+      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode) override;
+      virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false) override;
+      virtual inline uint32_t getSize(uint8_t mode) override;
+      virtual inline void* getReference() override{ return static_cast<void*>(const_cast<typename Loki::TypeTraits<T>::UnqualifiedType*>(&this->variable_)); }
     protected:
       T&                       variable_;
@@ -89,5 +89,5 @@
   {
     public:
-      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=0);
+      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=nullptr);
       virtual ~SynchronisableVariableBidirectional();
 
Index: code/branches/cpp11_v3/src/libraries/tools/BillboardSet.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/BillboardSet.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/BillboardSet.cc	(revision 11054)
@@ -46,5 +46,5 @@
     BillboardSet::BillboardSet()
     {
-        this->billboardSet_ = 0;
+        this->billboardSet_ = nullptr;
     }
 
@@ -81,5 +81,5 @@
         {
             orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
-            this->billboardSet_ = 0;
+            this->billboardSet_ = nullptr;
         }
 
@@ -104,5 +104,5 @@
         {
             orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
-            this->billboardSet_ = 0;
+            this->billboardSet_ = nullptr;
         }
 
@@ -114,5 +114,5 @@
         if (this->billboardSet_ && this->scenemanager_)
             this->scenemanager_->destroyBillboardSet(this->billboardSet_);
-        this->billboardSet_ = 0;
+        this->billboardSet_ = nullptr;
     }
 
Index: code/branches/cpp11_v3/src/libraries/tools/BulletDebugDrawer.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/BulletDebugDrawer.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/BulletDebugDrawer.h	(revision 11054)
@@ -13,4 +13,6 @@
 #include <btBulletCollisionCommon.h>
 #include <OgreFrameListener.h>
+#include <OgreVector3.h>
+#include <OgreColourValue.h>
 
 namespace orxonox
@@ -21,27 +23,27 @@
             BulletDebugDrawer(Ogre::SceneManager* sceneManager);
             ~BulletDebugDrawer();
-            virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color);
-//            virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar);
-            virtual void drawSphere (const btVector3& p, btScalar radius, const btVector3& color);
-            virtual void drawSphere(btScalar radius, const btTransform& transform, const btVector3& color);
-            virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color);
-            virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color);
-            virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color);
-            virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color);
-//            virtual void drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color);
+            virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color) override;
+//            virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar) override;
+            virtual void drawSphere (const btVector3& p, btScalar radius, const btVector3& color) override;
+            virtual void drawSphere(btScalar radius, const btTransform& transform, const btVector3& color) override;
+            virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color) override;
+            virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color) override;
+            virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color) override;
+            virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color) override;
+//            virtual void drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color) override;
 
-            virtual void drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color);
+            virtual void drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color) override;
 
-            virtual void reportErrorWarning(const char* warningString);
-            virtual void draw3dText(const btVector3& location, const char* textString);
+            virtual void reportErrorWarning(const char* warningString) override;
+            virtual void draw3dText(const btVector3& location, const char* textString) override;
 
-            virtual void setDebugMode(int debugMode);
-            virtual int getDebugMode() const;
+            virtual void setDebugMode(int debugMode) override;
+            virtual int getDebugMode() const override;
 
             void configure(bool bFill, float fillAlpha);
 
         protected:
-            bool frameStarted(const Ogre::FrameEvent& evt);
-            bool frameEnded(const Ogre::FrameEvent& evt);
+            virtual bool frameStarted(const Ogre::FrameEvent& evt) override;
+            virtual bool frameEnded(const Ogre::FrameEvent& evt) override;
 
         private:
Index: code/branches/cpp11_v3/src/libraries/tools/DebugDrawer.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/DebugDrawer.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/DebugDrawer.cc	(revision 11054)
@@ -21,5 +21,5 @@
 {
     DebugDrawer::DebugDrawer(Ogre::SceneManager *_sceneManager, float _fillAlpha) :
-            sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(0), isEnabled(true), linesIndex(0), trianglesIndex(0)
+            sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(nullptr), isEnabled(true), linesIndex(0), trianglesIndex(0)
     {
         initialise();
@@ -392,11 +392,11 @@
             manualObject->estimateVertexCount(lineVertices.size());
             manualObject->estimateIndexCount(lineIndices.size());
-            for (std::list<VertexPair>::iterator i = lineVertices.begin(); i != lineVertices.end(); i++)
+            for (const VertexPair& pair : lineVertices)
             {
-                manualObject->position(i->first);
-                manualObject->colour(i->second);
+                manualObject->position(pair.first);
+                manualObject->colour(pair.second);
             }
-            for (std::list<int>::iterator i = lineIndices.begin(); i != lineIndices.end(); i++)
-                manualObject->index(*i);
+            for (int lineIndex : lineIndices)
+                manualObject->index(lineIndex);
         }
         else
@@ -409,11 +409,11 @@
             manualObject->estimateVertexCount(triangleVertices.size());
             manualObject->estimateIndexCount(triangleIndices.size());
-            for (std::list<VertexPair>::iterator i = triangleVertices.begin(); i != triangleVertices.end(); i++)
+            for (const VertexPair& pair : triangleVertices)
             {
-                manualObject->position(i->first);
-                manualObject->colour(i->second.r, i->second.g, i->second.b, fillAlpha);
+                manualObject->position(pair.first);
+                manualObject->colour(pair.second.r, pair.second.g, pair.second.b, fillAlpha);
             }
-            for (std::list<int>::iterator i = triangleIndices.begin(); i != triangleIndices.end(); i++)
-                manualObject->index(*i);
+            for (int triangleIndex : triangleIndices)
+                manualObject->index(triangleIndex);
         }
         else
@@ -433,5 +433,5 @@
     int DebugDrawer::addLineVertex(const Ogre::Vector3& vertex, const Ogre::ColourValue& colour)
     {
-        lineVertices.push_back(VertexPair(vertex, colour));
+        lineVertices.emplace_back(vertex, colour);
         return linesIndex++;
     }
@@ -445,5 +445,5 @@
     int DebugDrawer::addTriangleVertex(const Ogre::Vector3& vertex, const Ogre::ColourValue& colour)
     {
-        triangleVertices.push_back(VertexPair(vertex, colour));
+        triangleVertices.emplace_back(vertex, colour);
         return trianglesIndex++;
     }
Index: code/branches/cpp11_v3/src/libraries/tools/DynamicLines.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/DynamicLines.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/DynamicLines.cc	(revision 11054)
@@ -69,5 +69,5 @@
     void DynamicLines::addPoint(Real x, Real y, Real z)
     {
-        mPoints.push_back(Vector3(x,y,z));
+        mPoints.emplace_back(x,y,z);
         mDirty = true;
     }
Index: code/branches/cpp11_v3/src/libraries/tools/DynamicLines.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/DynamicLines.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/DynamicLines.h	(revision 11054)
@@ -84,7 +84,7 @@
     protected:
         /// Implementation DynamicRenderable, creates a simple vertex-only decl
-        virtual void createVertexDeclaration();
+        virtual void createVertexDeclaration() override;
         /// Implementation DynamicRenderable, pushes point list out to hardware memory
-        virtual void fillHardwareBuffers();
+        virtual void fillHardwareBuffers() override;
 
     private:
Index: code/branches/cpp11_v3/src/libraries/tools/DynamicRenderable.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/DynamicRenderable.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/DynamicRenderable.h	(revision 11054)
@@ -61,7 +61,7 @@
 
         /// Implementation of SimpleRenderable
-        virtual Real getBoundingRadius(void) const;
+        virtual Real getBoundingRadius(void) const override;
         /// Implementation of SimpleRenderable
-        virtual Real getSquaredViewDepth(const Camera* cam) const;
+        virtual Real getSquaredViewDepth(const Camera* cam) const override;
 
     protected:
Index: code/branches/cpp11_v3/src/libraries/tools/IcoSphere.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/IcoSphere.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/IcoSphere.cc	(revision 11054)
@@ -116,7 +116,6 @@
             std::list<TriangleIndices> faces2;
 
-            for (std::list<TriangleIndices>::iterator j = faces.begin(); j != faces.end(); j++)
+            for (const TriangleIndices& f : faces)
             {
-                TriangleIndices f = *j;
                 int a = getMiddlePoint(f.v1, f.v2);
                 int b = getMiddlePoint(f.v2, f.v3);
@@ -127,8 +126,8 @@
                 removeLineIndices(f.v3, f.v1);
 
-                faces2.push_back(TriangleIndices(f.v1, a, c));
-                faces2.push_back(TriangleIndices(f.v2, b, a));
-                faces2.push_back(TriangleIndices(f.v3, c, b));
-                faces2.push_back(TriangleIndices(a, b, c));
+                faces2.emplace_back(f.v1, a, c);
+                faces2.emplace_back(f.v2, b, a);
+                faces2.emplace_back(f.v3, c, b);
+                faces2.emplace_back(a, b, c);
 
                 addTriangleLines(f.v1, a, c);
@@ -143,5 +142,5 @@
     void IcoSphere::addLineIndices(int index0, int index1)
     {
-        lineIndices.push_back(LineIndices(index0, index1));
+        lineIndices.emplace_back(index0, index1);
     }
 
@@ -164,5 +163,5 @@
     {
         Ogre::Real length = vertex.length();
-        vertices.push_back(Ogre::Vector3(vertex.x / length, vertex.y / length, vertex.z / length));
+        vertices.emplace_back(vertex.x / length, vertex.y / length, vertex.z / length);
         return index++;
     }
@@ -189,13 +188,13 @@
     void IcoSphere::addFace(int index0, int index1, int index2)
     {
-        faces.push_back(TriangleIndices(index0, index1, index2));
+        faces.emplace_back(index0, index1, index2);
     }
 
     void IcoSphere::addToLineIndices(int baseIndex, std::list<int>* target) const
     {
-        for (std::list<LineIndices>::const_iterator i = lineIndices.begin(); i != lineIndices.end(); i++)
+        for (const LineIndices& line : lineIndices)
         {
-            target->push_back(baseIndex + (*i).v1);
-            target->push_back(baseIndex + (*i).v2);
+            target->push_back(baseIndex + line.v1);
+            target->push_back(baseIndex + line.v2);
         }
     }
@@ -203,9 +202,9 @@
     void IcoSphere::addToTriangleIndices(int baseIndex, std::list<int>* target) const
     {
-        for (std::list<TriangleIndices>::const_iterator i = faces.begin(); i != faces.end(); i++)
+        for (const TriangleIndices& triangle : faces)
         {
-            target->push_back(baseIndex + (*i).v1);
-            target->push_back(baseIndex + (*i).v2);
-            target->push_back(baseIndex + (*i).v3);
+            target->push_back(baseIndex + triangle.v1);
+            target->push_back(baseIndex + triangle.v2);
+            target->push_back(baseIndex + triangle.v3);
         }
     }
@@ -217,6 +216,6 @@
         transform.setScale(Ogre::Vector3(scale, scale, scale));
 
-        for (int i = 0; i < (int) vertices.size(); i++)
-            target->push_back(VertexPair(transform * vertices[i], colour));
+        for (const Ogre::Vector3& vertex : vertices)
+            target->emplace_back(transform * vertex, colour);
 
         return vertices.size();
Index: code/branches/cpp11_v3/src/libraries/tools/Mesh.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/Mesh.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/Mesh.cc	(revision 11054)
@@ -44,5 +44,5 @@
     Mesh::Mesh()
     {
-        this->entity_ = 0;
+        this->entity_ = nullptr;
         this->bCastShadows_ = true;
     }
@@ -73,5 +73,5 @@
             {
                 orxout(internal_error) << "Couldn't load mesh \"" << meshsource << '"' << endl;
-                this->entity_ = 0;
+                this->entity_ = nullptr;
             }
         }
Index: code/branches/cpp11_v3/src/libraries/tools/OgreBulletUtils.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/OgreBulletUtils.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/OgreBulletUtils.h	(revision 11054)
@@ -10,4 +10,9 @@
 
 #include "tools/ToolsPrereqs.h"
+#include <OgreVector3.h>
+#include <OgreQuaternion.h>
+#include <OgreColourValue.h>
+#include <OgreMatrix3.h>
+#include <OgreMatrix4.h>
 
 namespace orxonox
@@ -42,5 +47,5 @@
     inline Ogre::Matrix3 matrix3(const btMatrix3x3& matrix)
     {
-        return Matrix3(
+        return Ogre::Matrix3(
                 matrix[0][0], matrix[0][1], matrix[0][2],
                 matrix[1][0], matrix[1][1], matrix[1][2],
Index: code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.cc	(revision 11054)
@@ -59,5 +59,5 @@
 
         this->scenemanager_ = scenemanager;
-        this->particleSystem_ = 0;
+        this->particleSystem_ = nullptr;
 
         this->bEnabled_ = true;
@@ -80,5 +80,5 @@
             {
                 orxout(internal_error) << "Couldn't load particle system \"" << templateName << '"' << endl;
-                this->particleSystem_ = 0;
+                this->particleSystem_ = nullptr;
             }
         }
@@ -110,5 +110,5 @@
         }
         else
-            return 0;
+            return nullptr;
     }
     Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
@@ -117,5 +117,5 @@
             return this->particleSystem_->getEmitter(emitterNr);
         else
-            return 0;
+            return nullptr;
     }
     void ParticleInterface::removeEmitter(unsigned int emitterNr)
@@ -142,5 +142,5 @@
             return this->particleSystem_->addAffector(name);
         else
-            return 0;
+            return nullptr;
     }
     Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr)
@@ -149,5 +149,5 @@
             return this->particleSystem_->getAffector(affectorNr);
         else
-            return 0;
+            return nullptr;
     }
     void ParticleInterface::removeAffector(unsigned int affectorNr)
Index: code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.h	(revision 11054)
@@ -78,5 +78,5 @@
 
         protected:
-            virtual void changedTimeFactor(float factor_new, float factor_old);
+            virtual void changedTimeFactor(float factor_new, float factor_old) override;
 
         private:
Index: code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.cc	(revision 11054)
@@ -48,8 +48,4 @@
     }
 
-    ResourceCollection::~ResourceCollection()
-    {
-    }
-
     void ResourceCollection::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
@@ -93,5 +89,5 @@
     {
         if (index >= resourceLocations_.size())
-            return NULL;
+            return nullptr;
         else
             return resourceLocations_[index];
Index: code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.h	(revision 11054)
@@ -42,7 +42,7 @@
     public:
         ResourceCollection(Context* context);
-        virtual ~ResourceCollection();
+        virtual ~ResourceCollection() = default;
 
-        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
         void setResourceGroup(const std::string& resourceGroup);
@@ -54,5 +54,7 @@
 
     private:
-        ResourceCollection(const ResourceCollection&);
+        // non-copyable:
+        ResourceCollection(const ResourceCollection&) = delete;
+        ResourceCollection& operator=(const ResourceCollection&) = delete;
 
         std::string resourceGroup_;
Index: code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.cc	(revision 11054)
@@ -54,8 +54,4 @@
     }
 
-    ResourceLocation::~ResourceLocation()
-    {
-    }
-
     void ResourceLocation::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
Index: code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.h	(revision 11054)
@@ -44,7 +44,7 @@
     public:
         ResourceLocation(Context* context);
-        virtual ~ResourceLocation();
+        virtual ~ResourceLocation() = default;
 
-        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
         void setPath(const std::string& path) { path_ = path; }
@@ -60,5 +60,7 @@
 
     private:
-        ResourceLocation(const ResourceLocation&);
+        // non-copyable:
+        ResourceLocation(const ResourceLocation&) = delete;
+        ResourceLocation& operator=(const ResourceLocation&) = delete;
 
         void load(const std::string& resourceGroup);
Index: code/branches/cpp11_v3/src/libraries/tools/Shader.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/Shader.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/Shader.cc	(revision 11054)
@@ -44,5 +44,5 @@
         @brief Initializes the values and sets the scene manager.
     */
-    Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(0)
+    Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(nullptr)
     {
         RegisterObject(Shader);
@@ -109,5 +109,5 @@
     {
         // For the moment, we get the viewport always from the graphics manager
-        // TODO: Try to support multiple viewports - note however that scenemanager_->getCurrentViewport() returns NULL
+        // TODO: Try to support multiple viewports - note however that scenemanager_->getCurrentViewport() returns nullptr
         //       after switching to a camera in a different scene (only for the first time this scene is displayed though)
         this->changedCompositorName(GraphicsManager::getInstance().getViewport());
@@ -127,5 +127,5 @@
                 Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->oldcompositorName_);
                 this->compositorInstance_->removeListener(this);
-                this->compositorInstance_ = 0;
+                this->compositorInstance_ = nullptr;
             }
             if (!this->compositorName_.empty())
@@ -197,23 +197,23 @@
     {
         // iterate through the list of parameters
-        for (std::list<ParameterContainer>::iterator it = this->parameters_.begin(); it != this->parameters_.end(); ++it)
-        {
-            Ogre::Technique* techniquePtr = materialPtr->getTechnique(it->technique_);
+        for (const ParameterContainer& parameter : this->parameters_)
+        {
+            Ogre::Technique* techniquePtr = materialPtr->getTechnique(parameter.technique_);
             if (techniquePtr)
             {
-                Ogre::Pass* passPtr = techniquePtr->getPass(it->pass_);
+                Ogre::Pass* passPtr = techniquePtr->getPass(parameter.pass_);
                 if (passPtr)
                 {
                     // change the value of the parameter depending on its type
-                    if (it->value_.isType<int>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<int>());
-                    else if (it->value_.isType<float>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<float>());
+                    if (parameter.value_.isType<int>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<int>());
+                    else if (parameter.value_.isType<float>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<float>());
                 }
                 else
-                    orxout(internal_warning) << "No pass " << it->pass_ << " in technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
+                    orxout(internal_warning) << "No pass " << parameter.pass_ << " in technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
             }
             else
-                orxout(internal_warning) << "No technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
+                orxout(internal_warning) << "No technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
         }
         this->parameters_.clear();
@@ -228,6 +228,6 @@
         {
             const Ogre::Root::PluginInstanceList& plugins = Ogre::Root::getSingleton().getInstalledPlugins();
-            for (size_t i = 0; i < plugins.size(); ++i)
-                if (plugins[i]->getName() == "Cg Program Manager")
+            for (Ogre::Plugin* plugin : plugins)
+                if (plugin->getName() == "Cg Program Manager")
                     return true;
         }
Index: code/branches/cpp11_v3/src/libraries/tools/Shader.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/Shader.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/Shader.h	(revision 11054)
@@ -48,5 +48,5 @@
     {
         public:
-            Shader(Ogre::SceneManager* scenemanager = 0);
+            Shader(Ogre::SceneManager* scenemanager = nullptr);
             virtual ~Shader();
 
@@ -87,10 +87,10 @@
                 { return this->scenemanager_; }
 
-            virtual void cameraChanged(Ogre::Viewport* viewport, Ogre::Camera* oldCamera);
+            virtual void cameraChanged(Ogre::Viewport* viewport, Ogre::Camera* oldCamera) override;
 
             void setParameter(unsigned short technique, unsigned short pass, const std::string& parameter, float value);
             void setParameter(unsigned short technique, unsigned short pass, const std::string& parameter, int value);
 
-            virtual void notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr& materialPtr);
+            virtual void notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr& materialPtr) override;
 
         private:
Index: code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.cc	(revision 11054)
@@ -71,5 +71,5 @@
 namespace orxonox
 {
-    std::map<std::string, std::map<ColourValue, std::string> > TextureGenerator::materials_s;
+    std::map<std::string, std::map<ColourValue, std::string>> TextureGenerator::materials_s;
     unsigned int TextureGenerator::materialCount_s = 0;
 
Index: code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.h	(revision 11054)
@@ -49,9 +49,11 @@
 
     private:
-        TextureGenerator();
-        TextureGenerator(const TextureGenerator&);
-        ~TextureGenerator();
+        // static class, no instances allowed:
+        TextureGenerator() = delete;
+        TextureGenerator(const TextureGenerator&) = delete;
+        TextureGenerator& operator=(const TextureGenerator&) = delete;
+        ~TextureGenerator() = delete;
 
-        static std::map<std::string, std::map<ColourValue, std::string> > materials_s;
+        static std::map<std::string, std::map<ColourValue, std::string>> materials_s;
         static unsigned int materialCount_s;
     };
Index: code/branches/cpp11_v3/src/libraries/tools/Timer.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/Timer.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/Timer.cc	(revision 11054)
@@ -163,5 +163,5 @@
     void Timer::init()
     {
-        this->executor_ = 0;
+        this->executor_ = nullptr;
         this->interval_ = 0;
         this->bLoop_ = false;
Index: code/branches/cpp11_v3/src/libraries/tools/Timer.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/Timer.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/Timer.h	(revision 11054)
@@ -175,5 +175,5 @@
 
         protected:
-            virtual float getTimeFactor();
+            virtual float getTimeFactor() override;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/tools/interfaces/TimeFactorListener.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/interfaces/TimeFactorListener.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/interfaces/TimeFactorListener.h	(revision 11054)
@@ -39,5 +39,5 @@
         public:
             TimeFactorListener();
-            virtual ~TimeFactorListener() {}
+            virtual ~TimeFactorListener() = default;
 
             static void setTimeFactor(float factor);
Index: code/branches/cpp11_v3/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc	(revision 11054)
@@ -60,6 +60,6 @@
         float oldFactor = TimeFactorListener::timefactor_s;
         TimeFactorListener::timefactor_s = factor;
-        for (ObjectList<TimeFactorListener>::iterator it = ObjectList<TimeFactorListener>::begin(); it != ObjectList<TimeFactorListener>::end(); ++it)
-            it->changedTimeFactor(factor, oldFactor);
+        for (TimeFactorListener* listener : ObjectList<TimeFactorListener>())
+            listener->changedTimeFactor(factor, oldFactor);
     }
 
Index: code/branches/cpp11_v3/src/libraries/util/CMakeLists.txt
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/CMakeLists.txt	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/CMakeLists.txt	(revision 11054)
@@ -26,5 +26,4 @@
   CRC32.cc
   ExprParser.cc
-  SharedPtr.cc
   Sleep.cc
   SmallObjectAllocator.cc
Index: code/branches/cpp11_v3/src/libraries/util/Clipboard.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/Clipboard.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/Clipboard.cc	(revision 11054)
@@ -93,5 +93,5 @@
             {
                 HANDLE hData = GetClipboardData(CF_TEXT);
-                if (hData == NULL)
+                if (hData == nullptr)
                     return "";
                 std::string output(static_cast<char*>(GlobalLock(hData)));
Index: code/branches/cpp11_v3/src/libraries/util/Clock.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/Clock.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/Clock.h	(revision 11054)
@@ -102,6 +102,7 @@
 
     private:
-        /// Undefined
-        Clock(const Clock& instance);
+        // non-copyable:
+        Clock(const Clock&) = delete;
+        Clock& operator=(const Clock&) = delete;
 
         Ogre::Timer*       timer_;       ///< Ogre timer object
Index: code/branches/cpp11_v3/src/libraries/util/DestructionHelper.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/DestructionHelper.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/DestructionHelper.h	(revision 11054)
@@ -36,5 +36,5 @@
     /** Deletes an object and resets the pointer
     @param object
-        Pointer to an object. Handing over NULL is safe.
+        Pointer to an object. Handing over nullptr is safe.
     */
     template <class T>
@@ -42,5 +42,5 @@
     {
         delete *object;
-        *object = NULL;
+        *object = nullptr;
     }
 
@@ -87,5 +87,7 @@
 
     private:
-        DestructionHelper(const DestructionHelper&); //!< Don't use (undefined)
+        // non-copyable:
+        DestructionHelper(const DestructionHelper&) = delete;
+        DestructionHelper& operator=(const DestructionHelper&) = delete;
 
         T* object_;
Index: code/branches/cpp11_v3/src/libraries/util/DisplayStringConversions.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/DisplayStringConversions.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/DisplayStringConversions.h	(revision 11054)
@@ -51,7 +51,7 @@
             {
                 Ogre::UTFString::code_point cp;
-                for (unsigned int i = 0; i < input.size(); ++i)
+                for (const char& character : input)
                 {
-                  cp = input[i];
+                  cp = character;
                   cp &= 0xFF;
                   output->append(1, cp);
Index: code/branches/cpp11_v3/src/libraries/util/ExprParser.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/ExprParser.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/ExprParser.cc	(revision 11054)
@@ -391,5 +391,5 @@
     }
 
-    char* ExprParser::parse_word(char* str)
+    void ExprParser::parse_word(char* str)
     {
         char* word = str;
@@ -402,9 +402,8 @@
             {
                 this->failed_ = true;
-                return '\0';
+                return;
             }
         };
         *word = '\0';
-        return str;
     }
 
Index: code/branches/cpp11_v3/src/libraries/util/ExprParser.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/ExprParser.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/ExprParser.h	(revision 11054)
@@ -139,5 +139,5 @@
         float parse_expr_7();
         float parse_expr_8();
-        char* parse_word(char* str);
+        void parse_word(char* str);
         binary_operator parse_binary_operator();
         unary_operator parse_unary_operator();
Index: code/branches/cpp11_v3/src/libraries/util/ImplicitConversion.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/ImplicitConversion.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/ImplicitConversion.h	(revision 11054)
@@ -68,5 +68,10 @@
     {
     private:
-        ImplicitConversion(); ImplicitConversion(const ImplicitConversion&); ~ImplicitConversion();
+        // static class, no instances allowed:
+        ImplicitConversion() = delete;
+        ImplicitConversion(const ImplicitConversion&) = delete;
+        ImplicitConversion& operator=(const ImplicitConversion&) = delete;
+        ~ImplicitConversion() = delete;
+
         // Gets chosen only if there is an implicit conversion from FromType to ToType.
         static char test(ToType);
Index: code/branches/cpp11_v3/src/libraries/util/Math.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/Math.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/Math.cc	(revision 11054)
@@ -371,4 +371,10 @@
     }
 
+
+    namespace detail
+    {
+        std::mt19937 rngen;
+    }
+
     /**
         @brief Returns a unique number. This function will never return the same value twice.
Index: code/branches/cpp11_v3/src/libraries/util/Math.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/Math.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/Math.h	(revision 11054)
@@ -46,4 +46,5 @@
 #include <cmath>
 #include <cstdlib>
+#include <random>
 
 #include <OgreMath.h>
@@ -73,11 +74,11 @@
     namespace math
     {
-        const float twoPi   = 6.283185482025146484375f;     ///< PI * 2
-        const float pi      = 3.1415927410125732421875f;    ///< PI
-        const float pi_2    = 1.57079637050628662109375f;   ///< PI / 2
-        const float pi_4    = 0.785398185253143310546875f;  ///< PI / 4
-        const float e       = 2.718281269073486328125f;     ///< e
-        const float sqrt2   = 1.41421353816986083984375f;   ///< sqrt(2)
-        const float sqrt2_2 = 0.707106769084930419921875f;  ///< sqrt(2) / 2
+        constexpr float twoPi   = 6.283185482025146484375f;     ///< PI * 2
+        constexpr float pi      = 3.1415927410125732421875f;    ///< PI
+        constexpr float pi_2    = 1.57079637050628662109375f;   ///< PI / 2
+        constexpr float pi_4    = 0.785398185253143310546875f;  ///< PI / 4
+        constexpr float e       = 2.718281269073486328125f;     ///< e
+        constexpr float sqrt2   = 1.41421353816986083984375f;   ///< sqrt(2)
+        constexpr float sqrt2_2 = 0.707106769084930419921875f;  ///< sqrt(2) / 2
     }
 
@@ -104,5 +105,5 @@
     */
     template <typename T>
-    inline T sgn(T x)
+    constexpr inline T sgn(T x)
     {
         return (x >= 0) ? (T)1 : (T)-1;
@@ -116,13 +117,7 @@
     */
     template <typename T>
-    inline T clamp(T x, T min, T max)
-    {
-        if (x < min)
-            return min;
-
-        if (x > max)
-            return max;
-
-        return x;
+    constexpr inline T clamp(T x, T min, T max)
+    {
+        return x < min ? min : (x > max ? max : x);
     }
 
@@ -131,5 +126,5 @@
     */
     template <typename T>
-    inline T square(T x)
+    constexpr inline T square(T x)
     {
         return x*x;
@@ -140,5 +135,5 @@
     */
     template <typename T>
-    inline T cube(T x)
+    constexpr inline T cube(T x)
     {
         return x*x*x;
@@ -186,8 +181,6 @@
     inline T zeroise()
     {
-        // Default, raise a compiler error without including large boost header cascade.
-        T temp();
-        *********temp; // If you reach this code, you abused zeroise()!
-        return temp;
+        // If you reach this code, you abused zeroise()!
+        static_assert(sizeof(T) != sizeof(T), "No template specialization available for T");
     }
 
@@ -206,5 +199,5 @@
     template <> inline long double          zeroise<long double>()          { return 0; }
     template <> inline bool                 zeroise<bool>()                 { return 0; }
-    template <> inline void*                zeroise<void*>()                { return 0; }
+    template <> inline void*                zeroise<void*>()                { return nullptr; }
     template <> inline std::string          zeroise<std::string>()          { return std::string(); }
     template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
@@ -258,4 +251,31 @@
     }
 
+    namespace detail
+    {
+        /**
+        Random number generator used for the functions below. Marked extern to only have one global instance.
+        */
+        _UtilExport extern std::mt19937 rngen;
+    }
+
+    /**
+    @brief Seeds the random number generator used for the functions below.
+    */
+    inline void rndseed(unsigned int seed)
+    {
+        detail::rngen.seed(seed);
+    }
+
+    /**
+    @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
+    @param min The minimum
+    @param max The maximum
+    */
+    inline float rnd(float min, float max)
+    {
+        std::uniform_real_distribution<float> dist(min, max);
+        return dist(detail::rngen);
+    }
+
     /**
         @brief Returns a random number between 0 and almost 1: <tt>0 <= rnd < 1</tt>.
@@ -263,5 +283,5 @@
     inline float rnd()
     {
-        return rand() / (RAND_MAX + 1.0f);
+        return rnd(0, 1);
     }
 
@@ -272,15 +292,5 @@
     inline float rnd(float max)
     {
-        return rnd() * max;
-    }
-
-    /**
-        @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
-        @param min The minimum
-        @param max The maximum
-    */
-    inline float rnd(float min, float max)
-    {
-        return rnd(max - min) + min;
+        return rnd(0, max);
     }
 
@@ -290,5 +300,6 @@
     inline float rndsgn()
     {
-        return static_cast<float>((rand() & 0x2) - 1); // rand() & 0x2 is either 2 or 0
+        std::uniform_int_distribution<> dist;
+        return static_cast<float>((dist(detail::rngen) & 0x2) - 1); // dist(...) & 0x2 is either 2 or 0
     }
 
Index: code/branches/cpp11_v3/src/libraries/util/MultiType.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/MultiType.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/MultiType.h	(revision 11054)
@@ -175,5 +175,5 @@
         public:
             inline MT_ValueBase(void* data, Type::Enum type) : type_(type), bLastConversionSuccessful(true), data_(data) {}
-            inline virtual ~MT_ValueBase() {}
+            virtual inline ~MT_ValueBase() {}
 
             virtual MT_ValueBase* clone() const = 0;
@@ -266,10 +266,10 @@
 
             /// Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
-            inline MultiType()                       : value_(0) { }
+            inline MultiType()                       : value_(nullptr) { }
             /// Constructor: Assigns the given value and sets the type.
             template <typename V>
-            inline MultiType(const V& value)         : value_(0) { this->set(value); }
+            inline MultiType(const V& value)         : value_(nullptr) { this->set(value); }
             /// Copyconstructor: Assigns value and type of the other MultiType.
-            inline MultiType(const MultiType& other) : value_(0) { this->set(other); }
+            inline MultiType(const MultiType& other) : value_(nullptr) { this->set(other); }
 
             /// Destructor: Deletes the MT_Value.
@@ -325,5 +325,5 @@
                 if (this->value_)
                     delete this->value_;
-                this->value_ = (other.value_) ? other.value_->clone() : 0;
+                this->value_ = (other.value_) ? other.value_->clone() : nullptr;
             }
 
@@ -332,5 +332,5 @@
 
             /// Resets value and type. Type will be void afterwards and null() returns true.
-            inline void reset() { if (this->value_) delete this->value_; this->value_ = 0; }
+            inline void reset() { if (this->value_) delete this->value_; this->value_ = nullptr; }
             /// Resets the value and changes the internal type to T.
             template <typename T> inline void reset() { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
@@ -428,5 +428,9 @@
             }
             /// Creates a new value container (works only with specialized types).
-            template <typename T> inline void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
+            template <typename T> 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");
+            }
 
             MT_ValueBase* value_; //!< A pointer to the value container
@@ -486,5 +490,5 @@
     template <> inline long double          MultiType::get() const { return (this->value_ ? this->value_->get<long double>()          : 0); }
     template <> inline bool                 MultiType::get() const { return (this->value_ ? this->value_->get<bool>()                 : 0); }
-    template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : 0); }
+    template <> inline 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>()); }
Index: code/branches/cpp11_v3/src/libraries/util/MultiTypeValue.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/MultiTypeValue.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/MultiTypeValue.h	(revision 11054)
@@ -58,32 +58,32 @@
 
         /// Creates a copy of itself.
-        inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
+        virtual inline MT_ValueBase* clone() const override { return new MT_Value<T>(this->value_, this->type_); }
 
         /// Resets the current value to the default.
-        inline void reset() { this->value_ = zeroise<T>(); bLastConversionSuccessful = true; }
-
-        inline bool getValue(char*                 value) const { return convertValue<T, char                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned char*        value) const { return convertValue<T, unsigned char       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(short*                value) const { return convertValue<T, short               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned short*       value) const { return convertValue<T, unsigned short      >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(int*                  value) const { return convertValue<T, int                 >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned int*         value) const { return convertValue<T, unsigned int        >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(long*                 value) const { return convertValue<T, long                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned long*        value) const { return convertValue<T, unsigned long       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(long long*            value) const { return convertValue<T, long long           >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(unsigned long long*   value) const { return convertValue<T, unsigned long long  >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(float*                value) const { return convertValue<T, float               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(double*               value) const { return convertValue<T, double              >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, NilValue<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, NilValue<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Vector3*     value) const { return convertValue<T, orxonox::Vector3    >(value, value_, NilValue<orxonox::Vector3>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Vector4*     value) const { return convertValue<T, orxonox::Vector4    >(value, value_, NilValue<orxonox::Vector4>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::ColourValue* value) const { return convertValue<T, orxonox::ColourValue>(value, value_, NilValue<orxonox::ColourValue>()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Quaternion*  value) const { return convertValue<T, orxonox::Quaternion >(value, value_, NilValue<orxonox::Quaternion> ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Radian*      value) const { return convertValue<T, orxonox::Radian     >(value, value_, NilValue<orxonox::Radian>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Degree*      value) const { return convertValue<T, orxonox::Degree     >(value, value_, NilValue<orxonox::Degree>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline void reset() override { this->value_ = zeroise<T>(); bLastConversionSuccessful = true; }
+
+        virtual inline bool getValue(char*                 value) const override { return convertValue<T, char                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned char*        value) const override { return convertValue<T, unsigned char       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(short*                value) const override { return convertValue<T, short               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned short*       value) const override { return convertValue<T, unsigned short      >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(int*                  value) const override { return convertValue<T, int                 >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned int*         value) const override { return convertValue<T, unsigned int        >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(long*                 value) const override { return convertValue<T, long                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned long*        value) const override { return convertValue<T, unsigned long       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(long long*            value) const override { return convertValue<T, long long           >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(unsigned long long*   value) const override { return convertValue<T, unsigned long long  >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(float*                value) const override { return convertValue<T, float               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(double*               value) const override { return convertValue<T, double              >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(long double*          value) const override { return convertValue<T, long double         >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(bool*                 value) const override { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(void**                value) const override { return convertValue<T, void*               >(value, value_, nullptr); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(std::string*          value) const override { return convertValue<T, std::string         >(value, value_, NilValue<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Vector2*     value) const override { return convertValue<T, orxonox::Vector2    >(value, value_, NilValue<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Vector3*     value) const override { return convertValue<T, orxonox::Vector3    >(value, value_, NilValue<orxonox::Vector3>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Vector4*     value) const override { return convertValue<T, orxonox::Vector4    >(value, value_, NilValue<orxonox::Vector4>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::ColourValue* value) const override { return convertValue<T, orxonox::ColourValue>(value, value_, NilValue<orxonox::ColourValue>()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Quaternion*  value) const override { return convertValue<T, orxonox::Quaternion >(value, value_, NilValue<orxonox::Quaternion> ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Radian*      value) const override { return convertValue<T, orxonox::Radian     >(value, value_, NilValue<orxonox::Radian>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        virtual inline bool getValue(orxonox::Degree*      value) const override { return convertValue<T, orxonox::Degree     >(value, value_, NilValue<orxonox::Degree>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
 
         /**
@@ -91,5 +91,5 @@
             @param other The other MultiType
         */
-        inline bool setValue(const MultiType& other)
+        virtual inline bool setValue(const MultiType& other) override
         {
             if (other.value_)
@@ -104,37 +104,37 @@
         }
 
-        inline bool setValue(const char& value)                 { return (bLastConversionSuccessful = convertValue<char                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned char& value)        { return (bLastConversionSuccessful = convertValue<unsigned char       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const short& value)                { return (bLastConversionSuccessful = convertValue<short               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned short& value)       { return (bLastConversionSuccessful = convertValue<unsigned short      , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const int& value)                  { return (bLastConversionSuccessful = convertValue<int                 , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned int& value)         { return (bLastConversionSuccessful = convertValue<unsigned int        , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long& value)                 { return (bLastConversionSuccessful = convertValue<long                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned long& value)        { return (bLastConversionSuccessful = convertValue<unsigned long       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long long& value)            { return (bLastConversionSuccessful = convertValue<long long           , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned long long& value)   { return (bLastConversionSuccessful = convertValue<unsigned long long  , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const float& value)                { return (bLastConversionSuccessful = convertValue<float               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const double& value)               { return (bLastConversionSuccessful = convertValue<double              , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long double& value)          { return (bLastConversionSuccessful = convertValue<long double         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const bool& value)                 { return (bLastConversionSuccessful = convertValue<bool                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(      void* const& value)          { return (bLastConversionSuccessful = convertValue<void*               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const std::string& value)          { return (bLastConversionSuccessful = convertValue<std::string         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector2& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector2    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector3& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector3    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector4& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector4    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::ColourValue& value) { return (bLastConversionSuccessful = convertValue<orxonox::ColourValue, T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Quaternion& value)  { return (bLastConversionSuccessful = convertValue<orxonox::Quaternion , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Radian& value)      { return (bLastConversionSuccessful = convertValue<orxonox::Radian     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Degree& value)      { return (bLastConversionSuccessful = convertValue<orxonox::Degree     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const char& value)                 override { return (bLastConversionSuccessful = convertValue<char                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned char& value)        override { return (bLastConversionSuccessful = convertValue<unsigned char       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const short& value)                override { return (bLastConversionSuccessful = convertValue<short               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned short& value)       override { return (bLastConversionSuccessful = convertValue<unsigned short      , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const int& value)                  override { return (bLastConversionSuccessful = convertValue<int                 , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned int& value)         override { return (bLastConversionSuccessful = convertValue<unsigned int        , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const long& value)                 override { return (bLastConversionSuccessful = convertValue<long                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned long& value)        override { return (bLastConversionSuccessful = convertValue<unsigned long       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const long long& value)            override { return (bLastConversionSuccessful = convertValue<long long           , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const unsigned long long& value)   override { return (bLastConversionSuccessful = convertValue<unsigned long long  , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const float& value)                override { return (bLastConversionSuccessful = convertValue<float               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const double& value)               override { return (bLastConversionSuccessful = convertValue<double              , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const long double& value)          override { return (bLastConversionSuccessful = convertValue<long double         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const bool& value)                 override { return (bLastConversionSuccessful = convertValue<bool                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(      void* const& value)          override { return (bLastConversionSuccessful = convertValue<void*               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const std::string& value)          override { return (bLastConversionSuccessful = convertValue<std::string         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Vector2& value)     override { return (bLastConversionSuccessful = convertValue<orxonox::Vector2    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Vector3& value)     override { return (bLastConversionSuccessful = convertValue<orxonox::Vector3    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Vector4& value)     override { return (bLastConversionSuccessful = convertValue<orxonox::Vector4    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::ColourValue& value) override { return (bLastConversionSuccessful = convertValue<orxonox::ColourValue, T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Quaternion& value)  override { return (bLastConversionSuccessful = convertValue<orxonox::Quaternion , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Radian& value)      override { return (bLastConversionSuccessful = convertValue<orxonox::Radian     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        virtual inline bool setValue(const orxonox::Degree& value)      override { return (bLastConversionSuccessful = convertValue<orxonox::Degree     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
 
         /// Puts the current value on the stream
-        inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+        virtual inline void toString(std::ostream& outstream) const override { outstream << this->value_; }
 
         /// loads data from the bytestream (mem) into the MT and increases the bytestream pointer by the size of the data
-        inline void importData( uint8_t*& mem )         { loadAndIncrease( /*(const T&)*/this->value_, mem ); }
+        virtual inline void importData( uint8_t*& mem ) override         { loadAndIncrease( /*(const T&)*/this->value_, mem ); }
         /// saves data from the MT into the bytestream (mem) and increases the bytestream pointer by the size of the data
-        inline void exportData( uint8_t*& mem ) const   { saveAndIncrease( /*(const T&)*/this->value_, mem ); }
+        virtual inline void exportData( uint8_t*& mem ) const override   { saveAndIncrease( /*(const T&)*/this->value_, mem ); }
         /// returns the size of the data that would be saved by exportData
-        inline uint8_t getSize() const { return returnSize( this->value_ ); }
+        virtual inline uint8_t getSize() const override { return returnSize( this->value_ ); }
 
         T value_; ///< The stored value
Index: code/branches/cpp11_v3/src/libraries/util/Serialise.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/Serialise.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/Serialise.h	(revision 11054)
@@ -672,6 +672,6 @@
     {
         uint32_t tempsize = sizeof(uint32_t); // for the number of entries
-        for( typename std::set<T>::iterator it=((std::set<T>*)(&variable))->begin(); it!=((std::set<T>*)(&variable))->end(); ++it)
-            tempsize += returnSize( *it );
+        for(const T& element : *((std::set<T>*)(&variable)))
+            tempsize += returnSize( element );
         return tempsize;
     }
@@ -679,8 +679,7 @@
     template <class T> inline void saveAndIncrease(  const std::set<T>& variable, uint8_t*& mem )
     {
-        typename std::set<T>::const_iterator it = variable.begin();
         saveAndIncrease( (uint32_t)variable.size(), mem );
-        for( ; it!=variable.end(); ++it )
-            saveAndIncrease( *it, mem );
+        for( const T& elem : variable )
+            saveAndIncrease( elem, mem );
     }
 
Index: code/branches/cpp11_v3/src/libraries/util/SharedPtr.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/SharedPtr.cc	(revision 11053)
+++ 	(revision )
@@ -1,46 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Static linkage of the SmallObjectAllocator used by SharedPtr.
-*/
-
-#include "SharedPtr.h"
-
-namespace orxonox
-{
-    namespace detail
-    {
-        SmallObjectAllocator& createSharedCounterPool()
-        {
-            static SmallObjectAllocator instance(sizeof(SharedCounterImpl<void>));
-            return instance;
-        }
-    }
-}
Index: code/branches/cpp11_v3/src/libraries/util/SharedPtr.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/SharedPtr.h	(revision 11053)
+++ 	(revision )
@@ -1,375 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @defgroup SharedPtr SharedPtr<T>
-    @ingroup Util
-*/
-
-/**
-    @file
-    @ingroup SharedPtr
-    @brief Definition of the SharedPtr template that is used to manage pointers.
-
-    @anchor SharedPtrExample
-
-    The orxonox::SharedPtr template can be used to manage a pointer to an object
-    that was created with new. The SharedPtr acts like the pointer itself, but it
-    keeps track of the number of references to it. If all references are removed,
-    SharedPtr deletes the managed object automatically.
-
-    Example:
-
-    Classic implementation using new and delete:
-    @code
-    void someFunction()
-    {
-        MyClass* object = new MyClass();            // Create a new instance of MyClass
-
-        object->myFunction();                       // Calls MyClass::myFunction()
-
-        delete object;                              // Delete the object at the end of the scope
-    }
-    @endcode
-
-    The same function using SharedPtr:
-    @code
-    void someFunction()
-    {
-        SharedPtr<MyClass> object = new MyClass();  // Create a new instance of MyClass and store its pointer in a SharedPtr
-
-        object->myFunction();                       // Calls MyClass::myFunction()
-
-    }                                               // At the end of the scope, the SharedPtr is destroyed. Because no other SharedPtrs
-                                                    // point at the object, the object itself is also destroyed automatically
-    @endcode
-
-    This is especially handy if you do not know what will happen with an object that was
-    created with new, for example if you pass it to another object. If multiple instances
-    share a pointer to the same object, none of these instances can delete the object
-    without interfering with the other instances. But if none of the instances destroy the
-    object, it will never be destroyed and results in a memory leak. With a SharedPtr
-    however you don't have to think about destroying the object, because the SharedPtr
-    itself keeps track of the references.
-
-    Example:
-
-    Classic implementation using new and delete:
-    @code
-    class OtherClass                                    // Declaration of some class
-    {
-        public:
-            OtherClass(MyClass* object)                 // Constructor
-            {
-                this->object_ = object;                 // Assigns the pointer to the member variable object_
-            }
-
-            ~OtherClass()                               // Destructor
-            {
-                ???                                     // What to do with object_?
-            }
-
-        private:
-            MyClass* object_;                           // A pointer to the object
-    };
-
-    void someFunction()
-    {
-        MyClass* object = new MyClass();                // Create a new instance of MyClass
-
-        OtherClass* other1 = new OtherClass(object);    // Create an instance of OtherClass and pass the object pointer
-        OtherClass* other2 = new OtherClass(object);    // "
-        OtherClass* other3 = new OtherClass(object);    // "
-
-        ???                                             // What happens with object now?
-    }
-    @endcode
-
-    If you use SharedPtr<MyClass> instead of a classic MyClass* pointer, the instance of
-    MyClass would be automatically destroyed if all instances of OtherClass are destroyed.
-    You don't need any code in the destructor and you can completely forget about the
-    object, because its managed by the SharedPtr.
-
-    The same code using SharedPtr:
-    @code
-    class OtherClass                                        // Declaration of some class
-    {
-        public:
-            OtherClass(const SharedPtr<MyClass>& object)    // Constructor
-            {
-                this->object_ = object;                     // Assigns the pointer to the member variable object_
-            }
-
-        private:
-            SharedPtr<MyClass> object_;                     // A SharedPtr to the object
-    };
-
-    void someFunction()
-    {
-        SharedPtr<MyClass> object = new MyClass();          // Create a new instance of MyClass
-
-        OtherClass* other1 = new OtherClass(object);        // Create an instance of OtherClass and pass the object pointer
-        OtherClass* other2 = new OtherClass(object);        // "
-        OtherClass* other3 = new OtherClass(object);        // "
-
-    }                                                       // The SharedPtr "object" is destroyed at the end of the scope,
-                                                            // but the three instances of OtherClass keep the object alive
-                                                            // until they are all destroyed.
-    @endcode
-*/
-
-#ifndef _SharedPtr_H__
-#define _SharedPtr_H__
-
-#include "UtilPrereqs.h"
-
-#include <algorithm>
-#include <cassert>
-
-#include "SmallObjectAllocator.h"
-
-namespace orxonox
-{
-    namespace detail
-    {
-        /// BaseClass of SharedCounterImpl, has a counter that is initialized with 1
-        class SharedCounter
-        {
-            public:
-                SharedCounter() : count_(1) {}
-                virtual ~SharedCounter() {}
-                virtual void destroy() = 0;
-
-                int count_;
-        };
-
-        /// Child class of SharedCounter, keeps a pointer to an object of type T that can be destroyed with destroy()
-        template <class T>
-        class SharedCounterImpl : public SharedCounter
-        {
-            public:
-                SharedCounterImpl(T* pointer) : pointer_(pointer) {}
-
-                void destroy()
-                {
-                    delete this->pointer_;
-                }
-
-            private:
-                T* pointer_;
-        };
-
-        _UtilExport SmallObjectAllocator& createSharedCounterPool();
-
-        ORX_FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
-        {
-            static SmallObjectAllocator& instance = createSharedCounterPool();
-            return instance;
-        }
-    }
-
-    /**
-        @brief The SharedPtr template is a utility to manage pointers to an object.
-        @param T The type of the managed object
-
-        SharedPtr acts like a real pointer, except that it keeps track of the number of
-        references to the object. If the the number of references drops to zero, the
-        object is destroyed automatically.
-
-        @see See @ref SharedPtrExample "this description" for some examples and more information.
-
-        @note The number of references is stored in a separate object that is shared
-        among all instances of SharedPtr that point to the same pointer. This object is
-        also responsible for destroying the pointer if the reference counter becomes zero.
-    */
-    template <class T>
-    class SharedPtr
-    {
-        template <class O>
-        friend class SharedPtr;
-
-        public:
-            /// Default constructor, the pointer is set to NULL.
-            inline SharedPtr() : pointer_(0), counter_(0)
-            {
-            }
-
-            /// Constructor, creates a SharedPtr that points to @a pointer, increments the counter.
-            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0)
-            {
-                if (this->pointer_)
-                {
-                    void* chunk = detail::getSharedCounterPool().alloc();
-                    this->counter_ = new (chunk) detail::SharedCounterImpl<T>(this->pointer_);
-                }
-            }
-
-            /// Copy-constructor, this SharedPtr now points to the same object like the other SharedPtr, increments the counter.
-            inline SharedPtr(const SharedPtr& other) : pointer_(other.pointer_), counter_(other.counter_)
-            {
-                if (this->pointer_)
-                    ++this->counter_->count_;
-            }
-
-            /// Copy-constructor for SharedPtr with another template agument, increments the counter.
-            template <class O>
-            inline SharedPtr(const SharedPtr<O>& other) : pointer_(other.pointer_), counter_(other.counter_)
-            {
-                if (this->pointer_)
-                    ++this->counter_->count_;
-            }
-
-            /// Destructor, decrements the counter and deletes the object if the counter becomes zero.
-            inline ~SharedPtr()
-            {
-                if (this->pointer_)
-                {
-                    --this->counter_->count_;
-
-                    if (this->counter_->count_ == 0)
-                    {
-                        this->counter_->destroy();
-                        detail::getSharedCounterPool().free(this->counter_);
-                    }
-                }
-            }
-
-            /// Assigns a new object, decrements the counter of the old object, increments the counter of the new object.
-            inline SharedPtr& operator=(const SharedPtr& other)
-            {
-                SharedPtr(other).swap(*this);
-                return *this;
-            }
-
-            /// Assigns a new object with another template argument, decrements the counter of the old object, increments the counter of the new object.
-            template <class O>
-            inline SharedPtr& operator=(const SharedPtr<O>& other)
-            {
-                SharedPtr(other).swap(*this);
-                return *this;
-            }
-
-            /// Casts the pointer to another type
-            template <class O>
-            inline SharedPtr<O> cast() const
-            {
-                O* temp = static_cast<O*>(this->pointer_); // temp value for prettier compiler error in case of an invalid static_cast
-                return SharedPtr<O>(temp, this->counter_);
-            }
-
-            /// Overloaded -> operator, returns the pointer to the managed object.
-            inline T* operator->() const
-            {
-                assert(this->pointer_ != 0);
-                return this->pointer_;
-            }
-
-            /// Overloaded * operator, returns a reference ot the managed object.
-            inline T& operator*() const
-            {
-                assert(this->pointer_ != 0);
-                return *this->pointer_;
-            }
-
-            /// Returns the pointer to the managed object.
-            inline T* get() const
-            {
-                return this->pointer_;
-            }
-
-            /// Returns true if the pointer is not NULL.
-            inline operator bool() const
-            {
-                return (this->pointer_ != 0);
-            }
-
-            /// Swaps the pointer and the counter of two instances of SharedPtr with the same template argument.
-            inline void swap(SharedPtr& other)
-            {
-                std::swap(this->pointer_, other.pointer_);
-                std::swap(this->counter_, other.counter_);
-            }
-
-        private:
-            /// Private constructor, used by the cast() function.
-            inline SharedPtr(T* pointer, detail::SharedCounter* counter) : pointer_(pointer), counter_(counter)
-            {
-                if (this->pointer_)
-                    ++this->counter_->count_;
-            }
-
-            T* pointer_;                        ///< A pointer to the managed object of type @a T
-            detail::SharedCounter* counter_;    ///< A pointer to the shared reference counter
-    };
-
-    /**
-        @brief A child class of SharedPtr, used to reflect the hierarchy of the underlying class @a T.
-        @param T The type of the managed object
-        @param Parent The type of the SharedPtr that manages the parent class of @a T
-
-        This class is used to reflect the hierarchy of the underlying class @a T.
-        For example the @c Functor classes: While a @c Functor* pointer would be managed by
-        @c SharedPtr<Functor>, the child class @c FunctorStatic is managed by the class
-        <tt>SharedChildPtr<FunctorStatic, SharedPtr<Functor> ></tt>.
-
-        The second template argument @a Parent is used as the parent class of
-        SharedChildPtr. This means that each instance of <tt>SharedChildPtr<T, Parent></tt>
-        can be upcasted to @c Parent.
-
-        So for example this works:
-        @code
-        SharedChildPtr<FunctorStatic, SharedPtr<Functor> > functorStatic = createFunctor(&MyClass::myStaticFunction);
-        SharedPtr<Functor> functor = functorStatic;
-        @endcode
-
-        @note There are some typedefs and more to make the usage of SharedChildPtr easier
-        for the classes Functor and Executor. See FunctorPtr.h and ExecutorPtr.h. The above
-        example could thus be simplified the following way:
-        @code
-        FunctorStaticPtr functorStatic = createFunctor(&MyClass::myStaticFunction);
-        FunctorPtr functor = functorStatic;
-        @endcode
-
-        @see See SharedPtr for more information about the base class SharedPtr.
-        @see See @ref SharedPtrExample "this description" for some examples about how to use SharedPtr.
-    */
-    template <class T, class Parent>
-    class SharedChildPtr : public Parent
-    {
-        public:
-            inline SharedChildPtr() : Parent() {}
-            inline SharedChildPtr(T* pointer) : Parent(pointer) {}
-            inline SharedChildPtr(const SharedPtr<T>& other) : Parent(other) {}
-
-            inline T* operator->() const { return static_cast<T*>(Parent::operator->()); }
-            inline T& operator*() const { return *static_cast<T*>(Parent::operator->()); }
-    };
-
-}
-
-#endif /* _SharedPtr_H__ */
Index: code/branches/cpp11_v3/src/libraries/util/SignalHandler.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/SignalHandler.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/SignalHandler.cc	(revision 11054)
@@ -44,5 +44,5 @@
 namespace orxonox
 {
-    SignalHandler* SignalHandler::singletonPtr_s = NULL;
+    SignalHandler* SignalHandler::singletonPtr_s = nullptr;
 }
 
@@ -81,7 +81,7 @@
     void SignalHandler::dontCatch()
     {
-      for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
-      {
-        signal( it->signal, it->handler );
+      for (const SignalRec& sigRec : sigRecList)
+      {
+        signal( sigRec.signal, sigRec.handler );
       }
 
@@ -127,5 +127,5 @@
       }
       // if the signalhandler has already been destroyed then don't do anything
-      if( SignalHandler::singletonPtr_s == 0 )
+      if( SignalHandler::singletonPtr_s == nullptr )
       {
         orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
@@ -133,7 +133,7 @@
       }
 
-      for ( SignalCallbackList::iterator it = SignalHandler::getInstance().callbackList.begin(); it != SignalHandler::getInstance().callbackList.end(); it++  )
-      {
-        (*(it->cb))( it->someData );
+      for (const SignalCallbackRec& callback : SignalHandler::getInstance().callbackList)
+      {
+        (*(callback.cb))( callback.someData );
       }
 
@@ -175,5 +175,5 @@
         dup2( gdbErr[1], STDERR_FILENO );
 
-        execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(NULL));
+        execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(nullptr));
       }
 
@@ -186,5 +186,5 @@
         perror("pipe failed!\n");
         kill( gdbPid, SIGTERM );
-        waitpid( gdbPid, NULL, 0 );
+        waitpid( gdbPid, nullptr, 0 );
         exit(EXIT_FAILURE);
       }
@@ -196,5 +196,5 @@
         perror("fork failed!\n");
         kill( gdbPid, SIGTERM );
-        waitpid( gdbPid, NULL, 0 );
+        waitpid( gdbPid, nullptr, 0 );
         exit(EXIT_FAILURE);
       }
@@ -297,6 +297,6 @@
 
 
-      waitpid( sigPid, NULL, 0 );
-      waitpid( gdbPid, NULL, 0 );
+      waitpid( sigPid, nullptr, 0 );
+      waitpid( gdbPid, nullptr, 0 );
 
       int wsRemoved = 0;
@@ -312,5 +312,5 @@
         bt.erase(0, 1);
 
-      time_t now = time(NULL);
+      time_t now = time(nullptr);
 
       std::string timeString =
@@ -388,5 +388,5 @@
     SignalHandler::SignalHandler()
     {
-        this->prevExceptionFilter_ = NULL;
+        this->prevExceptionFilter_ = nullptr;
     }
 
@@ -394,9 +394,9 @@
     SignalHandler::~SignalHandler()
     {
-        if (this->prevExceptionFilter_ != NULL)
+        if (this->prevExceptionFilter_ != nullptr)
         {
             // Remove the unhandled exception filter function
             SetUnhandledExceptionFilter(this->prevExceptionFilter_);
-            this->prevExceptionFilter_ = NULL;
+            this->prevExceptionFilter_ = nullptr;
         }
     }
@@ -408,7 +408,7 @@
 
         // don't register twice
-        assert(this->prevExceptionFilter_ == NULL);
-
-        if (this->prevExceptionFilter_ == NULL)
+        assert(this->prevExceptionFilter_ == nullptr);
+
+        if (this->prevExceptionFilter_ == nullptr)
         {
             // Install the unhandled exception filter function
@@ -430,5 +430,5 @@
 
             // if the signalhandler has already been destroyed then don't do anything
-            if (SignalHandler::singletonPtr_s == 0)
+            if (SignalHandler::singletonPtr_s == nullptr)
             {
                 orxout(user_error) << "Caught an unhandled exception" << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
@@ -441,5 +441,5 @@
             std::ofstream crashlog(SignalHandler::getInstance().filename_.c_str());
 
-            time_t now = time(NULL);
+            time_t now = time(nullptr);
 
             crashlog << "=======================================================" << endl;
@@ -480,5 +480,5 @@
     }
 
-    /// Returns the stack trace for either the current function, or, if @a pExceptionInfo is not NULL, for the given exception context.
+    /// Returns the stack trace for either the current function, or, if @a pExceptionInfo is not nullptr, for the given exception context.
     /* static */ std::string SignalHandler::getStackTrace(PEXCEPTION_POINTERS pExceptionInfo)
     {
@@ -625,5 +625,5 @@
 #ifdef ORXONOX_COMPILER_GCC
                 int status;
-                char* demangled = __cxxabiv1::__cxa_demangle(symbol->Name, NULL, NULL, &status);
+                char* demangled = __cxxabiv1::__cxa_demangle(symbol->Name, nullptr, nullptr, &status);
                 if (demangled)
                 {
@@ -684,5 +684,5 @@
         HMODULE hModule;
 
-        std::string output = (GetModuleFileName(NULL, szModule, MAX_PATH) ? SignalHandler::getModuleName(szModule) : "Application");
+        std::string output = (GetModuleFileName(nullptr, szModule, MAX_PATH) ? SignalHandler::getModuleName(szModule) : "Application");
         output += " caused ";
 
Index: code/branches/cpp11_v3/src/libraries/util/SignalHandler.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/SignalHandler.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/SignalHandler.h	(revision 11054)
@@ -113,5 +113,5 @@
             void doCatch(const std::string& appName, const std::string& filename);
 
-            static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = NULL);
+            static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = nullptr);
             static std::string getExceptionType(PEXCEPTION_POINTERS pExceptionInfo);
 
Index: code/branches/cpp11_v3/src/libraries/util/Singleton.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/Singleton.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/Singleton.h	(revision 11054)
@@ -66,5 +66,5 @@
     And don't forget to initialize the static singleton pointer in the source (*.cc) %file:
     @code
-    TestSingleton* TestSingleton::singletonPtr_s = NULL;
+    TestSingleton* TestSingleton::singletonPtr_s = nullptr;
     @endcode
 
@@ -118,5 +118,5 @@
         static T& getInstance()
         {
-            OrxVerify(T::singletonPtr_s != NULL, "T=" << typeid(T).name());
+            OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
             return *T::singletonPtr_s;
         }
@@ -125,5 +125,5 @@
         static bool exists()
         {
-            return (T::singletonPtr_s != NULL);
+            return (T::singletonPtr_s != nullptr);
         }
 
@@ -132,5 +132,5 @@
         Singleton()
         {
-            OrxVerify(T::singletonPtr_s == NULL, "T=" << typeid(T).name());
+            OrxVerify(T::singletonPtr_s == nullptr, "T=" << typeid(T).name());
             T::singletonPtr_s = static_cast<T*>(this);
         }
@@ -139,10 +139,12 @@
         virtual ~Singleton()
         {
-            OrxVerify(T::singletonPtr_s != NULL, "T=" << typeid(T).name());
-            T::singletonPtr_s = NULL;
+            OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
+            T::singletonPtr_s = nullptr;
         }
 
     private:
-        Singleton(const Singleton& rhs); //!< Don't use (undefined)
+        // non-copyable:
+        Singleton(const Singleton&) = delete;
+        Singleton& operator=(const Singleton&) = delete;
     };
 }
Index: code/branches/cpp11_v3/src/libraries/util/SmallObjectAllocator.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/SmallObjectAllocator.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/SmallObjectAllocator.cc	(revision 11054)
@@ -45,5 +45,5 @@
         this->chunkSize_ = std::max(objectSize, sizeof(Chunk)); // the chunk's size will be the maximum of the object's size and the size of a Chunk object itself
         this->numChunksPerBlock_ = numObjects;
-        this->first_ = 0;
+        this->first_ = nullptr;
     }
 
@@ -53,6 +53,6 @@
     SmallObjectAllocator::~SmallObjectAllocator()
     {
-        for (std::vector<char*>::iterator it = this->blocks_.begin(); it != this->blocks_.end(); ++it)
-            delete[] *it;
+        for (char* block : this->blocks_)
+            delete[] block;
     }
 
@@ -97,6 +97,6 @@
                 setNext(block + i * this->chunkSize_, block + (i + 1) * this->chunkSize_);
 
-            // the next_ pointer of the last chunk must point to NULL
-            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
+            // the next_ pointer of the last chunk must point to nullptr
+            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, nullptr);
 
             // The second chunk in the block is assigned to the first_ pointer
Index: code/branches/cpp11_v3/src/libraries/util/SmallObjectAllocator.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/SmallObjectAllocator.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/SmallObjectAllocator.h	(revision 11054)
@@ -77,4 +77,5 @@
 #include "UtilPrereqs.h"
 #include <vector>
+#include <cstdio>
 
 namespace orxonox
Index: code/branches/cpp11_v3/src/libraries/util/StringUtils.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/StringUtils.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/StringUtils.cc	(revision 11054)
@@ -36,5 +36,4 @@
 #include <cctype>
 #include <ctime>
-#include <boost/scoped_array.hpp>
 #include "Convert.h"
 #include "Math.h"
@@ -263,7 +262,7 @@
         std::string output(str.size() * 2, ' ');
         size_t i = 0;
-        for (size_t pos = 0; pos < str.size(); ++pos)
-        {
-            switch (str[pos])
+        for (const char& character : str)
+        {
+            switch (character)
             {
             case '\\': output[i] = '\\'; output[i + 1] = '\\'; break;
@@ -277,5 +276,5 @@
             case  '"': output[i] = '\\'; output[i + 1] =  '"'; break;
             case '\0': output[i] = '\\'; output[i + 1] =  '0'; break;
-            default  : output[i] = str[pos]; ++i; continue;
+            default  : output[i] = character; ++i; continue;
             }
             i += 2;
@@ -337,7 +336,7 @@
     void lowercase(std::string* str)
     {
-        for (size_t i = 0; i < str->size(); ++i)
-        {
-            (*str)[i] = static_cast<char>(tolower((*str)[i]));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(tolower(character));
         }
     }
@@ -354,7 +353,7 @@
     void uppercase(std::string* str)
     {
-        for (size_t i = 0; i < str->size(); ++i)
-        {
-            (*str)[i] = static_cast<char>(toupper((*str)[i]));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(toupper(character));
         }
     }
@@ -461,9 +460,9 @@
     {
         size_t j = 0;
-        for (size_t i = 0; i < str.size(); ++i)
-        {
-            if (str[i] == target)
+        for (char& character : str)
+        {
+            if (character == target)
             {
-                str[i] = replacement;
+                character = replacement;
                 ++j;
             }
@@ -482,5 +481,5 @@
         size_t cols = str1.size() + 1;
         size_t rows = str2.size() + 1;
-        boost::scoped_array<int> matrix(new int[rows * cols]);
+        const std::unique_ptr<int[]> matrix(new int[rows * cols]);
 
         for (size_t r = 0; r < rows; ++r)
Index: code/branches/cpp11_v3/src/libraries/util/SubString.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/SubString.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/SubString.cc	(revision 11054)
@@ -112,5 +112,5 @@
         for (size_t i = 0; i < argc; ++i)
         {
-            this->tokens_.push_back(std::string(argv[i]));
+            this->tokens_.emplace_back(argv[i]);
             this->bTokenInSafemode_.push_back(false);
         }
Index: code/branches/cpp11_v3/src/libraries/util/UtilPrereqs.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/UtilPrereqs.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/UtilPrereqs.h	(revision 11054)
@@ -80,6 +80,4 @@
     class OutputStream;
     class ScopeListener;
-    template <class T>
-    class SharedPtr;
     class SignalHandler;
     template <class T>
Index: code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.cc	(revision 11054)
@@ -47,5 +47,5 @@
         this->configurableMaxLevel_ = level::none;
         this->configurableAdditionalContextsMaxLevel_ = level::verbose;
-        this->configurableAdditionalContexts_.push_back("example");
+        this->configurableAdditionalContexts_.emplace_back("example");
 
         this->changedConfigurableLevel();
@@ -116,8 +116,6 @@
 
         // iterate over all strings in the config-vector
-        for (size_t i = 0; i < this->configurableAdditionalContexts_.size(); ++i)
+        for (const std::string& full_name : this->configurableAdditionalContexts_)
         {
-            const std::string& full_name = this->configurableAdditionalContexts_[i];
-
             // split the name into main-name and sub-name (if given; otherwise sub-name remains empty). both names are separated by ::
             std::string name = full_name;
Index: code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.h	(revision 11054)
@@ -103,5 +103,5 @@
 
         protected:
-            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines);
+            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) override;
 
         private:
Index: code/branches/cpp11_v3/src/libraries/util/output/ConsoleWriter.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/ConsoleWriter.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/ConsoleWriter.h	(revision 11054)
@@ -53,5 +53,4 @@
         public:
             ConsoleWriter(std::ostream& outputStream);
-            ConsoleWriter(const ConsoleWriter&);
             virtual ~ConsoleWriter();
 
@@ -63,7 +62,11 @@
 
         protected:
-            virtual void printLine(const std::string& line, OutputLevel level);
+            virtual void printLine(const std::string& line, OutputLevel level) override;
 
         private:
+            // non-copyable:
+            ConsoleWriter(const ConsoleWriter&) = delete;
+            ConsoleWriter& operator=(const ConsoleWriter&) = delete;
+
             std::ostream& outputStream_; ///< The ostream to which the console writer writes its output
             bool bEnabled_;              ///< If false, the instance will not write output to the console.
Index: code/branches/cpp11_v3/src/libraries/util/output/LogWriter.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/LogWriter.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/LogWriter.cc	(revision 11054)
@@ -35,4 +35,5 @@
 
 #include <ctime>
+#include <chrono>
 #include <cstdlib>
 
@@ -43,5 +44,5 @@
 namespace orxonox
 {
-    static const int MAX_ARCHIVED_FILES = 9;
+    static constexpr int MAX_ARCHIVED_FILES = 9;
 
     /**
@@ -180,14 +181,20 @@
             return;
 
+        // get the milliseconds
+        std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+        std::chrono::system_clock::duration timeSinceEpoch = now.time_since_epoch();
+        std::chrono::milliseconds millisSinceEpoch = std::chrono::duration_cast<std::chrono::milliseconds>(timeSinceEpoch);
+        unsigned int millis = (millisSinceEpoch.count() % 1000);
+
         // get the current time
-        time_t rawtime;
-        struct tm* timeinfo;
-        time(&rawtime);
-        timeinfo = localtime(&rawtime);
+        time_t rawtime = std::chrono::system_clock::to_time_t(now);
+        struct tm* timeinfo = localtime(&rawtime);
+
+        // format time: hh:mm:ss:xxx
+        char buffer[13];
+        snprintf(buffer, sizeof(buffer), "%.2i:%.2i:%.2i:%.3i", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, millis);
 
         // print timestamp and output line to the log file
-        this->file_ << (timeinfo->tm_hour < 10 ? "0" : "") << timeinfo->tm_hour << ':' <<
-                       (timeinfo->tm_min  < 10 ? "0" : "") << timeinfo->tm_min  << ':' <<
-                       (timeinfo->tm_sec  < 10 ? "0" : "") << timeinfo->tm_sec  << ' ' << line << std::endl;
+        this->file_ << buffer << ' ' << line << std::endl;
     }
 }
Index: code/branches/cpp11_v3/src/libraries/util/output/LogWriter.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/LogWriter.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/LogWriter.h	(revision 11054)
@@ -57,5 +57,4 @@
         public:
             LogWriter();
-            LogWriter(const LogWriter&);
             virtual ~LogWriter();
 
@@ -70,7 +69,11 @@
 
         protected:
-            virtual void printLine(const std::string& line, OutputLevel level);
+            virtual void printLine(const std::string& line, OutputLevel level) override;
 
         private:
+            // non-copyable:
+            LogWriter(const LogWriter&) = delete;
+            LogWriter& operator=(const LogWriter&) = delete;
+
             void openFile();
             void closeFile();
Index: code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.cc	(revision 11054)
@@ -57,5 +57,5 @@
     void MemoryWriter::output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
     {
-        this->messages_.push_back(Message(level, context, lines));
+        this->messages_.emplace_back(level, context, lines);
     }
 
@@ -65,7 +65,6 @@
     void MemoryWriter::resendOutput(OutputListener* listener) const
     {
-        for (size_t i = 0; i < this->messages_.size(); ++i)
+        for (const Message& message : this->messages_)
         {
-            const Message& message = this->messages_[i];
             listener->unfilteredOutput(message.level, *message.context, message.lines);
         }
Index: code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.h	(revision 11054)
@@ -68,5 +68,4 @@
         public:
             MemoryWriter();
-            MemoryWriter(const MemoryWriter&);
             virtual ~MemoryWriter();
 
@@ -75,7 +74,11 @@
 
         protected:
-            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines);
+            virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) override;
 
         private:
+            // non-copyable:
+            MemoryWriter(const MemoryWriter&) = delete;
+            MemoryWriter& operator=(const MemoryWriter&) = delete;
+
             std::vector<Message> messages_; ///< Stores all output messages from the creation of this instance until disable() is called.
     };
Index: code/branches/cpp11_v3/src/libraries/util/output/OutputDefinitions.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/OutputDefinitions.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/OutputDefinitions.h	(revision 11054)
@@ -132,8 +132,8 @@
     namespace context
     {
-        static const OutputContextMask all       = 0xFFFFFFFFFFFFFFFFull; ///< Context mask, all bits set to 1
-        static const OutputContextMask none      = 0x0000000000000000ull; ///< Context mask, all bits set to 0
+        static constexpr OutputContextMask all       = 0xFFFFFFFFFFFFFFFFull; ///< Context mask, all bits set to 1
+        static constexpr OutputContextMask none      = 0x0000000000000000ull; ///< Context mask, all bits set to 0
 
-        static const OutputContextSubID no_subcontext = 0; ///< Used as ID for contexts which are not sub-contexts
+        static constexpr OutputContextSubID no_subcontext = 0; ///< Used as ID for contexts which are not sub-contexts
 
         namespace
Index: code/branches/cpp11_v3/src/libraries/util/output/OutputListener.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/OutputListener.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/OutputListener.cc	(revision 11054)
@@ -111,6 +111,6 @@
         this->levelMask_ = mask;
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->updatedLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedLevelMask(this);
     }
 
@@ -142,6 +142,6 @@
         this->additionalContextsLevelMask_ = mask;
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->updatedAdditionalContextsLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsLevelMask(this);
     }
 
@@ -153,6 +153,6 @@
         this->additionalContextsMask_ = mask;
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->updatedAdditionalContextsMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsMask(this);
     }
 
Index: code/branches/cpp11_v3/src/libraries/util/output/OutputManager.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/OutputManager.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/OutputManager.cc	(revision 11054)
@@ -41,5 +41,4 @@
 #include "util/Output.h"
 #include "util/StringUtils.h"
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -57,7 +56,7 @@
 
         this->isInitialized_ = false;
-        this->memoryWriterInstance_ = 0;
-        this->consoleWriterInstance_ = 0;
-        this->logWriterInstance_ = 0;
+        this->memoryWriterInstance_ = nullptr;
+        this->consoleWriterInstance_ = nullptr;
+        this->logWriterInstance_ = nullptr;
 
         // register 'undefined' context in order to give it always the first context-ID
@@ -81,7 +80,7 @@
     }
 
-    /*static*/ SharedPtr<OutputManager>& OutputManager::Testing::getInstancePointer()
-    {
-        static SharedPtr<OutputManager> instance(new OutputManager());
+    /*static*/ std::shared_ptr<OutputManager>& OutputManager::Testing::getInstancePointer()
+    {
+        static std::shared_ptr<OutputManager> instance(new OutputManager());
         return instance;
     }
@@ -132,6 +131,6 @@
         vectorize(message, '\n', &lines);
 
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->listeners_[i]->unfilteredOutput(level, context, lines);
+        for (OutputListener* listener : this->listeners_)
+            listener->unfilteredOutput(level, context, lines);
     }
 
@@ -179,6 +178,6 @@
     {
         int mask = 0;
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            mask |= this->listeners_[i]->getLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getLevelMask();
         this->combinedLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -190,6 +189,6 @@
     {
         int mask = 0;
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            mask |= this->listeners_[i]->getAdditionalContextsLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getAdditionalContextsLevelMask();
         this->combinedAdditionalContextsLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -201,6 +200,6 @@
     {
         this->combinedAdditionalContextsMask_ = 0;
-        for (size_t i = 0; i < this->listeners_.size(); ++i)
-            this->combinedAdditionalContextsMask_ |= this->listeners_[i]->getAdditionalContextsMask();
+        for (OutputListener* listener : this->listeners_)
+            this->combinedAdditionalContextsMask_ |= listener->getAdditionalContextsMask();
     }
 
Index: code/branches/cpp11_v3/src/libraries/util/output/OutputManager.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/OutputManager.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/OutputManager.h	(revision 11054)
@@ -41,4 +41,5 @@
 #include <vector>
 #include <map>
+#include <memory>
 
 #include "OutputDefinitions.h"
@@ -66,5 +67,4 @@
         public:
             OutputManager();
-            OutputManager(const OutputManager&);
             virtual ~OutputManager();
 
@@ -81,9 +81,9 @@
             virtual void unregisterListener(OutputListener* listener);
 
-            virtual void updatedLevelMask(const OutputListener* listener)
+            virtual void updatedLevelMask(const OutputListener* listener) override
                 { this->updateCombinedLevelMask(); }
-            virtual void updatedAdditionalContextsLevelMask(const OutputListener* listener)
+            virtual void updatedAdditionalContextsLevelMask(const OutputListener* listener) override
                 { this->updateCombinedAdditionalContextsLevelMask(); }
-            virtual void updatedAdditionalContextsMask(const OutputListener* listener)
+            virtual void updatedAdditionalContextsMask(const OutputListener* listener) override
                 { this->updateCombinedAdditionalContextsMask(); }
 
@@ -114,4 +114,8 @@
 
         private:
+            // non-copyable:
+            OutputManager(const OutputManager&) = delete;
+            OutputManager& operator=(const OutputManager&) = delete;
+
             void updateMasks();
             void updateCombinedLevelMask();
@@ -137,5 +141,5 @@
             struct _UtilExport Testing
             {
-                static SharedPtr<OutputManager>& getInstancePointer();
+                static std::shared_ptr<OutputManager>& getInstancePointer();
             };
     };
Index: code/branches/cpp11_v3/src/libraries/util/output/OutputStream.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/OutputStream.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/OutputStream.cc	(revision 11054)
@@ -41,7 +41,6 @@
         @brief Default constructor, initializes level and context with default values.
     */
-    OutputStream::OutputStream()
+    OutputStream::OutputStream() : OutputStream(level::debug_output, context::undefined())
     {
-        this->setOutputAttributes(level::debug_output, context::undefined());
     }
 
Index: code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.cc
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.cc	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.cc	(revision 11054)
@@ -79,8 +79,8 @@
 
         // compose the mask of subcontexts and build the set of sub-context-IDs
-        for (std::set<const OutputContextContainer*>::const_iterator it = subcontexts.begin(); it != subcontexts.end(); ++it)
+        for (const OutputContextContainer* subcontext : subcontexts)
         {
-            this->subcontextsCheckMask_ |= (*it)->mask;
-            this->subcontexts_.insert((*it)->sub_id);
+            this->subcontextsCheckMask_ |= subcontext->mask;
+            this->subcontexts_.insert(subcontext->sub_id);
         }
 
Index: code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.h
===================================================================
--- code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.h	(revision 11053)
+++ code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.h	(revision 11054)
@@ -73,8 +73,8 @@
             virtual ~SubcontextOutputListener();
 
-            virtual void setAdditionalContextsMask(OutputContextMask mask);
+            virtual void setAdditionalContextsMask(OutputContextMask mask) override;
             void setAdditionalSubcontexts(const std::set<const OutputContextContainer*>& subcontexts);
 
-            virtual bool acceptsOutput(OutputLevel level, const OutputContextContainer& context) const;
+            virtual bool acceptsOutput(OutputLevel level, const OutputContextContainer& context) const override;
 
             inline const std::set<OutputContextSubID>& getSubcontexts() const
