Changeset 10916 for code/branches/cpp11_v2/src/libraries

Timestamp:

Dec 2, 2015, 11:22:03 PM (9 years ago)

Author:

landauf

Message:

use actual types instead of 'auto'. only exception is for complicated template types, e.g. when iterating over a map

Location:

code/branches/cpp11_v2/src/libraries

Files:

• core/BaseObject.cc (modified) (6 diffs)
• core/ClassTreeMask.cc (modified) (5 diffs)
• core/Core.cc (modified) (2 diffs)
• core/CoreStaticInitializationHandler.cc (modified) (3 diffs)
• core/Game.cc (modified) (1 diff)
• core/Language.cc (modified) (2 diffs)
• core/Loader.cc (modified) (2 diffs)
• core/LuaState.cc (modified) (4 diffs)
• core/Namespace.cc (modified) (6 diffs)
• core/NamespaceNode.cc (modified) (3 diffs)
• core/Resource.cc (modified) (2 diffs)
• core/class/Identifier.cc (modified) (5 diffs)
• core/class/Identifier.h (modified) (1 diff)
• core/class/IdentifierManager.cc (modified) (5 diffs)
• core/command/ArgumentCompletionFunctions.cc (modified) (5 diffs)
• core/command/CommandEvaluation.cc (modified) (7 diffs)
• core/command/ConsoleCommand.cc (modified) (1 diff)
• core/command/Shell.cc (modified) (1 diff)
• core/command/TclThreadList.h (modified) (1 diff)
• core/command/TclThreadManager.cc (modified) (1 diff)
• core/commandline/CommandLineParser.cc (modified) (1 diff)
• core/config/ConfigFile.cc (modified) (4 diffs)
• core/config/ConfigFileManager.cc (modified) (1 diff)
• core/config/ConfigFileSection.cc (modified) (3 diffs)
• core/config/ConfigValueContainer.h (modified) (3 diffs)
• core/input/Button.cc (modified) (1 diff)
• core/input/InputBuffer.cc (modified) (4 diffs)
• core/input/InputDevice.h (modified) (3 diffs)
• core/input/InputManager.cc (modified) (4 diffs)
• core/input/JoyStick.cc (modified) (1 diff)
• core/input/KeyBinder.cc (modified) (6 diffs)
• core/input/KeyBinder.h (modified) (1 diff)
• core/input/Mouse.cc (modified) (2 diffs)
• core/module/DynLibManager.cc (modified) (1 diff)
• core/module/ModuleInstance.cc (modified) (2 diffs)
• core/module/PluginManager.cc (modified) (2 diffs)
• core/module/StaticInitializationManager.cc (modified) (1 diff)
• core/object/Context.cc (modified) (1 diff)
• core/object/Listable.cc (modified) (2 diffs)
• core/object/ObjectListBase.cc (modified) (1 diff)
• core/singleton/ScopeManager.cc (modified) (1 diff)
• network/FunctionCall.cc (modified) (1 diff)
• network/Host.cc (modified) (3 diffs)
• network/synchronisable/Synchronisable.cc (modified) (1 diff)
• tools/DebugDrawer.cc (modified) (2 diffs)
• tools/IcoSphere.cc (modified) (4 diffs)
• tools/Shader.cc (modified) (2 diffs)
• util/DisplayStringConversions.h (modified) (1 diff)
• util/Serialise.h (modified) (1 diff)
• util/SignalHandler.cc (modified) (2 diffs)
• util/SmallObjectAllocator.cc (modified) (1 diff)
• util/StringUtils.cc (modified) (5 diffs)
• util/output/BaseWriter.cc (modified) (1 diff)
• util/output/MemoryWriter.cc (modified) (1 diff)
• util/output/OutputListener.cc (modified) (3 diffs)
• util/output/OutputManager.cc (modified) (4 diffs)
• util/output/SubcontextOutputListener.cc (modified) (1 diff)

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

@@ -234 +234 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->templates_)
+        for (Template* temp : this->templates_)
         {
             if (i == index)
-                return (elem);
+                return temp;
             i++;
         }
@@ -269 +269 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->eventSources_)
-        {
-            if (elem.second != state)
+        for (const auto& mapEntry : this->eventSources_)
+        {
+            if (mapEntry.second != state)
                 continue;
 
             if (i == index)
-                return elem.first;
+                return mapEntry.first;
             ++i;
         }
@@ -296 +296 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->eventListenersXML_)
+        for (BaseObject* listener : this->eventListenersXML_)
         {
             if (i == index)
-                return elem;
+                return listener;
             ++i;
         }
@@ -358 +358 @@
         Event event(activate, originator, name);
 
-        for (const auto & elem : this->eventListeners_)
-        {
-            event.statename_ = (elem)->eventSources_[this];
-            (elem)->processEvent(event);
+        for (BaseObject* listener : this->eventListeners_)
+        {
+            event.statename_ = listener->eventSources_[this];
+            listener->processEvent(event);
         }
     }
@@ -370 +370 @@
     void BaseObject::fireEvent(Event& event)
     {
-        for (const auto & elem : this->eventListeners_)
-            (elem)->processEvent(event);
+        for (BaseObject* listener : this->eventListeners_)
+            listener->processEvent(event);
     }
 
@@ -474 +474 @@
 
             // iterate through all states and get the event sources
-            for (auto & statename : eventnames)
-            {
-                
-
+            for (const std::string& statename : eventnames)
+            {
                 // if the event state is already known, continue with the next state
                 orxonox::EventState* eventstate = object->getEventState(statename);

code/branches/cpp11_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 (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);
+            for (const Identifier* directChild : subclass->getDirectChildren())
+                if (directChild->isA(this->root_->getClass()))
+                    if (overwrite || (!this->nodeExists(directChild))) // If we don't want to overwrite, only add nodes that don't already exist
+                        this->add(this->root_, directChild, bInclude, overwrite);
         }
 
@@ -325 +325 @@
         {
             // Search for an already existing node, containing the subclass we want to add
-            for (auto & elem : node->subnodes_)
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
             {
-                if (subclass->isA((elem)->getClass()))
+                if (subclass->isA(subnode->getClass()))
                 {
                     // We've found an existing node -> delegate the work with a recursive function-call and return
-                    this->add(elem, subclass, bInclude, overwrite);
+                    this->add(subnode, subclass, bInclude, overwrite);
                     return;
                 }
@@ -392 +392 @@
         if (!subclass)
             return;
-        for (const auto & elem : subclass->getDirectChildren())
-            this->add(elem, this->isIncluded(elem), false, false);
+        for (const Identifier* directChild : subclass->getDirectChildren())
+            this->add(directChild, this->isIncluded(directChild), 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 (auto & elem : node->subnodes_)
-                if (subclass->isA((elem)->getClass()))
-                    return isIncluded(elem, 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
@@ -957 +957 @@
             // The bool is "false", meaning they have no subnodes and therefore need no further checks
             if (node->isIncluded())
-                for (const auto & elem : directChildren)
-                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(elem, false));
+                for (const Identifier* directChild : directChildren)
+                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(directChild, false));
         }
     }

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

@@ -279 +279 @@
 
         const std::vector<std::string>& modulePaths = ApplicationPaths::getInstance().getModulePaths();
-        for (const auto & modulePath : modulePaths)
+        for (const std::string& modulePath : modulePaths)
         {
             ModuleInstance* module = new ModuleInstance(modulePath);
@@ -309 +309 @@
     void Core::unloadModules()
     {
-        for (auto module : this->modules_)
-        {
-            
+        for (ModuleInstance* 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 (const auto & instance : instances)
+        for (StaticallyInitializedInstance* instance : instances)
             identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(instance)->getIdentifier());
 
@@ -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 (const auto & identifier : identifiers)
-            (identifier)->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 (const auto & identifier : identifiers)
+        for (Identifier* identifier : identifiers)
         {
             ObjectListBase* objectList = Context::getRootContext()->getObjectList(identifier);
             if (objectList->size() > 0)
             {
-                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (identifier)->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 (const auto & identifier : identifiers)
+        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 (!(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((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 (auto & elem : loadedStates_)
-            graphicsRequired |= elem->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)

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

@@ -107 +107 @@
     Language::~Language()
     {
-        for (auto & elem : this->languageEntries_)
-            delete (elem.second);
+        for (auto& mapEntry : this->languageEntries_)
+            delete (mapEntry.second);
     }
 
@@ -319 +319 @@
 
         // Iterate through the list an write the lines into the file
-        for (const auto & elem : this->languageEntries_)
-        {
-            file << elem.second->getLabel() << '=' << elem.second->getDefault() << endl;
+        for (const auto& mapEntry : this->languageEntries_)
+        {
+            file << mapEntry.second->getLabel() << '=' << mapEntry.second->getDefault() << endl;
         }
 

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

@@ -165 +165 @@
                         std::ostringstream message;
                         message << "Possible sources of error:" << endl;
-                        for (auto & linesource : linesources)
+                        for (const std::pair<std::string, size_t>& pair : linesources)
                         {
-                            message << linesource.first << ", Line " << linesource.second << endl;
+                            message << pair.first << ", Line " << pair.second << endl;
                         }
                         orxout(user_error, context::loader) << message.str() << endl;
@@ -261 +261 @@
         {
             bool expectedValue = true;
-            for (auto & luaTag : luaTags)
-            {
-                if (luaTag.second == expectedValue)
+            for (auto& mapEntry : luaTags)
+            {
+                if (mapEntry.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 (const auto & interface : getToluaInterfaces())
-        {
-            if (interface.first == name || interface.second == function)
+        for (const auto& mapEntry : getToluaInterfaces())
+        {
+            if (mapEntry.first == name || mapEntry.second == function)
             {
                 orxout(internal_warning, context::lua) << "Trying to add a Tolua interface with the same name or function." << endl;
@@ -337 +337 @@
 
         // Open interface in all LuaStates
-        for (const auto & state : getInstances())
+        for (LuaState* state : getInstances())
             (*function)(state->luaState_);
 
@@ -354 +354 @@
 
         // Close interface in all LuaStates
-        for (const auto & state : getInstances())
+        for (LuaState* state : getInstances())
         {
             lua_pushnil(state->luaState_);
@@ -369 +369 @@
     /*static*/ void LuaState::openToluaInterfaces(lua_State* state)
     {
-        for (const auto & interface : getToluaInterfaces())
-            (interface.second)(state);
+        for (const auto& mapEntry : getToluaInterfaces())
+            (mapEntry.second)(state);
     }
 
     /*static*/ void LuaState::closeToluaInterfaces(lua_State* state)
     {
-        for (const auto & interface : getToluaInterfaces())
+        for (const auto& mapEntry : getToluaInterfaces())
         {
             lua_pushnil(state);
-            lua_setglobal(state, interface.first.c_str());
+            lua_setglobal(state, mapEntry.first.c_str());
         }
     }

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

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

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

@@ -103 +103 @@
                 bool bFoundMatchingNamespace = false;
 
-                for (auto & elem : this->subnodes_)
+                for (auto& mapEntry : this->subnodes_)
                 {
-                    if (elem.first.find(firstPart) == (elem.first.size() - firstPart.size()))
+                    if (mapEntry.first.find(firstPart) == (mapEntry.first.size() - firstPart.size()))
                     {
-                        std::set<NamespaceNode*> temp2 = elem.second->getNodeRelative(secondPart);
+                        std::set<NamespaceNode*> temp2 = mapEntry.second->getNodeRelative(secondPart);
                         nodes.insert(temp2.begin(), temp2.end());
                         bFoundMatchingNamespace = true;
@@ -132 +132 @@
         else
         {
-            for (const auto & elem : this->subnodes_)
-                if (elem.second->includes(ns))
+            for (const auto& mapEntry : this->subnodes_)
+                if (mapEntry.second->includes(ns))
                     return true;
         }
@@ -167 +167 @@
         std::string output = (indentation + this->name_ + '\n');
 
-        for (const auto & elem : this->subnodes_)
-            output += elem.second->toString(indentation + "  ");
+        for (const auto& mapEntry : this->subnodes_)
+            output += mapEntry.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 (const auto & group : groups)
+        for (const std::string& group : groups)
         {
             DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
@@ -121 +121 @@
         StringVectorPtr resourceNames(new Ogre::StringVector());
         const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-        for (const auto & group : groups)
+        for (const std::string& group : groups)
         {
             StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(group, pattern);

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 (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);
+        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 (auto& mapEntry : this->configValues_)
+            delete (mapEntry.second);
+        for (auto& mapEntry : this->xmlportParamContainers_)
+            delete (mapEntry.second);
+        for (auto& mapEntry : this->xmlportObjectContainers_)
+            delete (mapEntry.second);
     }
 
@@ -157 +157 @@
         if (this->directParents_.empty())
         {
-            for (const auto & elem : initializationTrace)
-                if (elem != this)
-                    this->parents_.push_back(elem);
+            for (const Identifier* identifier : initializationTrace)
+                if (identifier != this)
+                    this->parents_.push_back(identifier);
         }
         else
@@ -261 +261 @@
 
         // if any parent class is virtual, it will be instantiated first, so we need to add them first.
-        for (const auto & elem : this->parents_)
-        {
-            if ((elem)->isVirtualBase())
+        for (const Identifier* parent : this->parents_)
+        {
+            if (parent->isVirtualBase())
             {
-                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)
+                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(parent)->parents_.end(); ++it_parent_parent)
                     this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-                this->addIfNotExists(expectedIdentifierTrace, elem);
+                this->addIfNotExists(expectedIdentifierTrace, parent);
             }
         }
 
         // now all direct parents get created recursively. already added identifiers (e.g. virtual base classes) are not added again.
-        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)
+        for (const Identifier* directParent : this->directParents_)
+        {
+            for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(directParent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(directParent)->parents_.end(); ++it_parent_parent)
                 this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-            this->addIfNotExists(expectedIdentifierTrace, elem);
+            this->addIfNotExists(expectedIdentifierTrace, directParent);
         }
 
@@ -285 +285 @@
 
             orxout(internal_warning) << "  Actual trace (after creating a sample instance):" << endl << "    ";
-            for (const auto & elem : this->parents_)
-                orxout(internal_warning) << " " << (elem)->getName();
+            for (const Identifier* parent : this->parents_)
+                orxout(internal_warning) << " " << parent->getName();
             orxout(internal_warning) << endl;
 
@@ -295 +295 @@
 
             orxout(internal_warning) << "  Direct parents (according to class hierarchy definitions):" << endl << "    ";
-            for (const auto & elem : this->directParents_)
-                orxout(internal_warning) << " " << (elem)->getName();
+            for (const Identifier* directParent : this->directParents_)
+                orxout(internal_warning) << " " << directParent->getName();
             orxout(internal_warning) << endl;
         }

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

@@ -462 +462 @@
 
         if (updateChildren)
-            for (const auto & elem : this->getChildren())
-                (elem)->updateConfigValues(false);
+            for (const Identifier* child : this->getChildren())
+                child->updateConfigValues(false);
     }
 

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

@@ -93 +93 @@
         {
             Context temporaryContext(nullptr);
-            for (auto identifier : this->identifiers_)
+            for (Identifier* identifier : this->identifiers_)
             {
-                
                 if (identifier->isInitialized())
                     continue;
@@ -127 +126 @@
 
         // finish the initialization of all identifiers
-        for (const auto & initializedIdentifier : initializedIdentifiers)
-            (initializedIdentifier)->finishInitialization();
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
+            initializedIdentifier->finishInitialization();
 
         // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
@@ -144 +143 @@
     {
         // check if there are any uninitialized identifiers remaining
-        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 (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(nullptr);
-        for (const auto & initializedIdentifier : initializedIdentifiers)
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
         {
-            if (!(initializedIdentifier)->hasFactory())
+            if (!initializedIdentifier->hasFactory())
                 continue;
 
-            Identifiable* temp = (initializedIdentifier)->fabricate(&temporaryContext);
-
-            for (const auto & elem : this->identifiers_)
+            Identifiable* temp = initializedIdentifier->fabricate(&temporaryContext);
+
+            for (Identifier* identifier : this->identifiers_)
             {
-                bool isA_AccordingToRtti = (elem)->canDynamicCastObjectToIdentifierClass(temp);
-                bool isA_AccordingToClassHierarchy = temp->isA((elem));
+                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 " << (initializedIdentifier)->getName() <<
-                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << (elem)->getName() << " but RTTI says the opposite." << endl;
+                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << initializedIdentifier->getName() <<
+                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << identifier->getName() << " but RTTI says the opposite." << endl;
                 }
             }
@@ -184 +183 @@
     {
         orxout(internal_status) << "Destroy class-hierarchy" << endl;
-        for (const auto & elem : this->identifiers_)
-            (elem)->reset();
+        for (Identifier* identifier : this->identifiers_)
+            identifier->reset();
     }
 
@@ -260 +259 @@
     {
         // TODO: use std::type_index and a map to find identifiers by type_info (only with c++11)
-        for (const auto & elem : this->identifiers_)
-            if ((elem)->getTypeInfo() == typeInfo)
-                return (elem);
+        for (Identifier* identifer : this->identifiers_)
+            if (identifer->getTypeInfo() == typeInfo)
+                return identifer;
         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 (const auto & elem : group)
-                    if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden)
+                for (const auto& mapEntry : group)
+                    if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.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 (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)));
+                for (const auto& mapEntry : commands)
+                    if (groupIsVisible(mapEntry.second, bOnlyShowHidden) && mapEntry.first != "" && (fragmentLC == "" || getLowercase(mapEntry.first).find(fragmentLC) == 0))
+                        groupList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
 
                 // now add all shortcuts (in group "")
@@ -113 +113 @@
 
                     // add the shortcuts
-                    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)));
+                    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.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
                 }
 
@@ -146 +146 @@
                 if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                 {
-                    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)));
+                    for (const auto& mapEntry : it_group->second)
+                        if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden)
+                            commandList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
                 }
 
@@ -281 +281 @@
 
             const std::set<std::string>& names = SettingsConfigFile::getInstance().getSectionNames();
-            for (const auto & name : names)
+            for (const std::string& name : names)
                 sectionList.push_back(ArgumentCompletionListElement(name, getLowercase(name)));
 

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 (const auto & elem : ConsoleCommandManager::getInstance().getCommandsLC())
-                    if (elem.first == groupLC)
+                for (const auto& mapEntry : ConsoleCommandManager::getInstance().getCommandsLC())
+                    if (mapEntry.first == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
 
@@ -328 +328 @@
 
         // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
-        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;
+        for (const auto& mapEntry : ConsoleCommandManager::getInstance().getCommandsLC())
+        {
+            if (mapEntry.first != "")
+            {
+                for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = mapEntry.second.begin(); it_name != mapEntry.second.end(); ++it_name)
+                {
+                    std::string command = mapEntry.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 (const auto & elem : it_group->second)
-            {
-                std::string command = elem.first;
+            for (const auto& mapEntry : it_group->second)
+            {
+                std::string command = mapEntry.first;
                 unsigned int distance = getLevenshteinDistance(command, token0_LC);
                 if (distance < nearestDistance)
@@ -429 +429 @@
     {
         size_t count = 0;
-        for (const auto & elem : list)
-            if (elem.getComparable() != "")
+        for (const ArgumentCompletionListElement& element : list)
+            if (element.getComparable() != "")
                 ++count;
         return count;
@@ -495 +495 @@
         {
             // only one (non-empty) value in the list - search it and return it
-            for (const auto & elem : list)
-            {
-                if (elem.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 (elem.hasDisplay())
-                        return (elem.getString());
+                    if (element.hasDisplay())
+                        return (element.getString());
                     else
-                        return (elem.getString() + ' ');
+                        return (element.getString() + ' ');
                 }
             }
@@ -517 +517 @@
                 char tempComparable = '\0';
                 char temp = '\0';
-                for (const auto & elem : list)
-                {
-                    const std::string& argumentComparable = elem.getComparable();
-                    const std::string& argument = elem.getString();
+                for (const ArgumentCompletionListElement& element : list)
+                {
+                    const std::string& argumentComparable = element.getComparable();
+                    const std::string& argument = element.getString();
 
                     // ignore empty arguments
@@ -560 +560 @@
     {
         std::string output;
-        for (const auto & elem : list)
-        {
-            output += elem.getDisplay();
+        for (const ArgumentCompletionListElement& element : list)
+        {
+            output += element.getDisplay();
 
             // add a space character between two elements for all non-empty arguments
-            if (elem.getComparable() != "")
+            if (element.getComparable() != "")
                 output += ' ';
         }

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

@@ -75 +75 @@
         this->baseFunctor_ = executor->getFunctor();
 
-        for (auto & elem : this->argumentCompleter_)
-            elem = nullptr;
+        for (ArgumentCompleter*& completer : this->argumentCompleter_)
+            completer = nullptr;
 
         this->keybindMode_ = KeybindMode::OnPress;

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

@@ -258 +258 @@
         vectorize(text, '\n', &lines);
 
-        for (auto & line : lines)
+        for (const std::string& 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 (const auto & elem : this->list_)
-            if (elem == value)
+        for (const T& element : this->list_)
+            if (element == value)
                 return true;
 

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

@@ -551 +551 @@
 
         std::list<unsigned int> threads;
-        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);
+        for (const auto& mapEntry : this->interpreterBundles_)
+            if (mapEntry.first > 0 && mapEntry.first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
+                threads.push_back(mapEntry.first);
         return threads;
     }

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

@@ -124 +124 @@
             std::string shortcut;
             std::string value;
-            for (auto & argument : arguments)
+            for (const std::string& argument : arguments)
             {
                 if (argument.size() != 0)

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

@@ -234 +234 @@
         }
 
-        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)
+        for (ConfigFileSection* section : this->sections_)
+        {
+            file << section->getFileEntry() << endl;
+
+            for (std::list<ConfigFileEntry*>::const_iterator it_entries = section->getEntriesBegin(); it_entries != section->getEntriesEnd(); ++it_entries)
                 file << (*it_entries)->getFileEntry() << endl;
 
@@ -278 +278 @@
         @brief Returns a pointer to the section with given name (or nullptr if the section doesn't exist).
     */
-    ConfigFileSection* ConfigFile::getSection(const std::string& section) const
-    {
-        for (const auto & elem : this->sections_)
-            if ((elem)->getName() == section)
-                return (elem);
+    ConfigFileSection* ConfigFile::getSection(const std::string& sectionName) const
+    {
+        for (ConfigFileSection* section : this->sections_)
+            if (section->getName() == sectionName)
+                return section;
         return nullptr;
     }
@@ -289 +289 @@
         @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 (auto & elem : this->sections_)
-            if ((elem)->getName() == section)
-                return (elem);
+    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)));
     }
 
@@ -307 +307 @@
         bool sectionsUpdated = false;
 
-        for (auto & elem : this->sections_)
-        {
-            if ((elem)->bUpdated_)
+        for (ConfigFileSection* section : this->sections_)
+        {
+            if (section->bUpdated_)
             {
                 sectionsUpdated = true;
-                (elem)->bUpdated_ = false;
+                section->bUpdated_ = false;
             }
         }

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

@@ -53 +53 @@
     ConfigFileManager::~ConfigFileManager()
     {
-        for (const auto & elem : this->configFiles_)
-            if (elem)
-                delete (elem);
+        for (ConfigFile* configFile : this->configFiles_)
+            if (configFile)
+                delete configFile;
     }
 

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

@@ -80 +80 @@
     {
         unsigned int size = 0;
-        for (const auto & elem : this->entries_)
-            if ((elem)->getName() == name)
-                if ((elem)->getIndex() >= size)
-                    size = (elem)->getIndex() + 1;
+        for (ConfigFileEntry* entry : this->entries_)
+            if (entry->getName() == name)
+                if (entry->getIndex() >= size)
+                    size = entry->getIndex() + 1;
         return size;
     }
@@ -105 +105 @@
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name) const
     {
-        for (const auto & elem : this->entries_)
+        for (ConfigFileEntry* entry : this->entries_)
         {
-            if ((elem)->getName() == name)
-                return elem;
+            if (entry->getName() == name)
+                return entry;
         }
         return nullptr;
@@ -121 +121 @@
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name, unsigned int index) const
     {
-        for (const auto & elem : this->entries_)
+        for (ConfigFileEntry* entry : this->entries_)
         {
-            if (((elem)->getName() == name) && ((elem)->getIndex() == index))
-                return elem;
+            if ((entry->getName() == name) && (entry->getIndex() == index))
+                return entry;
         }
         return nullptr;

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

@@ -130 +130 @@
 
                 this->value_ = V();
-                for (auto & elem : defvalue)
-                    this->valueVector_.push_back(MultiType(elem));
+                for (const D& defvalueElement : defvalue)
+                    this->valueVector_.push_back(MultiType(defvalueElement));
 
                 this->initVector();
@@ -183 +183 @@
                     std::vector<T> temp = *value;
                     value->clear();
-                    for (auto & elem : this->valueVector_)
-                        value->push_back(elem);
+                    for (const MultiType& vectorEntry : this->valueVector_)
+                        value->push_back(vectorEntry);
 
                     if (value->size() != temp.size())
@@ -211 +211 @@
                 {
                     value->clear();
-                    for (auto & elem : this->valueVector_)
-                        value->push_back(elem);
+                    for (const MultiType& vectorEntry : this->valueVector_)
+                        value->push_back(vectorEntry);
                 }
                 return *this;

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

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

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

@@ -110 +110 @@
     void InputBuffer::insert(const std::string& input, bool update)
     {
-        for (auto & elem : input)
-        {
-            this->insert(elem, false);
+        for (const char& inputChar : input)
+        {
+            this->insert(inputChar, false);
 
             if (update)
-                this->updated(elem, false);
+                this->updated(inputChar, false);
         }
 
@@ -170 +170 @@
     void InputBuffer::updated()
     {
-        for (auto & elem : this->listeners_)
-        {
-            if ((elem)->bListenToAllChanges_)
-                (elem)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if (listener->bListenToAllChanges_)
+                listener->callFunction();
         }
     }
@@ -179 +179 @@
     void InputBuffer::updated(const char& update, bool bSingleInput)
     {
-        for (auto & elem : this->listeners_)
-        {
-            if ((!(elem)->trueKeyFalseChar_) && ((elem)->bListenToAllChanges_ || ((elem)->char_ == update)) && (!(elem)->bOnlySingleInput_ || bSingleInput))
-                (elem)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if ((!listener->trueKeyFalseChar_) && (listener->bListenToAllChanges_ || (listener->char_ == update)) && (!listener->bOnlySingleInput_ || bSingleInput))
+                listener->callFunction();
         }
     }
@@ -201 +201 @@
             return;
 
-        for (auto & elem : this->listeners_)
-        {
-            if ((elem)->trueKeyFalseChar_ && ((elem)->key_ == evt.getKeyCode()))
-                (elem)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if (listener->trueKeyFalseChar_ && (listener->key_ == evt.getKeyCode()))
+                listener->callFunction();
         }
 

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

@@ -158 +158 @@
 
             // Call all the states with the held button event
-            for (auto & button : pressedButtons_)
-                for (auto & state : inputStates_)
+            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 (auto & elem : inputStates_)
-                elem->update(time.getDeltaTime(), this->getDeviceID());
+            for (InputState* state : inputStates_)
+                state->update(time.getDeltaTime(), this->getDeviceID());
 
             static_cast<DeviceClass*>(this)->updateImpl(time);
@@ -196 +196 @@
 
             // Call states
-            for (auto & elem : inputStates_)
-                elem->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (InputState* state : inputStates_)
+                state->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 
@@ -218 +218 @@
 
             // Call states
-            for (auto & elem : inputStates_)
-                elem->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (InputState* state : inputStates_)
+                state->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 

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

@@ -373 +373 @@
         // check whether a state has changed its EMPTY situation
         bool bUpdateRequired = false;
-        for (auto & elem : activeStates_)
-        {
-            if (elem.second->hasExpired())
-            {
-                elem.second->resetExpiration();
+        for (auto& mapEntry : activeStates_)
+        {
+            if (mapEntry.second->hasExpired())
+            {
+                mapEntry.second->resetExpiration();
                 bUpdateRequired = true;
             }
@@ -391 +391 @@
 
         // Collect function calls for the update
-        for (auto & elem : activeStatesTicked_)
-            elem->update(time.getDeltaTime());
+        for (InputState* state : activeStatesTicked_)
+            state->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 (auto & elem : this->callBuffer_)
-            elem();
+        for (auto& function : this->callBuffer_)
+            function();
 
         this->callBuffer_.clear();
@@ -437 +437 @@
         // Using an std::set to avoid duplicates
         std::set<InputState*> tempSet;
-        for (auto & elem : devices_)
-            if (elem != nullptr)
-                for (unsigned int iState = 0; iState < elem->getStateListRef().size(); ++iState)
-                    tempSet.insert(elem->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 (const auto & elem : tempSet)
-            activeStatesTicked_.push_back(elem);
+        for (InputState* state : tempSet)
+            activeStatesTicked_.push_back(state);
 
         // 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 (auto & elem : povStates_)
-            elem = 0;
+        for (int& state : povStates_)
+            state = 0;
     }
 

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

@@ -153 +153 @@
     void KeyBinder::buttonThresholdChanged()
     {
-        for (auto & elem : allHalfAxes_)
-            if (!elem->bButtonThresholdUser_)
-                elem->buttonThreshold_ = this->buttonThreshold_;
+        for (HalfAxis* halfAxis : allHalfAxes_)
+            if (!halfAxis->bButtonThresholdUser_)
+                halfAxis->buttonThreshold_ = this->buttonThreshold_;
     }
 
@@ -383 +383 @@
             it->second->clear();
 
-        for (auto & elem : paramCommandBuffer_)
-            delete elem;
+        for (BufferedParamCommand* command : paramCommandBuffer_)
+            delete command;
         paramCommandBuffer_.clear();
     }
@@ -394 +394 @@
     {
         // iterate over all buttons
-        for (const auto & elem : this->allButtons_)
-        {
-            Button* button = elem.second;
+        for (const auto& mapEntry : this->allButtons_)
+        {
+            Button* button = mapEntry.second;
 
             // iterate over all modes
@@ -465 +465 @@
         this->mousePosition_[1] = 0.0f;
 
-        for (auto & elem : mouseAxes_)
-            elem.reset();
+        for (HalfAxis& axis : mouseAxes_)
+            axis.reset();
     }
 
@@ -505 +505 @@
         }
 
-        for (auto & elem : mouseAxes_)
+        for (HalfAxis& axis : 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..
-                elem.relVal_ /= dt;
-            }
-
-            tickHalfAxis(elem);
+                axis.relVal_ /= dt;
+            }
+
+            tickHalfAxis(axis);
         }
     }

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

@@ -226 +226 @@
     {
         // execute all buffered bindings (additional parameter)
-        for (auto & elem : paramCommandBuffer_)
+        for (BufferedParamCommand* command : paramCommandBuffer_)
         {
-            elem->rel_ *= dt;
-            elem->execute();
+            command->rel_ *= dt;
+            command->execute();
         }
 
         // always reset the relative movement of the mouse
-        for (auto & elem : mouseAxes_)
-            elem.relVal_ = 0.0f;
+        for (HalfAxis& axis : mouseAxes_)
+            axis.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 (auto & elem : inputStates_)
-                elem->mouseMoved(abs, rel, clippingSize);
+            for (InputState* state : inputStates_)
+                state->mouseMoved(abs, rel, clippingSize);
         }
 
@@ -89 +89 @@
         if (e.state.Z.rel != 0)
         {
-            for (auto & elem : inputStates_)
-                elem->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+            for (InputState* state : inputStates_)
+                state->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
         }
 

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

@@ -75 +75 @@
     {
         // Unload & delete resources in turn
-        for (auto & elem : mLibList)
+        for (auto& mapEntry : mLibList)
         {
-            elem.second->unload();
-            delete elem.second;
+            mapEntry.second->unload();
+            delete mapEntry.second;
         }
 

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

@@ -59 +59 @@
     {
         const std::set<StaticallyInitializedInstance*>& instances = this->staticallyInitializedInstancesByType_[type];
-        for (const auto & instance : instances)
-            (instance)->load();
+        for (StaticallyInitializedInstance* instance : instances)
+            instance->load();
     }
 
@@ -75 +75 @@
         std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
         this->staticallyInitializedInstancesByType_.clear();
-        for (auto & elem : copy)
-            for (std::set<StaticallyInitializedInstance*>::iterator it2 = elem.second.begin(); it2 != elem.second.end(); ++it2)
+        for (auto& mapEntry : copy)
+            for (std::set<StaticallyInitializedInstance*>::iterator it2 = mapEntry.second.begin(); it2 != mapEntry.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 (auto & elem : this->references_)
-            delete elem.second;
-        for (auto & elem : this->plugins_)
-            delete elem.second;
+        for (auto& mapEntry : this->references_)
+            delete mapEntry.second;
+        for (auto& mapEntry : this->plugins_)
+            delete mapEntry.second;
     }
 
@@ -68 +68 @@
     {
         const std::vector<std::string>& pluginPaths = ApplicationPaths::getInstance().getPluginPaths();
-        for (auto libraryName : pluginPaths)
+        for (const std::string& libraryName : pluginPaths)
         {
             std::string name;
-            
             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 (auto & elem : this->handlers_)
-            (elem)->loadModule(module);
+        for (StaticInitializationHandler* handler : this->handlers_)
+            handler->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 (auto & elem : this->objectLists_)
-            delete elem;
+        for (ObjectListBase* objectList : this->objectLists_)
+            delete objectList;
     }
 

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

@@ -76 +76 @@
     void Listable::unregisterObject()
     {
-        for (auto & elem : this->elements_)
-            Listable::deleteObjectListElement(elem);
+        for (ObjectListBaseElement* element : this->elements_)
+            Listable::deleteObjectListElement(element);
         this->elements_.clear();
     }
@@ -91 +91 @@
         this->elements_.clear();
 
-        for (auto & elem : copy)
+        for (ObjectListBaseElement* element : copy)
         {
-            elem->changeContext(this->context_, context);
-            Listable::deleteObjectListElement(elem);
+            element->changeContext(this->context_, context);
+            Listable::deleteObjectListElement(element);
         }
 

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

@@ -92 +92 @@
     void ObjectListBase::notifyRemovalListeners(ObjectListBaseElement* element) const
     {
-        for (const auto & elem : this->listeners_)
-            (elem)->removedElement(element);
+        for (ObjectListElementRemovalListener* listener : this->listeners_)
+            listener->removedElement(element);
     }
 

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

@@ -73 +73 @@
     void ScopeManager::activateListenersForScope(ScopeID::Value scope)
     {
-        for (const auto & elem : this->listeners_[scope])
-            this->activateListener(elem);
+        for (ScopeListener* listener : this->listeners_[scope])
+            this->activateListener(listener);
     }
 
     void ScopeManager::deactivateListenersForScope(ScopeID::Value scope)
     {
-        for (const auto & elem : this->listeners_[scope])
-            this->deactivateListener(elem);
+        for (ScopeListener* listener : this->listeners_[scope])
+            this->deactivateListener(listener);
     }
 

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

@@ -131 +131 @@
   *(uint32_t*)(mem+2*sizeof(uint32_t)) = this->objectID_;
   mem += 3*sizeof(uint32_t);
-  for(auto & elem : this->arguments_)
+  for(const MultiType& argument : this->arguments_)
   {
-    elem.exportData( mem );
+    argument.exportData( mem );
   }
 }

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

@@ -80 +80 @@
   void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
   {
-    for(auto & instances_ : instances_s)
+    for(Host* host : instances_s)
     {
-      if( (instances_)->isActive() )
+      if( host->isActive() )
       {
-        (instances_)->queuePacket(packet, clientID, channelID);
+        host->queuePacket(packet, clientID, channelID);
       }
     }
@@ -97 +97 @@
   void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for(auto & instances_ : instances_s)
-      if( (instances_)->isActive() )
-        (instances_)->doSendChat(message, sourceID, targetID);
+    for(Host* host : instances_s)
+      if( host->isActive() )
+        host->doSendChat(message, sourceID, targetID);
   }
 
@@ -114 +114 @@
   bool Host::isServer()
   {
-    for (auto & instances_ : instances_s)
+    for (Host* host : instances_s)
     {
-      if( (instances_)->isActive() )
+      if( host->isActive() )
       {
-        if( (instances_)->isServer_() )
+        if( host->isServer_() )
           return true;
       }

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

@@ -88 +88 @@
     }
     // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ )
-    for(auto & elem : syncList_)
-      delete (elem);
+    for(SynchronisableVariableBase* variable : syncList_)
+      delete variable;
     syncList_.clear();
     stringList_.clear();

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

@@ -392 +392 @@
             manualObject->estimateVertexCount(lineVertices.size());
             manualObject->estimateIndexCount(lineIndices.size());
-            for (auto & elem : lineVertices)
+            for (const VertexPair& pair : lineVertices)
             {
-                manualObject->position(elem.first);
-                manualObject->colour(elem.second);
+                manualObject->position(pair.first);
+                manualObject->colour(pair.second);
             }
-            for (auto & elem : lineIndices)
-                manualObject->index(elem);
+            for (int lineIndex : lineIndices)
+                manualObject->index(lineIndex);
         }
         else
@@ -409 +409 @@
             manualObject->estimateVertexCount(triangleVertices.size());
             manualObject->estimateIndexCount(triangleIndices.size());
-            for (auto & elem : triangleVertices)
+            for (const VertexPair& pair : triangleVertices)
             {
-                manualObject->position(elem.first);
-                manualObject->colour(elem.second.r, elem.second.g, elem.second.b, fillAlpha);
+                manualObject->position(pair.first);
+                manualObject->colour(pair.second.r, pair.second.g, pair.second.b, fillAlpha);
             }
-            for (auto & elem : triangleIndices)
-                manualObject->index(elem);
+            for (int triangleIndex : triangleIndices)
+                manualObject->index(triangleIndex);
         }
         else

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

@@ -116 +116 @@
             std::list<TriangleIndices> faces2;
 
-            for (auto f : faces)
+            for (const TriangleIndices& f : faces)
             {
-                
                 int a = getMiddlePoint(f.v1, f.v2);
                 int b = getMiddlePoint(f.v2, f.v3);
@@ -194 +193 @@
     void IcoSphere::addToLineIndices(int baseIndex, std::list<int>* target) const
     {
-        for (const auto & elem : lineIndices)
+        for (const LineIndices& line : lineIndices)
         {
-            target->push_back(baseIndex + (elem).v1);
-            target->push_back(baseIndex + (elem).v2);
+            target->push_back(baseIndex + line.v1);
+            target->push_back(baseIndex + line.v2);
         }
     }
@@ -203 +202 @@
     void IcoSphere::addToTriangleIndices(int baseIndex, std::list<int>* target) const
     {
-        for (const auto & elem : faces)
+        for (const TriangleIndices& triangle : faces)
         {
-            target->push_back(baseIndex + (elem).v1);
-            target->push_back(baseIndex + (elem).v2);
-            target->push_back(baseIndex + (elem).v3);
+            target->push_back(baseIndex + triangle.v1);
+            target->push_back(baseIndex + triangle.v2);
+            target->push_back(baseIndex + triangle.v3);
         }
     }
@@ -217 +216 @@
         transform.setScale(Ogre::Vector3(scale, scale, scale));
 
-        for (auto & elem : vertices)
-            target->push_back(VertexPair(transform * elem, colour));
+        for (const Ogre::Vector3& vertex : vertices)
+            target->push_back(VertexPair(transform * vertex, colour));
 
         return vertices.size();

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

@@ -197 +197 @@
     {
         // iterate through the list of parameters
-        for (auto & elem : this->parameters_)
-        {
-            Ogre::Technique* techniquePtr = materialPtr->getTechnique(elem.technique_);
+        for (const ParameterContainer& parameter : this->parameters_)
+        {
+            Ogre::Technique* techniquePtr = materialPtr->getTechnique(parameter.technique_);
             if (techniquePtr)
             {
-                Ogre::Pass* passPtr = techniquePtr->getPass(elem.pass_);
+                Ogre::Pass* passPtr = techniquePtr->getPass(parameter.pass_);
                 if (passPtr)
                 {
                     // change the value of the parameter depending on its type
-                    if (elem.value_.isType<int>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(elem.parameter_, elem.value_.get<int>());
-                    else if (elem.value_.isType<float>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(elem.parameter_, elem.value_.get<float>());
+                    if (parameter.value_.isType<int>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<int>());
+                    else if (parameter.value_.isType<float>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<float>());
                 }
                 else
-                    orxout(internal_warning) << "No pass " << elem.pass_ << " in technique " << elem.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
+                    orxout(internal_warning) << "No pass " << parameter.pass_ << " in technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
             }
             else
-                orxout(internal_warning) << "No technique " << elem.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
+                orxout(internal_warning) << "No technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
         }
         this->parameters_.clear();
@@ -228 +228 @@
         {
             const Ogre::Root::PluginInstanceList& plugins = Ogre::Root::getSingleton().getInstalledPlugins();
-            for (auto & plugin : plugins)
+            for (Ogre::Plugin* plugin : plugins)
                 if (plugin->getName() == "Cg Program Manager")
                     return true;

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

@@ -51 +51 @@
             {
                 Ogre::UTFString::code_point cp;
-                for (auto & elem : input)
+                for (const char& character : input)
                 {
-                  cp = elem;
+                  cp = character;
                   cp &= 0xFF;
                   output->append(1, cp);

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

@@ -672 +672 @@
     {
         uint32_t tempsize = sizeof(uint32_t); // for the number of entries
-        for(const auto & elem : *((std::set<T>*)(&variable)))
-            tempsize += returnSize( elem );
+        for(const T& element : *((std::set<T>*)(&variable)))
+            tempsize += returnSize( element );
         return tempsize;
     }

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

@@ -81 +81 @@
     void SignalHandler::dontCatch()
     {
-      for (auto & elem : sigRecList)
-      {
-        signal( elem.signal, elem.handler );
+      for (const SignalRec& sigRec : sigRecList)
+      {
+        signal( sigRec.signal, sigRec.handler );
       }
 
@@ -133 +133 @@
       }
 
-      for (auto & elem : SignalHandler::getInstance().callbackList)
-      {
-        (*(elem.cb))( elem.someData );
+      for (const SignalCallbackRec& callback : SignalHandler::getInstance().callbackList)
+      {
+        (*(callback.cb))( callback.someData );
       }
 

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

@@ -53 +53 @@
     SmallObjectAllocator::~SmallObjectAllocator()
     {
-        for (auto & elem : this->blocks_)
-            delete[] elem;
+        for (char* block : this->blocks_)
+            delete[] block;
     }
 

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

@@ -262 +262 @@
         std::string output(str.size() * 2, ' ');
         size_t i = 0;
-        for (auto & elem : str)
-        {
-            switch (elem)
+        for (const char& character : str)
+        {
+            switch (character)
             {
             case '\\': output[i] = '\\'; output[i + 1] = '\\'; break;
@@ -276 +276 @@
             case  '"': output[i] = '\\'; output[i + 1] =  '"'; break;
             case '\0': output[i] = '\\'; output[i + 1] =  '0'; break;
-            default  : output[i] = elem; ++i; continue;
+            default  : output[i] = character; ++i; continue;
             }
             i += 2;
@@ -336 +336 @@
     void lowercase(std::string* str)
     {
-        for (auto & elem : *str)
-        {
-            elem = static_cast<char>(tolower(elem));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(tolower(character));
         }
     }
@@ -353 +353 @@
     void uppercase(std::string* str)
     {
-        for (auto & elem : *str)
-        {
-            elem = static_cast<char>(toupper(elem));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(toupper(character));
         }
     }
@@ -460 +460 @@
     {
         size_t j = 0;
-        for (auto & elem : str)
-        {
-            if (elem == target)
+        for (char& character : str)
+        {
+            if (character == target)
             {
-                elem = replacement;
+                character = replacement;
                 ++j;
             }

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

@@ -116 +116 @@
 
         // iterate over all strings in the config-vector
-        for (auto & full_name : this->configurableAdditionalContexts_)
+        for (const std::string& full_name : this->configurableAdditionalContexts_)
         {
-            
-
             // split the name into main-name and sub-name (if given; otherwise sub-name remains empty). both names are separated by ::
             std::string name = full_name;

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

@@ -65 +65 @@
     void MemoryWriter::resendOutput(OutputListener* listener) const
     {
-        for (auto & message : this->messages_)
+        for (const Message& message : this->messages_)
         {
-            
             listener->unfilteredOutput(message.level, *message.context, message.lines);
         }

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

@@ -111 +111 @@
         this->levelMask_ = mask;
 
-        for (auto & elem : this->listeners_)
-            elem->updatedLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedLevelMask(this);
     }
 
@@ -142 +142 @@
         this->additionalContextsLevelMask_ = mask;
 
-        for (auto & elem : this->listeners_)
-            elem->updatedAdditionalContextsLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsLevelMask(this);
     }
 
@@ -153 +153 @@
         this->additionalContextsMask_ = mask;
 
-        for (auto & elem : this->listeners_)
-            elem->updatedAdditionalContextsMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsMask(this);
     }
 

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

@@ -131 +131 @@
         vectorize(message, '\n', &lines);
 
-        for (auto & elem : this->listeners_)
-            elem->unfilteredOutput(level, context, lines);
+        for (OutputListener* listener : this->listeners_)
+            listener->unfilteredOutput(level, context, lines);
     }
 
@@ -178 +178 @@
     {
         int mask = 0;
-        for (auto & elem : this->listeners_)
-            mask |= elem->getLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getLevelMask();
         this->combinedLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -189 +189 @@
     {
         int mask = 0;
-        for (auto & elem : this->listeners_)
-            mask |= elem->getAdditionalContextsLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getAdditionalContextsLevelMask();
         this->combinedAdditionalContextsLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -200 +200 @@
     {
         this->combinedAdditionalContextsMask_ = 0;
-        for (auto & elem : this->listeners_)
-            this->combinedAdditionalContextsMask_ |= elem->getAdditionalContextsMask();
+        for (OutputListener* listener : this->listeners_)
+            this->combinedAdditionalContextsMask_ |= listener->getAdditionalContextsMask();
     }
 

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

@@ -79 +79 @@
 
         // compose the mask of subcontexts and build the set of sub-context-IDs
-        for (const auto & subcontext : subcontexts)
+        for (const OutputContextContainer* subcontext : subcontexts)
         {
-            this->subcontextsCheckMask_ |= (subcontext)->mask;
-            this->subcontexts_.insert((subcontext)->sub_id);
+            this->subcontextsCheckMask_ |= subcontext->mask;
+            this->subcontexts_.insert(subcontext->sub_id);
         }