Changeset 10821 for code/branches/cpp11_v2/src/libraries/core

Timestamp:

Nov 21, 2015, 7:05:53 PM (9 years ago)

Author:

muemart

Message:

Run clang-modernize -loop-convert

• Again, not all possible loops were converted
• It can do pretty cool transformations, but I had to fix a few compile errors, so there might be some runtime errors lurking around too

Location:

code/branches/cpp11_v2/src/libraries/core

Files:

• BaseObject.cc (modified) (6 diffs)
• ClassTreeMask.cc (modified) (5 diffs)
• Core.cc (modified) (2 diffs)
• CoreStaticInitializationHandler.cc (modified) (3 diffs)
• Game.cc (modified) (1 diff)
• Language.cc (modified) (2 diffs)
• Loader.cc (modified) (2 diffs)
• LuaState.cc (modified) (4 diffs)
• Namespace.cc (modified) (6 diffs)
• NamespaceNode.cc (modified) (3 diffs)
• Resource.cc (modified) (2 diffs)
• class/Identifier.cc (modified) (5 diffs)
• class/Identifier.h (modified) (1 diff)
• class/IdentifierManager.cc (modified) (5 diffs)
• command/ArgumentCompletionFunctions.cc (modified) (5 diffs)
• command/CommandEvaluation.cc (modified) (7 diffs)
• command/ConsoleCommand.cc (modified) (1 diff)
• command/Shell.cc (modified) (1 diff)
• command/TclThreadList.h (modified) (1 diff)
• command/TclThreadManager.cc (modified) (1 diff)
• commandline/CommandLineParser.cc (modified) (3 diffs)
• config/ConfigFile.cc (modified) (4 diffs)
• config/ConfigFileManager.cc (modified) (1 diff)
• config/ConfigFileSection.cc (modified) (3 diffs)
• config/ConfigValueContainer.h (modified) (3 diffs)
• input/Button.cc (modified) (1 diff)
• input/InputBuffer.cc (modified) (4 diffs)
• input/InputDevice.h (modified) (3 diffs)
• input/InputManager.cc (modified) (4 diffs)
• input/JoyStick.cc (modified) (1 diff)
• input/KeyBinder.cc (modified) (6 diffs)
• input/KeyBinder.h (modified) (1 diff)
• input/Mouse.cc (modified) (2 diffs)
• module/DynLibManager.cc (modified) (1 diff)
• module/ModuleInstance.cc (modified) (2 diffs)
• module/PluginManager.cc (modified) (2 diffs)
• module/StaticInitializationManager.cc (modified) (1 diff)
• object/Context.cc (modified) (1 diff)
• object/Listable.cc (modified) (2 diffs)
• object/ObjectListBase.cc (modified) (1 diff)
• singleton/ScopeManager.cc (modified) (1 diff)

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

@@ -234 +234 @@
     {
         unsigned int i = 0;
-        for (std::set<Template*>::const_iterator it = this->templates_.begin(); it != this->templates_.end(); ++it)
+        for (const auto & elem : this->templates_)
         {
             if (i == index)
-                return (*it);
+                return (elem);
             i++;
         }
@@ -269 +269 @@
     {
         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 & elem : this->eventSources_)
+        {
+            if (elem.second != state)
                 continue;
 
             if (i == index)
-                return it->first;
+                return elem.first;
             ++i;
         }
@@ -296 +296 @@
     {
         unsigned int i = 0;
-        for (std::set<BaseObject*>::const_iterator it = this->eventListenersXML_.begin(); it != this->eventListenersXML_.end(); ++it)
+        for (const auto & elem : this->eventListenersXML_)
         {
             if (i == index)
-                return *it;
+                return elem;
             ++i;
         }
@@ -358 +358 @@
         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 (const auto & elem : this->eventListeners_)
+        {
+            event.statename_ = (elem)->eventSources_[this];
+            (elem)->processEvent(event);
         }
     }
@@ -370 +370 @@
     void BaseObject::fireEvent(Event& event)
     {
-        for (std::set<BaseObject*>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
-            (*it)->processEvent(event);
+        for (const auto & elem : this->eventListeners_)
+            (elem)->processEvent(event);
     }
 
@@ -474 +474 @@
 
             // iterate through all states and get the event sources
-            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            for (auto & statename : eventnames)
             {
-                const std::string& statename = (*it);
+                
 
                 // if the event state is already known, continue with the next state

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

@@ -293 +293 @@
         {
             // 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 auto & elem : subclass->getDirectChildren())
+                if ((elem)->isA(this->root_->getClass()))
+                    if (overwrite || (!this->nodeExists(elem))) // If we don't want to overwrite, only add nodes that don't already exist
+                        this->add(this->root_, elem, bInclude, overwrite);
         }
 
@@ -325 +325 @@
         {
             // 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 (auto & elem : node->subnodes_)
             {
-                if (subclass->isA((*it)->getClass()))
+                if (subclass->isA((elem)->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(elem, subclass, bInclude, overwrite);
                     return;
                 }
@@ -392 +392 @@
         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 auto & elem : subclass->getDirectChildren())
+            this->add(elem, this->isIncluded(elem), false, false);
 
         this->add(subclass, bInclude, false, clean);
@@ -435 +435 @@
 
             // 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 (auto & elem : node->subnodes_)
+                if (subclass->isA((elem)->getClass()))
+                    return isIncluded(elem, subclass);
 
             // There is no subnode containing our class -> the rule of the current node takes in effect
@@ -957 +957 @@
             // 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 auto & elem : directChildren)
+                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(elem, false));
         }
     }

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

@@ -279 +279 @@
 
         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 auto & modulePath : modulePaths)
+        {
+            ModuleInstance* module = new ModuleInstance(modulePath);
             this->loadModule(module);
             this->modules_.push_back(module);
@@ -309 +309 @@
     void Core::unloadModules()
     {
-        for (std::list<ModuleInstance*>::iterator it = this->modules_.begin(); it != this->modules_.end(); ++it)
-        {
-            ModuleInstance* module = (*it);
+        for (auto module : this->modules_)
+        {
+            
             this->unloadModule(module);
             delete module;

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

@@ -99 +99 @@
         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 (const auto & instance : instances)
+            identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(instance)->getIdentifier());
 
         // destroy objects. some objects may survive this at first because they still have strong pointers pointing at them. this is
@@ -106 +106 @@
         // 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 (const auto & 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 (const auto & identifier : identifiers)
         {
-            ObjectListBase* objectList = Context::getRootContext()->getObjectList(*it);
+            ObjectListBase* objectList = Context::getRootContext()->getObjectList(identifier);
             if (objectList->size() > 0)
             {
-                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (*it)->getName()
+                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (identifier)->getName()
                     << " after unloading the Identifier. This may lead to a crash" << endl;
             }
@@ -123 +123 @@
 
         // destroy object-lists in all contexts
-        for (std::set<Identifier*>::iterator it_identifier = identifiers.begin(); it_identifier != identifiers.end(); ++it_identifier)
+        for (const auto & 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));
+                    it_context->destroyObjectList((identifier));
             }
         }

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

@@ -612 +612 @@
         // Check if graphics is still required
         bool graphicsRequired = false;
-        for (unsigned i = 0; i < loadedStates_.size(); ++i)
-            graphicsRequired |= loadedStates_[i]->getInfo().bGraphicsMode;
+        for (auto & elem : loadedStates_)
+            graphicsRequired |= elem->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)

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

@@ -107 +107 @@
     Language::~Language()
     {
-        for (std::map<std::string, LanguageEntry*>::iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
-            delete (it->second);
+        for (auto & elem : this->languageEntries_)
+            delete (elem.second);
     }
 
@@ -319 +319 @@
 
         // 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 & elem : this->languageEntries_)
+        {
+            file << elem.second->getLabel() << '=' << elem.second->getDefault() << endl;
         }
 

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

@@ -165 +165 @@
                         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 (auto & linesource : linesources)
                         {
-                            message << it->first << ", Line " << it->second << endl;
+                            message << linesource.first << ", Line " << linesource.second << endl;
                         }
                         orxout(user_error, context::loader) << message.str() << endl;
@@ -261 +261 @@
         {
             bool expectedValue = true;
-            for (std::map<size_t, bool>::iterator it = luaTags.begin(); it != luaTags.end(); ++it)
-            {
-                if (it->second == expectedValue)
+            for (auto & luaTag : luaTags)
+            {
+                if (luaTag.second == expectedValue)
                     expectedValue = !expectedValue;
                 else

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

@@ -326 +326 @@
     /*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 & interface : getToluaInterfaces())
+        {
+            if (interface.first == name || interface.second == function)
             {
                 orxout(internal_warning, context::lua) << "Trying to add a Tolua interface with the same name or function." << endl;
@@ -337 +337 @@
 
         // Open interface in all LuaStates
-        for (std::vector<LuaState*>::const_iterator it = getInstances().begin(); it != getInstances().end(); ++it)
-            (*function)((*it)->luaState_);
+        for (const auto & state : getInstances())
+            (*function)(state->luaState_);
 
         // Return dummy bool
@@ -354 +354 @@
 
         // 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 (const auto & state : getInstances())
+        {
+            lua_pushnil(state->luaState_);
+            lua_setglobal(state->luaState_, it->first.c_str());
         }
 
@@ -369 +369 @@
     /*static*/ void LuaState::openToluaInterfaces(lua_State* state)
     {
-        for (ToluaInterfaceMap::const_iterator it = getToluaInterfaces().begin(); it != getToluaInterfaces().end(); ++it)
-            (*it->second)(state);
+        for (const auto & interface : getToluaInterfaces())
+            (interface.second)(state);
     }
 
     /*static*/ void LuaState::closeToluaInterfaces(lua_State* state)
     {
-        for (ToluaInterfaceMap::const_iterator it = getToluaInterfaces().begin(); it != getToluaInterfaces().end(); ++it)
+        for (const auto & interface : getToluaInterfaces())
         {
             lua_pushnil(state);
-            lua_setglobal(state, it->first.c_str());
+            lua_setglobal(state, interface.first.c_str());
         }
     }

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

@@ -53 +53 @@
     {
         if (this->bRoot_)
-            for (std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it)
-                delete (*it);
+            for (auto & elem : this->representingNamespaces_)
+                delete elem;
     }
 
@@ -80 +80 @@
             for (unsigned int i = 0; i < tokens.size(); i++)
             {
-                for (std::set<NamespaceNode*>::iterator it = this->getNamespace()->representingNamespaces_.begin(); it != this->getNamespace()->representingNamespaces_.end(); ++it)
+                for (auto & elem : this->getNamespace()->representingNamespaces_)
                 {
-                    std::set<NamespaceNode*> temp = (*it)->getNodeRelative(tokens[i]);
+                    std::set<NamespaceNode*> temp = elem->getNodeRelative(tokens[i]);
                     this->representingNamespaces_.insert(temp.begin(), temp.end());
                 }
@@ -93 +93 @@
         if (this->bAutogeneratedFileRootNamespace_)
         {
-            for (std::set<NamespaceNode*>::iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); ++it)
+            for (auto & elem : this->representingNamespaces_)
             {
-                (*it)->setRoot(true);
-                (*it)->setHidden(true);
+                elem->setRoot(true);
+                elem->setHidden(true);
             }
         }
@@ -114 +114 @@
     bool Namespace::includes(const Namespace* ns) const
     {
-        for (std::set<NamespaceNode*>::const_iterator it1 = this->representingNamespaces_.begin(); it1 != this->representingNamespaces_.end(); ++it1)
+        for (const auto & elem1 : this->representingNamespaces_)
         {
-            for (std::set<NamespaceNode*>::const_iterator it2 = ns->representingNamespaces_.begin(); it2 != ns->representingNamespaces_.end(); ++it2)
+            for (const auto & elem2 : ns->representingNamespaces_)
             {
-                if ((*it1)->includes(*it2))
+                if (elem1->includes(elem2))
                 {
                     if (this->operator_ == "or")
@@ -149 +149 @@
 
         int i = 0;
-        for (std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it)
+        for (const auto & elem : this->representingNamespaces_)
         {
             if (i > 0)
                 output += " / ";
 
-            output += (*it)->toString();
+            output += elem->toString();
+            i++;
         }
 
@@ -165 +166 @@
 
         int i = 0;
-        for (std::set<NamespaceNode*>::const_iterator it = this->representingNamespaces_.begin(); it != this->representingNamespaces_.end(); i++, ++it)
+        for (const auto & elem : this->representingNamespaces_)
         {
             if (i > 0)
                 output += '\n';
 
-            output += (*it)->toString(indentation);
+            output += elem->toString(indentation);
+            i++;
         }
 

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

@@ -103 +103 @@
                 bool bFoundMatchingNamespace = false;
 
-                for (std::map<std::string, NamespaceNode*>::iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
+                for (auto & elem : this->subnodes_)
                 {
-                    if (it->first.find(firstPart) == (it->first.size() - firstPart.size()))
+                    if (elem.first.find(firstPart) == (elem.first.size() - firstPart.size()))
                     {
-                        std::set<NamespaceNode*> temp2 = it->second->getNodeRelative(secondPart);
+                        std::set<NamespaceNode*> temp2 = elem.second->getNodeRelative(secondPart);
                         nodes.insert(temp2.begin(), temp2.end());
                         bFoundMatchingNamespace = true;
@@ -132 +132 @@
         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 & elem : this->subnodes_)
+                if (elem.second->includes(ns))
                     return true;
         }
@@ -167 +167 @@
         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 & elem : this->subnodes_)
+            output += elem.second->toString(indentation + "  ");
 
         return output;

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

@@ -58 +58 @@
         DataStreamListPtr resources(new Ogre::DataStreamList());
         const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        for (const auto & group : groups)
         {
-            DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, *it);
+            DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
             resources->insert(resources->end(), temp->begin(), temp->end());
         }
@@ -121 +121 @@
         StringVectorPtr resourceNames(new Ogre::StringVector());
         const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        for (const auto & group : groups)
         {
-            StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(*it, pattern);
+            StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(group, pattern);
             resourceNames->insert(resourceNames->end(), temp->begin(), temp->end());
         }

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

@@ -87 +87 @@
         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 auto & elem : this->children_)
+            const_cast<Identifier*>(elem)->parents_.remove(this);
+        for (const auto & elem : this->directChildren_)
+            const_cast<Identifier*>(elem)->directParents_.remove(this);
+
+        for (auto & elem : this->configValues_)
+            delete (elem.second);
+        for (auto & elem : this->xmlportParamContainers_)
+            delete (elem.second);
+        for (auto & elem : this->xmlportObjectContainers_)
+            delete (elem.second);
     }
 
@@ -157 +157 @@
         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 auto & elem : initializationTrace)
+                if (elem != this)
+                    this->parents_.push_back(elem);
         }
         else
@@ -261 +261 @@
 
         // 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 auto & elem : this->parents_)
+        {
+            if ((elem)->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)
+                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(elem)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(elem)->parents_.end(); ++it_parent_parent)
                     this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-                this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+                this->addIfNotExists(expectedIdentifierTrace, elem);
             }
         }
 
         // 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)
+        for (const auto & elem : this->directParents_)
+        {
+            for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(elem)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(elem)->parents_.end(); ++it_parent_parent)
                 this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-            this->addIfNotExists(expectedIdentifierTrace, *it_parent);
+            this->addIfNotExists(expectedIdentifierTrace, elem);
         }
 
@@ -285 +285 @@
 
             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 auto & elem : this->parents_)
+                orxout(internal_warning) << " " << (elem)->getName();
             orxout(internal_warning) << endl;
 
@@ -295 +295 @@
 
             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 auto & elem : this->directParents_)
+                orxout(internal_warning) << " " << (elem)->getName();
             orxout(internal_warning) << endl;
         }

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

@@ -462 +462 @@
 
         if (updateChildren)
-            for (std::set<const Identifier*>::const_iterator it = this->getChildren().begin(); it != this->getChildren().end(); ++it)
-                (*it)->updateConfigValues(false);
+            for (const auto & elem : this->getChildren())
+                (elem)->updateConfigValues(false);
     }
 

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

@@ -93 +93 @@
         {
             Context temporaryContext(nullptr);
-            for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
+            for (auto identifier : this->identifiers_)
             {
-                Identifier* identifier = (*it);
+                
                 if (identifier->isInitialized())
                     continue;
@@ -127 +127 @@
 
         // finish the initialization of all identifiers
-        for (std::set<Identifier*>::const_iterator it = initializedIdentifiers.begin(); it != initializedIdentifiers.end(); ++it)
-            (*it)->finishInitialization();
+        for (const auto & initializedIdentifier : initializedIdentifiers)
+            (initializedIdentifier)->finishInitialization();
 
         // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
@@ -144 +144 @@
     {
         // 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 (const auto & elem : this->identifiers_)
+            if (!(elem)->isInitialized())
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << (elem)->getName() << " / " << (elem)->getTypeInfo().name() << endl;
 
         // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
         Context temporaryContext(nullptr);
-        for (std::set<Identifier*>::const_iterator it1 = initializedIdentifiers.begin(); it1 != initializedIdentifiers.end(); ++it1)
+        for (const auto & 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 (const auto & elem : this->identifiers_)
             {
-                bool isA_AccordingToRtti = (*it2)->canDynamicCastObjectToIdentifierClass(temp);
-                bool isA_AccordingToClassHierarchy = temp->isA((*it2));
+                bool isA_AccordingToRtti = (elem)->canDynamicCastObjectToIdentifierClass(temp);
+                bool isA_AccordingToClassHierarchy = temp->isA((elem));
 
                 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 ") << (elem)->getName() << " but RTTI says the opposite." << endl;
                 }
             }
@@ -184 +184 @@
     {
         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 (const auto & elem : this->identifiers_)
+            (elem)->reset();
     }
 
@@ -260 +260 @@
     {
         // 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);
+        for (const auto & elem : this->identifiers_)
+            if ((elem)->getTypeInfo() == typeInfo)
+                return (elem);
         return nullptr;
     }

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

@@ -77 +77 @@
             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 & elem : group)
+                    if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden)
                         return true;
 
@@ -100 +100 @@
                 // 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)));
+                for (const auto & command : commands)
+                    if (groupIsVisible(command.second, bOnlyShowHidden) && command.first != "" && (fragmentLC == "" || getLowercase(command.first).find(fragmentLC) == 0))
+                        groupList.push_back(ArgumentCompletionListElement(command.first, getLowercase(command.first)));
 
                 // now add all shortcuts (in group "")
@@ -113 +113 @@
 
                     // 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 & elem : it_group->second)
+                        if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(elem.first).find(fragmentLC) == 0))
+                            groupList.push_back(ArgumentCompletionListElement(elem.first, getLowercase(elem.first)));
                 }
 
@@ -146 +146 @@
                 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 & elem : it_group->second)
+                        if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden)
+                            commandList.push_back(ArgumentCompletionListElement(elem.first, getLowercase(elem.first)));
                 }
 
@@ -281 +281 @@
 
             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 auto & name : names)
+                sectionList.push_back(ArgumentCompletionListElement(name, getLowercase(name)));
 
             return sectionList;

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

@@ -306 +306 @@
                 // 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 & elem : ConsoleCommandManager::getInstance().getCommandsLC())
+                    if (elem.first == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
 
@@ -328 +328 @@
 
         // 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 & elem : ConsoleCommandManager::getInstance().getCommandsLC())
+        {
+            if (elem.first != "")
+            {
+                for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = elem.second.begin(); it_name != elem.second.end(); ++it_name)
+                {
+                    std::string command = elem.first + " " + it_name->first;
                     unsigned int distance = getLevenshteinDistance(command, token0_LC + " " + token1_LC);
                     if (distance < nearestDistance)
@@ -349 +349 @@
         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 & elem : it_group->second)
+            {
+                std::string command = elem.first;
                 unsigned int distance = getLevenshteinDistance(command, token0_LC);
                 if (distance < nearestDistance)
@@ -429 +429 @@
     {
         size_t count = 0;
-        for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
-            if (it->getComparable() != "")
+        for (const auto & elem : list)
+            if (elem.getComparable() != "")
                 ++count;
         return count;
@@ -495 +495 @@
         {
             // 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 auto & elem : list)
+            {
+                if (elem.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 (elem.hasDisplay())
+                        return (elem.getString());
                     else
-                        return (it->getString() + ' ');
+                        return (elem.getString() + ' ');
                 }
             }
@@ -517 +517 @@
                 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 auto & elem : list)
+                {
+                    const std::string& argumentComparable = elem.getComparable();
+                    const std::string& argument = elem.getString();
 
                     // ignore empty arguments
@@ -560 +560 @@
     {
         std::string output;
-        for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            output += it->getDisplay();
+        for (const auto & elem : list)
+        {
+            output += elem.getDisplay();
 
             // add a space character between two elements for all non-empty arguments
-            if (it->getComparable() != "")
+            if (elem.getComparable() != "")
                 output += ' ';
         }

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

@@ -75 +75 @@
         this->baseFunctor_ = executor->getFunctor();
 
-        for (size_t i = 0; i < MAX_FUNCTOR_ARGUMENTS; ++i)
-            this->argumentCompleter_[i] = nullptr;
+        for (auto & elem : this->argumentCompleter_)
+            elem = nullptr;
 
         this->keybindMode_ = KeybindMode::OnPress;

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

@@ -258 +258 @@
         vectorize(text, '\n', &lines);
 
-        for (size_t i = 0; i < lines.size(); ++i)
-            this->addLine(lines[i], type);
+        for (auto & line : lines)
+            this->addLine(line, type);
     }
 

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

@@ -262 +262 @@
         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 auto & elem : this->list_)
+            if (elem == value)
                 return true;
 

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

@@ -551 +551 @@
 
         std::list<unsigned int> threads;
-        for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
-            if (it->first > 0 && it->first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
-                threads.push_back(it->first);
+        for (const auto & elem : this->interpreterBundles_)
+            if (elem.first > 0 && elem.first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
+                threads.push_back(elem.first);
         return threads;
     }

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

@@ -124 +124 @@
             std::string shortcut;
             std::string value;
-            for (unsigned int i = 0; i < arguments.size(); ++i)
-            {
-                if (arguments[i].size() != 0)
+            for (auto & argument : arguments)
+            {
+                if (argument.size() != 0)
                 {
                     // sure not ""
-                    if (arguments[i][0] == '-')
+                    if (argument[0] == '-')
                     {
                         // start with "-"
-                        if (arguments[i].size() == 1)
+                        if (argument.size() == 1)
                         {
                             // argument[i] is "-", probably a minus sign
                             value += "- ";
                         }
-                        else if (arguments[i][1] <= 57 && arguments[i][1] >= 48)
+                        else if (argument[1] <= 57 && argument[1] >= 48)
                         {
                             // negative number as a value
-                            value += arguments[i] + ' ';
+                            value += argument + ' ';
                         }
                         else
@@ -161 +161 @@
                             }
 
-                            if (arguments[i][1] == '-')
+                            if (argument[1] == '-')
                             {
                                 // full name argument with "--name"
-                                name = arguments[i].substr(2);
+                                name = argument.substr(2);
                             }
                             else
                             {
                                 // shortcut with "-s"
-                                shortcut = arguments[i].substr(1);
+                                shortcut = argument.substr(1);
                             }
 
@@ -186 +186 @@
 
                         // Concatenate strings as long as there's no new argument by "-" or "--"
-                        value += arguments[i] + ' ';
+                        value += argument + ' ';
                     }
                 }

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

@@ -234 +234 @@
         }
 
-        for (std::list<ConfigFileSection*>::const_iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
-        {
-            file << (*it)->getFileEntry() << endl;
-
-            for (std::list<ConfigFileEntry*>::const_iterator it_entries = (*it)->getEntriesBegin(); it_entries != (*it)->getEntriesEnd(); ++it_entries)
+        for (const auto & elem : this->sections_)
+        {
+            file << (elem)->getFileEntry() << endl;
+
+            for (std::list<ConfigFileEntry*>::const_iterator it_entries = (elem)->getEntriesBegin(); it_entries != (elem)->getEntriesEnd(); ++it_entries)
                 file << (*it_entries)->getFileEntry() << endl;
 
@@ -280 +280 @@
     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);
+        for (const auto & elem : this->sections_)
+            if ((elem)->getName() == section)
+                return (elem);
         return nullptr;
     }
@@ -291 +291 @@
     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);
+        for (auto & elem : this->sections_)
+            if ((elem)->getName() == section)
+                return (elem);
 
         this->bUpdated_ = true;
@@ -307 +307 @@
         bool sectionsUpdated = false;
 
-        for (std::list<ConfigFileSection*>::iterator it = this->sections_.begin(); it != this->sections_.end(); ++it)
-        {
-            if ((*it)->bUpdated_)
+        for (auto & elem : this->sections_)
+        {
+            if ((elem)->bUpdated_)
             {
                 sectionsUpdated = true;
-                (*it)->bUpdated_ = false;
+                (elem)->bUpdated_ = false;
             }
         }

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

@@ -53 +53 @@
     ConfigFileManager::~ConfigFileManager()
     {
-        for (std::array<ConfigFile*, 3>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); ++it)
-            if (*it)
-                delete (*it);
+        for (const auto & elem : this->configFiles_)
+            if (elem)
+                delete (elem);
     }
 

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

@@ -80 +80 @@
     {
         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 (const auto & elem : this->entries_)
+            if ((elem)->getName() == name)
+                if ((elem)->getIndex() >= size)
+                    size = (elem)->getIndex() + 1;
         return size;
     }
@@ -105 +105 @@
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name) const
     {
-        for (std::list<ConfigFileEntry*>::const_iterator it = this->entries_.begin(); it != this->entries_.end(); ++it)
+        for (const auto & elem : this->entries_)
         {
-            if ((*it)->getName() == name)
-                return *it;
+            if ((elem)->getName() == name)
+                return elem;
         }
         return nullptr;
@@ -121 +121 @@
     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 (const auto & elem : this->entries_)
         {
-            if (((*it)->getName() == name) && ((*it)->getIndex() == index))
-                return *it;
+            if (((elem)->getName() == name) && ((elem)->getIndex() == index))
+                return elem;
         }
         return nullptr;

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

@@ -130 +130 @@
 
                 this->value_ = V();
-                for (unsigned int i = 0; i < defvalue.size(); i++)
-                    this->valueVector_.push_back(MultiType(defvalue[i]));
+                for (auto & elem : defvalue)
+                    this->valueVector_.push_back(MultiType(elem));
 
                 this->initVector();
@@ -183 +183 @@
                     std::vector<T> temp = *value;
                     value->clear();
-                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
-                        value->push_back(this->valueVector_[i]);
+                    for (auto & elem : this->valueVector_)
+                        value->push_back(elem);
 
                     if (value->size() != temp.size())
@@ -211 +211 @@
                 {
                     value->clear();
-                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
-                        value->push_back(this->valueVector_[i]);
+                    for (auto & elem : this->valueVector_)
+                        value->push_back(elem);
                 }
                 return *this;

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

@@ -196 +196 @@
 
                     // add command to the buffer if not yet existing
-                    for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer_->size(); iParamCmd++)
-                    {
-                        if ((*paramCommandBuffer_)[iParamCmd]->evaluation_.getConsoleCommand()
+                    for (auto & elem : *paramCommandBuffer_)
+                    {
+                        if (elem->evaluation_.getConsoleCommand()
                             == eval.getConsoleCommand())
                         {
                             // already in list
-                            cmd->paramCommand_ = (*paramCommandBuffer_)[iParamCmd];
+                            cmd->paramCommand_ = elem;
                             break;
                         }

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

@@ -110 +110 @@
     void InputBuffer::insert(const std::string& input, bool update)
     {
-        for (unsigned int i = 0; i < input.size(); ++i)
-        {
-            this->insert(input[i], false);
+        for (auto & elem : input)
+        {
+            this->insert(elem, false);
 
             if (update)
-                this->updated(input[i], false);
+                this->updated(elem, false);
         }
 
@@ -170 +170 @@
     void InputBuffer::updated()
     {
-        for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-        {
-            if ((*it)->bListenToAllChanges_)
-                (*it)->callFunction();
+        for (auto & elem : this->listeners_)
+        {
+            if ((elem)->bListenToAllChanges_)
+                (elem)->callFunction();
         }
     }
@@ -179 +179 @@
     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 (auto & elem : this->listeners_)
+        {
+            if ((!(elem)->trueKeyFalseChar_) && ((elem)->bListenToAllChanges_ || ((elem)->char_ == update)) && (!(elem)->bOnlySingleInput_ || bSingleInput))
+                (elem)->callFunction();
         }
     }
@@ -201 +201 @@
             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 (auto & elem : this->listeners_)
+        {
+            if ((elem)->trueKeyFalseChar_ && ((elem)->key_ == evt.getKeyCode()))
+                (elem)->callFunction();
         }
 

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

@@ -158 +158 @@
 
             // 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]->template buttonEvent<ButtonEvent::THold, typename Traits::ButtonTypeParam>(
-                        this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(pressedButtons_[iB]));
+            for (auto & button : pressedButtons_)
+                for (auto & 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 (auto & elem : inputStates_)
+                elem->update(time.getDeltaTime(), this->getDeviceID());
 
             static_cast<DeviceClass*>(this)->updateImpl(time);
@@ -196 +196 @@
 
             // Call states
-            for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (auto & elem : inputStates_)
+                elem->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 
@@ -218 +218 @@
 
             // Call states
-            for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (auto & elem : inputStates_)
+                elem->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 

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

@@ -373 +373 @@
         // 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 (auto & elem : activeStates_)
+        {
+            if (elem.second->hasExpired())
+            {
+                elem.second->resetExpiration();
                 bUpdateRequired = true;
             }
@@ -391 +391 @@
 
         // Collect function calls for the update
-        for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
-            activeStatesTicked_[i]->update(time.getDeltaTime());
+        for (auto & elem : activeStatesTicked_)
+            elem->update(time.getDeltaTime());
 
         // Execute all cached function calls in order
@@ -401 +401 @@
         // 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 & elem : this->callBuffer_)
+            elem();
 
         this->callBuffer_.clear();
@@ -437 +437 @@
         // Using an std::set to avoid duplicates
         std::set<InputState*> tempSet;
-        for (unsigned int i = 0; i < devices_.size(); ++i)
-            if (devices_[i] != nullptr)
-                for (unsigned int iState = 0; iState < devices_[i]->getStateListRef().size(); ++iState)
-                    tempSet.insert(devices_[i]->getStateListRef()[iState]);
+        for (auto & elem : devices_)
+            if (elem != nullptr)
+                for (unsigned int iState = 0; iState < elem->getStateListRef().size(); ++iState)
+                    tempSet.insert(elem->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 (const auto & elem : tempSet)
+            activeStatesTicked_.push_back(elem);
 
         // Check whether we have to change the mouse mode

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

@@ -186 +186 @@
     void JoyStick::clearBuffersImpl()
     {
-        for (int j = 0; j < 4; ++j)
-            povStates_[j] = 0;
+        for (auto & elem : povStates_)
+            elem = 0;
     }
 

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

@@ -153 +153 @@
     void KeyBinder::buttonThresholdChanged()
     {
-        for (unsigned int i = 0; i < allHalfAxes_.size(); i++)
-            if (!allHalfAxes_[i]->bButtonThresholdUser_)
-                allHalfAxes_[i]->buttonThreshold_ = this->buttonThreshold_;
+        for (auto & elem : allHalfAxes_)
+            if (!elem->bButtonThresholdUser_)
+                elem->buttonThreshold_ = this->buttonThreshold_;
     }
 
@@ -383 +383 @@
             it->second->clear();
 
-        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
-            delete paramCommandBuffer_[i];
+        for (auto & elem : paramCommandBuffer_)
+            delete elem;
         paramCommandBuffer_.clear();
     }
@@ -394 +394 @@
     {
         // 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 & elem : this->allButtons_)
+        {
+            Button* button = elem.second;
 
             // iterate over all modes
@@ -465 +465 @@
         this->mousePosition_[1] = 0.0f;
 
-        for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
-            mouseAxes_[i].reset();
+        for (auto & elem : mouseAxes_)
+            elem.reset();
     }
 
@@ -505 +505 @@
         }
 
-        for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
+        for (auto & elem : mouseAxes_)
         {
             // Why dividing relative value by dt? The reason lies in the simple fact, that when you
@@ -515 +515 @@
             {
                 // just ignore if dt == 0.0 because we have multiplied by 0.0 anyway..
-                mouseAxes_[i].relVal_ /= dt;
-            }
-
-            tickHalfAxis(mouseAxes_[i]);
+                elem.relVal_ /= dt;
+            }
+
+            tickHalfAxis(elem);
         }
     }

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

@@ -226 +226 @@
     {
         // execute all buffered bindings (additional parameter)
-        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+        for (auto & elem : paramCommandBuffer_)
         {
-            paramCommandBuffer_[i]->rel_ *= dt;
-            paramCommandBuffer_[i]->execute();
+            elem->rel_ *= dt;
+            elem->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 (auto & elem : mouseAxes_)
+            elem.relVal_ = 0.0f;
     }
 }// tolua_export

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

@@ -82 +82 @@
             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 (auto & elem : inputStates_)
+                elem->mouseMoved(abs, rel, clippingSize);
         }
 
@@ -89 +89 @@
         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 (auto & elem : inputStates_)
+                elem->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
         }
 

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

@@ -75 +75 @@
     {
         // Unload & delete resources in turn
-        for (DynLibList::iterator it = mLibList.begin(); it != mLibList.end(); ++it)
+        for (auto & elem : mLibList)
         {
-            it->second->unload();
-            delete it->second;
+            elem.second->unload();
+            delete elem.second;
         }
 

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

@@ -59 +59 @@
     {
         const std::set<StaticallyInitializedInstance*>& instances = this->staticallyInitializedInstancesByType_[type];
-        for (std::set<StaticallyInitializedInstance*>::iterator it = instances.begin(); it != instances.end(); ++it)
-            (*it)->load();
+        for (const auto & instance : instances)
+            (instance)->load();
     }
 
@@ -75 +75 @@
         std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
         this->staticallyInitializedInstancesByType_.clear();
-        for (std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>>::iterator it1 = copy.begin(); it1 != copy.end(); ++it1)
-            for (std::set<StaticallyInitializedInstance*>::iterator it2 = it1->second.begin(); it2 != it1->second.end(); ++it2)
+        for (auto & elem : copy)
+            for (std::set<StaticallyInitializedInstance*>::iterator it2 = elem.second.begin(); it2 != elem.second.end(); ++it2)
                 delete (*it2);
     }

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

@@ -59 +59 @@
         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 (auto & elem : this->references_)
+            delete elem.second;
+        for (auto & elem : this->plugins_)
+            delete elem.second;
     }
 
@@ -68 +68 @@
     {
         const std::vector<std::string>& pluginPaths = ApplicationPaths::getInstance().getPluginPaths();
-        for (std::vector<std::string>::const_iterator it = pluginPaths.begin(); it != pluginPaths.end(); ++it)
+        for (auto libraryName : pluginPaths)
         {
             std::string name;
-            std::string libraryName = (*it);
+            
             std::string filename = libraryName +  + specialConfig::pluginExtension;
             std::ifstream infile(filename.c_str());

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

@@ -50 +50 @@
     {
         // attention: loading a module may add new handlers to the list
-        for (std::list<StaticInitializationHandler*>::iterator it = this->handlers_.begin(); it != this->handlers_.end(); ++it)
-            (*it)->loadModule(module);
+        for (auto & elem : this->handlers_)
+            (elem)->loadModule(module);
     }
 

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

@@ -70 +70 @@
         // 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 (auto & elem : this->objectLists_)
+            delete elem;
     }
 

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

@@ -76 +76 @@
     void Listable::unregisterObject()
     {
-        for (size_t i = 0; i < this->elements_.size(); ++i)
-            Listable::deleteObjectListElement(this->elements_[i]);
+        for (auto & elem : this->elements_)
+            Listable::deleteObjectListElement(elem);
         this->elements_.clear();
     }
@@ -91 +91 @@
         this->elements_.clear();
 
-        for (size_t i = 0; i < copy.size(); ++i)
+        for (auto & elem : copy)
         {
-            copy[i]->changeContext(this->context_, context);
-            Listable::deleteObjectListElement(copy[i]);
+            elem->changeContext(this->context_, context);
+            Listable::deleteObjectListElement(elem);
         }
 

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

@@ -92 +92 @@
     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 (const auto & elem : this->listeners_)
+            (elem)->removedElement(element);
     }
 

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

@@ -73 +73 @@
     void ScopeManager::activateListenersForScope(ScopeID::Value scope)
     {
-        for (std::set<ScopeListener*>::iterator it = this->listeners_[scope].begin(); it != this->listeners_[scope].end(); ++it)
-            this->activateListener(*it);
+        for (const auto & elem : this->listeners_[scope])
+            this->activateListener(elem);
     }
 
     void ScopeManager::deactivateListenersForScope(ScopeID::Value scope)
     {
-        for (std::set<ScopeListener*>::iterator it = this->listeners_[scope].begin(); it != this->listeners_[scope].end(); ++it)
-            this->deactivateListener(*it);
+        for (const auto & elem : this->listeners_[scope])
+            this->deactivateListener(elem);
     }