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

code/branches/cpp11_v3

Property svn:mergeinfo changed

/code/branches/cpp11 (added)	merged: 10439-10441,10443,10545
/code/branches/cpp11_v2	merged: 10732-10734,10736,10742,10744-10745,10765,10768-10778,10781,10813,10817-10818,10821-10822,10825,10828-10830,10845-10846,10852-10853,10857,10865,10876,10916-10920,10922,10975-10994

code/branches/cpp11_v3/src/libraries/core/ApplicationPaths.cc

-                      r10624
+                      r11054
     //! Static pointer to the singleton
     ApplicationPaths* ApplicationPaths::singletonPtr_s  = 0;
+    ApplicationPaths* ApplicationPaths::singletonPtr_s  = nullptr;
     ApplicationPaths::ApplicationPaths()
 …
         // 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.");

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

-                      r10624
+                      r11054
         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);

code/branches/cpp11_v3/src/libraries/core/BaseObject.cc

-                      r10624
+                      r11054
         this->bRegisteredEventStates_ = false;
         this->lastLoadedXMLElement_ = 0;
         this->mainStateFunctor_ = 0;
+        this->lastLoadedXMLElement_ = nullptr;
+        this->mainStateFunctor_ = nullptr;
         if (context)
 …
         else
+        {
             this->file_ = 0;
+            this->file_ = nullptr;
             this->sceneID_ = OBJECTID_UNKNOWN;
+        }
 …
         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);
 …
         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);
+    }
 …
             Template* link;
             assert(!(link = Template::getTemplate(temp->getLink())) || !link->isLink());
             link = NULL;
+            link = nullptr;
+        }
         else
 …
+    {
         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;
+    }
 …
+    {
         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;
+    }
 …
+    {
         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;
+    }
 …
             return (it->second);
         else
             return 0;
+            return nullptr;
+    }
 …
         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);
+        }
+    }
 …
     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);
+    }
 …
     void BaseObject::changedMainStateName()
+    {
         this->mainStateFunctor_ = 0;
+        this->mainStateFunctor_ = nullptr;
         if (!this->mainStateName_.empty())
 …
             // 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);

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

-                      r10624
+                      r11054
             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; }
 …
             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
 …
             return this->weakPtr_;
         else
             return NULL;
+            return nullptr;
+    }

code/branches/cpp11_v3/src/libraries/core/ClassTreeMask.cc

-                      r10624
+                      r11054
             return ((*this->nodes_.top().first) == compare);
         else
             return (compare == 0);
+            return (compare == nullptr);
+    }
 …
             return ((*this->nodes_.top().first) != compare);
         else
             return (compare != 0);
+            return (compare != nullptr);
+    }
 …
+        {
             // 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);
+        }
 …
+        {
             // 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;
+                }
 …
         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);
 …
             // 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
 …
             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 ++
 …
             // 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
 …
                     // 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
 …
             // 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));
+        }
+    }

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

-                      r10693
+                      r11054
             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)
     };
 …
             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);
 …
         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; }
 …
             /// 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_); }
 …
             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
     };
+}

code/branches/cpp11_v3/src/libraries/core/ConfigurablePaths.cc

-                      r10624
+                      r11054
 #include "util/Exception.h"
 #include "commandline/CommandLineIncludes.h"
+#include "core/ApplicationPaths.h"
 // Differentiate Boost Filesystem v2 and v3
 …
     //! Static pointer to the singleton
     ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = 0;
+    ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = nullptr;
     SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
 …
             char* userDataPathPtr(getenv("APPDATA"));
 #endif
             if (userDataPathPtr == NULL)
+            if (userDataPathPtr == nullptr)
                 ThrowException(General, "Could not retrieve user data path.");
             bf::path userDataPath(userDataPathPtr);
 …
         // 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)
+        {

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

-                      r10624
+                      r11054
         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

code/branches/cpp11_v3/src/libraries/core/Core.cc

-                      r11011
+                      r11054
+{
     //! Static pointer to the singleton
     Core* Core::singletonPtr_s  = 0;
+    Core* Core::singletonPtr_s  = nullptr;
     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
 …
     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)
+    {
 …
         // 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
 …
         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);
 …
     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;
 …
         module->deleteAllStaticallyInitializedInstances();
         this->dynLibManager_->unload(module->getDynLib());
         module->setDynLib(NULL);
+        module->setDynLib(nullptr);
+    }
 …
+    {
         // 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_)
+        {
 …
+        }
         // Process console events and status line
         if (this->ioConsole_ != NULL)
+        if (this->ioConsole_ != nullptr)
             this->ioConsole_->preUpdate(time);
         // Process thread commands
 …
+    {
         // 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_)
+        {

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

-                      r11012
+                      r11054
             /// Leave empty and use destroy() instead
             ~Core() {}
+            ~Core() = default;
             /// Destructor that also executes when the object fails to construct
             void destroy();
 …
         private:
+            Core(const Core&); //!< Don't use (undefined symbol)
+            // non-copyable:
+            Core(const Core&) = delete;
+            Core& operator=(const Core&) = delete;
             void setThreadAffinity(int limitToCPU);

code/branches/cpp11_v3/src/libraries/core/CoreConfig.cc

-                      r11052
+                      r11054
 #include "core/Language.h"
 #include "core/ApplicationPaths.h"
+#include <random>
 namespace orxonox
 …
+    {
         // 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_);
+    }
 …
         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;
 …
     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)));
+    }

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

r11052	r11054
76	76	public:
77	77	DevModeListener();
78		virtual ~DevModeListener() {}
	78	virtual ~DevModeListener() = default;
79	79	virtual void devModeChanged(bool value) = 0;
80	80	};

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

-                      r11020
+                      r11054
 */
 #define RegisterAbstractClass(ClassName) \
     RegisterClassWithFactory(ClassName, static_cast<ClassFactory<ClassName>*>(NULL), false)
+    RegisterClassWithFactory(ClassName, static_cast<ClassFactory<ClassName>*>(nullptr), false)
 /**
 …
         struct InheritsFromClass : public Identifier::InheritsFrom
+        {
             virtual Identifier* getParent() const { return Class(T); }
+            virtual Identifier* getParent() const override { return Class(T); }
         };
 …
             ~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_);

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

-                      r8858
+                      r11054
 #include <sstream>  // 53
 #include <set>      // 50
+#include <memory>
 #include "util/Output.h" // 48
 …
 #include <OgreColourValue.h> // 36
 #include <boost/preprocessor/cat.hpp> // 27
-#include <boost/shared_ptr.hpp> // 21
 #ifdef ORXONOX_COMPILER_MSVC
 …
 #include "util/SubString.h"  // 14
-#include <boost/scoped_ptr.hpp> // 13
 #include <stack> // 12

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

-                      r10624
+                      r11054
 namespace orxonox
+{
     static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
+    static constexpr uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
+}
 …
         //!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;
+    }
 …
         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;
+    }

code/branches/cpp11_v3/src/libraries/core/CoreStaticInitializationHandler.cc

-                      r10624
+                      r11054
         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
 …
         // 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;
+            }
 …
         // 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);
+            }
+        }

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

-                      r10624
+                      r11054
             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)

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

-                      r8729
+                      r11054
 #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); \

code/branches/cpp11_v3/src/libraries/core/GUIManager.cc

-                      r11052
+                      r11054
 #include <fstream>
 #include <memory>
 #include <boost/bind.hpp>
+#include <functional>
 #include <OgreRenderQueue.h>
 #include <OgreRenderWindow.h>
 …
 namespace orxonox
+{
+    namespace arg = std::placeholders;
     static void key_esc()
         { GUIManager::getInstance().keyESC(); }
 …
+    {
     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;
 …
         /// 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)
 …
                 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())
 …
     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())
 …
     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)
 …
     */
     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)
+    {
 …
         // 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_));
 …
         // 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");
 …
         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
 …
+    {
         assert(guiSystem_);
         this->protectedCeguiSystemCall(boost::bind(&CEGUI::System::injectTimePulse, _1, time.getDeltaTime()));
+        this->protectedCeguiSystemCall(std::bind(&CEGUI::System::injectTimePulse, arg::_1, time.getDeltaTime()));
+    }
 …
+    {
 #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
 …
+    {
 #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
+    }
 …
+    {
 #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
+    }
 …
+    {
 #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
+    }
 …
+    {
 #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
+    }
 …
+    {
 #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
+    }
 …
+    {
 #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
+    }
 …
+    {
 #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
+    }
 …
         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.
 …
             return;
         CEGUI::Font* font = NULL;
+        CEGUI::Font* font = nullptr;
         CEGUI::XMLAttributes xmlAttributes;
 …
         font = CEGUI::FontManager::getSingleton().createFont("FreeType", xmlAttributes);
         if(font != NULL)
+        if(font != nullptr)
             font->load();
 #else

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

-                      r11052
+                      r11054
 #include <map>
 #include <string>
+#include <memory>
 #if CEGUI_VERSION >= 0x000800
 …
 #   include <CEGUIVersion.h>
 #endif
-#include <boost/shared_ptr.hpp>
 #include "util/DestructionHelper.h"
 …
         //! Leave empty and use cleanup() instead
         ~GUIManager() {}
+        ~GUIManager() = default;
         /// Destructor that also executes when object fails to construct
         void destroy();
 …
         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
 …
     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);
 …
         // 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
 …
         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

code/branches/cpp11_v3/src/libraries/core/Game.cc

-                      r10624
+                      r11054
 #include <exception>
-#include <boost/weak_ptr.hpp>
 #include <loki/ScopeGuard.h>
 …
     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.
 …
+    {
         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)
+    {
 …
         // 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_;
 …
         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();
 …
         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())
 …
+    {
         // 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
 …
                 // 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())
 …
+        }
         shared_ptr<GameStateTreeNode> lastRequestedNode;
+        std::shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->loadedTopStateNode_;
 …
         // 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)
+        {
 …
+        {
             // 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)
 …
                 requestedNodes.push_back(currentNode);
+            }
             if (currentNode == NULL)
+            if (currentNode == nullptr)
                 requestedNodes.clear();
+        }
 …
     void Game::popState()
+    {
         shared_ptr<GameStateTreeNode> lastRequestedNode;
+        std::shared_ptr<GameStateTreeNode> lastRequestedNode;
         if (this->requestedStateNodes_.empty())
             lastRequestedNode = this->loadedTopStateNode_;
 …
+    }
     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);
 …
             else
                 orxout(internal_error) << "Could not find GameState '" << name << "'." << endl;
             return shared_ptr<GameState>();
+            return std::shared_ptr<GameState>();
+        }
+    }
 …
+    {
         // 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;
 …
             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_);
+    }
 …
     /*** 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)
 …
             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;
 …
             // 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!
+                }
 …
             graphicsUnloader.Dismiss();
         shared_ptr<GameState> state = this->getState(name);
+        std::shared_ptr<GameState> state = this->getState(name);
         state->activateInternal();
         if (!this->loadedStates_.empty())
 …
         try
+        {
             shared_ptr<GameState> state = this->getState(name);
+            std::shared_ptr<GameState> state = this->getState(name);
             state->activity_.topState = false;
             this->loadedStates_.pop_back();
 …
         // 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)
 …
+    }
     /*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);

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

-                      r10624
+                      r11054
 #include <string>
 #include <vector>
 #include <boost/shared_ptr.hpp>
+#include <memory>
 #include <boost/preprocessor/cat.hpp>
 …
     { // 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:
 …
         //! 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();
 …
+        {
         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>
 …
+        {
         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)); }
         };
 …
         };
+        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);

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

-                      r7401
+                      r11054
         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).

code/branches/cpp11_v3/src/libraries/core/GraphicsManager.cc

-                      r10624
+                      r11054
 #include <sstream>
 #include <boost/filesystem.hpp>
-#include <boost/shared_array.hpp>
 #include <OgreFrameListener.h>
 …
+    {
     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>();
 …
     GraphicsManager::GraphicsManager(bool bLoadRenderer)
         : ogreWindowEventListener_(new OgreWindowEventListener())
         , renderWindow_(0)
         , viewport_(0)
+        , renderWindow_(nullptr)
+        , viewport_(nullptr)
         , lastFrameStartTime_(0.0f)
         , lastFrameEndTime_(0.0f)
 …
     void GraphicsManager::upgradeToGraphics()
+    {
         if (renderWindow_ != NULL)
+        if (renderWindow_ != nullptr)
             return;
 …
         //       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);
 …
         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
 …
         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);
+    }

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

-                      r10624
+                      r11054
 #include <cassert>
 #include <string>
+#include <memory>
 #include <OgreLog.h>
-#include <boost/shared_ptr.hpp>
 #include "util/DestructionHelper.h"
 …
         //! Leave empty and use cleanup() instead
         ~GraphicsManager() {}
+        ~GraphicsManager() = default;
         /// Destructor that also executes when object fails to construct
         void destroy();
 …
         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
 …
         // 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
 …
         // 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

code/branches/cpp11_v3/src/libraries/core/Language.cc

-                      r10624
+                      r11054
     // ###############################
     Language* Language::singletonPtr_s = 0;
+    Language* Language::singletonPtr_s = nullptr;
     /**
 …
     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);
+    }
 …
         // 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;
+        }

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

-                      r10624
+                      r11054
         private:
+            Language(const Language&);
+            // non-copyable:
+            Language(const Language&) = delete;
+            Language& operator=(const Language&) = delete;
             void readDefaultLanguageFile();

code/branches/cpp11_v3/src/libraries/core/Loader.cc

-                      r10624
+                      r11054
 #include <sstream>
 #include <tinyxml/ticpp.h>
-#include <boost/scoped_ptr.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
 …
 namespace orxonox
+{
     Loader* Loader::singletonPtr_s = 0;
+    Loader* Loader::singletonPtr_s = nullptr;
     /**
 …
         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
 …
+        {
             // 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);
 …
         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;
 …
                     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;
 …
         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()))
 …
+        {
             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

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

r10624	r11054
67	67	static bool getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags);
68	68
69		std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_;
	69	std::vector<std::pair<const XMLFile*, ClassTreeMask>> files_;
70	70
71	71	static Loader* singletonPtr_s;

code/branches/cpp11_v3/src/libraries/core/LuaState.cc

-                      r10265
+                      r11054
     LuaState::LuaState()
         : bIsRunning_(false)
         , includeParseFunction_(NULL)
+        , includeParseFunction_(nullptr)
+    {
         // Create new lua state and configure it
 …
+    }
     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;
 …
     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
 …
+    }
     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
 …
         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);
+        }
 …
     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
 …
+    }
     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
 …
             //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
 …
+            {
                 //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);
+            }
+        }
 …
     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
 …
         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
 …
     /*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;
 …
         // 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
 …
         // 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());
+        }
 …
     /*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());
+        }
+    }

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

-                      r10265
+                      r11054
 #include <string>
 #include <vector>
 #include <boost/shared_ptr.hpp>
+#include <memory>
 #include "util/Output.h"
 …
         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
 …
         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
 …
     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&);

code/branches/cpp11_v3/src/libraries/core/Namespace.cc

r10624	r11054
53	53	{
54	54	if (this->bRoot_)
55		for (~~std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it~~)
56		delete ~~(*it)~~;
	55	for (NamespaceNode* node : this->representingNamespaces_)
	56	delete node;
57	57	}
58	58
…	…
80	80	for (unsigned int i = 0; i < tokens.size(); i++)
81	81	{
82		for (~~std::set<NamespaceNode*>::iterator it = this->getNamespace()->representingNamespaces_.begin(); it != this->getNamespace()->representingNamespaces_.end(); ++it~~)
	82	for (NamespaceNode* node : this->getNamespace()->representingNamespaces_)
83	83	{
84		std::set<NamespaceNode> temp = ~~(it)~~->getNodeRelative(tokens[i]);
	84	std::set<NamespaceNode*> temp = node->getNodeRelative(tokens[i]);
85	85	this->representingNamespaces_.insert(temp.begin(), temp.end());
86	86	}
…	…
93	93	if (this->bAutogeneratedFileRootNamespace_)
94	94	{
95		for (~~std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it~~)
	95	for (NamespaceNode* node : this->representingNamespaces_)
96	96	{
97		~~(*it)~~->setRoot(true);
98		~~(*it)~~->setHidden(true);
	97	node->setRoot(true);
	98	node->setHidden(true);
99	99	}
100	100	}
…	…
109	109	const BaseObject* Namespace::saveObjects(unsigned int index) const
110	110	{
111		return 0; // todo
	111	return nullptr; // todo
112	112	}
113	113
114	114	bool Namespace::includes(const Namespace* ns) const
115	115	{
116		for (~~std::set<NamespaceNode*>::const_iterator it1 = this->representingNamespaces_.begin(); it1 != this->representingNamespaces_.end(); ++it1~~)
	116	for (NamespaceNode* node1 : this->representingNamespaces_)
117	117	{
118		for (~~std::set<NamespaceNode*>::const_iterator it2 = ns->representingNamespaces_.begin(); it2 != ns->representingNamespaces_.end(); ++it2~~)
	118	for (NamespaceNode* node2 : ns->representingNamespaces_)
119	119	{
120		if (~~(it1)->includes(it~~2))
	120	if (node1->includes(node2))
121	121	{
122	122	if (this->operator_ == "or")
…	…
149	149
150	150	int i = 0;
151		for (~~std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it~~)
	151	for (NamespaceNode* node : this->representingNamespaces_)
152	152	{
153	153	if (i > 0)
154	154	output += " / ";
155	155
156		output += (*it)->toString();
	156	output += node->toString();
	157	i++;
157	158	}
158	159
…	…
165	166
166	167	int i = 0;
167		for (~~std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it~~)
	168	for (NamespaceNode* node : this->representingNamespaces_)
168	169	{
169	170	if (i > 0)
170	171	output += '\n';
171	172
172		output += (*it)->toString(indentation);
	173	output += node->toString(indentation);
	174	i++;
173	175	}
174	176

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

r9667	r11054
50	50	virtual ~Namespace();
51	51
52		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	52	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
53	53
54	54	void loadObjects(BaseObject* object);

code/branches/cpp11_v3/src/libraries/core/NamespaceNode.cc

-                      r8858
+                      r11054
                 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;
 …
         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;
+        }
 …
             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++;
+            }
 …
         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;

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

r7401	r11054
46	46	{
47	47	public:
48		NamespaceNode(const std::string& name, NamespaceNode* parent = 0);
	48	NamespaceNode(const std::string& name, NamespaceNode* parent = nullptr);
49	49	~NamespaceNode();
50	50

code/branches/cpp11_v3/src/libraries/core/Resource.cc

r9675	r11054
58	58	DataStreamListPtr resources(new Ogre::DataStreamList());
59	59	const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
60		for (~~Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it~~)
	60	for (const std::string& group : groups)
61	61	{
62		DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, *it);
	62	DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
63	63	resources->insert(resources->end(), temp->begin(), temp->end());
64	64	}
…	…
79	79	}
80	80
81		shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name)
	81	std::shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name)
82	82	{
83	83	std::string group;
…	…
88	88	catch (const Ogre::Exception&)
89	89	{
90		return shared_ptr<ResourceInfo>();
	90	return std::shared_ptr<ResourceInfo>();
91	91	}
92	92	Ogre::FileInfoListPtr infos = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(group, name);
…	…
95	95	if (it->filename == name)
96	96	{
97		s~~hared_ptr<ResourceInfo> ptr(new ResourceInfo~~());
	97	std::shared_ptr<ResourceInfo> ptr(std::make_shared<ResourceInfo>());
98	98	ptr->filename = name;
99	99	ptr->path = it->path;
…	…
102	102	ptr->size = it->uncompressedSize;
103	103	#if OGRE_VERSION >= 0x010800
104		if (dynamic_cast<const Ogre::FileSystemArchive*>(it->archive) != ~~NULL~~)
	104	if (dynamic_cast<const Ogre::FileSystemArchive*>(it->archive) != nullptr)
105	105	#else
106		if (dynamic_cast<Ogre::FileSystemArchive*>(it->archive) != ~~NULL~~)
	106	if (dynamic_cast<Ogre::FileSystemArchive*>(it->archive) != nullptr)
107	107	#endif
108	108	{
…	…
114	114	}
115	115	}
116		return shared_ptr<ResourceInfo>();
	116	return std::shared_ptr<ResourceInfo>();
117	117	}
118	118
…	…
121	121	StringVectorPtr resourceNames(new Ogre::StringVector());
122	122	const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
123		for (~~Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it~~)
	123	for (const std::string& group : groups)
124	124	{
125		StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(*it, pattern);
	125	StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(group, pattern);
126	126	resourceNames->insert(resourceNames->end(), temp->begin(), temp->end());
127	127	}

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

-                      r8351
+                      r11054
 #include "CorePrereqs.h"
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <OgreDataStream.h>
 #include <OgreStringVector.h>
 …
         //! 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);
 …
             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);
         /**
 …
     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;
     };
+}

code/branches/cpp11_v3/src/libraries/core/Template.cc

r9667	r11054
49	49	this->bLoadDefaults_ = true;
50	50	this->bIsReturningXMLElement_ = false;
51		this->baseclassIdentifier_ = 0;
	51	this->baseclassIdentifier_ = nullptr;
52	52	}
53	53
…	…
176	176	{
177	177	orxout(internal_warning, context::templates) << "Template with name " << name << " doesn't exist." << endl;
178		return 0;
	178	return nullptr;
179	179	}
180	180	}

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

-                      r9667
+                      r11054
             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)

code/branches/cpp11_v3/src/libraries/core/Thread.cc

-                      r8399
+                      r11054
 #include <cassert>
+#include <functional>
 #include <boost/thread/thread.hpp>
-#include <boost/bind.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread_time.hpp>
 …
     Thread::Thread():
         executor_(0),
+        executor_(nullptr),
         isWorking_(false),
         stopThread_(false)
 …
         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) );
+    }
 …
                 (*executor)();
                 this->executorMutex_->lock();
                 this->executor_ = 0;
+                this->executor_ = nullptr;
                 this->executorMutex_->unlock();
                 this->isWorkingMutex_->lock();

code/branches/cpp11_v3/src/libraries/core/ThreadPool.cc

r8394	r11054
83	83	bool ThreadPool::passFunction( const ExecutorPtr& executor, bool addThread )
84	84	{
85		std::vector<Thread*>::iterator it;
86		for ( it=this->threadPool_.begin(); it!=this->threadPool_.end(); ++it )
	85	for ( Thread* thread : threadPool_ )
87	86	{
88		if ( ! ~~(*it)~~->isWorking() )
	87	if ( ! thread->isWorking() )
89	88	{
90	89	// If that fails, then there is some code error
91		OrxVerify( ~~(*it)~~->evaluateExecutor( executor ), "ERROR: could not evaluate Executor" );
	90	OrxVerify( thread->evaluateExecutor( executor ), "ERROR: could not evaluate Executor" );
92	91	return true;
93	92	}
…	…
105	104	void ThreadPool::synchronise()
106	105	{
107		std::vector<Thread*>::iterator it;
108		for ( it=this->threadPool_.begin(); it!=this->threadPool_.end(); ++it )
	106	for ( Thread* thread : this->threadPool_ )
109	107	{
110		~~(*it)~~->waitUntilFinished();
	108	thread->waitUntilFinished();
111	109	}
112	110	}

code/branches/cpp11_v3/src/libraries/core/ThreadWin.cc

-                      r8706
+                      r11054
 #include <cassert>
+// #include <functional>
 // #include <boost/thread/thread.hpp>
-// #include <boost/bind.hpp>
 // #include <boost/thread/mutex.hpp>
 // #include <boost/thread/thread_time.hpp>
 …
     Thread::Thread():
         executor_(0),
+        executor_(nullptr),
         isWorking_(false),
         stopThread_(false)
 …
 //         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) );
+    }
 …
 //                 (*executor)();
 //                 this->executorMutex_->lock();
 //                 this->executor_ = 0;
+//                 this->executor_ = nullptr;
 //                 this->executorMutex_->unlock();
 //                 this->isWorkingMutex_->lock();

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

r9667	r11054
44	44	protected:
45	45	ViewportEventListener();
46		virtual ~ViewportEventListener() {}
	46	virtual ~ViewportEventListener() = default;
47	47	};
48	48	}

code/branches/cpp11_v3/src/libraries/core/WindowEventListener.cc

r10624	r11054
45	45	/static/ void WindowEventListener::moveWindow()
46	46	{
47		for (~~ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it~~)
48		it->windowMoved();
	47	for (WindowEventListener* listener : ObjectList<WindowEventListener>())
	48	listener->windowMoved();
49	49	}
50	50
…	…
54	54	windowWidth_s = newWidth;
55	55	windowHeight_s = newHeight;
56		for (~~ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it~~)
57		it->windowResized(newWidth, newHeight);
	56	for (WindowEventListener* listener : ObjectList<WindowEventListener>())
	57	listener->windowResized(newWidth, newHeight);
58	58	}
59	59
…	…
61	61	/static/ void WindowEventListener::changeWindowFocus(bool bFocus)
62	62	{
63		for (~~ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it~~)
64		it->windowFocusChanged(bFocus);
	63	for (WindowEventListener* listener : ObjectList<WindowEventListener>())
	64	listener->windowFocusChanged(bFocus);
65	65	}
66	66	}

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

r9667	r11054
47	47	protected:
48	48	WindowEventListener();
49		virtual ~WindowEventListener() ~~{ }~~
	49	virtual ~WindowEventListener() = default;
50	50
51	51	//! Returns the current render window width

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

r9667	r11054
44	44	public:
45	45	XMLNameListener();
46		virtual ~XMLNameListener() {}
	46	virtual ~XMLNameListener() = default;
47	47
48	48	virtual void loadedNewXMLName(BaseObject* object) = 0;

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

r9667	r11054
245	245	return my_added_objects[index];
246	246	else
247		return 0;
	247	return nullptr;
248	248	}
249	249	@endcode
…	…
334	334	XMLPortParamContainer()
335	335	{ this->parseResult_ = PR_not_started; }
336		virtual ~XMLPortParamContainer() {}
	336	virtual ~XMLPortParamContainer() = default;
337	337
338	338	inline const std::string& getName() const
…	…
378	378	}
379	379
380		~~~XMLPortClassParamContainer()~~
381		{
382		}
383
384	380	XMLPortParamContainer& port(BaseObject* owner, T* object, Element& xmlelement, XMLPort::Mode mode)
385	381	{
…	…
399	395	// Iterate through the attributes manually in order to make them case insensitive
400	396	ticpp::Attribute* attribute = xmlelement.FirstAttribute(false);
401		while (attribute != 0)
	397	while (attribute != nullptr)
402	398	{
403	399	this->owner_->xmlAttributes_[getLowercase(attribute->Name())] = attribute->Value();
…	…
459	455	}
460	456
461		virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param)
	457	virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param) override
462	458	{
463	459	if (!this->loadexecutor_->defaultValueSet(index))
…	…
465	461	return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
466	462	}
467		virtual XMLPortParamContainer& defaultValues(const MultiType& param1)
	463	virtual XMLPortParamContainer& defaultValues(const MultiType& param1) override
468	464	{
469	465	if (!this->loadexecutor_->defaultValueSet(0))
…	…
471	467	return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
472	468	}
473		virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2)
	469	virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2) override
474	470	{
475	471	if ((!this->loadexecutor_->defaultValueSet(0)) \|\| (!this->loadexecutor_->defaultValueSet(1)))
…	…
477	473	return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
478	474	}
479		virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
	475	virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3) override
480	476	{
481	477	if ((!this->loadexecutor_->defaultValueSet(0)) \|\| (!this->loadexecutor_->defaultValueSet(1)) \|\| (!this->loadexecutor_->defaultValueSet(2)))
…	…
483	479	return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
484	480	}
485		virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
	481	virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) override
486	482	{
487	483	if ((!this->loadexecutor_->defaultValueSet(0)) \|\| (!this->loadexecutor_->defaultValueSet(1)) \|\| (!this->loadexecutor_->defaultValueSet(2)) \|\| (!this->loadexecutor_->defaultValueSet(3)))
…	…
489	485	return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
490	486	}
491		virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
	487	virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) override
492	488	{
493	489	if ((!this->loadexecutor_->defaultValueSet(0)) \|\| (!this->loadexecutor_->defaultValueSet(1)) \|\| (!this->loadexecutor_->defaultValueSet(2)) \|\| (!this->loadexecutor_->defaultValueSet(3)) \|\| (!this->loadexecutor_->defaultValueSet(4)))
…	…
511	507	XMLPortObjectContainer()
512	508	{ this->bApplyLoaderMask_ = false; }
513		virtual ~XMLPortObjectContainer() {}
	509	virtual ~XMLPortObjectContainer() = default;
514	510
515	511	XMLPortObjectContainer& port(BaseObject* object, Element& xmlelement, XMLPort::Mode mode);
…	…
552	548	}
553	549
554		~XMLPortClassObjectContainer()
555		{
556		}
557
558		void callLoadExecutor(BaseObject* object, BaseObject* newObject)
	550	virtual void callLoadExecutor(BaseObject* object, BaseObject* newObject) override
559	551	{
560	552	T* castObject = orxonox_cast<T*>(object);

code/branches/cpp11_v3/src/libraries/core/class/Identifiable.cc

r10624	r11054
48	48	Identifiable::Identifiable()
49	49	{
50		this->identifier_ = 0;
	50	this->identifier_ = nullptr;
51	51	this->objectPointers_.reserve(6); // Optimisation
52	52

code/branches/cpp11_v3/src/libraries/core/class/Identifiable.h

-                      r9667
+                      r11054
                 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)
 …
                         return this->objectPointers_[i].second;
+                }
                 return NULL;
+                return nullptr;
+            }
 …
             /// '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_;
     };
+}

code/branches/cpp11_v3/src/libraries/core/class/Identifier.cc

-                      r10624
+                      r11054
             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);
+    }
 …
             orxout(user_error) << "Aborting..." << endl;
             abort();
             return 0;
+            return nullptr;
+        }
+    }
 …
         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
 …
             // 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();
 …
             // 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
 …
             // 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);
+            }
+        }
 …
         // 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();
+        }
 …
         // 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);
+        }
 …
             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;
+        }
 …
             return it->second;
         else
             return 0;
+            return nullptr;
+    }
 …
             return it->second;
         else
             return 0;
+            return nullptr;
+    }
 …
             return it->second;
         else
             return 0;
+            return nullptr;
+    }

code/branches/cpp11_v3/src/libraries/core/class/Identifier.h

-                      r10624
+                      r11054
     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
 …
 #include <typeinfo>
 #include <loki/TypeTraits.h>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 #include "util/Output.h"
 …
         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.
 …
             /// 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);
 …
     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
 …
             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;
 …
             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;
 …
             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;
     /**
 …
     /*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;
+    }
 …
             // 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;
+        }
 …
     void ClassIdentifier<T>::destroyObjects()
+    {
         this->destroyObjects((T*)0);
+        this->destroyObjects((T*)nullptr);
+    }
 …
     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++));
+    }
 …
     void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
+    {
         this->updateConfigValues(updateChildren, static_cast<T*>(NULL));
+        this->updateConfigValues(updateChildren, static_cast<T*>(nullptr));
+    }
 …
             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);
+    }
 …
         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.
 …
 #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);

code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.cc

-                      r10624
+                      r11054
 namespace orxonox
+{
     IdentifierManager* IdentifierManager::singletonPtr_s = 0;
+    IdentifierManager* IdentifierManager::singletonPtr_s = nullptr;
     IdentifierManager::IdentifierManager()
+    {
         this->hierarchyCreatingCounter_s = 0;
         this->recordTraceForIdentifier_ = NULL;
+        this->recordTraceForIdentifier_ = nullptr;
+    }
 …
         this->identifiers_.insert(identifier);
+        this->identifierByTypeIndex_[identifier->getTypeInfo()] = identifier;
         this->identifierByString_[identifier->getName()] = identifier;
         this->identifierByLowercaseString_[getLowercase(identifier->getName())] = identifier;
 …
+    {
         this->identifiers_.erase(identifier);
+        this->identifierByTypeIndex_.erase(identifier->getTypeInfo());
         this->identifierByString_.erase(identifier->getName());
         this->identifierByLowercaseString_.erase(getLowercase(identifier->getName()));
 …
         // 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;
 …
                     Identifiable* temp = identifier->fabricate(&temporaryContext);
                     this->recordTraceForIdentifier_ = NULL;
+                    this->recordTraceForIdentifier_ = nullptr;
                     if (temp->getIdentifier() != identifier)
 …
         // 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.
 …
+    {
         // 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;
+                }
+            }
 …
+    {
         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();
+    }
 …
             return it->second;
         else
             return 0;
+            return nullptr;
+    }
 …
             return it->second;
         else
             return 0;
+            return nullptr;
+    }
 …
             return it->second;
         else
             return 0;
+            return nullptr;
+    }
 …
     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;
+    }

code/branches/cpp11_v3/src/libraries/core/class/IdentifierManager.h

-                      r10624
+                      r11054
 #include "core/CorePrereqs.h"
+#include <typeindex>
 #include <map>
+#include <unordered_map>
 #include <set>
 #include <list>
 …
         public:
             IdentifierManager();
             ~IdentifierManager() {}
+            ~IdentifierManager() = default;
             void addIdentifier(Identifier* identifier);
 …
         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.
 …
                 { 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)
 …
             /// 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.

code/branches/cpp11_v3/src/libraries/core/class/SubclassIdentifier.h

r9667	r11054
127	127	else
128	128	{
129		orxout(internal_error) << "Can't assign ~~NULL~~ identifier" << endl;
	129	orxout(internal_error) << "Can't assign nullptr identifier" << endl;
130	130	}
131	131	}
…	…
189	189	orxout(user_error) << "Aborting..." << endl;
190	190	abort();
191		return 0;
	191	return nullptr;
192	192	}
193	193	}

code/branches/cpp11_v3/src/libraries/core/class/Super.h

-                      r10624
+                      r11054
             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(); \
             } \
 …
             { \
                 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; \
                 } \
             } \
 …
                 // 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)
 …
                 // 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;
+                }
+            }
 …
         // 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();

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

-                      r10624
+                      r11054
             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;
 …
                 // 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));
+                }
 …
                 // 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)
 …
                 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));
+                }
 …
+            {
                 ArgumentCompletionList list;
                 list.push_back(ArgumentCompletionListElement("", "", hint));
+                list.emplace_back("", "", hint);
                 return list;
+            }
 …
             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);
 …
+                {
                     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;
+                }
 …
             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;
 …
             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;
 …
+                {
                     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);
+                }
+            }
 …
             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;

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

-                      r11052
+                      r11054
+        {
             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");
+        }

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

-                      r10624
+                      r11054
     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;
 …
     /**
         @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)
     */
 …
                 // 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) + "\".";
 …
         // 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)
 …
         // 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)
 …
+    {
         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;
 …
+        {
             // 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() + ' ');
+                }
+            }
 …
                 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
 …
+    {
         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 += ' ';
+        }

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

-                      r8079
+                      r11054
             int execute();
             MultiType query(int* error = 0);
+            MultiType query(int* error = nullptr);
             std::string complete();
 …
             /// 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.
 …
             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

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

-                      r10624
+                      r11054
         @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)
 …
         @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)
 …
+        {
             // 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

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

-                      r8858
+                      r11054
             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);
 …
         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();

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

-                      r10624
+                      r11054
     */
     ConsoleCommand::ConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized)
+    {
         this->init("", name, executor, bInitialized);
+        : ConsoleCommand("", name, executor, bInitialized)
+    {
+    }
 …
         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;
 …
             this->executor_ = executor;
         this->names_.push_back(CommandName(group, name));
+        this->names_.emplace_back(group, name);
+    }
 …
     ConsoleCommand& ConsoleCommand::addShortcut()
+    {
         this->names_.push_back(CommandName("", this->baseName_));
+        this->names_.emplace_back("", this->baseName_);
         return *this;
+    }
 …
     ConsoleCommand& ConsoleCommand::addShortcut(const std::string&  name)
+    {
         this->names_.push_back(CommandName("", name));
+        this->names_.emplace_back("", name);
         return *this;
+    }
 …
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group)
+    {
         this->names_.push_back(CommandName(group, this->baseName_));
+        this->names_.emplace_back(group, this->baseName_);
         return *this;
+    }
 …
     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;
+    }
 …
+    {
         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;
 …
     /**
         @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();
+    }
 …
     void ConsoleCommand::popObject()
+    {
         void* newobject = 0;
+        void* newobject = nullptr;
         if (!this->objectStack_.empty())
+        {
 …
             return this->executor_->getFunctor()->getRawObjectPointer();
         else
             return 0;
+            return nullptr;
+    }
 …
             return this->argumentCompleter_[index];
         else
             return 0;
+            return nullptr;
+    }

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

-                      r10624
+                      r11054
                         { 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; }
 …
                     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; }

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

-                      r10624
+                      r11054
             ~StaticallyInitializedConsoleCommand() { delete command_; }
             virtual void load();
             virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
             inline ConsoleCommand& getCommand()
 …
         @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.
 …
         @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.

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

r11052	r11054
39	39	namespace orxonox
40	40	{
41		ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = 0;
	41	ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = nullptr;
42	42
43	43	/**
…	…
50	50	{
51	51	// find the group
52		std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMap_.find(group);
	52	std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMap_.find(group);
53	53	if (it_group != this->commandMap_.end())
54	54	{
…	…
68	68	orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
69	69	}
70		return 0;
	70	return nullptr;
71	71	}
72	72
…	…
83	83
84	84	// find the group
85		std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMapLC_.find(groupLC);
	85	std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMapLC_.find(groupLC);
86	86	if (it_group != this->commandMapLC_.end())
87	87	{
…	…
101	101	orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
102	102	}
103		return 0;
	103	return nullptr;
104	104	}
105	105
…	…
125	125
126	126	// check if a command with this name already exists
127		if (this->getCommand(group, name) != 0)
	127	if (this->getCommand(group, name) != nullptr)
128	128	{
129	129	if (group == "")
…	…
146	146	{
147	147	// iterate through all groups
148		for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
	148	for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
149	149	{
150	150	// iterate through all commands of each group
…	…
168	168
169	169	// iterate through all groups
170		for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
	170	for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
171	171	{
172	172	// iterate through all commands of each group

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

-                      r10624
+                      r11054
 #include "util/Singleton.h"
+#include <map>
 namespace orxonox
+{
 …
             /// 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_; }
 …
         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;

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

-                      r9550
+                      r11054
     /**
-        @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
 …
         @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
 …
         @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

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

-                      r9550
+                      r11054
     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,
 …
     @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().
 */
 …
             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.
 …
                 { 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.
 …
             /// 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();
 …
     inline ExecutorPtr createExecutor(const FunctorPtr& functor, const std::string& name = "")
+    {
         return new Executor(functor, name);
+        return std::make_shared<Executor>(functor, name);
+    }
 …
     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);
+    }
 …
     inline ExecutorStaticPtr createExecutor(const FunctorStaticPtr& functor, const std::string& name = "")
+    {
         return new ExecutorStatic(functor, name);
+        return std::make_shared<ExecutorStatic>(functor, name);
+    }
+}

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

-                      r7401
+                      r11054
     @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
 …
 #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>>;
+}

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

-                      r9667
+                      r11054
     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:
 …
         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)
 …
             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;
 …
         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
 …
             // see Functor::getType()
             inline Functor::Type::Enum getType() const
+            virtual inline Functor::Type::Enum getType() const override
                 { return Functor::Type::Member; }
 …
             // 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_)
 …
         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
     };
 …
         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 {}
     };
 …
     /**
         @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
 …
         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.
 …
                 { return this->functionPointer_; }
-            // see Functor::getFullIdentifier()
-            const std::type_info& getFullIdentifier() const
-                { return typeid(F); }
         protected:
             F functionPointer_;     ///< The stored function-pointer
 …
     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
 …
         { 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<> {};
+    }
 …
         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
 …
         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;
 …
             // 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 "";
+                }
 …
             // 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
+}

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

-                      r7401
+                      r11054
     @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
 …
 #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>>;
+}

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

-                      r9667
+                      r11054
 namespace orxonox
+{
     IOConsole* IOConsole::singletonPtr_s = NULL;
+    IOConsole* IOConsole::singletonPtr_s = nullptr;
     namespace EscapeMode
 …
         , promptString_("orxonox # ")
         , bStatusPrinted_(false)
         , originalTerminalSettings_(0)
+        , originalTerminalSettings_(nullptr)
+    {
         this->setTerminalMode();
 …
             tcsetattr(0, TCSANOW, IOConsole::singletonPtr_s->originalTerminalSettings_);
             delete IOConsole::singletonPtr_s->originalTerminalSettings_;
             IOConsole::singletonPtr_s->originalTerminalSettings_ = 0;
+            IOConsole::singletonPtr_s->originalTerminalSettings_ = nullptr;
+        }
+    }
 …
         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;

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

-                      r8858
+                      r11054
         // 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();

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

-                      r9676
+                      r11054
 namespace orxonox
+{
     IOConsole* IOConsole::singletonPtr_s = NULL;
+    IOConsole* IOConsole::singletonPtr_s = nullptr;
     //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
 …
                 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_);
 …
             // 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);
+        }
+    }
 …
             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)

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

-                      r9676
+                      r11054
         // 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();

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

r10624	r11054
44	44	namespace orxonox
45	45	{
46		static const unsigned int IRC_TCL_THREADID = 1421421421; ///< The ID of the thread in TclThreadManager that is used for the IRC connection
	46	static constexpr unsigned int IRC_TCL_THREADID = 1421421421; ///< The ID of the thread in TclThreadManager that is used for the IRC connection
47	47
48	48	SetConsoleCommand("IRC", "say", &IRC::say);
…	…
66	66	IRC::IRC()
67	67	{
68		this->interpreter_ = 0;
	68	this->interpreter_ = nullptr;
69	69	}
70	70

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

-                      r7401
+                      r11054
             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

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

-                      r10624
+                      r11054
         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);
+    }

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

-                      r10624
+                      r11054
         public:
+            virtual ~ShellListener() {}
+            ShellListener() = default;
+            virtual ~ShellListener() = default;
         private:
 …
             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;
 …
         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);
 …
             void clearInput();
             // BaseWriter
             virtual void printLine(const std::string& line, OutputLevel level);
+            virtual void printLine(const std::string& line, OutputLevel level) override;
             void configureInputBuffer();

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

-                      r10624
+                      r11054
     SetConsoleCommand("bgerror", &TclBind::bgerror).hide();
     TclBind* TclBind::singletonPtr_s = 0;
+    TclBind* TclBind::singletonPtr_s = nullptr;
     /**
 …
     TclBind::TclBind(const std::string& datapath)
+    {
         this->interpreter_ = 0;
+        this->interpreter_ = nullptr;
         this->bSetTclDataPath_ = false;
         this->setDataPath(datapath);
 …
         @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)
     */

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

-                      r8079
+                      r11054
             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);

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

-                      r7401
+                      r11054
         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;

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

r10624	r11054
34	34	#include "TclThreadManager.h"
35	35
36		#include <~~boost/bind.hpp~~>
	36	#include <functional>
37	37	#include <boost/thread/thread.hpp>
38	38	#include <boost/thread/locks.hpp>
…	…
86	86	};
87	87
88		TclThreadManager* TclThreadManager::singletonPtr_s = 0;
	88	TclThreadManager* TclThreadManager::singletonPtr_s = nullptr;
89	89
90	90	/**
…	…
145	145	{
146	146	boost::shared_lock<boost::shared_mutex> lock(*this->interpreterBundlesMutex_);
147		for (~~std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it~~)
	147	for (const auto& mapEntry : this->interpreterBundles_)
148	148	{
149		if (~~it->~~first == 0)
	149	if (mapEntry.first == 0)
150	150	continue; // We'll handle the default interpreter later (and without threads of course)
151	151
152		TclInterpreterBundle* bundle = ~~it->~~second;
	152	TclInterpreterBundle* bundle = mapEntry.second;
153	153	if (!bundle->queue_.empty())
154	154	{
…	…
163	163	{
164	164	// Start a thread to execute the command
165		boost::thread(~~boost~~::bind(&tclThread, bundle, command));
	165	boost::thread(std::bind(&tclThread, bundle, command));
166	166	}
167	167	else
…	…
289	289	catch (const Tcl::tcl_error& e)
290	290	{
291		bundle->interpreter_ = 0;
	291	bundle->interpreter_ = nullptr;
292	292	orxout(user_error, context::tcl) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << endl;
293	293	}
…	…
488	488	void TclThreadManager::source(const std::string& file)
489	489	{
490		boost::thread(~~boost~~::bind(&sourceThread, file));
	490	boost::thread(std::bind(&sourceThread, file));
491	491	}
492	492
…	…
521	521	{
522	522	TclThreadManager::error("No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
523		return 0;
	523	return nullptr;
524	524	}
525	525	}
…	…
551	551
552	552	std::list<unsigned int> threads;
553		for (~~std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it~~)
554		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)
555		threads.push_back(~~it->~~first);
	553	for (const auto& mapEntry : this->interpreterBundles_)
	554	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)
	555	threads.push_back(mapEntry.first);
556	556	return threads;
557	557	}

code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineIncludes.h

-                      r10535
+                      r11054
             ~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_); }

code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.cc

-                      r10542
+                      r11054
 namespace orxonox
+{
     CommandLineParser* CommandLineParser::singletonPtr_s = 0;
+    CommandLineParser* CommandLineParser::singletonPtr_s = nullptr;
     /**
 …
+            {
                 // 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;
 …
             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
 …
+                            }
                             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);
+                            }
 …
                         // Concatenate strings as long as there's no new argument by "-" or "--"
                         value += arguments[i] + ' ';
+                        value += argument + ' ';
+                    }
+                }
 …
         // 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);
+        }
 …
         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;
+        }

code/branches/cpp11_v3/src/libraries/core/commandline/CommandLineParser.h

-                      r10542
+                      r11054
     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.

code/branches/cpp11_v3/src/libraries/core/config/ConfigFile.cc

-                      r10624
+                      r11054
 #include <boost/filesystem.hpp>
+#include <iterator>
+#include <algorithm>
+#include <fstream>
 #include "util/Convert.h"
 …
                         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;
+                        }
 …
         if (file.is_open())
+        {
             ConfigFileSection* newsection = 0;
+            ConfigFileSection* newsection = nullptr;
             while (file.good() && !file.eof())
 …
+                }
                 if (newsection != 0)
+                if (newsection != nullptr)
+                {
                     if (isComment(line))
 …
+        }
         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;
 …
     /**
         @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;
+    }
 …
         @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)));
+    }
 …
         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;
+            }
+        }

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

r9559	r11054
51	51	public:
52	52	/// Destructor
53		virtual ~ConfigFileEntry() {};
	53	virtual ~ConfigFileEntry() = default;
54	54
55	55	/// Changes the value of the entry.

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

-                      r9559
+                      r11054
             /// 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_; }

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

-                      r9684
+                      r11054
             /// 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_; }

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

-                      r9559
+                      r11054
             /// 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

code/branches/cpp11_v3/src/libraries/core/config/ConfigFileManager.cc

-                      r9559
+                      r11054
     ///////////////////////
     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);
+    }
 …
     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;
+    }

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

-                      r9559
+                      r11054
 #include "core/CorePrereqs.h"
 #include <boost/array.hpp>
+#include <array>
 #include "util/Singleton.h"
 …
         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
     };

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

-                      r9559
+                      r11054
+    {
         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;
+    }
 …
     /**
         @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
 …
     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
 …
     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;
+    }

code/branches/cpp11_v3/src/libraries/core/config/ConfigValueContainer.cc

r9559	r11054
53	53	this->sectionname_ = sectionname;
54	54	this->varname_ = varname;
55		this->callback_ = 0;
	55	this->callback_ = nullptr;
56	56	this->bContainerIsNew_ = true;
57	57	this->bDoInitialCallback_ = false;
…	…
191	191	for (unsigned int i = this->valueVector_.size(); i <= index; i++)
192	192	{
193		this->valueVector_.~~push_back(MultiType()~~);
	193	this->valueVector_.emplace_back();
194	194	}
195	195	}

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

-                      r9667
+                      r11054
         public:
             virtual void call(void* object) = 0;
             inline virtual ~ConfigValueCallbackBase() {}
+            virtual inline ~ConfigValueCallbackBase() {}
     };
 …
         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())
 …
                 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();
 …
                     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())
 …
+                {
                     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;
 …
             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_; }

code/branches/cpp11_v3/src/libraries/core/config/SettingsConfigFile.cc

-                      r10624
+                      r11054
     SetConsoleCommand(__CC_getConfig_name,       &SettingsConfigFile::getConfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries());
     SettingsConfigFile* SettingsConfigFile::singletonPtr_s = 0;
+    SettingsConfigFile* SettingsConfigFile::singletonPtr_s = nullptr;
     /**
 …
     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);
+    }
 …
     void SettingsConfigFile::addConfigValueContainer(ConfigValueContainer* container)
+    {
         if (container == NULL)
+        if (container == nullptr)
             return;
         std::pair<std::string, ConfigValueContainer*> second(getLowercase(container->getName()), container);
 …
     void SettingsConfigFile::removeConfigValueContainer(ConfigValueContainer* container)
+    {
         if (container == NULL)
+        if (container == nullptr)
             return;
         const std::string& sectionLC = getLowercase(container->getSectionName());
 …
         // 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();
+        }
+    }
 …
+            {
                 std::string value;
                 it->second.second->getValue<std::string, void>(&value, NULL);
+                it->second.second->getValue<std::string, void>(&value, nullptr);
                 return value;
+            }

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

-                      r9684
+                      r11054
         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

code/branches/cpp11_v3/src/libraries/core/input/Button.cc

r9983	r11054
53	53	Button::Button()
54	54	: bButtonThresholdUser_(false)
55		, paramCommandBuffer_(0)
	55	, paramCommandBuffer_(nullptr)
56	56	{
57	57	nCommands_[0]=0;
…	…
75	75	delete commands_[j][i];
76	76	delete[] commands_[j];
77		commands_[j] = 0;
	77	commands_[j] = nullptr;
78	78	nCommands_[j] = 0;
79	79	}
…	…
196	196
197	197	// add command to the buffer if not yet existing
198		for (~~unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer_->size(); iParamCmd++~~)
199		{
200		if (~~(*paramCommandBuffer_)[iParamCmd]~~->evaluation_.getConsoleCommand()
	198	for (BufferedParamCommand* command : *paramCommandBuffer_)
	199	{
	200	if (command->evaluation_.getConsoleCommand()
201	201	== eval.getConsoleCommand())
202	202	{
203	203	// already in list
204		cmd->paramCommand_ = ~~(*paramCommandBuffer_)[iParamCmd]~~;
	204	cmd->paramCommand_ = command;
205	205	break;
206	206	}
207	207	}
208		if (cmd->paramCommand_ == 0)
	208	if (cmd->paramCommand_ == nullptr)
209	209	{
210	210	cmd->paramCommand_ = new BufferedParamCommand();
…	…
239	239	}
240	240	else
241		commands_[j] = 0;
	241	commands_[j] = nullptr;
242	242	}
243	243	}

code/branches/cpp11_v3/src/libraries/core/input/HalfAxis.h

-                      r7859
+                      r11054
             : relVal_(0.0f)
             , absVal_(0.0f)
             , paramCommands_(0)
+            , paramCommands_(nullptr)
             , nParamCommands_(0)
             , pressed_(false)
 …
         using Button::execute;
         bool execute();
         bool addParamCommand(ParamCommand* command);
         void clear();
+        virtual bool addParamCommand(ParamCommand* command) override;
+        virtual void clear() override;
         void reset();

code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.cc

-                      r9667
+                      r11054
     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;
+    }
 …
     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);
+        }
 …
     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();
+        }
+    }
 …
     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();
+        }
+    }
 …
             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();
+        }

code/branches/cpp11_v3/src/libraries/core/input/InputBuffer.h

-                      r9667
+                      r11054
               trueKeyFalseChar_(trueKeyFalseChar), char_(_char), key_(key)
         { }
         virtual ~BaseInputBufferListenerTuple() { }
+        virtual ~BaseInputBufferListenerTuple() = default;
         virtual void callFunction() = 0;
         bool bListenToAllChanges_;
 …
               listener_(listener), function_(function)
         { }
         virtual ~InputBufferListenerTuple() { }
         void callFunction()
+        virtual ~InputBufferListenerTuple() = default;
+        virtual void callFunction() override
+        {
             (listener_->*function_)();
 …
                 { 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_;

code/branches/cpp11_v3/src/libraries/core/input/InputCommands.h

-                      r9978
+                      r11054
     public:
         BaseCommand() : bFixedKeybindMode_(false) {}
         virtual ~BaseCommand() { }
+        virtual ~BaseCommand() = default;
         virtual bool execute(float abs = 1.0f, float rel = 1.0f) = 0;
 …
+    {
     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_;
 …
+    {
     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_;
 …
             return &this->paramCommand_->evaluation_;
         else
             return 0;
+            return nullptr;
+    }
+}

code/branches/cpp11_v3/src/libraries/core/input/InputDevice.h

-                      r8858
+                      r11054
         //! 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;
 …
     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
 …
         //! 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);
 …
         //! Clears the list of pressed buttons and calls the derived class's method
         void clearBuffers()
+        virtual void clearBuffers() override
+        {
             pressedButtons_.clear();
 …
         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:
 …
             // 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));
+        }
 …
             // 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));
+        }

code/branches/cpp11_v3/src/libraries/core/input/InputHandler.h

r8729	r11054
119	119	{
120	120	public:
121		virtual ~InputHandler() ~~{ }~~
	121	virtual ~InputHandler() = default;
122	122
123	123	template<class T> void buttonEvent(unsigned int device, T button, ButtonEvent::TPress)

code/branches/cpp11_v3/src/libraries/core/input/InputManager.cc

-                      r10624
+                      r11054
 #include <ois/OISException.h>
 #include <ois/OISInputManager.h>
-#include <boost/foreach.hpp>
 #include <loki/ScopeGuard.h>
 …
     InputHandler InputHandler::EMPTY;
     InputManager* InputManager::singletonPtr_s = 0;
+    InputManager* InputManager::singletonPtr_s = nullptr;
     //! Defines the |= operator for easier use.
 …
     InputManager::InputManager()
         : internalState_(Bad)
         , oisInputManager_(0)
+        , oisInputManager_(nullptr)
         , devices_(2)
         , exclusiveMouse_(false)
         , emptyState_(0)
         , calibratorCallbackHandler_(0)
+        , emptyState_(nullptr)
+        , calibratorCallbackHandler_(nullptr)
+    {
         RegisterObject(InputManager);
 …
         // 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);
 …
         catch (const std::exception& ex)
+        {
             oisInputManager_ = NULL;
+            oisInputManager_ = nullptr;
             internalState_ |= Bad;
             ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
 …
         // 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;
 …
         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
+        {
 …
                                                    << "Potential resource leak!" << endl;
+        }
         oisInputManager_ = NULL;
+        oisInputManager_ = nullptr;
         internalState_ |= Bad;
 …
         // 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;
+            }
 …
         // 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
 …
         // 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();
 …
         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();
 …
         // 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
 …
     void InputManager::clearBuffers()
+    {
         BOOST_FOREACH(InputDevice* device, devices_)
             if (device != NULL)
+        for (InputDevice* device : devices_)
+            if (device != nullptr)
                 device->clearBuffers();
+    }
 …
                         << "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();
 …
     void InputManager::stopCalibration()
+    {
         BOOST_FOREACH(InputDevice* device, devices_)
             if (device != NULL)
+        for (InputDevice* device : devices_)
+            if (device != nullptr)
                 device->stopCalibration();
 …
+    {
         Mouse* mouse = static_cast<Mouse*>(devices_[InputDeviceEnumerator::Mouse]);
         if (mouse != NULL)
+        if (mouse != nullptr)
+        {
             const OIS::MouseState state = mouse->getOISDevice()->getMouseState();
 …
+    {
         if (name.empty())
             return 0;
+            return nullptr;
         if (statesByName_.find(name) == statesByName_.end())
+        {
 …
+            {
                 // 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;
+                    }
+                }
 …
+        {
             orxout(internal_warning, context::input) << "Could not add an InputState with the same name '" << name << "'." << endl;
             return 0;
+            return nullptr;
+        }
+    }
 …
             return it->second;
         else
             return 0;
+            return nullptr;
+    }

code/branches/cpp11_v3/src/libraries/core/input/InputManager.h

-                      r8729
+                      r11054
 #include <string>
 #include <vector>
 #include <boost/function.hpp>
+#include <functional>
 #include "util/Singleton.h"
 …
             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);
 …
         // Function call caching
         //-------------------------------
         void pushCall(const boost::function<void ()>& function)
+        void pushCall(const std::function<void ()>& function)
             { this->callBuffer_.push_back(function); }
 …
     private: // functions
+        // don't mess with a Singleton
+        InputManager(const InputManager&);
+        // non-copyable:
+        InputManager(const InputManager&) = delete;
+        InputManager& operator=(const InputManager&) = delete;
         // Internal methods
 …
         // From WindowEventListener
         void windowFocusChanged(bool bFocus);
+        virtual void windowFocusChanged(bool bFocus) override;
     private: // variables
 …
         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

code/branches/cpp11_v3/src/libraries/core/input/InputPrereqs.h

-                      r8729
+                      r11054
         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;
     };
+}

code/branches/cpp11_v3/src/libraries/core/input/InputState.cc

-                      r8729
+                      r11054
         , bExpired_(true)
         , handlers_(2)
         , joyStickHandlerAll_(0)
         , enterFunctor_(0)
         , leaveFunctor_(0)
+        , joyStickHandlerAll_(nullptr)
+        , enterFunctor_(nullptr)
+        , leaveFunctor_(nullptr)
+    {
         if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)
 …
             priority_ = 0;
         handlers_.resize(InputDeviceEnumerator::FirstJoyStick + this->getJoyStickList().size(), NULL);
+        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + this->getJoyStickList().size(), nullptr);
+    }
 …
+    {
         if (device < handlers_.size())
             return handlers_[device] != NULL;
+            return handlers_[device] != nullptr;
         else
             return false;
 …
+    {
         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)

code/branches/cpp11_v3/src/libraries/core/input/InputState.h

-                      r8729
+                      r11054
 #include <string>
 #include <vector>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <functional>
 #include "util/tribool.h"
 …
 #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
 …
     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!)
 …
+    {
         for (unsigned int i = 0; i < handlers_.size(); ++i)
             if (handlers_[i] != NULL)
+            if (handlers_[i] != nullptr)
                 INPUT_STATE_PUSH_CALL(i, allDevicesUpdated, dt);
+    }
 …
+        {
         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;
 …
+    {
         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())));
+        }
+    }
 …
     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);
+    }
 …
     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);
+    }
 …
+    {
         assert(device < handlers_.size());
         if (handlers_[device] != NULL)
+        if (handlers_[device] != nullptr)
             INPUT_STATE_PUSH_CALL(device, axisMoved, device - firstJoyStickIndex_s, axis, value);
+    }

code/branches/cpp11_v3/src/libraries/core/input/JoyStick.cc

-                      r10624
+                      r11054
 #include <climits>
 #include <ois/OISJoyStick.h>
-#include <boost/foreach.hpp>
 #include "util/StringUtils.h"
 …
         //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)
 …
+    {
         // 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;
+    }
 …
     void JoyStick::clearBuffersImpl()
+    {
         for (int j = 0; j < 4; ++j)
             povStates_[j] = 0;
+        for (int& state : povStates_)
+            state = 0;
+    }
 …
                 fValue *= negativeCoeffs_[axis];
             BOOST_FOREACH(InputState* state, inputStates_)
+            for (InputState* state : inputStates_)
                 state->joyStickAxisMoved(this->getDeviceID(), axis, fValue);
+        }

code/branches/cpp11_v3/src/libraries/core/input/JoyStick.h

-                      r9667
+                      r11054
         //! Assigns a generated ID string and loads the calibration (if present)
         JoyStick(unsigned int id, OIS::InputManager* oisInputManager);
         ~JoyStick() { }
+        ~JoyStick() = default;
         void setConfigValues();
 …
     private:
         void calibrationStarted();
         void calibrationStopped();
+        virtual void calibrationStarted() override;
+        virtual void calibrationStopped() override;
         void evaluateCalibration();
 …
         //! 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));
 …
         //! 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));
 …
+        }
         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

code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.cc

r10624	r11054
47	47	{
48	48	joyStickList_s = joyStickList;
49		for (~~ObjectList<JoyStickQuantityListener>::iterator it = ObjectList<JoyStickQuantityListener>::begin(); it; ++it~~)
50		it->JoyStickQuantityChanged(joyStickList);
	49	for (JoyStickQuantityListener* listener : ObjectList<JoyStickQuantityListener>())
	50	listener->JoyStickQuantityChanged(joyStickList);
51	51	}
52	52	}

code/branches/cpp11_v3/src/libraries/core/input/JoyStickQuantityListener.h

r9667	r11054
48	48	protected:
49	49	JoyStickQuantityListener();
50		virtual ~JoyStickQuantityListener() ~~{ }~~
	50	virtual ~JoyStickQuantityListener() = default;
51	51
52	52	//! Returns a list with all JoySticks currently loaded

code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.cc

-                      r11052
+                      r11054
         : deriveTime_(0.0f)
         , filename_(filename)
         , configFile_(NULL)
         , fallbackConfigFile_(NULL)
+        , configFile_(nullptr)
+        , fallbackConfigFile_(nullptr)
+    {
         mouseRelative_[0] = 0;
 …
     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_;
+    }
 …
         // load the bindings if required
         if (configFile_ != NULL)
+        if (configFile_ != nullptr)
+        {
             for (unsigned int iDev = oldValue; iDev < joySticks_.size(); ++iDev)
 …
+    {
         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());
 …
         // 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);
+        }
 …
     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();
+    }
 …
+    {
         // 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
 …
+                        {
                             delete[] button->commands_[mode_index];
                             button->commands_[mode_index] = 0;
+                            button->commands_[mode_index] = nullptr;
+                        }
 …
         this->mousePosition_[1] = 0.0f;
         for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
             mouseAxes_[i].reset();
+        for (HalfAxis& axis : mouseAxes_)
+            axis.reset();
+    }
 …
+        }
         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
 …
+            {
                 // 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);
+        }
+    }

code/branches/cpp11_v3/src/libraries/core/input/KeyBinder.h

-                      r11052
+                      r11054
 #include <vector>
 #include <map>
 #include <boost/shared_ptr.hpp>
+#include <memory>
 #include "InputHandler.h"
 …
         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
 …
         };
         //! 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
 …
         };
         //! 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
 …
         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_;
         /**
 …
         //! 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
 …
+    {
         // 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

code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.cc

-                      r10624
+                      r11054
     KeyBinderManager::KeyBinderManager()
         : currentBinder_(NULL)
+        : currentBinder_(nullptr)
         , bDefaultFileLoaded_(true)
         , bBinding_(false)
 …
+    {
         // 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);
+    }
 …
     void KeyBinderManager::registerKeybindCallback(LuaFunctor* function)
+    {
         this->callbackFunction_ = function;
+        this->callbackFunction_.reset(function);
+    }
+}

code/branches/cpp11_v3/src/libraries/core/input/KeyBinderManager.h

-                      r9667
+                      r11054
 #include <map>
 #include <string>
+#include <memory>
 #include "util/Singleton.h"
 …
     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);
 …
         // 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;

code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.cc

-                      r10624
+                      r11054
     KeyDetector::~KeyDetector()
+    {
         inputState_->setHandler(NULL);
+        inputState_->setHandler(nullptr);
         InputManager::getInstance().destroyState("detector");
         ModifyConsoleCommand(__CC_KeyDetector_callback_name).resetFunction();
 …
+    {
         // 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_);
+    }

code/branches/cpp11_v3/src/libraries/core/input/KeyDetector.h

-                      r8729
+                      r11054
     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();

code/branches/cpp11_v3/src/libraries/core/input/Keyboard.h

-                      r8729
+                      r11054
         //! 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:
 …
+        }
         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

code/branches/cpp11_v3/src/libraries/core/input/Mouse.cc

-                      r10624
+                      r11054
+    {
 #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
+    }
 …
             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);
+        }
 …
         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);
+        }

code/branches/cpp11_v3/src/libraries/core/input/Mouse.h

-                      r7809
+                      r11054
     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));
 …
         //! 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));
 …
+        }
         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

code/branches/cpp11_v3/src/libraries/core/module/DynLib.cc

-                      r10540
+                      r11054
+    {
         mName = name;
         m_hInst = NULL;
+        m_hInst = nullptr;
+    }
 …
             FORMAT_MESSAGE_FROM_SYSTEM |
             FORMAT_MESSAGE_IGNORE_INSERTS,
             NULL,
+            nullptr,
             GetLastError(),
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
             (LPTSTR) &lpMsgBuf,
 ,
             NULL
+            nullptr
             );
         std::string ret = (char*)lpMsgBuf;

code/branches/cpp11_v3/src/libraries/core/module/DynLib.h

-                      r10541
+                      r11054
 #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 )
 …
                 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>.
         */

code/branches/cpp11_v3/src/libraries/core/module/DynLibManager.cc

-                      r10540
+                      r11054
     //-----------------------------------------------------------------------
     //! Static pointer to the singleton
     DynLibManager* DynLibManager::singletonPtr_s  = 0;
+    DynLibManager* DynLibManager::singletonPtr_s  = nullptr;
     //-----------------------------------------------------------------------
 …
+    {
         // 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;
+        }

code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.cc

r10549	r11054
33	33	namespace orxonox
34	34	{
35		ModuleInstance* ModuleInstance::currentModuleInstance_s = ~~NULL~~;
	35	ModuleInstance* ModuleInstance::currentModuleInstance_s = nullptr;
36	36
37	37	ModuleInstance::ModuleInstance(const std::string& libraryName)
38	38	: libraryName_(libraryName)
39		, dynLib_(~~NULL~~)
	39	, dynLib_(nullptr)
40	40	{
41	41	}
…	…
59	59	{
60	60	const std::set<StaticallyInitializedInstance*>& instances = this->staticallyInitializedInstancesByType_[type];
61		for (~~std::set<StaticallyInitializedInstance*>::iterator it = instances.begin(); it != instances.end(); ++it~~)
62		~~(*it)~~->load();
	61	for (StaticallyInitializedInstance* instance : instances)
	62	instance->load();
63	63	}
64	64
…	…
73	73	void ModuleInstance::deleteAllStaticallyInitializedInstances()
74	74	{
75		std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > copy(this->staticallyInitializedInstancesByType_);
	75	std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
76	76	this->staticallyInitializedInstancesByType_.clear();
77		for (~~std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> >::iterator it1 = copy.begin(); it1 != copy.end(); ++it1~~)
78		for (~~std::set<StaticallyInitializedInstance*>::iterator it2 = it1->second.begin(); it2 != it1->second.end(); ++it2~~)
79		delete ~~(*it2)~~;
	77	for (const auto& mapEntry : copy)
	78	for (StaticallyInitializedInstance* instance : mapEntry.second)
	79	delete instance;
80	80	}
81	81

code/branches/cpp11_v3/src/libraries/core/module/ModuleInstance.h

r10549	r11054
69	69
70	70	private:
71		std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > staticallyInitializedInstancesByType_;
	71	std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> staticallyInitializedInstancesByType_;
72	72	std::string libraryName_;
73	73	DynLib* dynLib_;

code/branches/cpp11_v3/src/libraries/core/module/Plugin.cc

r11015	r11054
39	39	{
40	40	this->referenceCounter_ = 0;
41		this->moduleInstance_ = ~~NULL~~;
	41	this->moduleInstance_ = nullptr;
42	42	}
43	43
…	…
45	45	{
46	46	// force unloading of the module when the plugin is destroyed
47		if (this->moduleInstance_ != ~~NULL~~)
	47	if (this->moduleInstance_ != nullptr)
48	48	this->unloadModule();
49	49	}

code/branches/cpp11_v3/src/libraries/core/module/PluginManager.cc

-                      r11017
+                      r11054
     SetConsoleCommand("PluginManager", __CC_PluginManager_unload_name, &PluginManager::unloadPlugin);
     PluginManager* PluginManager::singletonPtr_s  = 0;
+    PluginManager* PluginManager::singletonPtr_s  = nullptr;
     RegisterAbstractClass(PluginManager).inheritsFrom<Configurable>();
 …
     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;
+    }
 …
+    {
         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());
 …
+    {
         Plugin* plugin = this->plugins_[name];
         if (plugin != NULL)
+        if (plugin != nullptr)
             plugin->reference();
         else
 …
+    {
         Plugin* plugin = this->plugins_[name];
         if (plugin != NULL)
+        if (plugin != nullptr)
             plugin->dereference(this->bMerelyDeactivatePlugins_);
         else
 …
     void PluginManager::loadPlugin(const std::string& name)
+    {
         if (this->references_[name] == NULL)
+        if (this->references_[name] == nullptr)
+        {
             this->references_[name] = new PluginReference(name);
 …
+    {
         PluginReference* reference = this->references_[name];
         if (reference != NULL)
+        if (reference != nullptr)
+        {
             this->references_[name] = NULL;
+            this->references_[name] = nullptr;
             delete reference;
+        }

code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandler.h

-                      r10532
+                      r11054
+    {
         public:
             StaticInitializationHandler() {}
             virtual ~StaticInitializationHandler() {}
+            StaticInitializationHandler() = default;
+            virtual ~StaticInitializationHandler() = default;
             virtual void setupHandler() = 0;

code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationHandlerIncludes.h

-                      r10535
+                      r11054
             ~StaticallyInitializedStaticInitializationHandler() { delete handler_; }
             virtual void load();
             virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
             inline StaticInitializationHandler& getHandler()

code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.cc

r10542	r11054
33	33	namespace orxonox
34	34	{
35		StaticInitializationManager* StaticInitializationManager::singletonPtr_s = 0;
	35	StaticInitializationManager* StaticInitializationManager::singletonPtr_s = nullptr;
36	36
37	37	void StaticInitializationManager::addHandler(StaticInitializationHandler* handler)
…	…
50	50	{
51	51	// attention: loading a module may add new handlers to the list
52		for (~~std::list<StaticInitializationHandler*>::iterator it = this->handlers_.begin(); it != this->handlers_.end(); ++it~~)
53		~~(*it)~~->loadModule(module);
	52	for (StaticInitializationHandler* handler : this->handlers_)
	53	handler->loadModule(module);
54	54	}
55	55

code/branches/cpp11_v3/src/libraries/core/module/StaticInitializationManager.h

-                      r10542
+                      r11054
         public:
             StaticInitializationManager() {}
             virtual ~StaticInitializationManager() {}
+            StaticInitializationManager() = default;
+            virtual ~StaticInitializationManager() = default;
             void addHandler(StaticInitializationHandler* handler);

code/branches/cpp11_v3/src/libraries/core/object/ClassFactory.h

-                      r9667
+                      r11054
+    {
         public:
+            virtual ~Factory() {}
+            Factory() = default;
+            virtual ~Factory() = default;
             virtual Identifiable* fabricate(Context* context) = 0;
     };

code/branches/cpp11_v3/src/libraries/core/object/Context.cc

-                      r10624
+                      r11054
     RegisterClass(Context);
     Context* Context::rootContext_s = 0;
+    Context* Context::rootContext_s = nullptr;
     Context* getContextForInitializationOfOtherContexts()
 …
         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;
+        }
 …
         // 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;
+    }
 …
+    {
         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;
+    }
 …
         ObjectListBase* objectList = this->getObjectList(identifier);
         delete objectList;
         this->objectLists_[identifier->getClassID()] = NULL;
+        this->objectLists_[identifier->getClassID()] = nullptr;
+    }
+}

code/branches/cpp11_v3/src/libraries/core/object/DestroyLaterManager.h

-                      r10624
+                      r11054
             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)
 …
         private:
             std::vector<StrongPtr<Destroyable> > retainedInstances_;
+            std::vector<StrongPtr<Destroyable>> retainedInstances_;
             static DestroyLaterManager* singletonPtr_s;

code/branches/cpp11_v3/src/libraries/core/object/Destroyable.cc

r11019	r11054
70	70	void Destroyable::destroy()
71	71	{
72		assert(this); // Just in case someone tries to delete a ~~NULL pointe~~r
	72	assert(this); // Just in case someone tries to delete a nullptr
73	73	this->requestedDestruction_ = true;
74	74	if (this->referenceCount_ == 0)

code/branches/cpp11_v3/src/libraries/core/object/Iterator.h

-                      r10624
+                      r11054
     */
     template <class T>
     class Iterator : public IteratorBase<T, Iterator<T> >
+    class Iterator : public IteratorBase<T, Iterator<T>>
+    {
         public:
 …
                 @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>>() {}
             /**
 …
                 @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) {}
             /**

code/branches/cpp11_v3/src/libraries/core/object/IteratorBase.h

-                      r10624
+                      r11054
 #include "core/CorePrereqs.h"
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 #include "ObjectListBase.h"
 …
     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;
 …
+            }
-        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();
+            }
 …
                 @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);
+            }
 …
                 @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_;
+            }
 …
+                }
                 else
                     this->list_ = NULL;
+                    this->list_ = nullptr;
+            }

code/branches/cpp11_v3/src/libraries/core/object/Listable.cc

r10624	r11054
44	44	@brief Constructor: Allocates space in the element list.
45	45	*/
46		Listable::Listable()
	46	Listable::Listable() : Listable(Context::getRootContext())
47	47	{
48		~~this->context_ = Context::getRootContext();~~
49		~~this->elements_.reserve(6);~~
50
51		~~RegisterObject(Listable);~~
52	48	}
53	49
…	…
76	72	void Listable::unregisterObject()
77	73	{
78		for (~~size_t i = 0; i < this->elements_.size(); ++i~~)
79		Listable::deleteObjectListElement(~~this->elements_[i]~~);
	74	for (ObjectListBaseElement* element : this->elements_)
	75	Listable::deleteObjectListElement(element);
80	76	this->elements_.clear();
81	77	}
…	…
91	87	this->elements_.clear();
92	88
93		for (~~size_t i = 0; i < copy.size(); ++i~~)
	89	for (ObjectListBaseElement* element : copy)
94	90	{
95		~~copy[i]~~->changeContext(this->context_, context);
96		Listable::deleteObjectListElement(~~copy[i]~~);
	91	element->changeContext(this->context_, context);
	92	Listable::deleteObjectListElement(element);
97	93	}
98	94

code/branches/cpp11_v3/src/libraries/core/object/Listable.h

r9667	r11054
40	40	#include <vector>
41	41
	42	#include "util/SmallObjectAllocator.h"
42	43	#include "core/class/Identifiable.h"
43	44

code/branches/cpp11_v3/src/libraries/core/object/ObjectList.h

-                      r10624
+                      r11054
 #include "core/CorePrereqs.h"
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_base_of.hpp>
 #include "ObjectListBase.h"
 #include "ObjectListIterator.h"
 …
     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_;
     };
+}

code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.cc

-                      r9975
+                      r11054
     ObjectListBase::ObjectListBase()
+    {
         this->first_ = 0;
         this->last_ = 0;
+        this->first_ = nullptr;
+        this->last_ = nullptr;
         this->size_ = 0;
+    }
 …
             ObjectListBaseElement* next = current->next_;
             current->list_ = 0;
             current->next_ = 0;
             current->prev_ = 0;
+            current->list_ = nullptr;
+            current->next_ = nullptr;
+            current->prev_ = nullptr;
             current = next;
 …
     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);
+    }
 …
             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_;
+    }

code/branches/cpp11_v3/src/libraries/core/object/ObjectListBase.h

-                      r9667
+                      r11054
                 @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(); }
 …
             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
 …
+    {
         public:
+            virtual ~ObjectListElementRemovalListener() {}
+            ObjectListElementRemovalListener() = default;
+            virtual ~ObjectListElementRemovalListener() = default;
             virtual void removedElement(ObjectListBaseElement* element) = 0;
     };
 …
             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); }

code/branches/cpp11_v3/src/libraries/core/object/ObjectListIterator.h

-                      r10624
+                      r11054
     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(...);
 …
     */
     template <class T>
     class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T> >
+    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T>>
+    {
         public:
 …
                 @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
             */
             inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >() {}
+            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T>>() {}
             /**
 …
                 @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) {}
             /**
 …
                 @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) {}
             /**

code/branches/cpp11_v3/src/libraries/core/object/StrongPtr.h

-                      r10624
+                      r11054
     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.
 …
     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
 …
         public:
             /// Constructor: Initializes the strong pointer with a null pointer.
             inline StrongPtr() : pointer_(0), base_(0)
+            inline StrongPtr() : pointer_(nullptr), base_(nullptr)
+            {
+            }
 …
             /// 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_)
 …
+            }
+            /// 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()
 …
             /// 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;
+            }
 …
             inline T* operator->() const
+            {
                 assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return this->pointer_;
+            }
 …
             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);
+            }
 …
+            }
             /// Resets the strong pointer (equivalent to assigning a NULL pointer).
+            /// Resets the strong pointer (equivalent to assigning a nullptr).
             inline void reset()
+            {

code/branches/cpp11_v3/src/libraries/core/object/WeakPtr.h

-                      r10624
+                      r11054
     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.
 …
     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
 …
+{
     /**
         @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.
 …
         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_);
 …
             /// 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_);
 …
             /// 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_);
 …
             /// Destructor
             inline virtual ~WeakPtr()
+            virtual inline ~WeakPtr()
+            {
                 this->unregisterAsDestructionListener(this->base_);
 …
             /// 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;
+            }
 …
             inline T* operator->() const
+            {
                 assert(this->pointer_ != 0);
+                assert(this->pointer_ != nullptr);
                 return this->pointer_;
+            }
 …
             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);
+            }
 …
+            }
             /// Resets the weak pointer (equivalent to assigning a NULL pointer).
+            /// Resets the weak pointer (equivalent to assigning a nullptr).
             inline void reset()
+            {
 …
         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_)();

code/branches/cpp11_v3/src/libraries/core/singleton/Scope.h

r10514	r11054
72	72	protected:
73	73	ScopeListener() : bActivated_(false) { }
74		virtual ~ScopeListener() ~~{ }~~
	74	virtual ~ScopeListener() = default;
75	75
76	76	//! Gets called if the scope is activated

code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.cc

r10542	r11054
38	38	namespace orxonox
39	39	{
40		ScopeManager* ScopeManager::singletonPtr_s = 0;
	40	ScopeManager* ScopeManager::singletonPtr_s = nullptr;
41	41
42	42	void ScopeManager::addScope(ScopeID::Value scope)
…	…
73	73	void ScopeManager::activateListenersForScope(ScopeID::Value scope)
74	74	{
75		for (~~std::set<ScopeListener*>::iterator it = this->listeners_[scope].begin(); it != this->listeners_[scope].end(); ++it~~)
76		this->activateListener(*it);
	75	for (ScopeListener* listener : this->listeners_[scope])
	76	this->activateListener(listener);
77	77	}
78	78
79	79	void ScopeManager::deactivateListenersForScope(ScopeID::Value scope)
80	80	{
81		for (~~std::set<ScopeListener*>::iterator it = this->listeners_[scope].begin(); it != this->listeners_[scope].end(); ++it~~)
82		this->deactivateListener(*it);
	81	for (ScopeListener* listener : this->listeners_[scope])
	82	this->deactivateListener(listener);
83	83	}
84	84

code/branches/cpp11_v3/src/libraries/core/singleton/ScopeManager.h

r11012	r11054
83	83
84	84	std::set<ScopeID::Value> activeScopes_;
85		std::map<ScopeID::Value, std::set<ScopeListener*> > listeners_; //!< Stores all listeners for a scope
	85	std::map<ScopeID::Value, std::set<ScopeListener*>> listeners_; //!< Stores all listeners for a scope
86	86
87	87	static ScopeManager* singletonPtr_s;

code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonIncludes.h

-                      r11052
+                      r11054
 */
 #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()
 …
             ~StaticallyInitializedScopedSingletonWrapper() { delete wrapper_; }
             virtual void load();
             virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
             inline ScopedSingletonWrapper& getWrapper()

code/branches/cpp11_v3/src/libraries/core/singleton/ScopedSingletonWrapper.h

r10528	r11054
64	64	: className_(className)
65	65	{ }
66		virtual ~ScopedSingletonWrapper() ~~{ }~~
	66	virtual ~ScopedSingletonWrapper() = default;
67	67
68	68	protected:
…	…
91	91	ClassScopedSingletonWrapper(const std::string& className)
92	92	: ScopedSingletonWrapper(className)
93		, singletonPtr_(~~NULL~~)
	93	, singletonPtr_(nullptr)
94	94	{
95	95	}
…	…
102	102
103	103	//! Called if the Scope of the Singleton gets active (creates the instance)
104		v~~oid activated()~~
	104	virtual void activated() override
105	105	{
106		assert(singletonPtr_ == ~~NULL~~);
	106	assert(singletonPtr_ == nullptr);
107	107	singletonPtr_ = new T();
108	108	}
109	109
110	110	//! Called if the Scope of this Singleton gets deactivated (destroys the instance)
111		v~~oid deactivated()~~
	111	virtual void deactivated() override
112	112	{
113		assert(singletonPtr_ != ~~NULL~~);
	113	assert(singletonPtr_ != nullptr);
114	114	this->destroy(singletonPtr_);
115		singletonPtr_ = ~~NULL~~;
	115	singletonPtr_ = nullptr;
116	116	}
117	117
…	…
146	146	ClassScopedSingletonWrapper(const std::string& className)
147	147	: ScopedSingletonWrapper(className)
148		, singletonPtr_(~~NULL~~)
	148	, singletonPtr_(nullptr)
149	149	{
150	150	}
…	…
157	157
158	158	//! Called if the Scope of the Singleton gets active (creates the instance)
159		v~~oid activated()~~
	159	virtual void activated() override
160	160	{
161		assert(singletonPtr_ == ~~NULL~~);
	161	assert(singletonPtr_ == nullptr);
162	162	try
163	163	{ singletonPtr_ = new T(); }
…	…
169	169
170	170	//! Called if the Scope of this Singleton gets deactivated (destroys the instance)
171		v~~oid deactivated()~~
	171	virtual void deactivated() override
172	172	{
173		if (singletonPtr_ != ~~NULL~~)
	173	if (singletonPtr_ != nullptr)
174	174	{
175	175	this->destroy(singletonPtr_);
176		singletonPtr_ = ~~NULL~~;
	176	singletonPtr_ = nullptr;
177	177	}
178	178	}

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

r10624	r11054
161	161	{
162	162	std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
163		std::vector<packet::Gamestate*>::iterator it;
164		for( it = gamestates.begin(); it != gamestates.end(); ++it )
	163	for( packet::Gamestate* gamestate : gamestates )
165	164	{
166		~~(it)~~->send( static_cast<Host>(this) );
	165	gamestate->send( static_cast<Host*>(this) );
167	166	}
168	167	}

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

-                      r8858
+                      r11054
     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;

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

-                      r8858
+                      r11054
     Connection(NETWORK_PEER_ID_SERVER),
     established_(false),
     server_(NULL)
+    server_(nullptr)
+  {
     this->serverAddress_ = new ENetAddress();
 …
     // 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;
 …
     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;

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

-                      r8327
+                      r11054
     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();

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

r10624	r11054
44	44	void ClientConnectionListener::broadcastClientConnected(unsigned int clientID)
45	45	{
46		for (~~ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it~~)
47		it->clientConnected(clientID);
	46	for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
	47	listener->clientConnected(clientID);
48	48	}
49	49
50	50	void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
51	51	{
52		for (~~ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it~~)
53		it->clientDisconnected(clientID);
	52	for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
	53	listener->clientDisconnected(clientID);
54	54	}
55	55

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

-                      r8858
+                      r11054
   Connection::Connection(uint32_t firstPeerID):
     host_(0), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
+    host_(nullptr), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
+  {
     enet_initialize();
 …
+  {
 //     this->overallMutex_->lock();
     outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, 0, 0 };
+    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, nullptr, 0 };
     this->outgoingEventsMutex_->lock();
 …
   void Connection::disconnectPeers()
+  {
     outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, 0, 0 };
+    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, nullptr, 0 };
     this->outgoingEventsMutex_->lock();
 …
   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;
 …
     // create new peerEvent and return it
     incomingEvent inEvent = { peerID, incomingEventType::peerConnect, 0 };
+    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, nullptr };
     return inEvent;
+  }
 …
     // create new peerEvent and return it
     incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, 0 };
+    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, nullptr };
     return inEvent;
+  }

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

r8327	r11054
46	46	#include <map>
47	47	#include <enet/enet.h>
48		~~#include <boost/concept_check.hpp>~~
49	48
50	49	namespace boost

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

r10624	r11054
48	48	bool FunctionCall::execute(){
49	49	NetworkFunctionBase* fct = NetworkFunctionManager::getInstance().getFunctionByNetworkId( this->functionID_ );
50		assert( fct != ~~NULL~~ );
	50	assert( fct != nullptr );
51	51	assert( this->nrOfArguments_==this->arguments_.size() );
52	52	switch(this->nrOfArguments_)
…	…
119	119	for( unsigned int i=0; i<this->nrOfArguments_; ++i )
120	120	{
121		this->arguments_.~~push_back(MultiType()~~);
	121	this->arguments_.emplace_back();
122	122	this->arguments_.back().importData(mem);
123	123	}
…	…
131	131	(uint32_t)(mem+2*sizeof(uint32_t)) = this->objectID_;
132	132	mem += 3*sizeof(uint32_t);
133		for( ~~std::vector<MultiType>::iterator it = this->arguments_.begin(); it!=this->arguments_.end(); ++it~~ )
	133	for(const MultiType& argument : this->arguments_)
134	134	{
135		~~it->~~exportData( mem );
	135	argument.exportData( mem );
136	136	}
137	137	}

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

r10624	r11054
37	37
38	38	std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sPeerMap_;
39		std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > > FunctionCallManager::sIncomingFunctionCallBuffer_;
	39	std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>> FunctionCallManager::sIncomingFunctionCallBuffer_;
40	40
41	41
…	…
54	54	void FunctionCallManager::sendCalls(orxonox::Host* host)
55	55	{
56		std::map<uint32_t, packet::FunctionCalls*>::iterator it;
57		for (it = FunctionCallManager::sPeerMap_.begin(); it != FunctionCallManager::sPeerMap_.end(); ++it )
	56	for (const auto& mapEntry : FunctionCallManager::sPeerMap_ )
58	57	{
59	58	assert(!FunctionCallManager::sPeerMap_.empty());
60		~~it->~~second->send(host);
	59	mapEntry.second->send(host);
61	60	}
62	61	FunctionCallManager::sPeerMap_.clear();
…	…
65	64	void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall, uint32_t minGamestateID, uint32_t peerID)
66	65	{
67		FunctionCallManager::sIncomingFunctionCallBuffer_.~~push_back( std::make_pair(fctCall, std::make_pair(minGamestateID, peerID)~~));
	66	FunctionCallManager::sIncomingFunctionCallBuffer_.emplace_back(fctCall, std::make_pair(minGamestateID, peerID));
68	67	}
69	68
70	69	void FunctionCallManager::processBufferedFunctionCalls()
71	70	{
72		std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > >::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
	71	std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
73	72	while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
74	73	{

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

r10624	r11054
54	54
55	55	static std::map<uint32_t, packet::FunctionCalls*> sPeerMap_;
56		static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t> > > sIncomingFunctionCallBuffer_;
	56	static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t>>> sIncomingFunctionCallBuffer_;
57	57	protected:
58	58	FunctionCallManager();

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

r7801	r11054
32	32	namespace orxonox {
33	33
34		// GamestateHandler *GamestateHandler::instance_=0;
	34	// GamestateHandler *GamestateHandler::instance_=nullptr;
35	35
36	36	GamestateHandler::GamestateHandler()

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

-                      r8858
+                      r11054
+{
   GamestateManager::GamestateManager() :
   currentGamestate_(0), id_(0)
+  currentGamestate_(nullptr), id_(0)
+  {
 //     trafficControl_ = new TrafficControl();
 …
+  {
     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();
 …
     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
 …
   bool GamestateManager::getSnapshot(){
     if ( currentGamestate_ != 0 )
+    if ( currentGamestate_ != nullptr )
       delete currentGamestate_;
     uint8_t gsMode;
 …
     { //we have no data to send
       delete currentGamestate_;
       currentGamestate_=0;
+      currentGamestate_=nullptr;
       return false;
+    }
 …
     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)
+      {
 …
+      }
       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();
 …
+      {
         delete diffed1;
         destgamestate = 0;
+        destgamestate = nullptr;
         return;
+      }
 …
+  {
     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));
 …
 //   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;

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

-                      r10622
+                      r11054
 #include "core/CorePrereqs.h"
 #include "packet/Gamestate.h"
-#include <boost/concept_check.hpp>
 namespace orxonox
 …
     ~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();
 …
     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_;

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

r10624	r11054
44	44	SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
45	45
46		// Host* Host::instance_=0;
	46	// Host* Host::instance_=nullptr;
47	47	uint32_t Host::clientID_s=0;
48	48	// uint32_t Host::shipID_s=-1;
…	…
54	54	Host::Host()
55	55	{
56		// assert(instance_==0);
	56	// assert(instance_==nullptr);
57	57	instances_s.push_back(this);
58	58	ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
…	…
62	62
63	63	/**
64		* @brief Destructor: resets the instance pointer to 0
	64	* @brief Destructor: resets the instance pointer to nullptr
65	65	*/
66	66	Host::~Host()
…	…
68	68	assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
69	69	instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
70		ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
	70	ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(nullptr);
71	71	}
72	72
…	…
80	80	void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
81	81	{
82		for( ~~std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it~~ )
	82	for(Host* host : instances_s)
83	83	{
84		if( ~~(*it)~~->isActive() )
	84	if( host->isActive() )
85	85	{
86		~~(*it)~~->queuePacket(packet, clientID, channelID);
	86	host->queuePacket(packet, clientID, channelID);
87	87	}
88	88	}
…	…
97	97	void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
98	98	{
99		for( ~~std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it~~ )
100		if( ~~(*it)~~->isActive() )
101		~~(*it)~~->doSendChat(message, sourceID, targetID);
	99	for(Host* host : instances_s)
	100	if( host->isActive() )
	101	host->doSendChat(message, sourceID, targetID);
102	102	}
103	103
…	…
107	107	void Host::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
108	108	{
109		for (~~ObjectList<NetworkChatListener>::iterator it = ObjectList<NetworkChatListener>::begin(); it != ObjectList<NetworkChatListener>::end(); ++it~~)
110		it->incomingChat(message, sourceID);
	109	for (NetworkChatListener* listener : ObjectList<NetworkChatListener>())
	110	listener->incomingChat(message, sourceID);
111	111	}
112	112
…	…
114	114	bool Host::isServer()
115	115	{
116		for (~~std::vector<Host*>::iterator it=instances_s.begin(); it!=instances_s.end(); ++it~~ )
	116	for (Host* host : instances_s)
117	117	{
118		if( ~~(*it)~~->isActive() )
	118	if( host->isActive() )
119	119	{
120		if( ~~(*it)~~->isServer_() )
	120	if( host->isServer_() )
121	121	return true;
122	122	}
…	…
135	135	++it;
136	136	}
137		return 0;
	137	return nullptr;
138	138	}
139	139

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

-                      r11009
+                      r11054
   RegisterClassNoArgs(LANDiscoverable);
   LANDiscoverable::LANDiscoverable() : bActive_(false), host_(0)
+  LANDiscoverable::LANDiscoverable() : bActive_(false), host_(nullptr)
+  {
     /* register object in orxonox */
 …
       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;

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

-                      r10624
+                      r11054
   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_);
+  }
 …
     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;
 …
     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;

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

-                      r10624
+                      r11054
   /* forward declaration so the linker doesn't complain */
   MasterServer *MasterServer::instance = NULL;
+  MasterServer *MasterServer::instance = nullptr;
   /* command: list servers */
 …
   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;
+    }
 …
   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 )
 …
+      }
       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 */
 …
   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 */
 …
     /***** 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;

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

-                      r8858
+                      r11054
     /* initiate the client */
     this->client = enet_host_create( NULL /* create a client host */,
+    this->client = enet_host_create( nullptr /* create a client host */,
 ,
 , /* allow up 2 channels to be used, 0 and 1 */
 …
     /* 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;
 …
     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;
 …
     /* address buffer */
     char *addrconv = NULL;
+    char *addrconv = nullptr;
     int retval = 0;
 …
           /* call the supplied callback, if any. */
           if( listener != NULL )
+          if( listener != nullptr )
             retval = listener->rhandler( addrconv, &(this->event) );

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

-                      r10624
+                      r11054
 #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 {
 …
     // 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:
 …
     { }
     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)));
 …
         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);
 …
         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);
 …
         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);
 …
         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);
 …
         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);

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

-                      r11052
+                      r11054
 #include <boost/preprocessor/cat.hpp>
-#include <boost/static_assert.hpp>
 #include "NetworkFunction.h"
 …
             ~StaticallyInitializedNetworkFunction() { delete function_; }
             virtual void load();
             virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
             inline NetworkFunctionBase& getFunction()
 …
     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);
 …
     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);

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

-                      r11052
+                      r11054
 namespace orxonox
+{
     NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = 0;
+    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = nullptr;
     void NetworkFunctionManager::registerFunction(NetworkFunctionBase* function)
 …
             return it->second;
         else
             return NULL;
+            return nullptr;
+    }

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

-                      r10624
+                      r11054
 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;
+}

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

-                      r10624
+                      r11054
+    {
         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;
     };
+}

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

-                      r10622
+                      r11054
   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;
 …
   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;
+      }
 …
   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;
+  }

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

-                      r10622
+                      r11054
   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;
+  }
 …
+  {
     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;
 …
+  {
 //     ClientInformation *temp = ClientInformation::getBegin();
 //     if( temp == NULL )
+//     if( temp == nullptr )
       //no client connected
     if( this->clientIDs_.size()==0 )
 …
+    }
 //     orxout(verbose, context::network) << "sending DeleteObjects" << endl;
 //     while(temp != NULL){
+//     while(temp != nullptr){
 //       if( !(temp->getSynched()) )
 //       {
 …
       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;

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

-                      r10622
+                      r11054
     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();}
 …
     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);
 …
     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);

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

r8858	r11054
73	73	this->host_ = enet_host_create(this->bindAddress_, NETWORK_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
74	74
75		if ( this->host_ == ~~NULL~~ )
	75	if ( this->host_ == nullptr )
76	76	{
77		orxout(internal_error, context::network) << "ServerConnection: host_ == ~~NULL~~" << endl;
	77	orxout(internal_error, context::network) << "ServerConnection: host_ == nullptr" << endl;
78	78	return false;
79	79	}

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

-                      r9667
+                      r11054
 #include <cassert>
 #include <boost/bind.hpp>
+#include <functional>
 #include "core/CoreIncludes.h"
 …
 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)
 …
 *Initializing protected members
 */
     TrafficControl *TrafficControl::instance_=0;
+    TrafficControl *TrafficControl::instance_=nullptr;
     /**
 …
+    {
     RegisterObject(TrafficControl);
       assert(instance_==0);
+      assert(instance_==nullptr);
       instance_=this;
     this->setConfigValues();
 …
     /**
     * @brief Destructor: resets the instance pointer to 0
+    * @brief Destructor: resets the instance pointer to nullptr
     */
     TrafficControl::~TrafficControl()
+    {
       instance_=0;
+      instance_=nullptr;
+    }
 …
     // 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++)
 …
     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);
 …
       //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
 …
       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

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

-                      r6746
+                      r11054
     *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().
 …
     *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
 …
     //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;

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

-                      r7801
+                      r11054
   ~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();

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

-                      r8858
+                      r11054
   /* 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) */

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

-                      r9667
+                      r11054
   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();
 …
     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();

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

-                      r7801
+                      r11054
   ~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:

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

-                      r7801
+                      r11054
   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:

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

-                      r10624
+                      r11054
   ~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_;

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

r10624	r11054
53	53	uint32_t networkID;
54	54	flags_ = flags_ \| PACKET_FLAGS_FUNCTIONIDS;
55		std::queue<std::pair<uint32_t, std::string> > tempQueue;
	55	std::queue<std::pair<uint32_t, std::string>> tempQueue;
56	56
57	57	//calculate total needed size (for all strings and integers)

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

-                      r7801
+                      r11054
   ~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:

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

-                      r9667
+                      r11054
+{
   uint32_t tempsize=0, currentsize=0;
   assert(data_==0);
+  assert(data_==nullptr);
   uint32_t size = calcGamestateSize(id, mode);
 …
   mem += GamestateHeader::getSize();
   ObjectList<Synchronisable>::iterator it;
   for(it = ObjectList<Synchronisable>::begin(); it; ++it)
+  for(it = ObjectList<Synchronisable>().begin(); it; ++it)
+  {
 …
     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
 …
+  {
     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);
+        }
 …
       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
 …
+          }
+        }
         v1.push_back(it->getObjectID());
+        v1.push_back(synchronisable->getObjectID());
+      }
+    }
 …
   if(dest_length==0)
     return NULL;
+    return nullptr;
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
 …
   if(dest_length==0)
     return NULL;
+    return nullptr;
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
 …
   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;

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

-                      r7801
+                      r11054
+{
 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; }
 …
 //     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 );

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

-                      r8858
+                      r11054
 #define WIN32_LEAN_AND_MEAN
 #include <enet/enet.h>
-#include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
 …
 // 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
 …
   packetDirection_ = Direction::Outgoing;
   peerID_=0;
   data_=0;
   enetPacket_=0;
+  data_=nullptr;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
+}
 …
   peerID_=peerID;
   data_=data;
   enetPacket_=0;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
+}
 …
     memcpy(data_, p.data_, p.getSize());
   }else
     data_=0;
+    data_=nullptr;
   bDataENetAllocated_ = p.bDataENetAllocated_;
+}
 …
   // 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_)
+  {
 …
 #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);
 …
 //   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) )
 …
   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);

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

-                      r10622
+                      r11054
   } // 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;
+}

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

-                      r10622
+                      r11054
         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:
 …
+  }
-  _NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
+}
+_NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
 #endif // SERVERINFORMATION_H

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

-                      r8706
+                      r11054
   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:

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

-                      r6417
+                      r11054
       NetworkCallback(T* object, void (T::*function) (void)) : object_(object), function_(function) {}
       virtual ~NetworkCallback() {}
       virtual void call()
+      virtual void call() override
         { (this->object_->*function_)(); }
 …
       NetworkCallbackNotify() {}
       virtual ~NetworkCallbackNotify() {}
       virtual void call()
+      virtual void call() override
         { (this->object_->*function_)( this->oldValue_ ); }
       void setOldValue(const U& value){ this->oldValue_ = value; }

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

r10624	r11054
90	90	{
91	91	// const_cast<typename Loki::TypeTraits<T>::UnqualifiedType>(&variable) = dynamic_cast<T>(variable->getSynchronisable( (uint32_t)(mem) ));
92		const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType>(&variable) = orxonox_cast<T>(T::getSynchronisable((uint32_t*)(mem)));
	92	const_cast<typename Loki::TypeTraits<StrongPtr<T>>::UnqualifiedType>(&variable) = orxonox_cast<T>(T::getSynchronisable((uint32_t*)(mem)));
93	93	mem += returnSize( variable );
94	94	}
…	…
125	125	{
126	126	// const_cast<typename Loki::TypeTraits<T>::UnqualifiedType>(&variable) = dynamic_cast<T>(variable->getSynchronisable( (uint32_t)(mem) ));
127		const_cast<typename Loki::TypeTraits<WeakPtr<T> >::UnqualifiedType>(&variable) = orxonox_cast<T>(T::getSynchronisable((uint32_t*)(mem)));
	127	const_cast<typename Loki::TypeTraits<WeakPtr<T>>::UnqualifiedType>(&variable) = orxonox_cast<T>(T::getSynchronisable((uint32_t*)(mem)));
128	128	mem += returnSize( variable );
129	129	}

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

-                      r10624
+                      r11054
+    }
     // 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();
 …
   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
 …
+    {
       mem += header.getDataSize() + header.getSize();
       return 0;
+      return nullptr;
+    }
 //     assert( !header.isDiffed() );
 …
+    }
     assert(id);
     Context* context = 0;
+    Context* context = nullptr;
     if (header.getContextID() != OBJECTID_UNKNOWN)
+    {
 …
         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
 …
       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);
 …
       return it1->second;
     // if the objects not in the map it should'nt exist at all anymore
     return NULL;
+    return nullptr;
+  }
 …
     assert(this->classID_==this->getIdentifier()->getNetworkID());
     assert(this->objectID_!=OBJECTID_UNKNOWN);
-    std::vector<SynchronisableVariableBase*>::iterator i;
     // start copy header
 …
 //     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;
 …
       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() );
 …
     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;

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

-                      r9667
+                      r11054
   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);
 …
     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);
 …
   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 );

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

-                      r10624
+                      r11054
+  {
     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_;
 …
+  {
     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();

code/branches/cpp11_v3/src/libraries/tools/BillboardSet.cc

r8858	r11054
46	46	BillboardSet::BillboardSet()
47	47	{
48		this->billboardSet_ = 0;
	48	this->billboardSet_ = nullptr;
49	49	}
50	50
…	…
81	81	{
82	82	orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
83		this->billboardSet_ = 0;
	83	this->billboardSet_ = nullptr;
84	84	}
85	85
…	…
104	104	{
105	105	orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
106		this->billboardSet_ = 0;
	106	this->billboardSet_ = nullptr;
107	107	}
108	108
…	…
114	114	if (this->billboardSet_ && this->scenemanager_)
115	115	this->scenemanager_->destroyBillboardSet(this->billboardSet_);
116		this->billboardSet_ = 0;
	116	this->billboardSet_ = nullptr;
117	117	}
118	118

code/branches/cpp11_v3/src/libraries/tools/BulletDebugDrawer.h

-                      r10277
+                      r11054
 #include <btBulletCollisionCommon.h>
 #include <OgreFrameListener.h>
+#include <OgreVector3.h>
+#include <OgreColourValue.h>
 namespace orxonox
 …
             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:

code/branches/cpp11_v3/src/libraries/tools/DebugDrawer.cc

r10262	r11054
21	21	{
22	22	DebugDrawer::DebugDrawer(Ogre::SceneManager *_sceneManager, float _fillAlpha) :
23		sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(0), isEnabled(true), linesIndex(0), trianglesIndex(0)
	23	sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(nullptr), isEnabled(true), linesIndex(0), trianglesIndex(0)
24	24	{
25	25	initialise();
…	…
392	392	manualObject->estimateVertexCount(lineVertices.size());
393	393	manualObject->estimateIndexCount(lineIndices.size());
394		for (~~std::list<VertexPair>::iterator i = lineVertices.begin(); i != lineVertices.end(); i++~~)
	394	for (const VertexPair& pair : lineVertices)
395	395	{
396		manualObject->position(~~i->~~first);
397		manualObject->colour(~~i->~~second);
	396	manualObject->position(pair.first);
	397	manualObject->colour(pair.second);
398	398	}
399		for (~~std::list<int>::iterator i = lineIndices.begin(); i != lineIndices.end(); i++~~)
400		manualObject->index(*i);
	399	for (int lineIndex : lineIndices)
	400	manualObject->index(lineIndex);
401	401	}
402	402	else
…	…
409	409	manualObject->estimateVertexCount(triangleVertices.size());
410	410	manualObject->estimateIndexCount(triangleIndices.size());
411		for (~~std::list<VertexPair>::iterator i = triangleVertices.begin(); i != triangleVertices.end(); i++~~)
	411	for (const VertexPair& pair : triangleVertices)
412	412	{
413		manualObject->position(~~i->~~first);
414		manualObject->colour(~~i->second.r, i->second.g, i->~~second.b, fillAlpha);
	413	manualObject->position(pair.first);
	414	manualObject->colour(pair.second.r, pair.second.g, pair.second.b, fillAlpha);
415	415	}
416		for (~~std::list<int>::iterator i = triangleIndices.begin(); i != triangleIndices.end(); i++~~)
417		manualObject->index(*i);
	416	for (int triangleIndex : triangleIndices)
	417	manualObject->index(triangleIndex);
418	418	}
419	419	else
…	…
433	433	int DebugDrawer::addLineVertex(const Ogre::Vector3& vertex, const Ogre::ColourValue& colour)
434	434	{
435		lineVertices.~~push_back(VertexPair(vertex, colour)~~);
	435	lineVertices.emplace_back(vertex, colour);
436	436	return linesIndex++;
437	437	}
…	…
445	445	int DebugDrawer::addTriangleVertex(const Ogre::Vector3& vertex, const Ogre::ColourValue& colour)
446	446	{
447		triangleVertices.~~push_back(VertexPair(vertex, colour)~~);
	447	triangleVertices.emplace_back(vertex, colour);
448	448	return trianglesIndex++;
449	449	}

code/branches/cpp11_v3/src/libraries/tools/DynamicLines.cc

r5781	r11054
69	69	void DynamicLines::addPoint(Real x, Real y, Real z)
70	70	{
71		mPoints.~~push_back(Vector3(x,y,z)~~);
	71	mPoints.emplace_back(x,y,z);
72	72	mDirty = true;
73	73	}

code/branches/cpp11_v3/src/libraries/tools/DynamicLines.h

-                      r5781
+                      r11054
     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:

code/branches/cpp11_v3/src/libraries/tools/DynamicRenderable.h

-                      r5781
+                      r11054
         /// 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:

code/branches/cpp11_v3/src/libraries/tools/IcoSphere.cc

r10262	r11054
116	116	std::list<TriangleIndices> faces2;
117	117
118		for (~~std::list<TriangleIndices>::iterator j = faces.begin(); j != faces.end(); j++~~)
	118	for (const TriangleIndices& f : faces)
119	119	{
120		~~TriangleIndices f = *j;~~
121	120	int a = getMiddlePoint(f.v1, f.v2);
122	121	int b = getMiddlePoint(f.v2, f.v3);
…	…
127	126	removeLineIndices(f.v3, f.v1);
128	127
129		faces2.~~push_back(TriangleIndices(f.v1, a, c)~~);
130		faces2.~~push_back(TriangleIndices(f.v2, b, a)~~);
131		faces2.~~push_back(TriangleIndices(f.v3, c, b)~~);
132		faces2.~~push_back(TriangleIndices(a, b, c)~~);
	128	faces2.emplace_back(f.v1, a, c);
	129	faces2.emplace_back(f.v2, b, a);
	130	faces2.emplace_back(f.v3, c, b);
	131	faces2.emplace_back(a, b, c);
133	132
134	133	addTriangleLines(f.v1, a, c);
…	…
143	142	void IcoSphere::addLineIndices(int index0, int index1)
144	143	{
145		lineIndices.~~push_back(LineIndices(index0, index1)~~);
	144	lineIndices.emplace_back(index0, index1);
146	145	}
147	146
…	…
164	163	{
165	164	Ogre::Real length = vertex.length();
166		vertices.~~push_back(Ogre::Vector3(vertex.x / length, vertex.y / length, vertex.z / length)~~);
	165	vertices.emplace_back(vertex.x / length, vertex.y / length, vertex.z / length);
167	166	return index++;
168	167	}
…	…
189	188	void IcoSphere::addFace(int index0, int index1, int index2)
190	189	{
191		faces.~~push_back(TriangleIndices(index0, index1, index2)~~);
	190	faces.emplace_back(index0, index1, index2);
192	191	}
193	192
194	193	void IcoSphere::addToLineIndices(int baseIndex, std::list<int>* target) const
195	194	{
196		for (~~std::list<LineIndices>::const_iterator i = lineIndices.begin(); i != lineIndices.end(); i++~~)
	195	for (const LineIndices& line : lineIndices)
197	196	{
198		target->push_back(baseIndex + ~~(*i)~~.v1);
199		target->push_back(baseIndex + ~~(*i)~~.v2);
	197	target->push_back(baseIndex + line.v1);
	198	target->push_back(baseIndex + line.v2);
200	199	}
201	200	}
…	…
203	202	void IcoSphere::addToTriangleIndices(int baseIndex, std::list<int>* target) const
204	203	{
205		for (~~std::list<TriangleIndices>::const_iterator i = faces.begin(); i != faces.end(); i++~~)
	204	for (const TriangleIndices& triangle : faces)
206	205	{
207		target->push_back(baseIndex + ~~(*i)~~.v1);
208		target->push_back(baseIndex + ~~(*i)~~.v2);
209		target->push_back(baseIndex + ~~(*i)~~.v3);
	206	target->push_back(baseIndex + triangle.v1);
	207	target->push_back(baseIndex + triangle.v2);
	208	target->push_back(baseIndex + triangle.v3);
210	209	}
211	210	}
…	…
217	216	transform.setScale(Ogre::Vector3(scale, scale, scale));
218	217
219		for (~~int i = 0; i < (int) vertices.size(); i++~~)
220		target->~~push_back(VertexPair(transform * vertices[i], colour)~~);
	218	for (const Ogre::Vector3& vertex : vertices)
	219	target->emplace_back(transform * vertex, colour);
221	220
222	221	return vertices.size();

code/branches/cpp11_v3/src/libraries/tools/Mesh.cc

r8858	r11054
44	44	Mesh::Mesh()
45	45	{
46		this->entity_ = 0;
	46	this->entity_ = nullptr;
47	47	this->bCastShadows_ = true;
48	48	}
…	…
73	73	{
74	74	orxout(internal_error) << "Couldn't load mesh \"" << meshsource << '"' << endl;
75		this->entity_ = 0;
	75	this->entity_ = nullptr;
76	76	}
77	77	}

code/branches/cpp11_v3/src/libraries/tools/OgreBulletUtils.h

-                      r10262
+                      r11054
 #include "tools/ToolsPrereqs.h"
+#include <OgreVector3.h>
+#include <OgreQuaternion.h>
+#include <OgreColourValue.h>
+#include <OgreMatrix3.h>
+#include <OgreMatrix4.h>
 namespace orxonox
 …
     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],

code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.cc

-                      r11052
+                      r11054
         this->scenemanager_ = scenemanager;
         this->particleSystem_ = 0;
+        this->particleSystem_ = nullptr;
         this->bEnabled_ = true;
 …
+            {
                 orxout(internal_error) << "Couldn't load particle system \"" << templateName << '"' << endl;
                 this->particleSystem_ = 0;
+                this->particleSystem_ = nullptr;
+            }
+        }
 …
+        }
         else
             return 0;
+            return nullptr;
+    }
     Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
 …
             return this->particleSystem_->getEmitter(emitterNr);
         else
             return 0;
+            return nullptr;
+    }
     void ParticleInterface::removeEmitter(unsigned int emitterNr)
 …
             return this->particleSystem_->addAffector(name);
         else
             return 0;
+            return nullptr;
+    }
     Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr)
 …
             return this->particleSystem_->getAffector(affectorNr);
         else
             return 0;
+            return nullptr;
+    }
     void ParticleInterface::removeAffector(unsigned int affectorNr)

code/branches/cpp11_v3/src/libraries/tools/ParticleInterface.h

r11052	r11054
78	78
79	79	protected:
80		virtual void changedTimeFactor(float factor_new, float factor_old);
	80	virtual void changedTimeFactor(float factor_new, float factor_old) override;
81	81
82	82	private:

code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.cc

r9667	r11054
48	48	}
49	49
50		~~ResourceCollection::~ResourceCollection()~~
51		{
52		}
53
54	50	void ResourceCollection::XMLPort(Element& xmlelement, XMLPort::Mode mode)
55	51	{
…	…
93	89	{
94	90	if (index >= resourceLocations_.size())
95		return ~~NULL~~;
	91	return nullptr;
96	92	else
97	93	return resourceLocations_[index];

code/branches/cpp11_v3/src/libraries/tools/ResourceCollection.h

-                      r9667
+                      r11054
     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);
 …
     private:
+        ResourceCollection(const ResourceCollection&);
+        // non-copyable:
+        ResourceCollection(const ResourceCollection&) = delete;
+        ResourceCollection& operator=(const ResourceCollection&) = delete;
         std::string resourceGroup_;

code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.cc

r10624	r11054
54	54	}
55	55
56		~~ResourceLocation::~ResourceLocation()~~
57		{
58		}
59
60	56	void ResourceLocation::XMLPort(Element& xmlelement, XMLPort::Mode mode)
61	57	{

code/branches/cpp11_v3/src/libraries/tools/ResourceLocation.h

-                      r9667
+                      r11054
     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; }
 …
     private:
+        ResourceLocation(const ResourceLocation&);
+        // non-copyable:
+        ResourceLocation(const ResourceLocation&) = delete;
+        ResourceLocation& operator=(const ResourceLocation&) = delete;
         void load(const std::string& resourceGroup);

code/branches/cpp11_v3/src/libraries/tools/Shader.cc

-                      r10727
+                      r11054
         @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);
 …
+    {
         // 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());
 …
                 Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->oldcompositorName_);
                 this->compositorInstance_->removeListener(this);
                 this->compositorInstance_ = 0;
+                this->compositorInstance_ = nullptr;
+            }
             if (!this->compositorName_.empty())
 …
+    {
         // 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();
 …
+        {
             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;
+        }

code/branches/cpp11_v3/src/libraries/tools/Shader.h

-                      r10727
+                      r11054
+    {
         public:
             Shader(Ogre::SceneManager* scenemanager = 0);
+            Shader(Ogre::SceneManager* scenemanager = nullptr);
             virtual ~Shader();
 …
                 { 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:

code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.cc

r10546	r11054
71	71	namespace orxonox
72	72	{
73		std::map<std::string, std::map<ColourValue, std::string> > TextureGenerator::materials_s;
	73	std::map<std::string, std::map<ColourValue, std::string>> TextureGenerator::materials_s;
74	74	unsigned int TextureGenerator::materialCount_s = 0;
75	75

code/branches/cpp11_v3/src/libraries/tools/TextureGenerator.h

-                      r5781
+                      r11054
     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;
     };

code/branches/cpp11_v3/src/libraries/tools/Timer.cc

r11018	r11054
163	163	void Timer::init()
164	164	{
165		this->executor_ = 0;
	165	this->executor_ = nullptr;
166	166	this->interval_ = 0;
167	167	this->bLoop_ = false;

code/branches/cpp11_v3/src/libraries/tools/Timer.h

r11018	r11054
175	175
176	176	protected:
177		virtual float getTimeFactor();
	177	virtual float getTimeFactor() override;
178	178	};
179	179	}

code/branches/cpp11_v3/src/libraries/tools/interfaces/TimeFactorListener.h

r9667	r11054
39	39	public:
40	40	TimeFactorListener();
41		virtual ~TimeFactorListener() {}
	41	virtual ~TimeFactorListener() = default;
42	42
43	43	static void setTimeFactor(float factor);

code/branches/cpp11_v3/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc

-                      r10624
+                      r11054
         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);
+    }

code/branches/cpp11_v3/src/libraries/util/CMakeLists.txt

r10624	r11054
26	26	CRC32.cc
27	27	ExprParser.cc
28		~~SharedPtr.cc~~
29	28	Sleep.cc
30	29	SmallObjectAllocator.cc

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

r8858	r11054
93	93	{
94	94	HANDLE hData = GetClipboardData(CF_TEXT);
95		if (hData == ~~NULL~~)
	95	if (hData == nullptr)
96	96	return "";
97	97	std::string output(static_cast<char*>(GlobalLock(hData)));

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

-                      r7401
+                      r11054
     private:
+        /// Undefined
+        Clock(const Clock& instance);
+        // non-copyable:
+        Clock(const Clock&) = delete;
+        Clock& operator=(const Clock&) = delete;
         Ogre::Timer*       timer_;       ///< Ogre timer object

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

-                      r8423
+                      r11054
     /** 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>
 …
+    {
         delete *object;
         *object = NULL;
+        *object = nullptr;
+    }
 …
     private:
+        DestructionHelper(const DestructionHelper&); //!< Don't use (undefined)
+        // non-copyable:
+        DestructionHelper(const DestructionHelper&) = delete;
+        DestructionHelper& operator=(const DestructionHelper&) = delete;
         T* object_;

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

-                      r6417
+                      r11054
+            {
                 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);

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

r8351	r11054
391	391	}
392	392
393		char* ExprParser::parse_word(char* str)
	393	void ExprParser::parse_word(char* str)
394	394	{
395	395	char* word = str;
…	…
402	402	{
403	403	this->failed_ = true;
404		return ~~'\0'~~;
	404	return;
405	405	}
406	406	};
407	407	*word = '\0';
408		~~return str;~~
409	408	}
410	409

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

r8858	r11054
139	139	float parse_expr_7();
140	140	float parse_expr_8();
141		char* parse_word(char* str);
	141	void parse_word(char* str);
142	142	binary_operator parse_binary_operator();
143	143	unary_operator parse_unary_operator();

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

-                      r8267
+                      r11054
+    {
     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);

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

-                      r11052
+                      r11054
+    }
+    namespace detail
+    {
+        std::mt19937 rngen;
+    }
     /**
         @brief Returns a unique number. This function will never return the same value twice.

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

-                      r11052
+                      r11054
 #include <cmath>
 #include <cstdlib>
+#include <random>
 #include <OgreMath.h>
 …
     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
+    }
 …
     */
     template <typename T>
     inline T sgn(T x)
+    constexpr inline T sgn(T x)
+    {
         return (x >= 0) ? (T)1 : (T)-1;
 …
     */
     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);
+    }
 …
     */
     template <typename T>
     inline T square(T x)
+    constexpr inline T square(T x)
+    {
         return x*x;
 …
     */
     template <typename T>
     inline T cube(T x)
+    constexpr inline T cube(T x)
+    {
         return x*x*x;
 …
     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");
+    }
 …
     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); }
 …
+    }
+    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>.
 …
     inline float rnd()
+    {
         return rand() / (RAND_MAX + 1.0f);
+        return rnd(0, 1);
+    }
 …
     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);
+    }
 …
     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
+    }

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

-                      r10197
+                      r11054
         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;
 …
             /// 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.
 …
                 if (this->value_)
                     delete this->value_;
                 this->value_ = (other.value_) ? other.value_->clone() : 0;
+                this->value_ = (other.value_) ? other.value_->clone() : nullptr;
+            }
 …
             /// 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()); }
 …
+            }
             /// 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
 …
     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>()); }

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

-                      r9550
+                      r11054
         /// 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.
         /**
 …
             @param other The other MultiType
         */
         inline bool setValue(const MultiType& other)
+        virtual inline bool setValue(const MultiType& other) override
+        {
             if (other.value_)
 …
+        }
         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

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

r8706	r11054
672	672	{
673	673	uint32_t tempsize = sizeof(uint32_t); // for the number of entries
674		for( ~~typename std::set<T>::iterator it=((std::set<T>)(&variable))->begin(); it!=((std::set<T>)(&variable))->end(); ++it~~)
675		tempsize += returnSize( *it );
	674	for(const T& element : ((std::set<T>)(&variable)))
	675	tempsize += returnSize( element );
676	676	return tempsize;
677	677	}
…	…
679	679	template <class T> inline void saveAndIncrease( const std::set<T>& variable, uint8_t*& mem )
680	680	{
681		~~typename std::set<T>::const_iterator it = variable.begin();~~
682	681	saveAndIncrease( (uint32_t)variable.size(), mem );
683		for( ~~; it!=variable.end(); ++it~~ )
684		saveAndIncrease( *it, mem );
	682	for( const T& elem : variable )
	683	saveAndIncrease( elem, mem );
685	684	}
686	685

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

-                      r9682
+                      r11054
 namespace orxonox
+{
     SignalHandler* SignalHandler::singletonPtr_s = NULL;
+    SignalHandler* SignalHandler::singletonPtr_s = nullptr;
+}
 …
     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 );
+      }
 …
+      }
       // 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;
 …
+      }
       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 );
+      }
 …
         dup2( gdbErr[1], STDERR_FILENO );
         execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(NULL));
+        execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(nullptr));
+      }
 …
         perror("pipe failed!\n");
         kill( gdbPid, SIGTERM );
         waitpid( gdbPid, NULL, 0 );
+        waitpid( gdbPid, nullptr, 0 );
         exit(EXIT_FAILURE);
+      }
 …
         perror("fork failed!\n");
         kill( gdbPid, SIGTERM );
         waitpid( gdbPid, NULL, 0 );
+        waitpid( gdbPid, nullptr, 0 );
         exit(EXIT_FAILURE);
+      }
 …
       waitpid( sigPid, NULL, 0 );
       waitpid( gdbPid, NULL, 0 );
+      waitpid( sigPid, nullptr, 0 );
+      waitpid( gdbPid, nullptr, 0 );
       int wsRemoved = 0;
 …
         bt.erase(0, 1);
       time_t now = time(NULL);
+      time_t now = time(nullptr);
       std::string timeString =
 …
     SignalHandler::SignalHandler()
+    {
         this->prevExceptionFilter_ = NULL;
+        this->prevExceptionFilter_ = nullptr;
+    }
 …
     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;
+        }
+    }
 …
         // 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
 …
             // 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;
 …
             std::ofstream crashlog(SignalHandler::getInstance().filename_.c_str());
             time_t now = time(NULL);
+            time_t now = time(nullptr);
             crashlog << "=======================================================" << endl;
 …
+    }
     /// 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)
+    {
 …
 #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)
+                {
 …
         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 ";

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

r9550	r11054
113	113	void doCatch(const std::string& appName, const std::string& filename);
114	114
115		static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = ~~NULL~~);
	115	static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = nullptr);
116	116	static std::string getExceptionType(PEXCEPTION_POINTERS pExceptionInfo);
117	117

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

r10624	r11054
66	66	And don't forget to initialize the static singleton pointer in the source (*.cc) %file:
67	67	@code
68		TestSingleton* TestSingleton::singletonPtr_s = ~~NULL~~;
	68	TestSingleton* TestSingleton::singletonPtr_s = nullptr;
69	69	@endcode
70	70
…	…
118	118	static T& getInstance()
119	119	{
120		OrxVerify(T::singletonPtr_s != ~~NULL~~, "T=" << typeid(T).name());
	120	OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
121	121	return *T::singletonPtr_s;
122	122	}
…	…
125	125	static bool exists()
126	126	{
127		return (T::singletonPtr_s != ~~NULL~~);
	127	return (T::singletonPtr_s != nullptr);
128	128	}
129	129
…	…
132	132	Singleton()
133	133	{
134		OrxVerify(T::singletonPtr_s == ~~NULL~~, "T=" << typeid(T).name());
	134	OrxVerify(T::singletonPtr_s == nullptr, "T=" << typeid(T).name());
135	135	T::singletonPtr_s = static_cast<T*>(this);
136	136	}
…	…
139	139	virtual ~Singleton()
140	140	{
141		OrxVerify(T::singletonPtr_s != ~~NULL~~, "T=" << typeid(T).name());
142		T::singletonPtr_s = ~~NULL~~;
	141	OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
	142	T::singletonPtr_s = nullptr;
143	143	}
144	144
145	145	private:
146		Singleton(const Singleton& rhs); //!< Don't use (undefined)
	146	// non-copyable:
	147	Singleton(const Singleton&) = delete;
	148	Singleton& operator=(const Singleton&) = delete;
147	149	};
148	150	}

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

-                      r7401
+                      r11054
         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;
+    }
 …
     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;
+    }
 …
                 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

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

r7401	r11054
77	77	#include "UtilPrereqs.h"
78	78	#include <vector>
	79	#include <cstdio>
79	80
80	81	namespace orxonox

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

-                      r9550
+                      r11054
 #include <cctype>
 #include <ctime>
-#include <boost/scoped_array.hpp>
 #include "Convert.h"
 #include "Math.h"
 …
         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;
 …
             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;
 …
     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));
+        }
+    }
 …
     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));
+        }
+    }
 …
+    {
         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;
+            }
 …
         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)

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

r9550	r11054
112	112	for (size_t i = 0; i < argc; ++i)
113	113	{
114		this->tokens_.~~push_back(std::string(argv[i])~~);
	114	this->tokens_.emplace_back(argv[i]);
115	115	this->bTokenInSafemode_.push_back(false);
116	116	}

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

r10624	r11054
80	80	class OutputStream;
81	81	class ScopeListener;
82		~~template <class T>~~
83		~~class SharedPtr;~~
84	82	class SignalHandler;
85	83	template <class T>

code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.cc

-                      r8858
+                      r11054
         this->configurableMaxLevel_ = level::none;
         this->configurableAdditionalContextsMaxLevel_ = level::verbose;
         this->configurableAdditionalContexts_.push_back("example");
+        this->configurableAdditionalContexts_.emplace_back("example");
         this->changedConfigurableLevel();
 …
         // 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;

code/branches/cpp11_v3/src/libraries/util/output/BaseWriter.h

r8858	r11054
103	103
104	104	protected:
105		virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines);
	105	virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) override;
106	106
107	107	private:

code/branches/cpp11_v3/src/libraries/util/output/ConsoleWriter.h

-                      r9550
+                      r11054
         public:
             ConsoleWriter(std::ostream& outputStream);
-            ConsoleWriter(const ConsoleWriter&);
             virtual ~ConsoleWriter();
 …
         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.

code/branches/cpp11_v3/src/libraries/util/output/LogWriter.cc

-                      r9550
+                      r11054
 #include <ctime>
+#include <chrono>
 #include <cstdlib>
 …
 namespace orxonox
+{
     static const int MAX_ARCHIVED_FILES = 9;
+    static constexpr int MAX_ARCHIVED_FILES = 9;
     /**
 …
             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;
+    }
+}

code/branches/cpp11_v3/src/libraries/util/output/LogWriter.h

-                      r9550
+                      r11054
         public:
             LogWriter();
-            LogWriter(const LogWriter&);
             virtual ~LogWriter();
 …
         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();

code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.cc

r9550	r11054
57	57	void MemoryWriter::output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
58	58	{
59		this->messages_.~~push_back(Message(level, context, lines)~~);
	59	this->messages_.emplace_back(level, context, lines);
60	60	}
61	61
…	…
65	65	void MemoryWriter::resendOutput(OutputListener* listener) const
66	66	{
67		for (~~size_t i = 0; i < this->messages_.size(); ++i~~)
	67	for (const Message& message : this->messages_)
68	68	{
69		~~const Message& message = this->messages_[i];~~
70	69	listener->unfilteredOutput(message.level, *message.context, message.lines);
71	70	}

code/branches/cpp11_v3/src/libraries/util/output/MemoryWriter.h

-                      r9550
+                      r11054
         public:
             MemoryWriter();
-            MemoryWriter(const MemoryWriter&);
             virtual ~MemoryWriter();
 …
         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.
     };

code/branches/cpp11_v3/src/libraries/util/output/OutputDefinitions.h

-                      r10624
+                      r11054
     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

code/branches/cpp11_v3/src/libraries/util/output/OutputListener.cc

-                      r9550
+                      r11054
         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);
+    }
 …
         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);
+    }
 …
         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);
+    }

code/branches/cpp11_v3/src/libraries/util/output/OutputManager.cc

-                      r9550
+                      r11054
 #include "util/Output.h"
 #include "util/StringUtils.h"
-#include "util/SharedPtr.h"
 namespace orxonox
 …
         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
 …
+    }
     /*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;
+    }
 …
         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);
+    }
 …
+    {
         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);
+    }
 …
+    {
         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);
+    }
 …
+    {
         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();
+    }

code/branches/cpp11_v3/src/libraries/util/output/OutputManager.h

-                      r9550
+                      r11054
 #include <vector>
 #include <map>
+#include <memory>
 #include "OutputDefinitions.h"
 …
         public:
             OutputManager();
-            OutputManager(const OutputManager&);
             virtual ~OutputManager();
 …
             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(); }
 …
         private:
+            // non-copyable:
+            OutputManager(const OutputManager&) = delete;
+            OutputManager& operator=(const OutputManager&) = delete;
             void updateMasks();
             void updateCombinedLevelMask();
 …
             struct _UtilExport Testing
+            {
                 static SharedPtr<OutputManager>& getInstancePointer();
+                static std::shared_ptr<OutputManager>& getInstancePointer();
             };
     };

code/branches/cpp11_v3/src/libraries/util/output/OutputStream.cc

r8858	r11054
41	41	@brief Default constructor, initializes level and context with default values.
42	42	*/
43		OutputStream::OutputStream()
	43	OutputStream::OutputStream() : OutputStream(level::debug_output, context::undefined())
44	44	{
45		~~this->setOutputAttributes(level::debug_output, context::undefined());~~
46	45	}
47	46

code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.cc

-                      r8858
+                      r11054
         // 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);
+        }

code/branches/cpp11_v3/src/libraries/util/output/SubcontextOutputListener.h

-                      r9550
+                      r11054
             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

Context Navigation

Legend: