Changeset 11071 for code/trunk/src/libraries/core

code/trunk

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,10996-11008,11010
/code/branches/cpp11_v3 (added)	merged: 11053-11054,11057-11070

code/trunk/src/libraries/core/ApplicationPaths.cc

-                      r10624
+                      r11071
     //! 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/trunk/src/libraries/core/ApplicationPaths.h

-                      r10624
+                      r11071
         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/trunk/src/libraries/core/BaseObject.cc

-                      r10624
+                      r11071
         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/trunk/src/libraries/core/BaseObject.h

-                      r10624
+                      r11071
             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/trunk/src/libraries/core/ClassTreeMask.cc

-                      r10624
+                      r11071
             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/trunk/src/libraries/core/ClassTreeMask.h

-                      r10693
+                      r11071
             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/trunk/src/libraries/core/ConfigurablePaths.cc

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/ConfigurablePaths.h

-                      r10624
+                      r11071
         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/trunk/src/libraries/core/Core.cc

-                      r11011
+                      r11071
+{
     //! 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/trunk/src/libraries/core/Core.h

-                      r11012
+                      r11071
             /// 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/trunk/src/libraries/core/CoreConfig.cc

-                      r11052
+                      r11071
 #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/trunk/src/libraries/core/CoreConfig.h

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

code/trunk/src/libraries/core/CoreIncludes.h

-                      r11020
+                      r11071
 */
 #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/trunk/src/libraries/core/CorePrecompiledHeaders.h

-                      r8858
+                      r11071
 #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/trunk/src/libraries/core/CorePrereqs.h

-                      r10624
+                      r11071
 #include "OrxonoxConfig.h"
 #include <boost/version.hpp>
+#include <string>
 //-----------------------------------------------------------------------
 …
 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/trunk/src/libraries/core/CoreStaticInitializationHandler.cc

-                      r10624
+                      r11071
         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/trunk/src/libraries/core/CoreStaticInitializationHandler.h

-                      r10624
+                      r11071
             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/trunk/src/libraries/core/EventIncludes.h

-                      r8729
+                      r11071
 #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/trunk/src/libraries/core/GUIManager.cc

-                      r11052
+                      r11071
 #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)
 …
             ArgumentCompletionList names;
             const std::vector<std::string> guis = GUIManager::getInstance().getLoadedGUIs();
             for (size_t i = 0; i < guis.size(); ++i)
                 names.push_back(ArgumentCompletionListElement(guis[i], getLowercase(guis[i])));
+            for (const std::string gui : guis)
+                names.push_back(ArgumentCompletionListElement(gui, getLowercase(gui)));
             return names;
+        }
 …
     */
     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/trunk/src/libraries/core/GUIManager.h

-                      r11052
+                      r11071
 #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/trunk/src/libraries/core/Game.cc

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/Game.h

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/GameMode.h

-                      r7401
+                      r11071
         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/trunk/src/libraries/core/GraphicsManager.cc

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/GraphicsManager.h

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/Language.cc

-                      r10624
+                      r11071
     // ###############################
     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/trunk/src/libraries/core/Language.h

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

code/trunk/src/libraries/core/Loader.cc

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/Loader.h

r10624	r11071
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/trunk/src/libraries/core/LuaState.cc

-                      r10265
+                      r11071
     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/trunk/src/libraries/core/LuaState.h

-                      r10265
+                      r11071
 #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/trunk/src/libraries/core/Namespace.cc

r10624	r11071
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/trunk/src/libraries/core/Namespace.h

r9667	r11071
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/trunk/src/libraries/core/NamespaceNode.cc

-                      r8858
+                      r11071
                 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/trunk/src/libraries/core/NamespaceNode.h

r7401	r11071
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/trunk/src/libraries/core/Resource.cc

r9675	r11071
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/trunk/src/libraries/core/Resource.h

-                      r8351
+                      r11071
 #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/trunk/src/libraries/core/Template.cc

r9667	r11071
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/trunk/src/libraries/core/Template.h

-                      r9667
+                      r11071
             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/trunk/src/libraries/core/Thread.cc

-                      r8399
+                      r11071
 #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/trunk/src/libraries/core/ThreadPool.cc

r8394	r11071
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/trunk/src/libraries/core/ThreadWin.cc

-                      r8706
+                      r11071
 #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/trunk/src/libraries/core/ViewportEventListener.h

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

code/trunk/src/libraries/core/WindowEventListener.cc

r10624	r11071
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/trunk/src/libraries/core/WindowEventListener.h

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

code/trunk/src/libraries/core/XMLNameListener.h

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

code/trunk/src/libraries/core/XMLPort.h

-                      r9667
+                      r11071
             return my_added_objects[index];
           else
             return 0;
+            return nullptr;
+        }
       @endcode
 …
+    {
     public:
         enum ParseResult
+        enum class ParseResult
+        {
             PR_not_started,
             PR_finished,
             PR_waiting_for_default_values
+            not_started,
+            finished,
+            waiting_for_default_values
         };
         public:
             XMLPortParamContainer()
                 { this->parseResult_ = PR_not_started; }
             virtual ~XMLPortParamContainer() {}
+                { this->parseResult_ = ParseResult::not_started; }
+            virtual ~XMLPortParamContainer() = default;
             inline const std::string& getName() const
 …
+            }
-            ~XMLPortClassParamContainer()
+            {
+            }
             XMLPortParamContainer& port(BaseObject* owner, T* object, Element& xmlelement, XMLPort::Mode mode)
+            {
 …
                             // Iterate through the attributes manually in order to make them case insensitive
                             ticpp::Attribute* attribute = xmlelement.FirstAttribute(false);
                             while (attribute != 0)
+                            while (attribute != nullptr)
+                            {
                                 this->owner_->xmlAttributes_[getLowercase(attribute->Name())] = attribute->Value();
 …
                             this->loadexecutor_->parse(object, attributeValue, &error, ",");
                             if (!error || (mode  == XMLPort::ExpandObject))
                                 this->parseResult_ = PR_finished;
+                                this->parseResult_ = ParseResult::finished;
                             else
                                 this->parseResult_ = PR_waiting_for_default_values;
+                                this->parseResult_ = ParseResult::waiting_for_default_values;
+                        }
                         else if (mode == XMLPort::ExpandObject)
                             this->parseResult_ = PR_finished;
+                            this->parseResult_ = ParseResult::finished;
                         else
                             this->parseResult_ = PR_waiting_for_default_values;
+                            this->parseResult_ = ParseResult::waiting_for_default_values;
+                    }
                     catch (ticpp::Exception& ex)
 …
             XMLPortParamContainer& portIfWaitingForDefaultValues(const ParseResult& result, const ParseParams& params)
+            {
                 if (result == PR_waiting_for_default_values)
+                if (result == ParseResult::waiting_for_default_values)
                     return this->port(this->owner_, params);
                 else
 …
+            }
             virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param)
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param) override
+            {
                 if (!this->loadexecutor_->defaultValueSet(index))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiType& param1)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1) override
+            {
                 if (!this->loadexecutor_->defaultValueSet(0))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2) override
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3) override
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) override
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)))
 …
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
+            }
             virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) override
+            {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)) || (!this->loadexecutor_->defaultValueSet(4)))
 …
             XMLPortObjectContainer()
                 { this->bApplyLoaderMask_ = false; }
             virtual ~XMLPortObjectContainer() {}
+            virtual ~XMLPortObjectContainer() = default;
             XMLPortObjectContainer& port(BaseObject* object, Element& xmlelement, XMLPort::Mode mode);
 …
+            }
+            ~XMLPortClassObjectContainer()
+            {
+            }
+            void callLoadExecutor(BaseObject* object, BaseObject* newObject)
+            virtual void callLoadExecutor(BaseObject* object, BaseObject* newObject) override
+            {
                 T* castObject = orxonox_cast<T*>(object);

code/trunk/src/libraries/core/class/Identifiable.cc

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

code/trunk/src/libraries/core/class/Identifiable.h

-                      r9667
+                      r11071
                 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/trunk/src/libraries/core/class/Identifier.cc

-                      r10624
+                      r11071
             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/trunk/src/libraries/core/class/Identifier.h

-                      r10624
+                      r11071
     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);
 …
             /// Returns the map that stores all XMLPort params.
             inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
-            /// Returns a const_iterator to the beginning of the map that stores all XMLPort params.
-            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
-            /// Returns a const_iterator to the end of the map that stores all XMLPort params.
-            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
             /// Returns the map that stores all XMLPort objects.
             inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
-            /// Returns a const_iterator to the beginning of the map that stores all XMLPort objects.
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
-            /// Returns a const_iterator to the end of the map that stores all XMLPort objects.
-            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
             void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
 …
     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/trunk/src/libraries/core/class/IdentifierManager.cc

-                      r10624
+                      r11071
 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/trunk/src/libraries/core/class/IdentifierManager.h

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/class/SubclassIdentifier.h

r9667	r11071
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/trunk/src/libraries/core/class/Super.h

-                      r10624
+                      r11071
             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/trunk/src/libraries/core/command/ArgumentCompletionFunctions.cc

-                      r10624
+                      r11071
             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/trunk/src/libraries/core/command/ArgumentCompletionFunctions.h

-                      r11052
+                      r11071
+        {
             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/trunk/src/libraries/core/command/CommandEvaluation.cc

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/command/CommandEvaluation.h

-                      r8079
+                      r11071
             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/trunk/src/libraries/core/command/CommandExecutor.cc

-                      r10624
+                      r11071
         @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/trunk/src/libraries/core/command/CommandExecutor.h

-                      r8858
+                      r11071
             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/trunk/src/libraries/core/command/ConsoleCommand.cc

-                      r10624
+                      r11071
     */
     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/trunk/src/libraries/core/command/ConsoleCommand.h

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

code/trunk/src/libraries/core/command/ConsoleCommandIncludes.h

-                      r10624
+                      r11071
             ~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/trunk/src/libraries/core/command/ConsoleCommandManager.cc

r11052	r11071
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/trunk/src/libraries/core/command/ConsoleCommandManager.h

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/command/Executor.cc

-                      r9550
+                      r11071
     /**
-        @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/trunk/src/libraries/core/command/Executor.h

-                      r9550
+                      r11071
     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.
 …
                 { return this->functor_->hasReturnvalue(); }
             /// Returns the type of the wrapped function (static or member).
             inline Functor::Type::Enum getType() const
+            inline Functor::Type getType() const
                 { return this->functor_->getType(); }
             /// Returns the name of the type of a parameter with given index (the first parameter has index 0).
 …
             /// 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/trunk/src/libraries/core/command/ExecutorPtr.h

-                      r7401
+                      r11071
     @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/trunk/src/libraries/core/command/Functor.h

-                      r9667
+                      r11071
     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:
+            struct Type
+            {
+                /// Defines the type of a function (static or member)
+                enum Enum
+                {
+                    Static,
+                    Member
+                };
+            /// Defines the type of a function (static or member)
+            enum class Type
+            {
+                Static,
+                Member
             };
         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)
 …
             /// Returns the type of the function: static or member.
             virtual Type::Enum getType() const = 0;
+            virtual Type getType() const = 0;
             /// Returns the number of parameters of the function.
             virtual unsigned int getParamCount() const = 0;
 …
             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 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 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/trunk/src/libraries/core/command/FunctorPtr.h

-                      r7401
+                      r11071
     @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/trunk/src/libraries/core/command/IOConsolePOSIX.cc

-                      r9667
+                      r11071
 namespace orxonox
+{
+    IOConsole* IOConsole::singletonPtr_s = NULL;
+    namespace EscapeMode
+    {
+        enum Value
+        {
+            None,
+            First,
+            Second
+        };
+    }
+    IOConsole* IOConsole::singletonPtr_s = nullptr;
+    enum class EscapeMode
+    {
+        None,
+        First,
+        Second
+    };
     IOConsole::IOConsole()
 …
         , promptString_("orxonox # ")
         , bStatusPrinted_(false)
         , originalTerminalSettings_(0)
+        , originalTerminalSettings_(nullptr)
+    {
         this->setTerminalMode();
 …
         std::cout.flush();
         if (!this->origCout_.str().empty())
             this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
         // Erase input and status lines
         this->cout_ << "\033[1G\033[J";
 …
         unsigned char c;
         std::string escapeSequence;
         EscapeMode::Value escapeMode = EscapeMode::None;
+        EscapeMode escapeMode = EscapeMode::None;
         while (std::cin.good())
+        {
 …
         if (!this->origCout_.str().empty())
+        {
             this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
             this->origCout_.str("");
+        }
 …
         switch (type)
+        {
             case Shell::Message:
             case Shell::DebugOutput:     this->cout_ << "\033[0m"; break;
             case Shell::UserError:       this->cout_ << "\033[91m"; break;
             case Shell::UserWarning:     this->cout_ << "\033[93m"; break;
             case Shell::UserStatus:      this->cout_ << "\033[92m"; break;
             case Shell::UserInfo:        this->cout_ << "\033[96m"; break;
             case Shell::InternalError:   this->cout_ << "\033[31m"; break;
             case Shell::InternalWarning: this->cout_ << "\033[33m"; break;
             case Shell::InternalStatus:  this->cout_ << "\033[32m"; break;
             case Shell::InternalInfo:    this->cout_ << "\033[36m"; break;
             case Shell::Verbose:         this->cout_ << "\033[94m"; break;
             case Shell::VerboseMore:     this->cout_ << "\033[34m"; break;
             case Shell::VerboseUltra:    this->cout_ << "\033[34m"; break;
             case Shell::Command:         this->cout_ << "\033[95m"; break;
             case Shell::Hint:            this->cout_ << "\033[35m"; break;
             default:                     this->cout_ << "\033[37m"; break;
+            case Shell::LineType::Message:
+            case Shell::LineType::DebugOutput:     this->cout_ << "\033[0m"; break;
+            case Shell::LineType::UserError:       this->cout_ << "\033[91m"; break;
+            case Shell::LineType::UserWarning:     this->cout_ << "\033[93m"; break;
+            case Shell::LineType::UserStatus:      this->cout_ << "\033[92m"; break;
+            case Shell::LineType::UserInfo:        this->cout_ << "\033[96m"; break;
+            case Shell::LineType::InternalError:   this->cout_ << "\033[31m"; break;
+            case Shell::LineType::InternalWarning: this->cout_ << "\033[33m"; break;
+            case Shell::LineType::InternalStatus:  this->cout_ << "\033[32m"; break;
+            case Shell::LineType::InternalInfo:    this->cout_ << "\033[36m"; break;
+            case Shell::LineType::Verbose:         this->cout_ << "\033[94m"; break;
+            case Shell::LineType::VerboseMore:     this->cout_ << "\033[34m"; break;
+            case Shell::LineType::VerboseUltra:    this->cout_ << "\033[34m"; break;
+            case Shell::LineType::Command:         this->cout_ << "\033[95m"; break;
+            case Shell::LineType::Hint:            this->cout_ << "\033[35m"; break;
+            default:                               this->cout_ << "\033[37m"; break;
+        }
 …
             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;
 …
     void IOConsole::executed()
+    {
         this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::LineType::Command);
+    }

code/trunk/src/libraries/core/command/IOConsolePOSIX.h

-                      r8858
+                      r11071
         // 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/trunk/src/libraries/core/command/IOConsoleWindows.cc

-                      r9676
+                      r11071
 namespace orxonox
+{
     IOConsole* IOConsole::singletonPtr_s = NULL;
+    IOConsole* IOConsole::singletonPtr_s = nullptr;
     //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
 …
         std::cout.flush();
         if (!this->origCout_.str().empty())
             this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
         this->shell_->unregisterListener(this);
 …
         if (!this->origCout_.str().empty())
+        {
             this->shell_->addOutput(this->origCout_.str(), Shell::Cout);
+            this->shell_->addOutput(this->origCout_.str(), Shell::LineType::Cout);
             this->origCout_.str("");
+        }
 …
         switch (type)
+        {
             case Shell::Message:
             case Shell::DebugOutput:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
             case Shell::UserError:       colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | 0              ; break;
             case Shell::UserWarning:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
             case Shell::UserStatus:      colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | 0              ; break;
             case Shell::UserInfo:        colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
             case Shell::InternalError:   colour = 0                    | FOREGROUND_RED | 0                | 0              ; break;
             case Shell::InternalWarning: colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
             case Shell::InternalStatus:  colour = 0                    | 0              | FOREGROUND_GREEN | 0              ; break;
             case Shell::InternalInfo:    colour = 0                    | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
             case Shell::Verbose:         colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
             case Shell::VerboseMore:     colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
             case Shell::VerboseUltra:    colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
             case Shell::Command:         colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
             case Shell::Hint:            colour = 0                    | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
             default:                     colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::LineType::Message:
+            case Shell::LineType::DebugOutput:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::LineType::UserError:       colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::LineType::UserWarning:     colour = FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::UserStatus:      colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::UserInfo:        colour = FOREGROUND_INTENSITY | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::LineType::InternalError:   colour = 0                    | FOREGROUND_RED | 0                | 0              ; break;
+            case Shell::LineType::InternalWarning: colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::InternalStatus:  colour = 0                    | 0              | FOREGROUND_GREEN | 0              ; break;
+            case Shell::LineType::InternalInfo:    colour = 0                    | 0              | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+            case Shell::LineType::Verbose:         colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::LineType::VerboseMore:     colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::LineType::VerboseUltra:    colour = FOREGROUND_INTENSITY | 0              | 0                | FOREGROUND_BLUE; break;
+            case Shell::LineType::Command:         colour = FOREGROUND_INTENSITY | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+            case Shell::LineType::Hint:            colour = 0                    | FOREGROUND_RED | 0                | FOREGROUND_BLUE; break;
+            default:                               colour = 0                    | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; break;
+        }
 …
                 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);
+        }
+    }
 …
     void IOConsole::executed()
+    {
         this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::Command);
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput(), Shell::LineType::Command);
+    }
 …
             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/trunk/src/libraries/core/command/IOConsoleWindows.h

-                      r9676
+                      r11071
         // 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/trunk/src/libraries/core/command/IRC.cc

r10624	r11071
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/trunk/src/libraries/core/command/IRC.h

-                      r7401
+                      r11071
             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/trunk/src/libraries/core/command/Shell.cc

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

code/trunk/src/libraries/core/command/Shell.h

-                      r10624
+                      r11071
         public:
+            virtual ~ShellListener() {}
+            ShellListener() = default;
+            virtual ~ShellListener() = default;
         private:
 …
         public:
             /// Defines the type of a line of text in the Shell - some types depend on the output level, others are of internal use.
             enum LineType
+            enum class LineType
+            {
                 DebugOutput     = debug_output,
 …
             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;
             void addOutput(const std::string& text, LineType type = DebugOutput);
             void addLine(const std::string& line, LineType type = DebugOutput);
+            void addOutput(const std::string& text, LineType type = LineType::DebugOutput);
+            void addLine(const std::string& line, LineType type = LineType::DebugOutput);
             void clearOutput();
 …
         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/trunk/src/libraries/core/command/TclBind.cc

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/command/TclBind.h

-                      r8079
+                      r11071
             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/trunk/src/libraries/core/command/TclThreadList.h

-                      r7401
+                      r11071
         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/trunk/src/libraries/core/command/TclThreadManager.cc

r10624	r11071
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/trunk/src/libraries/core/commandline/CommandLineIncludes.h

-                      r10535
+                      r11071
             ~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/trunk/src/libraries/core/commandline/CommandLineParser.cc

-                      r10542
+                      r11071
 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/trunk/src/libraries/core/commandline/CommandLineParser.h

-                      r10542
+                      r11071
     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/trunk/src/libraries/core/config/ConfigFile.cc

-                      r10624
+                      r11071
 #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)
                 file << (*it_entries)->getFileEntry() << endl;
+        for (ConfigFileSection* section : this->sections_)
+        {
+            file << section->getFileEntry() << endl;
+            for (ConfigFileEntry* entry : section->getEntries())
+                file << entry->getFileEntry() << endl;
             file << 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/trunk/src/libraries/core/config/ConfigFileEntry.h

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

code/trunk/src/libraries/core/config/ConfigFileEntryComment.h

-                      r9559
+                      r11071
             /// 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/trunk/src/libraries/core/config/ConfigFileEntryValue.h

-                      r9684
+                      r11071
             /// 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/trunk/src/libraries/core/config/ConfigFileEntryVectorValue.h

-                      r9559
+                      r11071
             /// 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/trunk/src/libraries/core/config/ConfigFileManager.cc

-                      r9559
+                      r11071
     ///////////////////////
     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/trunk/src/libraries/core/config/ConfigFileManager.h

-                      r9559
+                      r11071
 #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/trunk/src/libraries/core/config/ConfigFileSection.cc

-                      r9559
+                      r11071
+    {
         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/trunk/src/libraries/core/config/ConfigFileSection.h

-                      r9684
+                      r11071
 #include <string>
 #include <list>
+#include "util/StringUtils.h"
 #include "ConfigFileEntry.h"
 …
             std::list<ConfigFileEntry*>& getEntries()
                 { return this->entries_; }
+            /// Returns the begin-iterator of the list of entries in this section.
+            std::list<ConfigFileEntry*>::const_iterator getEntriesBegin() const
+                { return this->entries_.begin(); }
+            /// Returns the end-iterator of the list of entries in this section.
+            std::list<ConfigFileEntry*>::const_iterator getEntriesEnd() const
+                { return this->entries_.end(); }
+            const std::list<ConfigFileEntry*>& getEntries() const
+                { return this->entries_; }
             std::list<ConfigFileEntry*>::iterator getOrCreateEntryIterator(const std::string& name, const std::string& fallback, bool bString);

code/trunk/src/libraries/core/config/ConfigValueContainer.cc

r9559	r11071
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/trunk/src/libraries/core/config/ConfigValueContainer.h

-                      r9667
+                      r11071
         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/trunk/src/libraries/core/config/SettingsConfigFile.cc

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/config/SettingsConfigFile.h

-                      r9684
+                      r11071
         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/trunk/src/libraries/core/input/Button.cc

r9983	r11071
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/trunk/src/libraries/core/input/HalfAxis.h

-                      r7859
+                      r11071
             : 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/trunk/src/libraries/core/input/InputBuffer.cc

-                      r9667
+                      r11071
     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/trunk/src/libraries/core/input/InputBuffer.h

-                      r9667
+                      r11071
               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/trunk/src/libraries/core/input/InputCommands.h

-                      r9978
+                      r11071
     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/trunk/src/libraries/core/input/InputDevice.h

-                      r8858
+                      r11071
         //! 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/trunk/src/libraries/core/input/InputHandler.h

r8729	r11071
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/trunk/src/libraries/core/input/InputManager.cc

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/input/InputManager.h

-                      r8729
+                      r11071
 #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/trunk/src/libraries/core/input/InputPrereqs.h

-                      r8729
+                      r11071
         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/trunk/src/libraries/core/input/InputState.cc

-                      r8729
+                      r11071
         , 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/trunk/src/libraries/core/input/InputState.h

-                      r8729
+                      r11071
 #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/trunk/src/libraries/core/input/JoyStick.cc

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/input/JoyStick.h

-                      r9667
+                      r11071
         //! 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/trunk/src/libraries/core/input/JoyStickQuantityListener.cc

r10624	r11071
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/trunk/src/libraries/core/input/JoyStickQuantityListener.h

r9667	r11071
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/trunk/src/libraries/core/input/KeyBinder.cc

-                      r11052
+                      r11071
         : 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/trunk/src/libraries/core/input/KeyBinder.h

-                      r11052
+                      r11071
 #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/trunk/src/libraries/core/input/KeyBinderManager.cc

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/input/KeyBinderManager.h

-                      r9667
+                      r11071
 #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/trunk/src/libraries/core/input/KeyDetector.cc

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/input/KeyDetector.h

-                      r8729
+                      r11071
     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/trunk/src/libraries/core/input/Keyboard.h

-                      r8729
+                      r11071
         //! 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/trunk/src/libraries/core/input/Mouse.cc

-                      r10624
+                      r11071
+    {
 #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/trunk/src/libraries/core/input/Mouse.h

-                      r7809
+                      r11071
     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/trunk/src/libraries/core/module/DynLib.cc

-                      r10540
+                      r11071
+    {
         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/trunk/src/libraries/core/module/DynLib.h

-                      r10541
+                      r11071
 #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/trunk/src/libraries/core/module/DynLibManager.cc

-                      r10540
+                      r11071
     //-----------------------------------------------------------------------
     //! 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/trunk/src/libraries/core/module/ModuleInstance.cc

r10549	r11071
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/trunk/src/libraries/core/module/ModuleInstance.h

r10549	r11071
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/trunk/src/libraries/core/module/Plugin.cc

r11015	r11071
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	}
…	…
79	79	{
80	80	// only load module if it isn't already loaded. otherwise merely activate it.
81		if (this->moduleInstance_ == ~~NULL~~)
	81	if (this->moduleInstance_ == nullptr)
82	82	this->loadModule();
83	83	else
…	…
112	112	Core::getInstance().unloadModule(this->moduleInstance_);
113	113	delete this->moduleInstance_;
114		this->moduleInstance_ = ~~NULL~~;
	114	this->moduleInstance_ = nullptr;
115	115	}
116	116	void Plugin::deactivateModule()

code/trunk/src/libraries/core/module/PluginManager.cc

-                      r11017
+                      r11071
     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/trunk/src/libraries/core/module/StaticInitializationHandler.h

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

code/trunk/src/libraries/core/module/StaticInitializationHandlerIncludes.h

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

code/trunk/src/libraries/core/module/StaticInitializationManager.cc

r10542	r11071
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/trunk/src/libraries/core/module/StaticInitializationManager.h

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

code/trunk/src/libraries/core/object/ClassFactory.h

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

code/trunk/src/libraries/core/object/Context.cc

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/object/DestroyLaterManager.h

-                      r10624
+                      r11071
             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/trunk/src/libraries/core/object/Destroyable.cc

-                      r11019
+                      r11071
     Destroyable::~Destroyable()
+    {
         if (!this->requestedDestruction_ && !IdentifierManager::getInstance().isCreatingHierarchy())
+        if (!this->requestedDestruction_ && IdentifierManager::exists() && !IdentifierManager::getInstance().isCreatingHierarchy())
             orxout(internal_warning) << "Deleted destroyable object without destroy()" << endl;
 …
     void Destroyable::destroy()
+    {
         assert(this); // Just in case someone tries to delete a NULL pointer
+        assert(this); // Just in case someone tries to delete a nullptr
         this->requestedDestruction_ = true;
         if (this->referenceCount_ == 0)

code/trunk/src/libraries/core/object/Iterator.h

-                      r10624
+                      r11071
     */
     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/trunk/src/libraries/core/object/IteratorBase.h

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/object/Listable.cc

r10624	r11071
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/trunk/src/libraries/core/object/Listable.h

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

code/trunk/src/libraries/core/object/ObjectList.h

-                      r10624
+                      r11071
 #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/trunk/src/libraries/core/object/ObjectListBase.cc

-                      r9975
+                      r11071
     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/trunk/src/libraries/core/object/ObjectListBase.h

-                      r9667
+                      r11071
                 @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/trunk/src/libraries/core/object/ObjectListIterator.h

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/object/StrongPtr.h

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/object/WeakPtr.h

-                      r10624
+                      r11071
     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/trunk/src/libraries/core/singleton/Scope.h

r10514	r11071
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/trunk/src/libraries/core/singleton/ScopeManager.cc

r10542	r11071
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/trunk/src/libraries/core/singleton/ScopeManager.h

r11012	r11071
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/trunk/src/libraries/core/singleton/ScopedSingletonIncludes.h

-                      r11052
+                      r11071
 */
 #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/trunk/src/libraries/core/singleton/ScopedSingletonWrapper.h

r10528	r11071
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	}

Context Navigation

Legend: