Index: code/branches/cpp11_v2/src/libraries/core/BaseObject.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/BaseObject.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/BaseObject.cc	(revision 10919)
@@ -163,6 +163,6 @@
         this->setName(name);
 
-        for (ObjectList<XMLNameListener>::iterator it = ObjectList<XMLNameListener>::begin(); it != ObjectList<XMLNameListener>::end(); ++it)
-            it->loadedNewXMLName(this);
+        for (XMLNameListener* listener : ObjectList<XMLNameListener>())
+            listener->loadedNewXMLName(this);
     }
 
Index: code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc	(revision 10919)
@@ -915,8 +915,8 @@
 
             // Iterate through all subnodes
-            for (std::list<ClassTreeMaskNode*>::iterator it1 = node->subnodes_.begin(); it1 != node->subnodes_.end(); ++it1)
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
             {
                 // Recursive call to this function with the subnode
-                this->create(*it1);
+                this->create(subnode);
 
                 // Only execute the following code if the current node is included, meaning some of the subnodes might be included too
@@ -926,22 +926,22 @@
 
                     // Iterate through all direct children
-                    for (std::set<const Identifier*>::iterator it2 = directChildren.begin(); it2 != directChildren.end(); ++it2)
+                    for (std::set<const Identifier*>::iterator it = directChildren.begin(); it != directChildren.end(); ++it)
                     {
                         // Check if the subnode (it1) is a child of the directChild (it2)
-                        if ((*it1)->getClass()->isA(*it2))
+                        if (subnode->getClass()->isA(*it))
                         {
                             // Yes it is - remove the directChild (it2) from the list, because it will already be handled by a recursive call to the create() function
-                            directChildren.erase(it2);
+                            directChildren.erase(it);
 
                             // Check if the removed directChild was exactly the subnode
-                            if (!(*it1)->getClass()->isExactlyA(*it2))
+                            if (!subnode->getClass()->isExactlyA(*it))
                             {
                                 // No, it wasn't exactly the subnode - therefore there are some classes between
 
                                 // Add the previously removed directChild (it2) to the subclass-list
-                                this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(*it2, true));
+                                this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(*it, true));
 
                                 // Insert all directChildren of the directChild
-                                directChildren.insert((*it2)->getDirectChildren().begin(), (*it2)->getDirectChildren().end());
+                                directChildren.insert((*it)->getDirectChildren().begin(), (*it)->getDirectChildren().end());
 
                                 // Restart the scan with the expanded set of directChildren
Index: code/branches/cpp11_v2/src/libraries/core/Core.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/Core.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/Core.cc	(revision 10919)
@@ -460,6 +460,6 @@
     {
         // Update UpdateListeners before general ticking
-        for (ObjectList<UpdateListener>::iterator it = ObjectList<UpdateListener>::begin(); it != ObjectList<UpdateListener>::end(); ++it)
-            it->preUpdate(time);
+        for (UpdateListener* listener : ObjectList<UpdateListener>())
+            listener->preUpdate(time);
         if (this->bGraphicsLoaded_)
         {
@@ -479,6 +479,6 @@
     {
         // Update UpdateListeners just before rendering
-        for (ObjectList<UpdateListener>::iterator it = ObjectList<UpdateListener>::begin(); it != ObjectList<UpdateListener>::end(); ++it)
-            it->postUpdate(time);
+        for (UpdateListener* listener : ObjectList<UpdateListener>())
+            listener->postUpdate(time);
         if (this->bGraphicsLoaded_)
         {
Index: code/branches/cpp11_v2/src/libraries/core/CoreConfig.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/CoreConfig.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/CoreConfig.cc	(revision 10919)
@@ -108,7 +108,6 @@
     {
         // Inform listeners
-        ObjectList<DevModeListener>::iterator it = ObjectList<DevModeListener>::begin();
-        for (; it != ObjectList<DevModeListener>::end(); ++it)
-            it->devModeChanged(bDevMode_);
+        for (DevModeListener* listener : ObjectList<DevModeListener>())
+            listener->devModeChanged(bDevMode_);
     }
 
Index: code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 10919)
@@ -129,6 +129,6 @@
             {
                 // iterate over all contexts
-                for (ObjectList<Context>::iterator it_context = ObjectList<Context>::begin(); it_context != ObjectList<Context>::end(); ++it_context)
-                    it_context->destroyObjectList(identifier);
+                for (Context* context : ObjectList<Context>())
+                    context->destroyObjectList(identifier);
             }
         }
Index: code/branches/cpp11_v2/src/libraries/core/Game.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/Game.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/Game.cc	(revision 10919)
@@ -115,9 +115,8 @@
 
         // After the core has been created, we can safely instantiate the GameStates that don't require graphics
-        for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
-            it != gameStateDeclarations_s.end(); ++it)
-        {
-            if (!it->second.bGraphicsMode)
-                constructedStates_[it->second.stateName] = GameStateFactory::fabricate(it->second);
+        for (const auto& mapEntry : gameStateDeclarations_s)
+        {
+            if (!mapEntry.second.bGraphicsMode)
+                constructedStates_[mapEntry.second.stateName] = GameStateFactory::fabricate(mapEntry.second);
         }
 
@@ -262,6 +261,5 @@
     {
         // Note: The first element is the empty root state, which doesn't need ticking
-        for (GameStateVector::const_iterator it = this->loadedStates_.begin() + 1;
-            it != this->loadedStates_.end(); ++it)
+        for (const std::shared_ptr<GameState>& state : this->loadedStates_)
         {
             try
@@ -269,17 +267,17 @@
                 // Add tick time for most of the states
                 uint64_t timeBeforeTick = 0;
-                if ((*it)->getInfo().bIgnoreTickTime)
+                if (state->getInfo().bIgnoreTickTime)
                     timeBeforeTick = this->gameClock_->getRealMicroseconds();
-                (*it)->update(*this->gameClock_);
-                if ((*it)->getInfo().bIgnoreTickTime)
+                state->update(*this->gameClock_);
+                if (state->getInfo().bIgnoreTickTime)
                     this->subtractTickTime(static_cast<int32_t>(this->gameClock_->getRealMicroseconds() - timeBeforeTick));
             }
             catch (...)
             {
-                orxout(user_error) << "An exception occurred while updating '" << (*it)->getName() << "': " << Exception::handleMessage() << endl;
+                orxout(user_error) << "An exception occurred while updating '" << state->getName() << "': " << Exception::handleMessage() << endl;
                 orxout(user_error) << "This should really never happen!" << endl;
                 orxout(user_error) << "Unloading all GameStates depending on the one that crashed." << endl;
                 std::shared_ptr<GameStateTreeNode> current = this->loadedTopStateNode_;
-                while (current->name_ != (*it)->getName() && current)
+                while (current->name_ != state->getName() && current)
                     current = current->parent_.lock();
                 if (current && current->parent_.lock())
@@ -520,13 +518,12 @@
 
             // Construct all the GameStates that require graphics
-            for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
-                it != gameStateDeclarations_s.end(); ++it)
-            {
-                if (it->second.bGraphicsMode)
+            for (const auto& mapEntry : gameStateDeclarations_s)
+            {
+                if (mapEntry.second.bGraphicsMode)
                 {
                     // Game state loading failure is serious --> don't catch
-                    std::shared_ptr<GameState> gameState = GameStateFactory::fabricate(it->second);
+                    std::shared_ptr<GameState> gameState = GameStateFactory::fabricate(mapEntry.second);
                     if (!constructedStates_.insert(std::make_pair(
-                        it->second.stateName, gameState)).second)
+                        mapEntry.second.stateName, gameState)).second)
                         assert(false); // GameState was already created!
                 }
Index: code/branches/cpp11_v2/src/libraries/core/GraphicsManager.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/GraphicsManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/GraphicsManager.cc	(revision 10919)
@@ -389,6 +389,6 @@
         GUIManager::getInstance().setCamera(camera);
 
-        for (ObjectList<ViewportEventListener>::iterator it = ObjectList<ViewportEventListener>::begin(); it != ObjectList<ViewportEventListener>::end(); ++it)
-            it->cameraChanged(this->viewport_, oldCamera);
+        for (ViewportEventListener* listener : ObjectList<ViewportEventListener>())
+            listener->cameraChanged(this->viewport_, oldCamera);
     }
 
Index: code/branches/cpp11_v2/src/libraries/core/NamespaceNode.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/NamespaceNode.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/NamespaceNode.cc	(revision 10919)
@@ -149,10 +149,11 @@
 
             int i = 0;
-            for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); i++, ++it)
+            for (const auto& mapEntry : this->subnodes_)
             {
                 if (i > 0)
                     output += ", ";
 
-                output += it->second->toString();
+                output += mapEntry.second->toString();
+                i++;
             }
 
Index: code/branches/cpp11_v2/src/libraries/core/ThreadPool.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/ThreadPool.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/ThreadPool.cc	(revision 10919)
@@ -83,11 +83,10 @@
     bool ThreadPool::passFunction( const ExecutorPtr& executor, bool addThread )
     {
-        std::vector<Thread*>::iterator it;
-        for ( it=this->threadPool_.begin(); it!=this->threadPool_.end(); ++it )
+        for ( Thread* thread : threadPool_ )
         {
-            if ( ! (*it)->isWorking() )
+            if ( ! thread->isWorking() )
             {
                 // If that fails, then there is some code error
-                OrxVerify( (*it)->evaluateExecutor( executor ), "ERROR: could not evaluate Executor" );
+                OrxVerify( thread->evaluateExecutor( executor ), "ERROR: could not evaluate Executor" );
                 return true;
             }
@@ -105,8 +104,7 @@
     void ThreadPool::synchronise()
     {
-        std::vector<Thread*>::iterator it;
-        for ( it=this->threadPool_.begin(); it!=this->threadPool_.end(); ++it )
+        for ( Thread* thread : this->threadPool_ )
         {
-            (*it)->waitUntilFinished();
+            thread->waitUntilFinished();
         }
     }
Index: code/branches/cpp11_v2/src/libraries/core/WindowEventListener.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/WindowEventListener.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/WindowEventListener.cc	(revision 10919)
@@ -45,6 +45,6 @@
     /*static*/ void WindowEventListener::moveWindow()
     {
-        for (ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it)
-            it->windowMoved();
+        for (WindowEventListener* listener : ObjectList<WindowEventListener>())
+            listener->windowMoved();
     }
 
@@ -54,6 +54,6 @@
         windowWidth_s = newWidth;
         windowHeight_s = newHeight;
-        for (ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it)
-            it->windowResized(newWidth, newHeight);
+        for (WindowEventListener* listener : ObjectList<WindowEventListener>())
+            listener->windowResized(newWidth, newHeight);
     }
 
@@ -61,6 +61,6 @@
     /*static*/ void WindowEventListener::changeWindowFocus(bool bFocus)
     {
-        for (ObjectList<WindowEventListener>::iterator it = ObjectList<WindowEventListener>::begin(); it; ++it)
-            it->windowFocusChanged(bFocus);
+        for (WindowEventListener* listener : ObjectList<WindowEventListener>())
+            listener->windowFocusChanged(bFocus);
     }
 }
Index: code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc	(revision 10919)
@@ -79,12 +79,12 @@
             delete this->factory_;
 
-        for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
-            delete (*it);
+        for (const InheritsFrom* manualDirectParent : this->manualDirectParents_)
+            delete manualDirectParent;
 
         // erase this Identifier from all related identifiers
-        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-            const_cast<Identifier*>(*it)->children_.erase(this);
-        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-            const_cast<Identifier*>(*it)->directChildren_.erase(this);
+        for (const Identifier* parent : this->parents_)
+            const_cast<Identifier*>(parent)->children_.erase(this);
+        for (const Identifier* directParent : this->directParents_)
+            const_cast<Identifier*>(directParent)->directChildren_.erase(this);
         for (const Identifier* child : this->children_)
             const_cast<Identifier*>(child)->parents_.remove(this);
@@ -184,12 +184,12 @@
 
             // initialize all parents
-            for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-                const_cast<Identifier*>(*it)->finishInitialization(); // initialize parent
+            for (const Identifier* parent : this->parents_)
+                const_cast<Identifier*>(parent)->finishInitialization(); // initialize parent
 
             // parents of parents are no direct parents of this identifier
             this->directParents_ = this->parents_;
-            for (std::list<const Identifier*>::const_iterator it_parent = this->parents_.begin(); it_parent != this->parents_.end(); ++it_parent)
-                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
-                    this->directParents_.remove(*it_parent_parent);
+            for (const Identifier* parent : this->parents_)
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->directParents_.remove(parent_parent);
 
             this->verifyIdentifierTrace();
@@ -200,7 +200,7 @@
 
             // initialize all direct parents
-            for (std::list<const InheritsFrom*>::const_iterator it = this->manualDirectParents_.begin(); it != this->manualDirectParents_.end(); ++it)
+            for (const InheritsFrom* manualDirectParent : this->manualDirectParents_)
             {
-                Identifier* directParent = (*it)->getParent();
+                Identifier* directParent = manualDirectParent->getParent();
                 this->directParents_.push_back(directParent);
                 directParent->finishInitialization(); // initialize parent
@@ -208,9 +208,9 @@
 
             // direct parents and their parents are also parents of this identifier (but only add them once)
-            for (std::list<const Identifier*>::const_iterator it_parent = this->directParents_.begin(); it_parent != this->directParents_.end(); ++it_parent)
+            for (const Identifier* parent : this->directParents_)
             {
-                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(*it_parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(*it_parent)->parents_.end(); ++it_parent_parent)
-                    this->addIfNotExists(this->parents_, *it_parent_parent);
-                this->addIfNotExists(this->parents_, *it_parent);
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->addIfNotExists(this->parents_, parent_parent);
+                this->addIfNotExists(this->parents_, parent);
             }
         }
@@ -224,14 +224,14 @@
 
         // tell all parents that this identifier is a child
-        for (std::list<const Identifier*>::const_iterator it = this->parents_.begin(); it != this->parents_.end(); ++it)
-            const_cast<Identifier*>(*it)->children_.insert(this);
+        for (const Identifier* parent : this->parents_)
+            const_cast<Identifier*>(parent)->children_.insert(this);
 
         // tell all direct parents that this identifier is a direct child
-        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
-        {
-            const_cast<Identifier*>(*it)->directChildren_.insert(this);
+        for (const Identifier* directChild : this->directParents_)
+        {
+            const_cast<Identifier*>(directChild)->directChildren_.insert(this);
 
             // Create the super-function dependencies
-            (*it)->createSuperFunctionCaller();
+            directChild->createSuperFunctionCaller();
         }
 
@@ -265,6 +265,6 @@
             if (parent->isVirtualBase())
             {
-                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);
+                for (const Identifier* parent_parent : const_cast<Identifier*>(parent)->parents_)
+                    this->addIfNotExists(expectedIdentifierTrace, parent_parent);
                 this->addIfNotExists(expectedIdentifierTrace, parent);
             }
@@ -274,6 +274,6 @@
         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);
+            for (const Identifier* parent_parent : const_cast<Identifier*>(directParent)->parents_)
+                this->addIfNotExists(expectedIdentifierTrace, parent_parent);
             this->addIfNotExists(expectedIdentifierTrace, directParent);
         }
@@ -290,6 +290,6 @@
 
             orxout(internal_warning) << "  Expected trace (according to class hierarchy definitions):" << endl << "    ";
-            for (std::list<const Identifier*>::const_iterator it_parent = expectedIdentifierTrace.begin(); it_parent != expectedIdentifierTrace.end(); ++it_parent)
-                orxout(internal_warning) << " " << (*it_parent)->getName();
+            for (const Identifier* parent : expectedIdentifierTrace)
+                orxout(internal_warning) << " " << parent->getName();
             orxout(internal_warning) << endl;
 
Index: code/branches/cpp11_v2/src/libraries/core/class/Identifier.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/class/Identifier.h	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/class/Identifier.h	(revision 10919)
@@ -458,6 +458,6 @@
             return;
 
-        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
-            this->setConfigValues(*it, *it);
+        for (T* object : ObjectList<T>())
+            this->setConfigValues(object, object);
 
         if (updateChildren)
Index: code/branches/cpp11_v2/src/libraries/core/class/Super.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/class/Super.h	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/class/Super.h	(revision 10919)
@@ -103,20 +103,20 @@
             { \
                 ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier(); \
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it) \
+                for (const Identifier* child : identifier->getDirectChildren()) \
                 { \
-                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
+                    if (((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_) \
                     { \
-                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_; \
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = nullptr; \
-                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
+                        delete ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_; \
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = nullptr; \
+                        ((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
                     } \
                     \
-                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
+                    if (!((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_) \
                     { \
-                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << endl; \
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
+                        orxout(verbose, context::super) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)child)->getName() << endl; \
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
                     } \
-                    else if (((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier()) \
-                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)(*it))->getName() << " calls function of " << ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl; \
+                    else if (((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier()) \
+                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)child)->getName() << " calls function of " << ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl; \
                 } \
             } \
@@ -171,26 +171,26 @@
 
                 // Iterate through all children
-                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildren().begin(); it != identifier->getDirectChildren().end(); ++it)
+                for (const Identifier* child : identifier->getDirectChildren())
                 {
                     // Check if the caller is a fallback-caller
-                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
+                    if (((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_)
                     {
                         // Delete the fallback caller an prepare to get a real caller
-                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_;
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = nullptr;
-                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false;
+                        delete ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_;
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = nullptr;
+                        ((ClassIdentifier<T>*)child)->bSuperFunctionCaller_##functionname##_isFallback_ = false;
                     }
 
                     // Check if there's not already a caller
-                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
+                    if (!((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_)
                     {
                         // Add the SuperFunctionCaller
-                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << endl;
-                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
+                        orxout(verbose, context::super) << "adding functionpointer to " << ((ClassIdentifier<T>*)child)->getName() << endl;
+                        ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
                     }
 
                     // If there is already a caller, but for another parent, print a warning
-                    else if (((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier())
-                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)(*it))->getName() << " calls function of " << ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl;
+                    else if (((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier() != ClassIdentifier<T>::getIdentifier())
+                        orxout(internal_warning, context::super) << "SuperFunctionCaller for " << #functionname << " in " << ((ClassIdentifier<T>*)child)->getName() << " calls function of " << ((ClassIdentifier<T>*)child)->superFunctionCaller_##functionname##_->getParentIdentifier()->getName() << " but " << ClassIdentifier<T>::getIdentifier()->getName() << " is also possible (do you use multiple inheritance?)" << endl;
                 }
             }
Index: code/branches/cpp11_v2/src/libraries/core/command/ArgumentCompletionFunctions.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 10919)
@@ -334,6 +334,6 @@
             ArgumentCompletionList threads;
 
-            for (std::list<unsigned int>::const_iterator it = threadnumbers.begin(); it != threadnumbers.end(); ++it)
-                threads.emplace_back(multi_cast<std::string>(*it));
+            for (unsigned int threadnumber : threadnumbers)
+                threads.emplace_back(multi_cast<std::string>(threadnumber));
 
             return threads;
Index: code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc	(revision 10919)
@@ -328,11 +328,11 @@
 
         // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
-        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;
+        for (const auto& mapEntryGroup : ConsoleCommandManager::getInstance().getCommandsLC())
+        {
+            if (mapEntryGroup.first != "")
+            {
+                for (const auto& mapEntryName : mapEntryGroup.second)
+                {
+                    std::string command = mapEntryGroup.first + " " + mapEntryName.first;
                     unsigned int distance = getLevenshteinDistance(command, token0_LC + " " + token1_LC);
                     if (distance < nearestDistance)
Index: code/branches/cpp11_v2/src/libraries/core/command/TclThreadManager.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/command/TclThreadManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/command/TclThreadManager.cc	(revision 10919)
@@ -145,10 +145,10 @@
             {
                 boost::shared_lock<boost::shared_mutex> lock(*this->interpreterBundlesMutex_);
-                for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
+                for (const auto& mapEntry : this->interpreterBundles_)
                 {
-                    if (it->first == 0)
+                    if (mapEntry.first == 0)
                         continue; // We'll handle the default interpreter later (and without threads of course)
 
-                    TclInterpreterBundle* bundle = it->second;
+                    TclInterpreterBundle* bundle = mapEntry.second;
                     if (!bundle->queue_.empty())
                     {
Index: code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc	(revision 10919)
@@ -110,11 +110,10 @@
             {
                 // first shove all the shortcuts in a map
-                for (std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
-                    it != cmdLineArgs_.end(); ++it)
+                for (const auto& mapEntry : cmdLineArgs_)
                 {
-                    OrxAssert(cmdLineArgsShortcut_.find(it->second->getShortcut()) == cmdLineArgsShortcut_.end(),
+                    OrxAssert(cmdLineArgsShortcut_.find(mapEntry.second->getShortcut()) == cmdLineArgsShortcut_.end(),
                         "Cannot have two command line shortcut with the same name.");
-                    if (!it->second->getShortcut().empty())
-                        cmdLineArgsShortcut_[it->second->getShortcut()] = it->second;
+                    if (!mapEntry.second->getShortcut().empty())
+                        cmdLineArgsShortcut_[mapEntry.second->getShortcut()] = mapEntry.second;
                 }
                 bFirstTimeParse_ = false;
@@ -257,8 +256,7 @@
         // determine maximum name size
         size_t maxNameSize = 0;
-        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
-            it != inst.cmdLineArgs_.end(); ++it)
-        {
-            maxNameSize = std::max(it->second->getName().size(), maxNameSize);
+        for (const auto& mapEntry : inst.cmdLineArgs_)
+        {
+            maxNameSize = std::max(mapEntry.second->getName().size(), maxNameSize);
         }
 
@@ -267,19 +265,18 @@
         infoStr << "Available options:" << endl;
 
-        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst.cmdLineArgs_.begin();
-            it != inst.cmdLineArgs_.end(); ++it)
-        {
-            if (!it->second->getShortcut().empty())
-                infoStr << " [-" << it->second->getShortcut() << "] ";
+        for (const auto& mapEntry : inst.cmdLineArgs_)
+        {
+            if (!mapEntry.second->getShortcut().empty())
+                infoStr << " [-" << mapEntry.second->getShortcut() << "] ";
             else
                 infoStr << "      ";
-            infoStr << "--" << it->second->getName() << ' ';
-            if (it->second->getValue().isType<bool>())
+            infoStr << "--" << mapEntry.second->getName() << ' ';
+            if (mapEntry.second->getValue().isType<bool>())
                 infoStr << "    ";
             else
                 infoStr << "ARG ";
             // fill with the necessary amount of blanks
-            infoStr << std::string(maxNameSize - it->second->getName().size(), ' ');
-            infoStr << ": " << it->second->getInformation();
+            infoStr << std::string(maxNameSize - mapEntry.second->getName().size(), ' ');
+            infoStr << ": " << mapEntry.second->getInformation();
             infoStr << endl;
         }
Index: code/branches/cpp11_v2/src/libraries/core/config/SettingsConfigFile.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/config/SettingsConfigFile.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/config/SettingsConfigFile.cc	(revision 10919)
@@ -142,8 +142,8 @@
         // todo: can this be done more efficiently? looks like some identifiers will be updated multiple times.
 
-        for (ContainerMap::const_iterator it = this->containers_.begin(); it != this->containers_.end(); ++it)
-        {
-            it->second.second->update();
-            it->second.second->getIdentifier()->updateConfigValues();
+        for (const auto& mapEntry : this->containers_)
+        {
+            mapEntry.second.second->update();
+            mapEntry.second.second->getIdentifier()->updateConfigValues();
         }
     }
Index: code/branches/cpp11_v2/src/libraries/core/input/InputBuffer.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/input/InputBuffer.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/input/InputBuffer.cc	(revision 10919)
@@ -75,7 +75,6 @@
     InputBuffer::~InputBuffer()
     {
-        for (std::list<BaseInputBufferListenerTuple*>::const_iterator it = this->listeners_.begin();
-            it != this->listeners_.end(); ++it)
-            delete *it;
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+            delete listener;
     }
 
Index: code/branches/cpp11_v2/src/libraries/core/input/InputManager.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/input/InputManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/input/InputManager.cc	(revision 10919)
@@ -531,8 +531,7 @@
             {
                 // Make sure we don't add two high priority states with the same priority
-                for (std::map<std::string, InputState*>::const_iterator it = this->statesByName_.begin();
-                    it != this->statesByName_.end(); ++it)
+                for (const auto& mapEntry : this->statesByName_)
                 {
-                    if (it->second->getPriority() == priority)
+                    if (mapEntry.second->getPriority() == priority)
                     {
                         orxout(internal_warning, context::input) << "Could not add an InputState with the same priority '"
Index: code/branches/cpp11_v2/src/libraries/core/input/JoyStickQuantityListener.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/input/JoyStickQuantityListener.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/input/JoyStickQuantityListener.cc	(revision 10919)
@@ -47,6 +47,6 @@
     {
         joyStickList_s = joyStickList;
-        for (ObjectList<JoyStickQuantityListener>::iterator it = ObjectList<JoyStickQuantityListener>::begin(); it; ++it)
-            it->JoyStickQuantityChanged(joyStickList);
+        for (JoyStickQuantityListener* listener : ObjectList<JoyStickQuantityListener>())
+            listener->JoyStickQuantityChanged(joyStickList);
     }
 }
Index: code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc	(revision 10919)
@@ -274,8 +274,8 @@
 
         // Parse bindings and create the ConfigValueContainers if necessary
-        for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
-        {
-            it->second->readBinding(this->configFile_, this->fallbackConfigFile_);
-            addButtonToCommand(it->second->bindingString_, it->second);
+        for (const auto& mapEntry : allButtons_)
+        {
+            mapEntry.second->readBinding(this->configFile_, this->fallbackConfigFile_);
+            addButtonToCommand(mapEntry.second->bindingString_, mapEntry.second);
         }
 
@@ -380,6 +380,6 @@
     void KeyBinder::clearBindings()
     {
-        for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
-            it->second->clear();
+        for (const auto& mapEntry : allButtons_)
+            mapEntry.second->clear();
 
         for (BufferedParamCommand* command : paramCommandBuffer_)
Index: code/branches/cpp11_v2/src/libraries/core/input/KeyBinderManager.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/input/KeyBinderManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/input/KeyBinderManager.cc	(revision 10919)
@@ -76,6 +76,6 @@
     {
         // Delete all remaining KeyBinders
-        for (std::map<std::string, KeyBinder*>::const_iterator it = this->binders_.begin(); it != this->binders_.end(); ++it)
-            delete it->second;
+        for (const auto& mapEntry : this->binders_)
+            delete mapEntry.second;
 
         // Reset console commands
Index: code/branches/cpp11_v2/src/libraries/core/input/KeyDetector.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/input/KeyDetector.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/input/KeyDetector.cc	(revision 10919)
@@ -70,6 +70,6 @@
     {
         // Assign every button/axis the same command, but with its name as argument
-        for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
-            it->second->parse(__CC_KeyDetector_callback_name + ' ' + it->second->groupName_ + "." + it->second->name_);
+        for (const auto& mapEntry : allButtons_)
+            mapEntry.second->parse(__CC_KeyDetector_callback_name + ' ' + mapEntry.second->groupName_ + "." + mapEntry.second->name_);
     }
 
Index: code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.cc	(revision 10919)
@@ -76,6 +76,6 @@
         this->staticallyInitializedInstancesByType_.clear();
         for (const auto& mapEntry : copy)
-            for (std::set<StaticallyInitializedInstance*>::iterator it2 = mapEntry.second.begin(); it2 != mapEntry.second.end(); ++it2)
-                delete (*it2);
+            for (StaticallyInitializedInstance* instance : mapEntry.second)
+                delete instance;
     }
 
Index: code/branches/cpp11_v2/src/libraries/network/Client.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/Client.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/Client.cc	(revision 10919)
@@ -161,8 +161,7 @@
         {
           std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-          std::vector<packet::Gamestate*>::iterator it;
-          for( it = gamestates.begin(); it != gamestates.end(); ++it )
+          for( packet::Gamestate* gamestate : gamestates )
           {
-            (*it)->send( static_cast<Host*>(this) );
+            gamestate->send( static_cast<Host*>(this) );
           }
         }
Index: code/branches/cpp11_v2/src/libraries/network/ClientConnectionListener.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/ClientConnectionListener.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/ClientConnectionListener.cc	(revision 10919)
@@ -44,12 +44,12 @@
     void ClientConnectionListener::broadcastClientConnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientConnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientConnected(clientID);
     }
 
     void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientDisconnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientDisconnected(clientID);
     }
 
Index: code/branches/cpp11_v2/src/libraries/network/Connection.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/Connection.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/Connection.cc	(revision 10919)
@@ -237,8 +237,7 @@
   void Connection::disconnectPeersInternal()
   {
-    std::map<uint32_t, ENetPeer*>::iterator it;
-    for( it=this->peerMap_.begin(); it!=this->peerMap_.end(); ++it )
-    {
-      enet_peer_disconnect(it->second, 0);
+    for( const auto& mapEntry : this->peerMap_ )
+    {
+      enet_peer_disconnect(mapEntry.second, 0);
     }
     uint32_t iterations = NETWORK_DISCONNECT_TIMEOUT/NETWORK_WAIT_TIMEOUT;
Index: code/branches/cpp11_v2/src/libraries/network/FunctionCallManager.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/FunctionCallManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/FunctionCallManager.cc	(revision 10919)
@@ -54,9 +54,8 @@
 void FunctionCallManager::sendCalls(orxonox::Host* host)
 {
-  std::map<uint32_t, packet::FunctionCalls*>::iterator it;
-  for (it = FunctionCallManager::sPeerMap_.begin(); it != FunctionCallManager::sPeerMap_.end(); ++it )
+  for (const auto& mapEntry : FunctionCallManager::sPeerMap_ )
   {
     assert(!FunctionCallManager::sPeerMap_.empty());
-    it->second->send(host);
+    mapEntry.second->send(host);
   }
   FunctionCallManager::sPeerMap_.clear();
Index: code/branches/cpp11_v2/src/libraries/network/GamestateManager.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/GamestateManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/GamestateManager.cc	(revision 10919)
@@ -70,13 +70,11 @@
   {
     if( this->currentGamestate_ )
-        delete this->currentGamestate_;std::map<unsigned int, packet::Gamestate*>::iterator it;
-    for( it = gamestateQueue.begin(); it != gamestateQueue.end(); ++it )
-      delete it->second;
-    std::map<uint32_t, peerInfo>::iterator peerIt;
-    std::map<uint32_t, packet::Gamestate*>::iterator gamestateIt;
-    for( peerIt = peerMap_.begin(); peerIt != peerMap_.end(); ++peerIt )
-    {
-      for( gamestateIt = peerIt->second.gamestates.begin(); gamestateIt != peerIt->second.gamestates.end(); ++gamestateIt )
-        delete gamestateIt->second;
+        delete this->currentGamestate_;
+    for( const auto& mapEntry : gamestateQueue )
+      delete mapEntry.second;
+    for( const auto& mapEntryPeer : peerMap_ )
+    {
+      for( const auto& mapEntryGamestate : mapEntryPeer.second.gamestates )
+        delete mapEntryGamestate.second;
     }
 //     this->trafficControl_->destroy();
@@ -107,11 +105,10 @@
     if( this->gamestateQueue.empty() )
         return true;
-    std::map<unsigned int, packet::Gamestate*>::iterator it;
     // now push only the most recent gamestates we received (ignore obsolete ones)
-    for(it = gamestateQueue.begin(); it!=gamestateQueue.end(); it++)
-    {
-      OrxVerify(processGamestate(it->second), "ERROR: could not process Gamestate");
-      sendAck( it->second->getID(), it->second->getPeerID() );
-      delete it->second;
+    for(const auto& mapEntry : gamestateQueue)
+    {
+      OrxVerify(processGamestate(mapEntry.second), "ERROR: could not process Gamestate");
+      sendAck( mapEntry.second->getID(), mapEntry.second->getPeerID() );
+      delete mapEntry.second;
     }
     // now clear the queue
@@ -177,17 +174,16 @@
     std::vector<packet::Gamestate*> peerGamestates;
     
-    std::map<uint32_t, peerInfo>::iterator peerIt;
-    for( peerIt=peerMap_.begin(); peerIt!=peerMap_.end(); ++peerIt )
-    {
-      if( !peerIt->second.isSynched )
+    for( const auto& mapEntry : peerMap_ )
+    {
+      if( !mapEntry.second.isSynched )
       {
         orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
         continue;
       }
-      orxout(verbose_more, context::network) << "client id: " << peerIt->first << endl;
+      orxout(verbose_more, context::network) << "client id: " << mapEntry.first << endl;
       orxout(verbose_more, context::network) << "Server: doing gamestate gamestate preparation" << endl;
-      int peerID = peerIt->first; //get client id
-
-      unsigned int lastAckedGamestateID = peerIt->second.lastAckedGamestateID;
+      int peerID = mapEntry.first; //get client id
+
+      unsigned int lastAckedGamestateID = mapEntry.second.lastAckedGamestateID;
 
       packet::Gamestate* baseGamestate=nullptr;
@@ -340,8 +336,7 @@
   {
     assert(peerMap_.find(peerID)!=peerMap_.end());
-    std::map<uint32_t, packet::Gamestate*>::iterator peerIt;
-    for( peerIt = peerMap_[peerID].gamestates.begin(); peerIt!=peerMap_[peerID].gamestates.end(); ++peerIt )
-    {
-      delete peerIt->second;
+    for( const auto& mapEntry : peerMap_[peerID].gamestates )
+    {
+      delete mapEntry.second;
     }
     peerMap_.erase(peerMap_.find(peerID));
Index: code/branches/cpp11_v2/src/libraries/network/Host.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/Host.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/Host.cc	(revision 10919)
@@ -107,6 +107,6 @@
   void Host::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for (ObjectList<NetworkChatListener>::iterator it = ObjectList<NetworkChatListener>::begin(); it != ObjectList<NetworkChatListener>::end(); ++it)
-      it->incomingChat(message, sourceID);
+    for (NetworkChatListener* listener : ObjectList<NetworkChatListener>())
+      listener->incomingChat(message, sourceID);
   }
 
Index: code/branches/cpp11_v2/src/libraries/network/MasterServer.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/MasterServer.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/MasterServer.cc	(revision 10919)
@@ -49,15 +49,11 @@
   MasterServer::listServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* print list header */
     orxout(user_info) << "List of connected servers" << std::endl;
 
     /* loop through list elements */
-    for( i = MasterServer::getInstance()->mainlist.serverlist.begin();
-      i != MasterServer::getInstance()->mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : MasterServer::getInstance()->mainlist.serverlist )
     {
-      orxout(user_info) << "  " << (*i).ServerInfo.getServerIP() << std::endl;
+      orxout(user_info) << "  " << elem.ServerInfo.getServerIP() << std::endl;
     }
 
@@ -112,17 +108,13 @@
   MasterServer::helper_sendlist( ENetEvent *event )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* packet holder */
     ENetPacket *reply;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     {
       /* send this particular server */
       /* build reply string */
-      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + (*i).ServerInfo.getServerIP().length() + 1 + (*i).ServerInfo.getServerName().length() + 1 + sizeof((*i).ServerInfo.getClientNumber()) + 1;
+      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + elem.ServerInfo.getServerIP().length() + 1 + elem.ServerInfo.getServerName().length() + 1 + sizeof(elem.ServerInfo.getClientNumber()) + 1;
       char *tosend = (char *)calloc(packetlen ,1 );
       if( !tosend )
@@ -131,5 +123,5 @@
       }
       sprintf( tosend, "%s %s %s %u", MSPROTO_SERVERLIST_ITEM,
-          (*i).ServerInfo.getServerIP().c_str(), (*i).ServerInfo.getServerName().c_str(), (*i).ServerInfo.getClientNumber());
+          elem.ServerInfo.getServerIP().c_str(), elem.ServerInfo.getServerName().c_str(), elem.ServerInfo.getClientNumber());
 
       /* create packet from it */
@@ -167,21 +159,17 @@
   MasterServer::helper_cleanupServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     if( mainlist.serverlist.size() == 0 )
       return;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     { /* see if we have a disconnected peer */
-      if( (*i).peer &&
-         ((*i).peer->state == ENET_PEER_STATE_DISCONNECTED ||
-          (*i).peer->state == ENET_PEER_STATE_ZOMBIE ))
+      if( elem.peer &&
+         (elem.peer->state == ENET_PEER_STATE_DISCONNECTED ||
+          elem.peer->state == ENET_PEER_STATE_ZOMBIE ))
       {
         /* Remove it from the list */
-        orxout(internal_warning) << (char*)(*i).peer->data << " timed out.\n";
-        mainlist.delServerByName( (*i).ServerInfo.getServerName() );
+        orxout(internal_warning) << (char*)elem.peer->data << " timed out.\n";
+        mainlist.delServerByName( elem.ServerInfo.getServerName() );
 
         /* stop iterating, we manipulated the list */
Index: code/branches/cpp11_v2/src/libraries/network/PeerList.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/PeerList.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/PeerList.cc	(revision 10919)
@@ -65,12 +65,10 @@
   bool
   PeerList::remPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
       { /* found this name, remove and quit */
-        this->peerlist.remove( *i );
+        this->peerlist.remove( peer );
         return true;
       }
@@ -82,12 +80,10 @@
   ENetPeer *
   PeerList::findPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
         /* found this name, remove and quit */
-        return *i;
+        return peer;
 
     /* not found */
Index: code/branches/cpp11_v2/src/libraries/network/Server.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/Server.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/Server.cc	(revision 10919)
@@ -232,8 +232,7 @@
   {
     std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-    std::vector<packet::Gamestate*>::iterator it;
-    for( it = gamestates.begin(); it != gamestates.end(); ++it )
+    for( packet::Gamestate* gamestate : gamestates )
     {
-      (*it)->send(static_cast<Host*>(this));
+      gamestate->send(static_cast<Host*>(this));
     }
     return true;
@@ -434,7 +433,6 @@
       return true;
 
-    std::vector<uint32_t>::iterator it;
-    for( it=this->clientIDs_.begin(); it!=this->clientIDs_.end(); ++it )
-      if( *it == targetID )
+    for( uint32_t id : this->clientIDs_ )
+      if( id == targetID )
         return true;
 
Index: code/branches/cpp11_v2/src/libraries/network/packet/ClassID.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/packet/ClassID.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/packet/ClassID.cc	(revision 10919)
@@ -55,7 +55,6 @@
 
   //calculate total needed size (for all strings and integers)
-  std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getInstance().getIdentifierByStringMap().begin();
-  for(;it != IdentifierManager::getInstance().getIdentifierByStringMap().end();++it){
-    id = it->second;
+  for(const auto& mapEntry : IdentifierManager::getInstance().getIdentifierByStringMap()){
+    id = mapEntry.second;
     if(id == nullptr || !id->hasFactory())
       continue;
Index: code/branches/cpp11_v2/src/libraries/network/packet/Gamestate.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/packet/Gamestate.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/packet/Gamestate.cc	(revision 10919)
@@ -213,14 +213,13 @@
   {
     std::list<uint32_t> v1;
-    ObjectList<Synchronisable>::iterator it;
-    for (it = ObjectList<Synchronisable>::begin(); it != ObjectList<Synchronisable>::end(); ++it)
-    {
-      if (it->getObjectID() == OBJECTID_UNKNOWN)
-      {
-        if (it->objectMode_ != 0x0)
+    for (Synchronisable* synchronisable : ObjectList<Synchronisable>())
+    {
+      if (synchronisable->getObjectID() == OBJECTID_UNKNOWN)
+      {
+        if (synchronisable->objectMode_ != 0x0)
         {
           orxout(user_error, context::packets) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << endl;
           orxout(user_error, context::packets) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << endl;
-          orxout(user_error, context::packets) << "Objects class: " << it->getIdentifier()->getName() << endl;
+          orxout(user_error, context::packets) << "Objects class: " << synchronisable->getIdentifier()->getName() << endl;
           assert(false);
         }
@@ -228,8 +227,7 @@
       else
       {
-        std::list<uint32_t>::iterator it2;
-        for (it2 = v1.begin(); it2 != v1.end(); ++it2)
+        for (uint32_t id : v1)
         {
-          if (it->getObjectID() == *it2)
+          if (synchronisable->getObjectID() == id)
           {
             orxout(user_error, context::packets) << "Found duplicate objectIDs on the client!" << endl
@@ -239,5 +237,5 @@
           }
         }
-        v1.push_back(it->getObjectID());
+        v1.push_back(synchronisable->getObjectID());
       }
     }
@@ -762,10 +760,8 @@
   uint32_t size = 0;
   uint32_t nrOfVariables = 0;
-    // get the start of the Synchronisable list
-  ObjectList<Synchronisable>::iterator it;
     // get total size of gamestate
-  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
-    size+=it->getSize(id, mode); // size of the actual data of the synchronisable
-    nrOfVariables += it->getNrOfVariables();
+  for(Synchronisable* synchronisable : ObjectList<Synchronisable>()){
+    size+=synchronisable->getSize(id, mode); // size of the actual data of the synchronisable
+    nrOfVariables += synchronisable->getNrOfVariables();
   }
 //   orxout() << "allocating " << nrOfVariables << " ints" << endl;
Index: code/branches/cpp11_v2/src/libraries/network/packet/ServerInformation.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/packet/ServerInformation.h	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/packet/ServerInformation.h	(revision 10919)
@@ -50,10 +50,10 @@
         void          send( ENetPeer* peer );
         void          setServerName(std::string name) { this->serverName_ = name; }
-        std::string   getServerName() { return this->serverName_; }
+        std::string   getServerName() const { return this->serverName_; }
         void          setServerIP( std::string IP ) { this->serverIP_ = IP; }
-        std::string   getServerIP() { return this->serverIP_; }
+        std::string   getServerIP() const { return this->serverIP_; }
         void          setClientNumber( int clientNumber ) { this->clientNumber_ = clientNumber; }
-        int           getClientNumber() { return this->clientNumber_; }
-        uint32_t      getServerRTT() { return this->serverRTT_; }
+        int           getClientNumber() const { return this->clientNumber_; }
+        uint32_t      getServerRTT() const { return this->serverRTT_; }
 
       private:
Index: code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc	(revision 10919)
@@ -266,5 +266,4 @@
     assert(this->classID_==this->getIdentifier()->getNetworkID());
     assert(this->objectID_!=OBJECTID_UNKNOWN);
-    std::vector<SynchronisableVariableBase*>::iterator i;
 
     // start copy header
@@ -276,7 +275,7 @@
 //     orxout(verbose, context::network) << "objectid: " << this->objectID_ << ":";
     // copy to location
-    for(i=syncList_.begin(); i!=syncList_.end(); ++i)
-    {
-      uint32_t varsize = (*i)->getData( mem, mode );
+    for(SynchronisableVariableBase* variable : syncList_)
+    {
+      uint32_t varsize = variable->getData( mem, mode );
 //       orxout(verbose, context::network) << " " << varsize;
       tempsize += varsize;
@@ -348,9 +347,8 @@
       assert( this->getContextID() == syncHeader2.getContextID() );
       mem += SynchronisableHeader::getSize();
-      std::vector<SynchronisableVariableBase *>::iterator i;
-      for(i=syncList_.begin(); i!=syncList_.end(); ++i)
+      for(SynchronisableVariableBase* variable : syncList_)
       {
         assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream
-        (*i)->putData( mem, mode, forceCallback );
+        variable->putData( mem, mode, forceCallback );
       }
       assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeader::getSize() );
@@ -388,8 +386,7 @@
     assert( mode==state_ );
     tsize += this->dataSize_;
-    std::vector<SynchronisableVariableBase*>::iterator i;
-    for(i=stringList_.begin(); i!=stringList_.end(); ++i)
-    {
-      tsize += (*i)->getSize( mode );
+    for(SynchronisableVariableBase* variable : stringList_)
+    {
+      tsize += variable->getSize( mode );
     }
     return tsize;
Index: code/branches/cpp11_v2/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc
===================================================================
--- code/branches/cpp11_v2/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc	(revision 10919)
@@ -60,6 +60,6 @@
         float oldFactor = TimeFactorListener::timefactor_s;
         TimeFactorListener::timefactor_s = factor;
-        for (ObjectList<TimeFactorListener>::iterator it = ObjectList<TimeFactorListener>::begin(); it != ObjectList<TimeFactorListener>::end(); ++it)
-            it->changedTimeFactor(factor, oldFactor);
+        for (TimeFactorListener* listener : ObjectList<TimeFactorListener>())
+            listener->changedTimeFactor(factor, oldFactor);
     }
 
Index: code/branches/cpp11_v2/src/libraries/util/Serialise.h
===================================================================
--- code/branches/cpp11_v2/src/libraries/util/Serialise.h	(revision 10918)
+++ code/branches/cpp11_v2/src/libraries/util/Serialise.h	(revision 10919)
@@ -679,8 +679,7 @@
     template <class T> inline void saveAndIncrease(  const std::set<T>& variable, uint8_t*& mem )
     {
-        typename std::set<T>::const_iterator it = variable.begin();
         saveAndIncrease( (uint32_t)variable.size(), mem );
-        for( ; it!=variable.end(); ++it )
-            saveAndIncrease( *it, mem );
+        for( const T& elem : variable )
+            saveAndIncrease( elem, mem );
     }
 
Index: code/branches/cpp11_v2/src/modules/docking/Dock.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/docking/Dock.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/docking/Dock.cc	(revision 10919)
@@ -214,7 +214,7 @@
     {
         PlayerInfo* player = HumanController::getLocalControllerSingleton()->getPlayer();
-        for(ObjectList<Dock>::iterator it = ObjectList<Dock>::begin(); it != ObjectList<Dock>::end(); ++it)
-        {
-            if(it->dock(player))
+        for(Dock* dock : ObjectList<Dock>())
+        {
+            if(dock->dock(player))
                 break;
         }
@@ -224,7 +224,7 @@
     {
         PlayerInfo* player = HumanController::getLocalControllerSingleton()->getPlayer();
-        for(ObjectList<Dock>::iterator it = ObjectList<Dock>::begin(); it != ObjectList<Dock>::end(); ++it)
-        {
-            if(it->undock(player))
+        for(Dock* dock : ObjectList<Dock>())
+        {
+            if(dock->undock(player))
                 break;
         }
@@ -295,7 +295,7 @@
         int i = 0;
         PlayerInfo* player = HumanController::getLocalControllerSingleton()->getPlayer();
-        for(ObjectList<Dock>::iterator it = ObjectList<Dock>::begin(); it != ObjectList<Dock>::end(); ++it)
-        {
-            if(it->candidates_.find(player) != it->candidates_.end())
+        for(Dock* dock : ObjectList<Dock>())
+        {
+            if(dock->candidates_.find(player) != dock->candidates_.end())
                 i++;
         }
@@ -306,10 +306,10 @@
     {
         PlayerInfo* player = HumanController::getLocalControllerSingleton()->getPlayer();
-        for(ObjectList<Dock>::iterator it = ObjectList<Dock>::begin(); it != ObjectList<Dock>::end(); ++it)
-        {
-            if(it->candidates_.find(player) != it->candidates_.end())
+        for(Dock* dock : ObjectList<Dock>())
+        {
+            if(dock->candidates_.find(player) != dock->candidates_.end())
             {
                 if(index == 0)
-                    return *it;
+                    return dock;
                 index--;
             }
Index: code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc	(revision 10919)
@@ -65,8 +65,8 @@
 
     DockingTarget *DockingEffect::findTarget(std::string name) {
-        for (ObjectList<DockingTarget>::iterator it = ObjectList<DockingTarget>::begin(); it != ObjectList<DockingTarget>::end(); ++it)
+        for (DockingTarget* target : ObjectList<DockingTarget>())
         {
-            if ((*it)->getName().compare(name) == 0)
-                return (*it);
+            if (target->getName().compare(name) == 0)
+                return target;
         }
         return nullptr;
Index: code/branches/cpp11_v2/src/modules/dodgerace/DodgeRace.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/dodgerace/DodgeRace.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/dodgerace/DodgeRace.cc	(revision 10919)
@@ -136,7 +136,7 @@
         if (player == nullptr)
         {
-            for (ObjectList<DodgeRaceShip>::iterator it = ObjectList<DodgeRaceShip>::begin(); it != ObjectList<DodgeRaceShip>::end(); ++it)
-            {
-                player = *it;
+            for (DodgeRaceShip* ship : ObjectList<DodgeRaceShip>())
+            {
+                player = ship;
             }
         }
Index: code/branches/cpp11_v2/src/modules/dodgerace/DodgeRaceShip.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/dodgerace/DodgeRaceShip.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/dodgerace/DodgeRaceShip.cc	(revision 10919)
@@ -154,7 +154,7 @@
         if (game == nullptr)
         {
-            for (ObjectList<DodgeRace>::iterator it = ObjectList<DodgeRace>::begin(); it != ObjectList<DodgeRace>::end(); ++it)
+            for (DodgeRace* race : ObjectList<DodgeRace>())
             {
-                game = *it;
+                game = race;
             }
         }
Index: code/branches/cpp11_v2/src/modules/gametypes/SpaceRace.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/gametypes/SpaceRace.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/gametypes/SpaceRace.cc	(revision 10919)
@@ -88,6 +88,6 @@
             this->cantMove_ = true;
 
-            for (ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it)
-                it->setActive(false);
+            for (Engine* engine : ObjectList<Engine>())
+                engine->setActive(false);
         }
 
@@ -95,6 +95,6 @@
         if (!this->isStartCountdownRunning() && this->cantMove_)
         {
-            for (ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it)
-                it->setActive(true);
+            for (Engine* engine : ObjectList<Engine>())
+                engine->setActive(true);
 
             this->cantMove_= false;
Index: code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc	(revision 10919)
@@ -61,8 +61,8 @@
         if (ObjectList<SpaceRaceManager>::size() != 1)
             orxout(internal_warning) << "Expected 1 instance of SpaceRaceManager but found " << ObjectList<SpaceRaceManager>::size() << endl;
-        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it != ObjectList<SpaceRaceManager>::end(); ++it)
-        {
-            checkpoints = it->getAllCheckpoints();
-            nextRaceCheckpoint_ = it->findCheckpoint(0);
+        for (SpaceRaceManager* manager : ObjectList<SpaceRaceManager>())
+        {
+            checkpoints = manager->getAllCheckpoints();
+            nextRaceCheckpoint_ = manager->findCheckpoint(0);
         }
 
@@ -187,15 +187,15 @@
         {
             int numberOfWays = 0; // counts number of ways from this Point to the last point
-            for (std::set<int>::iterator it = currentCheckpoint->getNextCheckpoints().begin(); it!= currentCheckpoint->getNextCheckpoints().end(); ++it)
-            {
-                if (currentCheckpoint == findCheckpoint(*it))
+            for (int checkpointIndex : currentCheckpoint->getNextCheckpoints())
+            {
+                if (currentCheckpoint == findCheckpoint(checkpointIndex))
                 {
                     //orxout() << currentCheckpoint->getCheckpointIndex()<<endl;
                     continue;
                 }
-                if (findCheckpoint(*it) == nullptr)
-                    orxout(internal_warning) << "Problematic Point: " << (*it) << endl;
+                if (findCheckpoint(checkpointIndex) == nullptr)
+                    orxout(internal_warning) << "Problematic Point: " << checkpointIndex << endl;
                 else
-                    numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(*it), zaehler);
+                    numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(checkpointIndex), zaehler);
             }
             zaehler[currentCheckpoint] += numberOfWays;
@@ -255,9 +255,9 @@
         {
             float minimum = std::numeric_limits<float>::max();
-            for (std::set<int>::iterator it = currentCheckPoint->getNextCheckpoints().begin(); it != currentCheckPoint->getNextCheckpoints().end(); ++it)
+            for (int checkpointIndex : currentCheckPoint->getNextCheckpoints())
             {
                 int dist_currentCheckPoint_currentPosition = static_cast<int> ((currentPosition- currentCheckPoint->getPosition()).length());
 
-                minimum = std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(*it), currentCheckPoint->getPosition()));
+                minimum = std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(checkpointIndex), currentCheckPoint->getPosition()));
                 // minimum of distanz from 'currentPosition' to the next static Checkpoint
             }
Index: code/branches/cpp11_v2/src/modules/invader/Invader.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/invader/Invader.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/invader/Invader.cc	(revision 10919)
@@ -98,6 +98,6 @@
         if (player == nullptr)
         {
-            for (ObjectList<InvaderShip>::iterator it = ObjectList<InvaderShip>::begin(); it != ObjectList<InvaderShip>::end(); ++it)
-                player = *it;
+            for (InvaderShip* ship : ObjectList<InvaderShip>())
+                player = ship;
         }
         return player;
Index: code/branches/cpp11_v2/src/modules/invader/InvaderEnemy.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/invader/InvaderEnemy.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/invader/InvaderEnemy.cc	(revision 10919)
@@ -75,6 +75,6 @@
         if (game == nullptr)
         {
-            for (ObjectList<Invader>::iterator it = ObjectList<Invader>::begin(); it != ObjectList<Invader>::end(); ++it)
-                game = *it;
+            for (Invader* invader : ObjectList<Invader>())
+                game = invader;
         }
         return game;
Index: code/branches/cpp11_v2/src/modules/invader/InvaderShip.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/invader/InvaderShip.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/invader/InvaderShip.cc	(revision 10919)
@@ -184,6 +184,6 @@
         if (game == nullptr)
         {
-            for (ObjectList<Invader>::iterator it = ObjectList<Invader>::begin(); it != ObjectList<Invader>::end(); ++it)
-                game = *it;
+            for (Invader* invader : ObjectList<Invader>())
+                game = invader;
         }
         return game;
Index: code/branches/cpp11_v2/src/modules/jump/JumpProjectile.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/jump/JumpProjectile.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/jump/JumpProjectile.cc	(revision 10919)
@@ -69,13 +69,13 @@
         Vector3 projectilePosition = getPosition();
 
-        for (ObjectList<JumpEnemy>::iterator it = ObjectList<JumpEnemy>::begin(); it != ObjectList<JumpEnemy>::end(); ++it)
+        for (JumpEnemy* enemy : ObjectList<JumpEnemy>())
         {
-            Vector3 enemyPosition = it->getPosition();
-            float enemyWidth = it->getWidth();
-            float enemyHeight = it->getHeight();
+            Vector3 enemyPosition = enemy->getPosition();
+            float enemyWidth = enemy->getWidth();
+            float enemyHeight = enemy->getHeight();
 
             if(projectilePosition.x > enemyPosition.x-enemyWidth && projectilePosition.x < enemyPosition.x+enemyWidth && projectilePosition.z > enemyPosition.z-enemyHeight && projectilePosition.z < enemyPosition.z+enemyHeight)
             {
-                it->dead_ = true;
+                enemy->dead_ = true;
             }
         }
Index: code/branches/cpp11_v2/src/modules/objects/Attacher.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/Attacher.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/Attacher.cc	(revision 10919)
@@ -101,10 +101,10 @@
             return;
 
-        for (ObjectList<WorldEntity>::iterator it = ObjectList<WorldEntity>::begin(); it != ObjectList<WorldEntity>::end(); ++it)
+        for (WorldEntity* worldEntity : ObjectList<WorldEntity>())
         {
-            if (it->getName() == this->targetname_)
+            if (worldEntity->getName() == this->targetname_)
             {
-                this->target_ = *it;
-                this->attachToParent(*it);
+                this->target_ = worldEntity;
+                this->attachToParent(worldEntity);
             }
         }
Index: code/branches/cpp11_v2/src/modules/objects/ForceField.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/ForceField.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/ForceField.cc	(revision 10919)
@@ -118,5 +118,5 @@
         {
             // Iterate over all objects that could possibly be affected by the ForceField.
-            for (ObjectList<MobileEntity>::iterator it = ObjectList<MobileEntity>::begin(); it != ObjectList<MobileEntity>::end(); ++it)
+            for (MobileEntity* mobileEntity : ObjectList<MobileEntity>())
             {
                 // The direction of the orientation of the force field.
@@ -125,5 +125,5 @@
 
                 // Vector from the center of the force field to the object its acting on.
-                Vector3 distanceVector = it->getWorldPosition() - (this->getWorldPosition() + (this->halfLength_ * direction));
+                Vector3 distanceVector = mobileEntity->getWorldPosition() - (this->getWorldPosition() + (this->halfLength_ * direction));
 
                 // The object is outside a ball around the center with radius length/2 of the ForceField.
@@ -132,5 +132,5 @@
 
                 // The distance of the object form the orientation vector. (Or rather the smallest distance from the orientation vector)
-                float distanceFromDirectionVector = ((it->getWorldPosition() - this->getWorldPosition()).crossProduct(direction)).length();
+                float distanceFromDirectionVector = ((mobileEntity->getWorldPosition() - this->getWorldPosition()).crossProduct(direction)).length();
 
                 // If the object in a tube of radius 'radius' around the direction of orientation.
@@ -140,5 +140,5 @@
                 // Apply a force to the object in the direction of the orientation.
                 // The force is highest when the object is directly on the direction vector, with a linear decrease, finally reaching zero, when distanceFromDirectionVector = radius.
-                it->applyCentralForce((this->radius_ - distanceFromDirectionVector)/this->radius_ * this->velocity_ * direction);
+                mobileEntity->applyCentralForce((this->radius_ - distanceFromDirectionVector)/this->radius_ * this->velocity_ * direction);
             }
         }
@@ -146,7 +146,7 @@
         {
             // Iterate over all objects that could possibly be affected by the ForceField.
-            for (ObjectList<MobileEntity>::iterator it = ObjectList<MobileEntity>::begin(); it != ObjectList<MobileEntity>::end(); ++it)
-            {
-                Vector3 distanceVector = it->getWorldPosition() - this->getWorldPosition();
+            for (MobileEntity* mobileEntity : ObjectList<MobileEntity>())
+            {
+                Vector3 distanceVector = mobileEntity->getWorldPosition() - this->getWorldPosition();
                 float distance = distanceVector.length();
                 // If the object is within 'radius' distance.
@@ -155,5 +155,5 @@
                     distanceVector.normalise();
                     // Apply a force proportional to the velocity, with highest force at the origin of the sphere, linear decreasing until reaching a distance of 'radius' from the origin, where the force reaches zero. 
-                    it->applyCentralForce((this->radius_ - distance)/this->radius_ * this->velocity_ * distanceVector);
+                    mobileEntity->applyCentralForce((this->radius_ - distance)/this->radius_ * this->velocity_ * distanceVector);
                 }
             }
@@ -162,7 +162,7 @@
         {
             // Iterate over all objects that could possibly be affected by the ForceField.
-            for (ObjectList<MobileEntity>::iterator it = ObjectList<MobileEntity>::begin(); it != ObjectList<MobileEntity>::end(); ++it)
-            {
-                Vector3 distanceVector = this->getWorldPosition() - it->getWorldPosition();
+            for (MobileEntity* mobileEntity : ObjectList<MobileEntity>())
+            {
+                Vector3 distanceVector = this->getWorldPosition() - mobileEntity->getWorldPosition();
                 float distance = distanceVector.length();
                 // If the object is within 'radius' distance and no more than 'length' away from the boundary of the sphere.
@@ -172,5 +172,5 @@
                     distanceVector.normalise();
                     // Apply a force proportional to the velocity, with highest force at the boundary of the sphere, linear decreasing until reaching a distance of 'radius-length' from the origin, where the force reaches zero.
-                    it->applyCentralForce((distance-range)/range * this->velocity_ * distanceVector);
+                    mobileEntity->applyCentralForce((distance-range)/range * this->velocity_ * distanceVector);
                 }
             }
@@ -179,7 +179,7 @@
         {
             // Iterate over all objects that could possibly be affected by the ForceField.
-            for (ObjectList<MobileEntity>::iterator it = ObjectList<MobileEntity>::begin(); it != ObjectList<MobileEntity>::end(); ++it)
-            {
-                Vector3 distanceVector = it->getWorldPosition() - this->getWorldPosition();
+            for (MobileEntity* mobileEntity : ObjectList<MobileEntity>())
+            {
+                Vector3 distanceVector = mobileEntity->getWorldPosition() - this->getWorldPosition();
                 float distance = distanceVector.length();
                 // If the object is within 'radius' distance and especially further away than massRadius_
@@ -197,5 +197,5 @@
                     
                     // Note: this so called force is actually an acceleration!
-                    it->applyCentralForce((-1) * (ForceField::attenFactor_ * ForceField::gravConstant_ * this->getMass()) / (distance * distance) * distanceVector);
+                    mobileEntity->applyCentralForce((-1) * (ForceField::attenFactor_ * ForceField::gravConstant_ * this->getMass()) / (distance * distance) * distanceVector);
                 }
             }
@@ -204,7 +204,7 @@
         {
             // Iterate over all objects that could possibly be affected by the ForceField.
-            for (ObjectList<MobileEntity>::iterator it = ObjectList<MobileEntity>::begin(); it != ObjectList<MobileEntity>::end(); ++it)
-            {
-                Vector3 distanceVector = it->getWorldPosition() - this->getWorldPosition();
+            for (MobileEntity* mobileEntity : ObjectList<MobileEntity>())
+            {
+                Vector3 distanceVector = mobileEntity->getWorldPosition() - this->getWorldPosition();
                 float distance = distanceVector.length();
                 if (distance < this->radius_ && distance > this->massRadius_)
@@ -212,5 +212,5 @@
                     // Add a Acceleration in forceDirection_.
                     // Vector3(0,0,0) is the direction, where the force should work.
-                    it->addAcceleration(forceDirection_ , Vector3(0,0,0));
+                    mobileEntity->addAcceleration(forceDirection_ , Vector3(0,0,0));
                 }
             }
Index: code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc	(revision 10919)
@@ -73,7 +73,6 @@
     {
         pawnsIn_.clear();
-        for(ObjectList<Pawn>::iterator current = ObjectList<Pawn>::begin(); current != ObjectList<Pawn>::end(); ++current)
-        {
-            Pawn* currentPawn = *current;
+        for(Pawn* currentPawn : ObjectList<Pawn>())
+        {
             if( this->reaction_ == 0 )
             {
Index: code/branches/cpp11_v2/src/modules/objects/controllers/TurretController.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/controllers/TurretController.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/controllers/TurretController.cc	(revision 10919)
@@ -103,10 +103,9 @@
         Pawn* minScorePawn = nullptr;
 
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
-        {
-            Pawn* entity = orxonox_cast<Pawn*>(*it);
-            if (!entity || FormationController::sameTeam(turret, entity, this->getGametype()))
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            if (!pawn || FormationController::sameTeam(turret, pawn, this->getGametype()))
                 continue;
-            tempScore = turret->isInRange(entity);
+            tempScore = turret->isInRange(pawn);
             if(tempScore != -1.f)
             {
@@ -114,5 +113,5 @@
                 {
                     minScore = tempScore;
-                    minScorePawn = entity;
+                    minScorePawn = pawn;
                 }
             }
Index: code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc	(revision 10919)
@@ -70,7 +70,7 @@
         {
             bool success = false;
-            for (std::list<EventName*>::const_iterator it = this->names_.begin(); it != this->names_.end(); ++it)
+            for (EventName* name : this->names_)
             {
-                if ((*it)->getName() == event.name_)
+                if (name->getName() == event.name_)
                 {
                     success = true;
Index: code/branches/cpp11_v2/src/modules/objects/eventsystem/EventListener.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/eventsystem/EventListener.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/eventsystem/EventListener.cc	(revision 10919)
@@ -78,7 +78,7 @@
             return;
 
-        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
-            if (it->getName() == this->eventName_)
-                this->addEventSource(*it, "");
+        for (BaseObject* object : ObjectList<BaseObject>())
+            if (object->getName() == this->eventName_)
+                this->addEventSource(object, "");
     }
 
Index: code/branches/cpp11_v2/src/modules/objects/eventsystem/EventTarget.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/eventsystem/EventTarget.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/eventsystem/EventTarget.cc	(revision 10919)
@@ -73,7 +73,7 @@
         this->target_ = name;
 
-        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
-            if (it->getName() == this->target_)
-                this->addEventTarget(*it);
+        for (BaseObject* object : ObjectList<BaseObject>())
+            if (object->getName() == this->target_)
+                this->addEventTarget(object);
     }
 
Index: code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc	(revision 10919)
@@ -346,6 +346,6 @@
     {
         // Iterate over all Triggers.
-        for (ObjectList<Trigger>::iterator it = ObjectList<Trigger>::begin(); it != ObjectList<Trigger>::end(); ++it)
-            it->setVisible(bVisible);
+        for (Trigger* trigger : ObjectList<Trigger>())
+            trigger->setVisible(bVisible);
     }
 
Index: code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc	(revision 10919)
@@ -165,7 +165,6 @@
     {
         const std::set<RadarViewable*>& objectSet = this->getCreator()->getScene()->getRadar()->getRadarObjects();
-        std::set<RadarViewable*>::const_iterator it;
-        for( it=objectSet.begin(); it!=objectSet.end(); ++it )
-            this->addObject(*it);
+        for( RadarViewable* viewable : objectSet )
+            this->addObject(viewable);
         this->radarTick(0);
     }
@@ -183,6 +182,4 @@
 
         // update the distances for all objects
-        std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it;
-
 
         if(RadarMode_)
@@ -201,8 +198,8 @@
         }
 
-        for( it = this->radarObjects_.begin(); it != this->radarObjects_.end(); ++it )
+        for( const auto& mapEntry : this->radarObjects_ )
         {
             // Make sure the object really is a WorldEntity
-            const WorldEntity* wePointer = it->first->getWorldEntity();
+            const WorldEntity* wePointer = mapEntry.first->getWorldEntity();
             if( !wePointer )
             {
@@ -210,5 +207,5 @@
                 assert(0);
             }
-            bool isFocus = (it->first == focusObject);
+            bool isFocus = (mapEntry.first == focusObject);
             // set size to fit distance...
             float distance = (wePointer->getWorldPosition() - this->owner_->getPosition()).length();
@@ -217,8 +214,8 @@
             float size;
             if(RadarMode_)
-                size = maximumDotSize3D_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * it->first->getRadarObjectScale();
+                size = maximumDotSize3D_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * mapEntry.first->getRadarObjectScale();
             else
-                size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * it->first->getRadarObjectScale();
-            it->second->setDimensions(size, size);
+                size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * mapEntry.first->getRadarObjectScale();
+            mapEntry.second->setDimensions(size, size);
 
             // calc position on radar...
@@ -234,7 +231,7 @@
                 int zOrder = determineMap3DZOrder(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition(), detectionLimit_);
                 if(overXZPlain == false /*&& (it->second->getZOrder() >  100 * this->overlay_->getZOrder())*/) // it appears that zOrder of attached Overlayelements is 100 times the zOrder of the Overlay
-                    it->second->_notifyZOrder(this->overlay_->getZOrder() * 100 - 70 + zOrder);
+                    mapEntry.second->_notifyZOrder(this->overlay_->getZOrder() * 100 - 70 + zOrder);
                 if(overXZPlain == true /*&& (it->second->getZOrder() <= 100 * this->overlay_->getZOrder())*/)
-                    it->second->_notifyZOrder(this->overlay_->getZOrder() * 100 + 70 + zOrder);
+                    mapEntry.second->_notifyZOrder(this->overlay_->getZOrder() * 100 + 70 + zOrder);
             }
             else
@@ -242,10 +239,10 @@
 
             coord *= math::pi / 3.5f; // small adjustment to make it fit the texture
-            it->second->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
+            mapEntry.second->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
 
             if( distance < detectionLimit_ || detectionLimit_ < 0 )
-                it->second->show();
+                mapEntry.second->show();
             else
-                it->second->hide();
+                mapEntry.second->hide();
 
             // if this object is in focus, then set the focus marker
@@ -255,5 +252,5 @@
                 this->marker_->setPosition((1.0f + coord.x - size * 1.5f) * 0.5f, (1.0f - coord.y - size * 1.5f) * 0.5f);
                 if(RadarMode_)
-                    this->marker_->_notifyZOrder(it->second->getZOrder() -1);
+                    this->marker_->_notifyZOrder(mapEntry.second->getZOrder() -1);
                 this->marker_->show();
             }
Index: code/branches/cpp11_v2/src/modules/pickup/PickupSpawner.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/pickup/PickupSpawner.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/pickup/PickupSpawner.cc	(revision 10919)
@@ -158,16 +158,16 @@
 
             // Iterate trough all Pawns.
-            for(ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+            for(Pawn* pawn : ObjectList<Pawn>())
             {
                 if(spawner == nullptr) // Stop if the PickupSpawner has been deleted (e.g. because it has run out of pickups to distribute).
                     break;
 
-                Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
-                PickupCarrier* carrier = static_cast<PickupCarrier*>(*it);
+                Vector3 distance = pawn->getWorldPosition() - this->getWorldPosition();
+                PickupCarrier* carrier = static_cast<PickupCarrier*>(pawn);
                 // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawner, is in trigger-distance and the carrier is not blocked.
                 if(distance.length() < this->triggerDistance_ && carrier != nullptr && this->blocked_.find(carrier) == this->blocked_.end())
                 {
                     if(carrier->isTarget(this->pickup_))
-                        this->trigger(*it);
+                        this->trigger(pawn);
                 }
             }
Index: code/branches/cpp11_v2/src/modules/tetris/Tetris.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/tetris/Tetris.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/tetris/Tetris.cc	(revision 10919)
@@ -136,7 +136,7 @@
             return false;
 
-        for(std::list<StrongPtr<TetrisStone>>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
-        {
-            const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
+        for(TetrisStone* someStone : this->stones_)
+        {
+            const Vector3& currentStonePosition = someStone->getPosition(); //!< Saves the position of the currentStone
 
             if((position.x == currentStonePosition.x) && abs(position.y-currentStonePosition.y) < this->center_->getStoneSize())
@@ -192,8 +192,8 @@
 
         // check for collisions with all stones
-        for(std::list<StrongPtr<TetrisStone>>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for(TetrisStone* someStone : this->stones_)
         {
             //Vector3 currentStonePosition = rotateVector((*it)->getPosition(), this->activeBrick_->getRotationCount());
-            const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
+            const Vector3& currentStonePosition = someStone->getPosition(); //!< Saves the position of the currentStone
 
             //filter out cases where the falling stone is already below a steady stone
Index: code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseEnemy.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseEnemy.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseEnemy.cc	(revision 10919)
@@ -49,6 +49,6 @@
         if (game == nullptr)
         {
-            for (ObjectList<TowerDefense>::iterator it = ObjectList<TowerDefense>::begin(); it != ObjectList<TowerDefense>::end(); ++it)
-                game = *it;
+            for (TowerDefense* towerDefense : ObjectList<TowerDefense>())
+                game = towerDefense;
         }
         return game;
Index: code/branches/cpp11_v2/src/modules/weapons/projectiles/GravityBombField.cc
===================================================================
--- code/branches/cpp11_v2/src/modules/weapons/projectiles/GravityBombField.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/modules/weapons/projectiles/GravityBombField.cc	(revision 10919)
@@ -125,18 +125,18 @@
 
             //Check if any pawn is inside the shockwave and hit it with dammage proportional to the distance between explosion centre and pawn. Make sure, the same pawn is damaged only once.
-            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+            for (Pawn* pawn : ObjectList<Pawn>())
             {
-                Vector3 distanceVector = it->getWorldPosition()-this->getWorldPosition();
+                Vector3 distanceVector = pawn->getWorldPosition()-this->getWorldPosition();
                  //orxout(debug_output) << "Found Pawn:" << it->getWorldPosition() << endl;
                 if(distanceVector.length()< forceSphereRadius_)
                 {
                     //orxout(debug_output) << "Force sphere radius is: " << forceSphereRadius_ << " Distance to Pawn is: " << distanceVector.length();
-                    if (std::find(victimsAlreadyDamaged_.begin(),victimsAlreadyDamaged_.end(),*it) == victimsAlreadyDamaged_.end())
+                    if (std::find(victimsAlreadyDamaged_.begin(),victimsAlreadyDamaged_.end(),pawn) == victimsAlreadyDamaged_.end())
                     {
                         //orxout(debug_output) << "Found Pawn to damage: " << it->getWorldPosition() << endl;
                         float damage = FORCE_FIELD_EXPLOSION_DAMMAGE*(1-distanceVector.length()/EXPLOSION_RADIUS);
                         //orxout(debug_output) << "Damage: " << damage << endl;
-                        it->hit(shooter_, it->getWorldPosition(), nullptr, damage, 0,0);
-                        victimsAlreadyDamaged_.push_back(*it);
+                        pawn->hit(shooter_, pawn->getWorldPosition(), nullptr, damage, 0,0);
+                        victimsAlreadyDamaged_.push_back(pawn);
                     }
                 }
Index: code/branches/cpp11_v2/src/orxonox/LevelManager.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/LevelManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/LevelManager.cc	(revision 10919)
@@ -78,7 +78,6 @@
     {
         // Delete all the LevelInfoItem objects because the LevelManager created them
-        std::set<LevelInfoItem*, LevelInfoCompare>::iterator it = availableLevels_.begin();
-        for (; it != availableLevels_.end(); ++it)
-            delete *it;
+        for (LevelInfoItem* info : availableLevels_)
+            delete info;
     }
 
@@ -279,7 +278,7 @@
 
                 // Find the LevelInfo object we've just loaded (if there was one)
-                for(ObjectList<LevelInfo>::iterator item = ObjectList<LevelInfo>::begin(); item != ObjectList<LevelInfo>::end(); ++item)
-                    if(item->getXMLFilename() == *it)
-                        info = item->copy();
+                for(LevelInfo* levelInfo : ObjectList<LevelInfo>())
+                    if(levelInfo->getXMLFilename() == *it)
+                        info = levelInfo->copy();
 
                 // We don't need the loaded stuff anymore
Index: code/branches/cpp11_v2/src/orxonox/MoodManager.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/MoodManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/MoodManager.cc	(revision 10919)
@@ -103,6 +103,6 @@
     /*static*/ void MoodListener::changedMood(const std::string& mood)
     {
-        for (ObjectList<MoodListener>::iterator it = ObjectList<MoodListener>::begin(); it; ++it)
-            it->moodChanged(mood);
+        for (MoodListener* listener : ObjectList<MoodListener>())
+            listener->moodChanged(mood);
     }
 }
Index: code/branches/cpp11_v2/src/orxonox/PlayerManager.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/PlayerManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/PlayerManager.cc	(revision 10919)
@@ -111,7 +111,7 @@
         else
         {
-            for (ObjectList<PlayerInfo>::iterator it = ObjectList<PlayerInfo>::begin(); it != ObjectList<PlayerInfo>::end(); ++it)
-                if (it->getClientID() == clientID)
-                    return (*it);
+            for (PlayerInfo* info : ObjectList<PlayerInfo>())
+                if (info->getClientID() == clientID)
+                    return info;
         }
         return nullptr;
Index: code/branches/cpp11_v2/src/orxonox/Radar.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/Radar.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/Radar.cc	(revision 10919)
@@ -84,7 +84,7 @@
         this->radarObjects_.insert(rv);
         // iterate through all radarlisteners and notify them
-        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
-        {
-            (*itListener)->addObject(rv);
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->addObject(rv);
         }
     }
@@ -95,7 +95,7 @@
         this->radarObjects_.erase(rv);
         // iterate through all radarlisteners and notify them
-        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
-        {
-            (*itListener)->removeObject(rv);
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->removeObject(rv);
         }
     }
@@ -130,7 +130,7 @@
         }
 
-        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
-        {
-            (*itListener)->radarTick(dt);
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->radarTick(dt);
         }
     }
@@ -200,7 +200,8 @@
         // iterate through all Radar Objects
         unsigned int i = 0;
-        for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it, ++i)
-        {
-            orxout(debug_output) << i++ << ": " << (*it)->getRVWorldPosition() << endl;
+        for (RadarViewable* viewable : ObjectList<RadarViewable>())
+        {
+            orxout(debug_output) << i++ << ": " << viewable->getRVWorldPosition() << endl;
+            ++i;
         }
     }
@@ -208,7 +209,7 @@
     void Radar::radarObjectChanged(RadarViewable* rv)
     {
-        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
-        {
-          (*itListener)->objectChanged(rv);
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->objectChanged(rv);
         }
     }
Index: code/branches/cpp11_v2/src/orxonox/Scene.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/Scene.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/Scene.cc	(revision 10919)
@@ -389,6 +389,6 @@
     /*static*/ void Scene::consoleCommand_debugDrawPhysics(bool bDraw, bool bFill, float fillAlpha)
     {
-        for (ObjectListIterator<Scene> it = ObjectList<Scene>::begin(); it != ObjectList<Scene>::end(); ++it)
-            it->setDebugDrawPhysics(bDraw, bFill, fillAlpha);
+        for (Scene* scene : ObjectList<Scene>())
+            scene->setDebugDrawPhysics(bDraw, bFill, fillAlpha);
     }
 }
Index: code/branches/cpp11_v2/src/orxonox/chat/ChatHistory.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/chat/ChatHistory.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/chat/ChatHistory.cc	(revision 10919)
@@ -160,11 +160,7 @@
   void ChatHistory::debug_printhist()
   {
-    /* create deque iterator */
-    std::deque<std::string>::iterator it;
-
     /* output all the strings */
-    for( it = this->hist_buffer.begin(); it != this->hist_buffer.end();
-      ++it )
-      orxout(debug_output) << *it << endl;
+    for( const std::string& hist : this->hist_buffer )
+      orxout(debug_output) << hist << endl;
 
     /* output size */
Index: code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc	(revision 10919)
@@ -200,12 +200,12 @@
         bool bEmpty = true; // Whether the CompoundCollisionShape is empty.
         // Iterate over all CollisionShapes that belong to this CompoundCollisionShape.
-        for (std::map<CollisionShape*, btCollisionShape*>::const_iterator it = this->attachedShapes_.begin(); it != this->attachedShapes_.end(); ++it)
+        for (const auto& mapEntry : this->attachedShapes_)
         {
             // TODO: Make sure this is correct.
-            if (it->second)
+            if (mapEntry.second)
             {
                 bEmpty = false;
-                if (!it->first->hasTransform() && bPrimitive)
-                    primitive = it->second;
+                if (!mapEntry.first->hasTransform() && bPrimitive)
+                    primitive = mapEntry.second;
                 else
                 {
Index: code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc	(revision 10919)
@@ -97,21 +97,21 @@
             this->removeFromFormation();
 
-            for (ObjectList<FormationController>::iterator it = ObjectList<FormationController>::begin(); it; ++it)
-            {
-                if (*it != this)
+            for (FormationController* controller : ObjectList<FormationController>())
+            {
+                if (controller != this)
                 {
-                    if (it->myMaster_ == this)
+                    if (controller->myMaster_ == this)
                     {
-                        orxout(internal_error) << this << " is still master in " << (*it) << endl;
-                        it->myMaster_ = nullptr;
+                        orxout(internal_error) << this << " is still master in " << controller << endl;
+                        controller->myMaster_ = nullptr;
                     }
 
                     while (true)
                     {
-                        std::vector<FormationController*>::iterator it2 = std::find(it->slaves_.begin(), it->slaves_.end(), this);
-                        if (it2 != it->slaves_.end())
+                        std::vector<FormationController*>::iterator it2 = std::find(controller->slaves_.begin(), controller->slaves_.end(), this);
+                        if (it2 != controller->slaves_.end())
                         {
-                            orxout(internal_error) << this << " is still slave in " << (*it) << endl;
-                            it->slaves_.erase(it2);
+                            orxout(internal_error) << this << " is still slave in " << controller << endl;
+                            controller->slaves_.erase(it2);
                         }
                         else
@@ -140,12 +140,12 @@
     void FormationController::formationflight(const bool form)
     {
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
             Controller* controller = nullptr;
 
-            if (it->getController())
-                controller = it->getController();
-            else if (it->getXMLController())
-                controller = it->getXMLController();
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
 
             if (!controller)
@@ -171,12 +171,12 @@
     void FormationController::masteraction(const int action)
     {
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
             Controller* controller = nullptr;
 
-            if (it->getController())
-                controller = it->getController();
-            else if (it->getXMLController())
-                controller = it->getXMLController();
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
 
             if (!controller)
@@ -201,12 +201,12 @@
     void FormationController::passivebehaviour(const bool passive)
     {
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
             Controller* controller = nullptr;
 
-            if (it->getController())
-                controller = it->getController();
-            else if (it->getXMLController())
-                controller = it->getXMLController();
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
 
             if (!controller)
@@ -228,12 +228,12 @@
     void FormationController::formationsize(const int size)
     {
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
             Controller* controller = nullptr;
 
-            if (it->getController())
-                controller = it->getController();
-            else if (it->getXMLController())
-                controller = it->getXMLController();
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
 
             if (!controller)
@@ -398,5 +398,5 @@
         int teamSize = 0;
         //go through all pawns
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
 
@@ -405,7 +405,7 @@
             if (!gt)
             {
-                gt=it->getGametype();
-            }
-            if (!FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it),gt))
+                gt=pawn->getGametype();
+            }
+            if (!FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(pawn),gt))
                 continue;
 
@@ -413,8 +413,8 @@
             Controller* controller = nullptr;
 
-            if (it->getController())
-                controller = it->getController();
-            else if (it->getXMLController())
-                controller = it->getXMLController();
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
 
             if (!controller)
@@ -422,5 +422,5 @@
 
             //is pawn oneself?
-            if (orxonox_cast<ControllableEntity*>(*it) == this->getControllableEntity())
+            if (orxonox_cast<ControllableEntity*>(pawn) == this->getControllableEntity())
                 continue;
 
@@ -433,5 +433,5 @@
                 continue;
 
-            float distance = (it->getPosition() - this->getControllableEntity()->getPosition()).length();
+            float distance = (pawn->getPosition() - this->getControllableEntity()->getPosition()).length();
 
             // is pawn in range?
@@ -520,7 +520,7 @@
             newMaster->myMaster_ = nullptr;
 
-            for(std::vector<FormationController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
-            {
-                (*it)->myMaster_ = newMaster;
+            for(FormationController* slave : newMaster->slaves_)
+            {
+                slave->myMaster_ = newMaster;
             }
         }
@@ -549,7 +549,7 @@
                 newMaster->myMaster_ = nullptr;
 
-                for(std::vector<FormationController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
+                for(FormationController* slave : newMaster->slaves_)
                 {
-                    (*it)->myMaster_ = newMaster;
+                    slave->myMaster_ = newMaster;
                 }
             }
@@ -777,12 +777,12 @@
         std::vector<FormationController*> allMasters;
 
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
             Controller* controller = nullptr;
 
-            if (it->getController())
-                controller = it->getController();
-            else if (it->getXMLController())
-                controller = it->getXMLController();
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
 
             if (!controller)
@@ -791,5 +791,5 @@
             currentHumanController = orxonox_cast<NewHumanController*>(controller);
 
-            if(currentHumanController) humanPawn = *it;
+            if(currentHumanController) humanPawn = pawn;
 
             FormationController *aiController = orxonox_cast<FormationController*>(controller);
@@ -808,9 +808,10 @@
             int i = 0;
 
-            for(std::vector<FormationController*>::iterator it = allMasters.begin(); it != allMasters.end(); it++, i++)
-            {
-                if (!FormationController::sameTeam((*it)->getControllableEntity(), humanPawn, (*it)->getGametype())) continue;
-                distance = posHuman - (*it)->getControllableEntity()->getPosition().length();
+            for(FormationController* master : allMasters)
+            {
+                if (!FormationController::sameTeam(master->getControllableEntity(), humanPawn, master->getGametype())) continue;
+                distance = posHuman - master->getControllableEntity()->getPosition().length();
                 if(distance < minDistance) index = i;
+                i++;
             }
             allMasters[index]->followInit(humanPawn);
@@ -847,14 +848,14 @@
         NewHumanController *currentHumanController = nullptr;
 
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
-        {
-            if (!it->getController())
-                continue;
-
-            currentHumanController = orxonox_cast<NewHumanController*>(it->getController());
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            if (!pawn->getController())
+                continue;
+
+            currentHumanController = orxonox_cast<NewHumanController*>(pawn->getController());
             if(currentHumanController)
             {
-                if (!FormationController::sameTeam(this->getControllableEntity(), *it, this->getGametype())) continue;
-                humanPawn = *it;
+                if (!FormationController::sameTeam(this->getControllableEntity(), pawn, this->getGametype())) continue;
+                humanPawn = pawn;
                 break;
             }
@@ -918,22 +919,22 @@
         this->forgetTarget();
 
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
-        {
-            if (FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it), this->getGametype()))
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            if (FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), this->getGametype()))
                 continue;
 
             /* So AI won't choose invisible Spaceships as target */
-            if (!it->getRadarVisibility())
-                continue;
-
-            if (static_cast<ControllableEntity*>(*it) != this->getControllableEntity())
+            if (!pawn->getRadarVisibility())
+                continue;
+
+            if (static_cast<ControllableEntity*>(pawn) != this->getControllableEntity())
             {
                 float speed = this->getControllableEntity()->getVelocity().length();
                 Vector3 distanceCurrent = this->targetPosition_ - this->getControllableEntity()->getPosition();
-                Vector3 distanceNew = it->getPosition() - this->getControllableEntity()->getPosition();
-                if (!this->target_ || it->getPosition().squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceNew) / speed / distanceNew.length()) / math::twoPi)
+                Vector3 distanceNew = pawn->getPosition() - this->getControllableEntity()->getPosition();
+                if (!this->target_ || pawn->getPosition().squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceNew) / speed / distanceNew.length()) / math::twoPi)
                         < this->targetPosition_.squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceCurrent) / speed / distanceCurrent.length()) / math::twoPi) + rnd(-250, 250))
                 {
-                    this->setTarget(*it);
+                    this->setTarget(pawn);
                 }
             }
Index: code/branches/cpp11_v2/src/orxonox/controllers/ScriptController.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/controllers/ScriptController.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/controllers/ScriptController.cc	(revision 10919)
@@ -121,18 +121,14 @@
 
       /* Debugging: print all the scriptcontroller object pointers */
-      for(ObjectList<ScriptController>::iterator it = 
-        ObjectList<ScriptController>::begin(); 
-        it != ObjectList<ScriptController>::end(); ++it)
-      { orxout(verbose) << "Have object in list: " << *it << endl; }
+      for(ScriptController* controller : ObjectList<ScriptController>())
+      { orxout(verbose) << "Have object in list: " << controller << endl; }
 
       /* Find the first one with a nonzero ID */
-      for(ObjectList<ScriptController>::iterator it = 
-        ObjectList<ScriptController>::begin(); 
-        it != ObjectList<ScriptController>::end(); ++it)
+      for(ScriptController* controller : ObjectList<ScriptController>())
       { 
         // TODO: do some selection here. Currently just returns the first one
-        if( (*it)->getID() > 0 )
-        { orxout(verbose) << "Controller to return: " << *it << endl;
-          return *it; 
+        if( controller->getID() > 0 )
+        { orxout(verbose) << "Controller to return: " << controller << endl;
+          return controller;
         }
       
Index: code/branches/cpp11_v2/src/orxonox/controllers/WaypointPatrolController.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/controllers/WaypointPatrolController.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/controllers/WaypointPatrolController.cc	(revision 10919)
@@ -87,14 +87,14 @@
         float shortestsqdistance = (float)static_cast<unsigned int>(-1);
 
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
-            if (ArtificialController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it), this->getGametype()))
+            if (ArtificialController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), this->getGametype()))
                 continue;
 
-            float sqdistance = it->getPosition().squaredDistance(myposition);
+            float sqdistance = pawn->getPosition().squaredDistance(myposition);
             if (sqdistance < shortestsqdistance)
             {
                 shortestsqdistance = sqdistance;
-                this->target_ = (*it);
+                this->target_ = pawn;
             }
         }
Index: code/branches/cpp11_v2/src/orxonox/gamestates/GSLevel.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/gamestates/GSLevel.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/gamestates/GSLevel.cc	(revision 10919)
@@ -164,12 +164,12 @@
         // Note: Temporarily moved to GSRoot.
         //// Call the scene objects
-        //for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
-        //    it->tick(time.getDeltaTime() * this->timeFactor_);
+        //for (Tickable* tickable : ObjectList<Tickable>())
+        //    tickable->tick(time.getDeltaTime() * this->timeFactor_);
     }
 
     void GSLevel::prepareObjectTracking()
     {
-        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
-            this->staticObjects_.insert(*it);
+        for (BaseObject* baseObject : ObjectList<BaseObject>())
+            this->staticObjects_.insert(baseObject);
     }
 
@@ -178,10 +178,10 @@
         orxout(internal_info) << "Remaining objects:" << endl;
         unsigned int i = 0;
-        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
-        {
-            std::set<BaseObject*>::const_iterator find = this->staticObjects_.find(*it);
+        for (BaseObject* baseObject : ObjectList<BaseObject>())
+        {
+            std::set<BaseObject*>::const_iterator find = this->staticObjects_.find(baseObject);
             if (find == this->staticObjects_.end())
             {
-                orxout(internal_warning) << ++i << ": " << it->getIdentifier()->getName() << " (" << *it << "), references: " << it->getReferenceCount() << endl;
+                orxout(internal_warning) << ++i << ": " << baseObject->getIdentifier()->getName() << " (" << baseObject << "), references: " << baseObject->getReferenceCount() << endl;
             }
         }
@@ -235,7 +235,7 @@
         // export all states
         std::vector<GSLevelMementoState*> states;
-        for (ObjectList<GSLevelMemento>::iterator it = ObjectList<GSLevelMemento>::begin(); it != ObjectList<GSLevelMemento>::end(); ++it)
-        {
-            GSLevelMementoState* state = it->exportMementoState();
+        for (GSLevelMemento* memento : ObjectList<GSLevelMemento>())
+        {
+            GSLevelMementoState* state = memento->exportMementoState();
             if (state)
                 states.push_back(state);
@@ -247,6 +247,6 @@
 
         // import all states
-        for (ObjectList<GSLevelMemento>::iterator it = ObjectList<GSLevelMemento>::begin(); it != ObjectList<GSLevelMemento>::end(); ++it)
-            it->importMementoState(states);
+        for (GSLevelMemento* memento : ObjectList<GSLevelMemento>())
+            memento->importMementoState(states);
 
         // delete states
Index: code/branches/cpp11_v2/src/orxonox/gamestates/GSRoot.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/gamestates/GSRoot.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/gamestates/GSRoot.cc	(revision 10919)
@@ -74,11 +74,11 @@
     {
         unsigned int nr=0;
-        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; ++it)
-        {
-            Synchronisable* synchronisable = orxonox_cast<Synchronisable*>(*it);
+        for (BaseObject* baseObject : ObjectList<BaseObject>())
+        {
+            Synchronisable* synchronisable = orxonox_cast<Synchronisable*>(baseObject);
             if (synchronisable)
-                orxout(debug_output) << "object: " << it->getIdentifier()->getName() << " id: " << synchronisable->getObjectID() << endl;
+                orxout(debug_output) << "object: " << baseObject->getIdentifier()->getName() << " id: " << synchronisable->getObjectID() << endl;
             else
-                orxout(debug_output) << "object: " << it->getIdentifier()->getName() << endl;
+                orxout(debug_output) << "object: " << baseObject->getIdentifier()->getName() << endl;
             nr++;
         }
Index: code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc	(revision 10919)
@@ -571,9 +571,9 @@
         // find correct scene
         Scene* scene = nullptr;
-        for (ObjectList<Scene>::iterator it = ObjectList<Scene>::begin(); it != ObjectList<Scene>::end(); ++it)
-        {
-            if (it->getName() == state->sceneName_)
-            {
-                scene = *it;
+        for (Scene* someScene : ObjectList<Scene>())
+        {
+            if (someScene->getName() == state->sceneName_)
+            {
+                scene = someScene;
                 break;
             }
Index: code/branches/cpp11_v2/src/orxonox/gametypes/Mission.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/gametypes/Mission.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/gametypes/Mission.cc	(revision 10919)
@@ -101,7 +101,6 @@
     void Mission::setTeams()
     { //Set pawn-colours
-        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
         {
-            Pawn* pawn = static_cast<Pawn*>(*it);
             if (!pawn)
                 continue;
@@ -111,8 +110,8 @@
     void Mission::endMission(bool accomplished)
     {
-        for (ObjectList<Mission>::iterator it = ObjectList<Mission>::begin(); it != ObjectList<Mission>::end(); ++it)
+        for (Mission* mission : ObjectList<Mission>())
         { //TODO: make sure that only the desired mission is ended !! This is a dirty HACK, that would end ALL missions!
-            it->setMissionAccomplished(accomplished);
-            it->end();
+            mission->setMissionAccomplished(accomplished);
+            mission->end();
         }
     }
@@ -120,7 +119,7 @@
     void Mission::setLivesWrapper(unsigned int amount)
     {
-        for (ObjectList<Mission>::iterator it = ObjectList<Mission>::begin(); it != ObjectList<Mission>::end(); ++it)
+        for (Mission* mission : ObjectList<Mission>())
         { //TODO: make sure that only the desired mission is ended !! This is a dirty HACK, that would affect ALL missions!
-            it->setLives(amount);
+            mission->setLives(amount);
         }
     }
Index: code/branches/cpp11_v2/src/orxonox/infos/GametypeInfo.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/infos/GametypeInfo.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/infos/GametypeInfo.cc	(revision 10919)
@@ -461,30 +461,30 @@
     void GametypeInfo::dispatchAnnounceMessage(const std::string& message) const
     {
-        for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
-            it->announcemessage(this, message);
+        for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
+            listener->announcemessage(this, message);
     }
 
     void GametypeInfo::dispatchKillMessage(const std::string& message) const
     {
-        for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
-            it->killmessage(this, message);
+        for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
+            listener->killmessage(this, message);
     }
 
     void GametypeInfo::dispatchDeathMessage(const std::string& message) const
     {
-        for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
-            it->deathmessage(this, message);
+        for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
+            listener->deathmessage(this, message);
     }
 
      void GametypeInfo::dispatchStaticMessage(const std::string& message, const ColourValue& colour) const
     {
-        for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
-            it->staticmessage(this, message, colour);
+        for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
+            listener->staticmessage(this, message, colour);
     }
 
      void GametypeInfo::dispatchFadingMessage(const std::string& message) const
     {
-        for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
-            it->fadingmessage(this, message);
+        for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
+            listener->fadingmessage(this, message);
     }
 }
Index: code/branches/cpp11_v2/src/orxonox/interfaces/NotificationListener.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/interfaces/NotificationListener.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/interfaces/NotificationListener.cc	(revision 10919)
@@ -108,9 +108,9 @@
     {
         // Iterate through all NotificationListeners and notify them by calling the method they overloaded.
-        for(ObjectList<NotificationListener>::iterator it = ObjectList<NotificationListener>::begin(); it != ObjectList<NotificationListener>::end(); ++it)
+        for(NotificationListener* listener : ObjectList<NotificationListener>())
         {
             // If the notification is a message.
             if(!isCommand)
-                it->registerNotification(message, sender, notificationMessageType::Value(messageType));
+                listener->registerNotification(message, sender, notificationMessageType::Value(messageType));
 
             // If the notification is a command.
@@ -119,5 +119,5 @@
                 notificationCommand::Value command = str2Command(message);
                 if(command != notificationCommand::none)
-                    it->executeCommand(command, sender);
+                    listener->executeCommand(command, sender);
             }
         }
Index: code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc	(revision 10919)
@@ -101,7 +101,7 @@
         // Go recursively through all children to check whether they are a target.
         std::vector<PickupCarrier*>* children = this->getCarrierChildren();
-        for(std::vector<PickupCarrier*>::const_iterator it = children->begin(); it != children->end(); it++)
+        for(PickupCarrier* carrier : *children)
         {
-            if((*it)->isTarget(pickup))
+            if(carrier->isTarget(pickup))
             {
                 isTarget = true;
Index: code/branches/cpp11_v2/src/orxonox/interfaces/PickupListener.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/interfaces/PickupListener.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/interfaces/PickupListener.cc	(revision 10919)
@@ -74,6 +74,6 @@
 
         // Iterate through all PickupListeners and notify them by calling the method they overloaded.
-        for(ObjectList<PickupListener>::iterator it = ObjectList<PickupListener>::begin(); it != ObjectList<PickupListener>::end(); ++it)
-            it->pickupChangedUsed(pickup, used);
+        for(PickupListener* listener : ObjectList<PickupListener>())
+            listener->pickupChangedUsed(pickup, used);
     }
 
@@ -92,6 +92,6 @@
 
         // Iterate through all PickupListeners and notify them by calling the method they overloaded.
-        for(ObjectList<PickupListener>::iterator it = ObjectList<PickupListener>::begin(); it != ObjectList<PickupListener>::end(); ++it)
-            it->pickupChangedPickedUp(pickup, pickedUp);
+        for(PickupListener* listener : ObjectList<PickupListener>())
+            listener->pickupChangedPickedUp(pickup, pickedUp);
     }
 
Index: code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc	(revision 10919)
@@ -85,7 +85,7 @@
             {
                 // We have no ship, so the effects are not attached and won't be destroyed automatically
-                for (std::vector<EffectContainer*>::const_iterator it = this->effectContainers_.begin(); it != this->effectContainers_.end(); ++it)
-                    for (std::vector<WorldEntity*>::const_iterator it2 = (*it)->getEffectsBegin(); it2 != (*it)->getEffectsBegin(); ++it2)
-                        (*it2)->destroy();
+                for (EffectContainer* container : this->effectContainers_)
+                    for (std::vector<WorldEntity*>::const_iterator it = container->getEffectsBegin(); it != container->getEffectsBegin(); ++it)
+                        (*it)->destroy();
                 if (this->defEngineSndNormal_)
                     this->defEngineSndNormal_->destroy();
@@ -178,6 +178,6 @@
 
                 // Update all effect conditions
-                for (std::vector<EffectContainer*>::const_iterator it = this->effectContainers_.begin(); it != this->effectContainers_.end(); ++it)
-                    (*it)->updateCondition();
+                for (EffectContainer* container : this->effectContainers_)
+                    container->updateCondition();
             }
         }
@@ -198,7 +198,7 @@
             this->getShip()->attach(defEngineSndBoost_);
 
-        for (std::vector<EffectContainer*>::const_iterator it = this->effectContainers_.begin(); it != this->effectContainers_.end(); ++it)
-            for (std::vector<WorldEntity*>::const_iterator it2 = (*it)->getEffectsBegin(); it2 != (*it)->getEffectsEnd(); ++it2)
-                this->getShip()->attach(*it2);
+        for (EffectContainer* container : this->effectContainers_)
+            for (std::vector<WorldEntity*>::const_iterator it = container->getEffectsBegin(); it != container->getEffectsEnd(); ++it)
+                this->getShip()->attach(*it);
     }
 
Index: code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc	(revision 10919)
@@ -170,8 +170,8 @@
     /*static*/ void OverlayGroup::toggleVisibility(const std::string& name)
     {
-        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
-        {
-            if ((*it)->getName() == name)
-                (*it)->setVisible(!((*it)->isVisible()));
+        for (OverlayGroup* group : ObjectList<OverlayGroup>())
+        {
+            if (group->getName() == name)
+                group->setVisible(!(group->isVisible()));
         }
     }
@@ -185,12 +185,12 @@
     /*static*/ void OverlayGroup::show(const std::string& name)
     {
-        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
-        {
-            if ((*it)->getName() == name)
+        for (OverlayGroup* group : ObjectList<OverlayGroup>())
+        {
+            if (group->getName() == name)
             {
-                if((*it)->isVisible())
-                    (*it)->changedVisibility();
+                if(group->isVisible())
+                    group->changedVisibility();
                 else
-                    (*it)->setVisible(!((*it)->isVisible()));
+                    group->setVisible(!(group->isVisible()));
             }
         }
@@ -208,8 +208,8 @@
     /*static*/ void OverlayGroup::scaleGroup(const std::string& name, float scale)
     {
-        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
-        {
-            if ((*it)->getName() == name)
-                (*it)->scale(Vector2(scale, scale));
+        for (OverlayGroup* group : ObjectList<OverlayGroup>())
+        {
+            if (group->getName() == name)
+                group->scale(Vector2(scale, scale));
         }
     }
@@ -226,8 +226,8 @@
     /*static*/ void OverlayGroup::scrollGroup(const std::string& name, const Vector2& scroll)
     {
-        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
-        {
-            if ((*it)->getName() == name)
-                (*it)->scroll(scroll);
+        for (OverlayGroup* group : ObjectList<OverlayGroup>())
+        {
+            if (group->getName() == name)
+                group->scroll(scroll);
         }
     }
Index: code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc	(revision 10919)
@@ -294,14 +294,14 @@
         {
         case SoundType::All:
-            for (ObjectList<BaseSound>::iterator it = ObjectList<BaseSound>::begin(); it != ObjectList<BaseSound>::end(); ++it)
-                (*it)->updateVolume();
+            for (BaseSound* sound : ObjectList<BaseSound>())
+                sound->updateVolume();
             break;
         case SoundType::Music:
-            for (ObjectList<AmbientSound>::iterator it = ObjectList<AmbientSound>::begin(); it != ObjectList<AmbientSound>::end(); ++it)
-                (*it)->updateVolume();
+            for (AmbientSound* sound : ObjectList<AmbientSound>())
+                sound->updateVolume();
             break;
         case SoundType::Effects:
-            for (ObjectList<WorldSound>::iterator it = ObjectList<WorldSound>::begin(); it != ObjectList<WorldSound>::end(); ++it)
-                (*it)->updateVolume();
+            for (WorldSound* sound : ObjectList<WorldSound>())
+                sound->updateVolume();
             break;
         default:
Index: code/branches/cpp11_v2/src/orxonox/sound/WorldAmbientSound.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/sound/WorldAmbientSound.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/sound/WorldAmbientSound.cc	(revision 10919)
@@ -114,8 +114,7 @@
 
         //HACK: Assuption - there is only one WorldAmbientSound in a level and only one level is used.
-        for (ObjectList<WorldAmbientSound>::iterator it = ObjectList<WorldAmbientSound>::begin();
-             it != ObjectList<WorldAmbientSound>::end(); ++it)
+        for (WorldAmbientSound* sound : ObjectList<WorldAmbientSound>())
         {
-            while(it->ambientSound_->setAmbientSource(WorldAmbientSound::soundList_[WorldAmbientSound::soundNumber_]) == false){
+            while(sound->ambientSound_->setAmbientSource(WorldAmbientSound::soundList_[WorldAmbientSound::soundNumber_]) == false){
                 WorldAmbientSound::soundNumber_ = (WorldAmbientSound::soundNumber_ + 1) % WorldAmbientSound::soundList_.size();
             }
Index: code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc	(revision 10919)
@@ -153,6 +153,6 @@
     void WeaponPack::notifyWeapons()
     {
-        for (std::vector<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
-            (*it)->setWeaponPack(this);
+        for (Weapon* weapon : this->weapons_)
+            weapon->setWeaponPack(this);
     }
 }
Index: code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc	(revision 10919)
@@ -108,6 +108,6 @@
                 this->camera_->destroy();
 
-            for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
-                (*it)->destroy();
+            for (CameraPosition* cameraPosition : this->cameraPositions_)
+                cameraPosition->destroy();
 
             if (this->getScene()->getSceneManager())
Index: code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc	(revision 10919)
@@ -103,7 +103,7 @@
             bool result = (bool)lua_toboolean(this->lua_->getInternalLuaState(), -1);
             lua_pop(this->lua_->getInternalLuaState(), 1);
-            for (std::vector<WorldEntity*>::const_iterator it = this->effects_.begin(); it != this->effects_.end(); ++it)
+            for (WorldEntity* effect : this->effects_)
             {
-                (*it)->setMainState(result);
+                effect->setMainState(result);
             }
         }
Index: code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc	(revision 10919)
@@ -174,9 +174,9 @@
     void ModularSpaceShip::killShipPartStatic(std::string name)
     {
-        for (std::map<StaticEntity*, ShipPart*>::const_iterator it = ModularSpaceShip::partMap_s->begin(); it != ModularSpaceShip::partMap_s->end(); ++it)
-        {
-            if (it->second->getName() == name)
-            {
-                it->second->death();
+        for (const auto& mapEntry : *ModularSpaceShip::partMap_s)
+        {
+            if (mapEntry.second->getName() == name)
+            {
+                mapEntry.second->death();
                 return;
             }
@@ -193,9 +193,9 @@
     void ModularSpaceShip::killShipPart(std::string name)
     {
-        for (std::map<StaticEntity*, ShipPart*>::const_iterator it = ModularSpaceShip::partMap_.begin(); it != ModularSpaceShip::partMap_.end(); ++it)
-        {
-            if (it->second->getName() == name)
-            {
-                it->second->death();
+        for (const auto& mapEntry : ModularSpaceShip::partMap_)
+        {
+            if (mapEntry.second->getName() == name)
+            {
+                mapEntry.second->death();
                 return;
             }
Index: code/branches/cpp11_v2/src/orxonox/worldentities/pawns/Pawn.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/worldentities/pawns/Pawn.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/worldentities/pawns/Pawn.cc	(revision 10919)
@@ -574,10 +574,8 @@
     bool Pawn::hasSlaves()
     {
-        for (ObjectList<FormationController>::iterator it =
-             ObjectList<FormationController>::begin();
-             it != ObjectList<FormationController>::end(); ++it )
+        for (FormationController* controller : ObjectList<FormationController>())
         {
             // checks if the pawn's controller has a slave
-            if (this->hasHumanController() && it->getMaster() == this->getPlayer()->getController())
+            if (this->hasHumanController() && controller->getMaster() == this->getPlayer()->getController())
                 return true;
         }
@@ -587,10 +585,8 @@
     // A function that returns a slave of the pawn's controller
     Controller* Pawn::getSlave(){
-        for (ObjectList<FormationController>::iterator it =
-                ObjectList<FormationController>::begin();
-                it != ObjectList<FormationController>::end(); ++it )
-        {
-            if (this->hasHumanController() && it->getMaster() == this->getPlayer()->getController())
-                return it->getController();
+        for (FormationController* controller : ObjectList<FormationController>())
+        {
+            if (this->hasHumanController() && controller->getMaster() == this->getPlayer()->getController())
+                return controller->getController();
         }
         return nullptr;
Index: code/branches/cpp11_v2/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc
===================================================================
--- code/branches/cpp11_v2/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc	(revision 10918)
+++ code/branches/cpp11_v2/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc	(revision 10919)
@@ -92,6 +92,6 @@
 
         // Call this so bots stop shooting at the base after they converted it
-        for (ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it != ObjectList<ArtificialController>::end(); ++it)
-            it->abandonTarget(this);
+        for (ArtificialController* controller : ObjectList<ArtificialController>())
+            controller->abandonTarget(this);
     }
 }
