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

Timestamp:

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

Author:

landauf

Message:

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

Location:

code/branches/cpp11_v2/src/modules

Files:

• docking/Dock.cc (modified) (2 diffs)
• docking/DockingAnimation.cc (modified) (1 diff)
• docking/DockingEffect.cc (modified) (1 diff)
• gametypes/RaceCheckPoint.cc (modified) (1 diff)
• gametypes/SpaceRaceController.cc (modified) (4 diffs)
• gametypes/SpaceRaceManager.cc (modified) (6 diffs)
• jump/Jump.cc (modified) (3 diffs)
• mini4dgame/Mini4Dgame.cc (modified) (1 diff)
• notifications/NotificationManager.cc (modified) (5 diffs)
• notifications/NotificationQueue.cc (modified) (4 diffs)
• objects/Attacher.cc (modified) (3 diffs)
• objects/Script.cc (modified) (1 diff)
• objects/SpaceBoundaries.cc (modified) (3 diffs)
• objects/eventsystem/EventDispatcher.cc (modified) (3 diffs)
• objects/eventsystem/EventFilter.cc (modified) (2 diffs)
• objects/triggers/DistanceMultiTrigger.cc (modified) (1 diff)
• objects/triggers/DistanceTrigger.cc (modified) (1 diff)
• objects/triggers/MultiTrigger.cc (modified) (3 diffs)
• objects/triggers/Trigger.cc (modified) (3 diffs)
• overlays/hud/ChatOverlay.cc (modified) (2 diffs)
• overlays/hud/HUDNavigation.cc (modified) (5 diffs)
• overlays/hud/HUDRadar.cc (modified) (1 diff)
• overlays/stats/Scoreboard.cc (modified) (2 diffs)
• pickup/PickupCollection.cc (modified) (6 diffs)
• pickup/PickupManager.cc (modified) (1 diff)
• pickup/items/MetaPickup.cc (modified) (1 diff)
• pong/Pong.cc (modified) (2 diffs)
• pong/PongAI.cc (modified) (1 diff)
• questsystem/GlobalQuest.cc (modified) (3 diffs)
• questsystem/Quest.cc (modified) (4 diffs)
• questsystem/QuestEffect.cc (modified) (1 diff)
• questsystem/QuestEffectBeacon.cc (modified) (1 diff)
• questsystem/QuestListener.cc (modified) (1 diff)
• questsystem/QuestManager.cc (modified) (6 diffs)
• questsystem/effects/AddReward.cc (modified) (2 diffs)
• tetris/Tetris.cc (modified) (3 diffs)
• tetris/TetrisBrick.cc (modified) (1 diff)
• towerdefense/TowerDefense.cc (modified) (1 diff)

code/branches/cpp11_v2/src/modules/docking/Dock.cc

@@ -327 +327 @@
     const DockingEffect* Dock::getEffect(unsigned int i) const
     {
-        for (const auto & elem : this->effects_)
+        for (DockingEffect* effect : this->effects_)
         {
             if(i == 0)
-               return elem;
+               return effect;
             i--;
         }
@@ -346 +346 @@
     const DockingAnimation* Dock::getAnimation(unsigned int i) const
     {
-        for (const auto & elem : this->animations_)
+        for (DockingAnimation* animation : this->animations_)
         {
             if(i == 0)
-               return elem;
+               return animation;
             i--;
         }

code/branches/cpp11_v2/src/modules/docking/DockingAnimation.cc

@@ -57 +57 @@
         bool check = true;
 
-        for (auto & animations_animation : animations)
+        for (DockingAnimation* animation : animations)
         {
             if(dock)
-                check &= (animations_animation)->docking(player);
+                check &= animation->docking(player);
             else
-                check &= (animations_animation)->release(player);
+                check &= animation->release(player);
         }
 

code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc

@@ -53 +53 @@
         bool check = true;
 
-        for (auto & effects_effect : effects)
+        for (DockingEffect* effect : effects)
         {
             if (dock)
-                check &= (effects_effect)->docking(player);
+                check &= effect->docking(player);
             else
-                check &= (effects_effect)->release(player);
+                check &= effect->release(player);
         }
 

code/branches/cpp11_v2/src/modules/gametypes/RaceCheckPoint.cc

@@ -146 +146 @@
     {
         Vector3 checkpoints(-1,-1,-1); int count=0;
-        for (const auto & elem : nextCheckpoints_)
+        for (int nextCheckpoint : nextCheckpoints_)
         {
             switch (count)
             {
-                case 0: checkpoints.x = static_cast<Ogre::Real>(elem); break;
-                case 1: checkpoints.y = static_cast<Ogre::Real>(elem); break;
-                case 2: checkpoints.z = static_cast<Ogre::Real>(elem); break;
+                case 0: checkpoints.x = static_cast<Ogre::Real>(nextCheckpoint); break;
+                case 1: checkpoints.y = static_cast<Ogre::Real>(nextCheckpoint); break;
+                case 2: checkpoints.z = static_cast<Ogre::Real>(nextCheckpoint); break;
             }
             ++count;

code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc

@@ -154 +154 @@
     {
         std::map<RaceCheckPoint*, int> zaehler; // counts how many times the checkpoint was reached (for simulation)
-        for (auto & allCheckpoint : allCheckpoints)
-        {
-            zaehler.insert(std::pair<RaceCheckPoint*, int>(allCheckpoint,0));
+        for (RaceCheckPoint* checkpoint : allCheckpoints)
+        {
+            zaehler.insert(std::pair<RaceCheckPoint*, int>(checkpoint,0));
         }
         int maxWays = rekSimulationCheckpointsReached(currentCheckpoint, zaehler);
 
         std::vector<RaceCheckPoint*> returnVec;
-        for (auto & elem : zaehler)
-        {
-            if (elem.second == maxWays)
-            {
-                returnVec.push_back(elem.first);
+        for (auto& mapEntry : zaehler)
+        {
+            if (mapEntry.second == maxWays)
+            {
+                returnVec.push_back(mapEntry.first);
             }
         }
@@ -226 +226 @@
 
         // find the next checkpoint with the minimal distance
-        for (auto elem : raceCheckpoint->getNextCheckpoints())
-        {
-            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(elem);
+        for (int checkpointIndex : raceCheckpoint->getNextCheckpoints())
+        {
+            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(checkpointIndex);
             float distance = recCalculateDistance(nextRaceCheckPoint, this->getControllableEntity()->getPosition());
 
@@ -289 +289 @@
     RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
     {
-        for (auto & elem : this->checkpoints_)
-            if (elem->getCheckpointIndex() == index)
-                return elem;
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+            if (checkpoint->getCheckpointIndex() == index)
+                return checkpoint;
         return nullptr;
     }
@@ -414 +414 @@
         btScalar radiusObject;
 
-        for (const auto & allObject : allObjects)
-        {
-            for (int everyShape=0; (allObject)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
-            {
-                btCollisionShape* currentShape = (allObject)->getAttachedCollisionShape(everyShape)->getCollisionShape();
+        for (StaticEntity* object : allObjects)
+        {
+            for (int everyShape=0; object->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
+            {
+                btCollisionShape* currentShape = object->getAttachedCollisionShape(everyShape)->getCollisionShape();
                 if(currentShape == nullptr)
                 continue;

code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceManager.cc

@@ -54 +54 @@
     SpaceRaceManager::~SpaceRaceManager()
     {
-        for (auto & elem : this->checkpoints_)
-        elem->destroy();
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+        checkpoint->destroy();
     }
 
@@ -77 +77 @@
         }
 
-        for (auto & elem : players_)
+        for (auto& mapEntry : players_)
         {
 
-            for (auto & _i : this->checkpoints_)
+            for (RaceCheckPoint* checkpoint : this->checkpoints_)
             {
-                if (_i->playerWasHere(elem.first)){
-                this->checkpointReached(_i, elem.first /*this->checkpoints_[i]->getPlayer()*/);
+                if (checkpoint->playerWasHere(mapEntry.first)){
+                this->checkpointReached(checkpoint, mapEntry.first /*this->checkpoints_[i]->getPlayer()*/);
                 }
             }
@@ -113 +113 @@
     RaceCheckPoint* SpaceRaceManager::findCheckpoint(int index) const
     {
-        for (auto & elem : this->checkpoints_)
-        if (elem->getCheckpointIndex() == index)
-        return elem;
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+        if (checkpoint->getCheckpointIndex() == index)
+        return checkpoint;
         return nullptr;
     }
@@ -125 +125 @@
             // the player already visited an old checkpoint; see which checkpoints are possible now
             const std::set<int>& possibleCheckpoints = oldCheckpoint->getNextCheckpoints();
-            for (const auto & possibleCheckpoint : possibleCheckpoints)
+            for (int possibleCheckpoint : possibleCheckpoints)
             if (this->findCheckpoint(possibleCheckpoint) == newCheckpoint)
             return true;
@@ -179 +179 @@
         {
             const std::set<int>& oldVisible = oldCheckpoint->getNextCheckpoints();
-            for (const auto & elem : oldVisible)
-            this->findCheckpoint(elem)->setRadarVisibility(false);
+            for (int checkpointIndex : oldVisible)
+            this->findCheckpoint(checkpointIndex)->setRadarVisibility(false);
         }
 
@@ -188 +188 @@
 
             const std::set<int>& newVisible = newCheckpoint->getNextCheckpoints();
-            for (const auto & elem : newVisible)
-            this->findCheckpoint(elem)->setRadarVisibility(true);
+            for (int checkpointIndex : newVisible)
+            this->findCheckpoint(checkpointIndex)->setRadarVisibility(true);
         }
     }

code/branches/cpp11_v2/src/modules/jump/Jump.cc

@@ -633 +633 @@
 
 
-        for (auto & elem : matrix)
+        for (int i = 0; i < numI; ++i)
         {
             for (int j = 0; j < numJ; ++j)
             {
-                elem[j].type = PLATFORM_EMPTY;
-                elem[j].done = false;
+                matrix[i][j].type = PLATFORM_EMPTY;
+                matrix[i][j].done = false;
             }
         }
@@ -795 +795 @@
 
         // Fill matrix with selected platform types
-        for (auto & elem : matrix)
+        for (int i = 0; i < numI; ++ i)
         {
             for (int j = 0; j < numJ; ++ j)
@@ -801 +801 @@
                 if (rand()%3 == 0)
                 {
-                    elem[j].type = platformtype1;
+                    matrix[i][j].type = platformtype1;
                 }
                 else
                 {
-                    elem[j].type = platformtype2;
+                    matrix[i][j].type = platformtype2;
                 }
-                elem[j].done = false;
+                matrix[i][j].done = false;
             }
         }

code/branches/cpp11_v2/src/modules/mini4dgame/Mini4Dgame.cc

@@ -155 +155 @@
     {
         // first spawn human players to assign always the left bat to the player in singleplayer
-        for (auto & elem : this->players_)
-            if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
         // now spawn bots
-        for (auto & elem : this->players_)
-            if (!elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (!mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
     }
 

code/branches/cpp11_v2/src/modules/notifications/NotificationManager.cc

@@ -69 +69 @@
     {
         // Destroys all Notifications.
-        for(auto & elem : this->allNotificationsList_)
-            elem.second->destroy();
+        for(auto& mapEntry : this->allNotificationsList_)
+            mapEntry.second->destroy();
         this->allNotificationsList_.clear();
 
@@ -152 +152 @@
         bool executed = false;
         // Clear all NotificationQueues that have the input sender as target.
-        for(auto & elem : this->queues_) // Iterate through all NotificationQueues.
-        {
-            const std::set<std::string>& set = elem.second->getTargetsSet();
+        for(auto& mapEntry : this->queues_) // Iterate through all NotificationQueues.
+        {
+            const std::set<std::string>& set = mapEntry.second->getTargetsSet();
             // If either the sender is 'all', the NotificationQueue has as target all or the NotificationQueue has the input sender as a target.
             if(all || set.find(NotificationListener::ALL) != set.end() || set.find(sender) != set.end())
-                executed = elem.second->tidy() || executed;
+                executed = mapEntry.second->tidy() || executed;
         }
 
@@ -187 +187 @@
 
         // Insert the Notification in all NotificationQueues that have its sender as target.
-        for(auto & elem : this->queues_) // Iterate through all NotificationQueues.
-        {
-            const std::set<std::string>& set = elem.second->getTargetsSet();
+        for(auto& mapEntry : this->queues_) // Iterate through all NotificationQueues.
+        {
+            const std::set<std::string>& set = mapEntry.second->getTargetsSet();
             bool bAll = set.find(NotificationListener::ALL) != set.end();
             // If either the Notification has as sender 'all', the NotificationQueue displays all Notifications or the NotificationQueue has the sender of the Notification as target.
@@ -195 +195 @@
             {
                 if(!bAll)
-                    this->notificationLists_[elem.second->getName()]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationQueue.
-                elem.second->update(notification, time); // Update the NotificationQueue.
+                    this->notificationLists_[mapEntry.second->getName()]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationQueue.
+                mapEntry.second->update(notification, time); // Update the NotificationQueue.
             }
         }
@@ -345 +345 @@
 
         // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
-        for(auto & elem : this->allNotificationsList_)
-        {
-            if(!bAll && set.find(elem.second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
-                map->insert(std::pair<std::time_t, Notification*>(elem.first, elem.second));
+        for(auto& mapEntry : this->allNotificationsList_)
+        {
+            if(!bAll && set.find(mapEntry.second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
+                map->insert(std::pair<std::time_t, Notification*>(mapEntry.first, mapEntry.second));
         }
 

code/branches/cpp11_v2/src/modules/notifications/NotificationQueue.cc

@@ -206 +206 @@
         {
             // Add all Notifications that have been created after this NotificationQueue was created.
-            for(auto & notification : *notifications)
+            for(auto& mapEntry : *notifications)
             {
-                if(notification.first >= this->creationTime_)
-                    this->push(notification.second, notification.first);
+                if(mapEntry.first >= this->creationTime_)
+                    this->push(mapEntry.second, mapEntry.first);
             }
         }
@@ -336 +336 @@
         this->ordering_.clear();
         // Delete all NotificationContainers in the list.
-        for(auto & elem : this->notifications_)
-            delete elem;
+        for(NotificationContainer* notification : this->notifications_)
+            delete notification;
 
         this->notifications_.clear();
@@ -426 +426 @@
         bool first = true;
         // Iterate through the set of targets.
-        for(const auto & elem : this->targets_)
+        for(const std::string& target : this->targets_)
         {
             if(!first)
@@ -432 +432 @@
             else
                 first = false;
-            stream << elem;
+            stream << target;
         }
 

code/branches/cpp11_v2/src/modules/objects/Attacher.cc

@@ -61 +61 @@
         SUPER(Attacher, changedActivity);
 
-        for (auto & elem : this->objects_)
-            (elem)->setActive(this->isActive());
+        for (WorldEntity* object : this->objects_)
+            object->setActive(this->isActive());
     }
 
@@ -69 +69 @@
         SUPER(Attacher, changedVisibility);
 
-        for (auto & elem : this->objects_)
-            (elem)->setVisible(this->isVisible());
+        for (WorldEntity* object : this->objects_)
+            object->setVisible(this->isVisible());
     }
 
@@ -83 +83 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->objects_)
+        for (WorldEntity* object : this->objects_)
         {
             if (i == index)
-                return (elem);
+                return object;
 
             ++i;

code/branches/cpp11_v2/src/modules/objects/Script.cc

@@ -196 +196 @@
             {
                 const std::map<unsigned int, PlayerInfo*> clients = PlayerManager::getInstance().getClients();
-                for(const auto & client : clients)
+                for(const auto& mapEntry : clients)
                 {
-                    callStaticNetworkFunction(&Script::executeHelper, client.first, this->getCode(), this->getMode(), this->getNeedsGraphics());
+                    callStaticNetworkFunction(&Script::executeHelper, mapEntry.first, this->getCode(), this->getMode(), this->getNeedsGraphics());
                     if(this->times_ != Script::INF) // Decrement the number of remaining executions.
                     {

code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc

@@ -59 +59 @@
             this->pawnsIn_.clear();
 
-            for(auto & elem : this->billboards_)
+            for(BillboardAdministration& billboard : this->billboards_)
             {
-                if( elem.billy != nullptr)
-                {
-                    delete elem.billy;
+                if( billboard.billy != nullptr)
+                {
+                    delete billboard.billy;
                 }
             }
@@ -138 +138 @@
     void SpaceBoundaries::removeAllBillboards()
     {
-        for(auto & elem : this->billboards_)
-        {
-            elem.usedYet = false;
-            elem.billy->setVisible(false);
+        for(BillboardAdministration& billboard : this->billboards_)
+        {
+            billboard.usedYet = false;
+            billboard.billy->setVisible(false);
         }
     }
@@ -208 +208 @@
         float distance;
         bool humanItem;
-        for(auto currentPawn : pawnsIn_)
-        {
-            
+        for(Pawn* currentPawn : pawnsIn_)
+        {
             if( currentPawn && currentPawn->getNode() ) 
             {

code/branches/cpp11_v2/src/modules/objects/eventsystem/EventDispatcher.cc

@@ -45 +45 @@
     {
         if (this->isInitialized())
-            for (auto & elem : this->targets_)
-                (elem)->destroy();
+            for (BaseObject* target : this->targets_)
+                target->destroy();
     }
 
@@ -61 +61 @@
     void EventDispatcher::processEvent(Event& event)
     {
-        for (auto & elem : this->targets_)
-            (elem)->processEvent(event);
+        for (BaseObject* target : this->targets_)
+            target->processEvent(event);
     }
 
@@ -73 +73 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->targets_)
+        for (BaseObject* target : this->targets_)
         {
             if (i == index)
-                return (elem);
+                return target;
             ++i;
         }

code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc

@@ -96 +96 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->sources_)
+        for (BaseObject* source : this->sources_)
         {
             if (i == index)
-                return (elem);
+                return source;
             ++i;
         }
@@ -113 +113 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->names_)
+        for (EventName* name : this->names_)
         {
             if (i == index)
-                return (elem);
+                return name;
             ++i;
         }

code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.cc

@@ -158 +158 @@
             {
                 
-                const std::set<WorldEntity*> attached = entity->getAttachedObjects();
+                const std::set<WorldEntity*> attachedObjects = entity->getAttachedObjects();
                 bool found = false;
-                for(const auto & elem : attached)
+                for(WorldEntity* attachedObject : attachedObjects)
                 {
-                    if((elem)->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(elem)->getName() == this->targetName_)
+                    if(attachedObject->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(attachedObject)->getName() == this->targetName_)
                     {
                         found = true;

code/branches/cpp11_v2/src/modules/objects/triggers/DistanceTrigger.cc

@@ -180 +180 @@
             {
 
-                const std::set<WorldEntity*> attached = entity->getAttachedObjects();
+                const std::set<WorldEntity*> attachedObjects = entity->getAttachedObjects();
                 bool found = false;
-                for(const auto & elem : attached)
+                for(WorldEntity* attachedObject : attachedObjects)
                 {
-                    if((elem)->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(elem)->getName() == this->targetName_)
+                    if(attachedObject->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(attachedObject)->getName() == this->targetName_)
                     {
                         found = true;

code/branches/cpp11_v2/src/modules/objects/triggers/MultiTrigger.cc

@@ -504 +504 @@
     bool MultiTrigger::checkAnd(BaseObject* triggerer)
     {
-        for(auto trigger : this->children_)
-        {
-            
+        for(TriggerBase* trigger : this->children_)
+        {
             if(trigger->isMultiTrigger())
             {
@@ -531 +530 @@
     bool MultiTrigger::checkOr(BaseObject* triggerer)
     {
-        for(auto trigger : this->children_)
-        {
-            
+        for(TriggerBase* trigger : this->children_)
+        {
             if(trigger->isMultiTrigger())
             {
@@ -559 +557 @@
     {
         bool triggered = false;
-        for(auto trigger : this->children_)
-        {
-            
+        for(TriggerBase* trigger : this->children_)
+        {
             if(triggered)
             {

code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc

@@ -234 +234 @@
     {
         // Iterate over all sub-triggers.
-        for (const auto & elem : this->children_)
-        {
-            if (!(elem)->isActive())
+        for (TriggerBase* child : this->children_)
+        {
+            if (!child->isActive())
                 return false;
         }
@@ -252 +252 @@
     {
         // Iterate over all sub-triggers.
-        for (const auto & elem : this->children_)
-        {
-            if ((elem)->isActive())
+        for (TriggerBase* child : this->children_)
+        {
+            if (child->isActive())
                 return true;
         }
@@ -270 +270 @@
     {
         bool test = false;
-        for (const auto & elem : this->children_)
-        {
-            if (test && (elem)->isActive())
+        for (TriggerBase* child : this->children_)
+        {
+            if (test && child->isActive())
                 return false;
-            if ((elem)->isActive())
+            if (child->isActive())
                 test = true;
         }

code/branches/cpp11_v2/src/modules/overlays/hud/ChatOverlay.cc

@@ -58 +58 @@
     ChatOverlay::~ChatOverlay()
     {
-        for (const auto & elem : this->timers_)
-            delete (elem);
+        for (Timer* timer : this->timers_)
+            delete timer;
     }
 
@@ -92 +92 @@
         this->text_->setCaption("");
 
-        for (auto & elem : this->messages_)
+        for (const Ogre::DisplayString& message : this->messages_)
         {
-            this->text_->setCaption(this->text_->getCaption() + "\n" + (elem));
+            this->text_->setCaption(this->text_->getCaption() + "\n" + message);
         }
     }

code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.cc

@@ -131 +131 @@
         }
         this->fontName_ = font;
-        for (auto & elem : this->activeObjectList_)
-        {
-            if (elem.second.text_ != nullptr)
-                elem.second.text_->setFontName(this->fontName_);
+        for (auto& mapEntry : this->activeObjectList_)
+        {
+            if (mapEntry.second.text_ != nullptr)
+                mapEntry.second.text_->setFontName(this->fontName_);
         }
     }
@@ -151 +151 @@
         }
         this->textSize_ = size;
-        for (auto & elem : this->activeObjectList_)
-        {
-            if (elem.second.text_)
-                elem.second.text_->setCharHeight(size);
+        for (auto& mapEntry : this->activeObjectList_)
+        {
+            if (mapEntry.second.text_)
+                mapEntry.second.text_->setCharHeight(size);
         }
     }
@@ -186 +186 @@
         const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
 
-        for (auto & elem : this->sortedObjectList_)
-        elem.second = (int)((elem.first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
+        for (std::pair<RadarViewable*, unsigned int>& pair : this->sortedObjectList_)
+        pair.second = (int)((pair.first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
 
         this->sortedObjectList_.sort(compareDistance);
@@ -531 +531 @@
         float yScale = this->getActualSize().y;
 
-        for (auto & elem : this->activeObjectList_)
-        {
-            if (elem.second.health_ != nullptr)
-                elem.second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
-            if (elem.second.healthLevel_ != nullptr)
-                elem.second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
-            if (elem.second.panel_ != nullptr)
-                elem.second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
-            if (elem.second.text_ != nullptr)
-                elem.second.text_->setCharHeight(this->textSize_ * yScale);
-            if (elem.second.target_ != nullptr)
-                elem.second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
+        for (auto& mapEntry : this->activeObjectList_)
+        {
+            if (mapEntry.second.health_ != nullptr)
+                mapEntry.second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
+            if (mapEntry.second.healthLevel_ != nullptr)
+                mapEntry.second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
+            if (mapEntry.second.panel_ != nullptr)
+                mapEntry.second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
+            if (mapEntry.second.text_ != nullptr)
+                mapEntry.second.text_->setCharHeight(this->textSize_ * yScale);
+            if (mapEntry.second.target_ != nullptr)
+                mapEntry.second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
         }
     }
@@ -670 +670 @@
     {
         const std::set<RadarViewable*>& respawnObjects = this->getOwner()->getScene()->getRadar()->getRadarObjects();
-        for (const auto & respawnObject : respawnObjects)
-        {
-            if (!(respawnObject)->isHumanShip_)
+        for (RadarViewable* respawnObject : respawnObjects)
+        {
+            if (!respawnObject->isHumanShip_)
             this->addObject(respawnObject);
         }

code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc

@@ -92 +92 @@
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->map3DBack_);
 
-            for (auto & elem : this->radarObjects_)
-            {
-                Ogre::OverlayManager::getSingleton().destroyOverlayElement(elem.second);
+            for (auto& mapEntry : this->radarObjects_)
+            {
+                Ogre::OverlayManager::getSingleton().destroyOverlayElement(mapEntry.second);
             }
         }

code/branches/cpp11_v2/src/modules/overlays/stats/Scoreboard.cc

@@ -60 +60 @@
         SUPER(Scoreboard, changedVisibility);
 
-        for (auto & elem : this->lines_)
-            elem->changedVisibility();
+        for (CreateLines* line : this->lines_)
+            line->changedVisibility();
     }
 
@@ -94 +94 @@
 
         unsigned int index = 0;
-        for (const auto & elem : playerList)
+        for (const auto& mapEntry : playerList)
         {
-            this->lines_[index]->setPlayerName(multi_cast<std::string>(elem.first->getName()));
-            this->lines_[index]->setScore(multi_cast<std::string>(elem.second.frags_));
-            this->lines_[index]->setDeaths(multi_cast<std::string>(elem.second.killed_));
+            this->lines_[index]->setPlayerName(multi_cast<std::string>(mapEntry.first->getName()));
+            this->lines_[index]->setScore(multi_cast<std::string>(mapEntry.second.frags_));
+            this->lines_[index]->setDeaths(multi_cast<std::string>(mapEntry.second.killed_));
             index++;
         }

code/branches/cpp11_v2/src/modules/pickup/PickupCollection.cc

@@ -68 +68 @@
     {
         // Destroy all Pickupables constructing this PickupCollection.
-        for(auto & elem : this->pickups_)
-        {
-            (elem)->wasRemovedFromCollection();
-            (elem)->destroy();
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            pickup->wasRemovedFromCollection();
+            pickup->destroy();
         }
         this->pickups_.clear();
@@ -99 +99 @@
         this->processingUsed_ = true;
         // Change used for all Pickupables this PickupCollection consists of.
-        for(auto & elem : this->pickups_)
-            (elem)->setUsed(this->isUsed());
+        for(CollectiblePickup* pickup : this->pickups_)
+            pickup->setUsed(this->isUsed());
 
         this->processingUsed_ = false;
@@ -119 +119 @@
         size_t numPickupsEnabled = 0;
         size_t numPickupsInUse = 0;
-        for(auto & elem : this->pickups_)
-        {
-            if ((elem)->isEnabled())
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if (pickup->isEnabled())
                 ++numPickupsEnabled;
-            if ((elem)->isUsed())
+            if (pickup->isUsed())
                 ++numPickupsInUse;
         }
@@ -146 +146 @@
 
         // Change the PickupCarrier for all Pickupables this PickupCollection consists of.
-        for(auto & elem : this->pickups_)
+        for(CollectiblePickup* pickup : this->pickups_)
         {
             if(this->getCarrier() == nullptr)
-                (elem)->setCarrier(nullptr);
+                pickup->setCarrier(nullptr);
             else
-                (elem)->setCarrier(this->getCarrier()->getTarget(elem));
+                pickup->setCarrier(this->getCarrier()->getTarget(pickup));
         }
     }
@@ -186 +186 @@
         // If at least all the enabled pickups of this PickupCollection are no longer picked up.
         bool isOnePickupEnabledAndPickedUp = false;
-        for(auto & elem : this->pickups_)
-        {
-            if ((elem)->isEnabled() && (elem)->isPickedUp())
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if (pickup->isEnabled() && pickup->isPickedUp())
             {
                 isOnePickupEnabledAndPickedUp = true;
@@ -208 +208 @@
     bool PickupCollection::isTarget(const PickupCarrier* carrier) const
     {
-        for(const auto & elem : this->pickups_)
-        {
-            if(!carrier->isTarget(elem))
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if(!carrier->isTarget(pickup))
                 return false;
         }

code/branches/cpp11_v2/src/modules/pickup/PickupManager.cc

@@ -91 +91 @@
 
         // Destroying all the PickupInventoryContainers that are still there.
-        for(auto & elem : this->pickupInventoryContainers_)
-            delete elem.second;
+        for(auto& mapEntry : this->pickupInventoryContainers_)
+            delete mapEntry.second;
         this->pickupInventoryContainers_.clear();
 

code/branches/cpp11_v2/src/modules/pickup/items/MetaPickup.cc

@@ -118 +118 @@
                 std::set<Pickupable*> pickups = carrier->getPickups();
                 // Iterate over all Pickupables of the PickupCarrier.
-                for(auto pickup : pickups)
+                for(Pickupable* pickup : pickups)
                 {
-                    
                     if(pickup == nullptr || pickup == this)
                         continue;

code/branches/cpp11_v2/src/modules/pong/Pong.cc

@@ -145 +145 @@
 
             // If one of the bats is missing, create it. Apply the template for the bats as specified in the centerpoint.
-            for (auto & elem : this->bat_)
+            for (WeakPtr<orxonox::PongBat>& bat : this->bat_)
             {
-                if (elem == nullptr)
+                if (bat == nullptr)
                 {
-                    elem = new PongBat(this->center_->getContext());
-                    elem->addTemplate(this->center_->getBattemplate());
+                    bat = new PongBat(this->center_->getContext());
+                    bat->addTemplate(this->center_->getBattemplate());
                 }
             }
@@ -211 +211 @@
     {
         // first spawn human players to assign always the left bat to the player in singleplayer
-        for (auto & elem : this->players_)
-            if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
         // now spawn bots
-        for (auto & elem : this->players_)
-            if (!elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (!mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
     }
 

code/branches/cpp11_v2/src/modules/pong/PongAI.cc

@@ -77 +77 @@
     PongAI::~PongAI()
     {
-        for (auto & elem : this->reactionTimers_)
-            elem.first->destroy();
+        for (std::pair<Timer*, char>& pair : this->reactionTimers_)
+            pair.first->destroy();
     }
 

code/branches/cpp11_v2/src/modules/questsystem/GlobalQuest.cc

@@ -94 +94 @@
 
         // Iterate through all players possessing this Quest.
-        for(const auto & elem : players_)
-            QuestEffect::invokeEffects(elem, this->getFailEffectList());
+        for(PlayerInfo* questPlayer : players_)
+            QuestEffect::invokeEffects(questPlayer, this->getFailEffectList());
 
         return true;
@@ -119 +119 @@
 
         // Iterate through all players possessing the Quest.
-        for(const auto & elem : players_)
-            QuestEffect::invokeEffects(elem, this->getCompleteEffectList());
+        for(PlayerInfo* questPlayer : players_)
+            QuestEffect::invokeEffects(questPlayer, this->getCompleteEffectList());
 
         Quest::complete(player);
@@ -242 +242 @@
     {
         int i = index;
-        for (const auto & elem : this->rewards_)
+        for (QuestEffect* reward : this->rewards_)
         {
             if(i == 0)
-               return elem;
+               return reward;
 
             i--;

code/branches/cpp11_v2/src/modules/questsystem/Quest.cc

@@ -190 +190 @@
 
         // Iterate through all subquests.
-        for (const auto & elem : this->subQuests_)
+        for (Quest* quest : this->subQuests_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return quest;
 
             i--;
@@ -214 +214 @@
 
         // Iterate through all QuestHints.
-        for (const auto & elem : this->hints_)
+        for (QuestHint* hint : this->hints_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return hint;
 
             i--;
@@ -237 +237 @@
 
         // Iterate through all fail QuestEffects.
-        for (const auto & elem : this->failEffects_)
+        for (QuestEffect* effect : this->failEffects_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return effect;
 
             i--;
@@ -260 +260 @@
 
         // Iterate through all complete QuestEffects.
-        for (const auto & elem : this->completeEffects_)
+        for (QuestEffect* effect : this->completeEffects_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return effect;
 
             i--;

code/branches/cpp11_v2/src/modules/questsystem/QuestEffect.cc

@@ -74 +74 @@
         orxout(verbose, context::quests) << "Invoking QuestEffects on player: " << player << " ."  << endl;
 
-        for (auto & effects_effect : effects)
-            temp = temp && (effects_effect)->invoke(player);
+        for (QuestEffect* effect : effects)
+            temp = temp && effect->invoke(player);
 
         return temp;

code/branches/cpp11_v2/src/modules/questsystem/QuestEffectBeacon.cc

@@ -236 +236 @@
     {
         int i = index;
-        for (const auto & elem : this->effects_)
+        for (QuestEffect* effect : this->effects_)
         {
             if(i == 0)
-               return elem;
+               return effect;
 
             i--;

code/branches/cpp11_v2/src/modules/questsystem/QuestListener.cc

@@ -97 +97 @@
     /* static */ void QuestListener::advertiseStatusChange(std::list<QuestListener*> & listeners, const std::string & status)
     {
-        for (auto listener : listeners) // Iterate through all QuestListeners
-        {
-            
+        for (QuestListener* listener : listeners) // Iterate through all QuestListeners
+        {
             if(listener->getMode() == status || listener->getMode() == QuestListener::ALL) // Check whether the status change affects the give QuestListener.
                 listener->execute();

code/branches/cpp11_v2/src/modules/questsystem/QuestManager.cc

@@ -235 +235 @@
     {
         int numQuests = 0;
-        for(auto & elem : this->questMap_)
-        {
-            if(elem.second->getParentQuest() == nullptr && !elem.second->isInactive(player))
+        for(auto& mapEntry : this->questMap_)
+        {
+            if(mapEntry.second->getParentQuest() == nullptr && !mapEntry.second->isInactive(player))
                 numQuests++;
         }
@@ -255 +255 @@
     Quest* QuestManager::getRootQuest(PlayerInfo* player, int index)
     {
-        for(auto & elem : this->questMap_)
-        {
-            if(elem.second->getParentQuest() == nullptr && !elem.second->isInactive(player) && index-- == 0)
-                return elem.second;
+        for(auto& mapEntry : this->questMap_)
+        {
+            if(mapEntry.second->getParentQuest() == nullptr && !mapEntry.second->isInactive(player) && index-- == 0)
+                return mapEntry.second;
         }
         return nullptr;
@@ -280 +280 @@
         std::list<Quest*> quests = quest->getSubQuestList();
         int numQuests = 0;
-        for(auto & quest : quests)
-        {
-            if(!(quest)->isInactive(player))
+        for(Quest* subquest : quests)
+        {
+            if(!subquest->isInactive(player))
                 numQuests++;
         }
@@ -304 +304 @@
 
         std::list<Quest*> quests = quest->getSubQuestList();
-        for(auto & quest : quests)
-        {
-            if(!(quest)->isInactive(player) && index-- == 0)
+        for(Quest* subquest : quests)
+        {
+            if(!subquest->isInactive(player) && index-- == 0)
                 return quest;
         }
@@ -326 +326 @@
         std::list<QuestHint*> hints = quest->getHintsList();
         int numHints = 0;
-        for(auto & hint : hints)
-        {
-            if((hint)->isActive(player))
+        for(QuestHint* hint : hints)
+        {
+            if(hint->isActive(player))
                 numHints++;
         }
@@ -349 +349 @@
     {
         std::list<QuestHint*> hints = quest->getHintsList();
-        for(auto & hint : hints)
-        {
-            if((hint)->isActive(player) && index-- == 0)
+        for(QuestHint* hint : hints)
+        {
+            if(hint->isActive(player) && index-- == 0)
                 return hint;
         }

code/branches/cpp11_v2/src/modules/questsystem/effects/AddReward.cc

@@ -84 +84 @@
     {
         int i = index;
-        for (const auto & elem : this->rewards_)
+        for (Rewardable* reward : this->rewards_)
         {
             if(i == 0)
-               return elem;
+               return reward;
             i--;
         }
@@ -106 +106 @@
 
         bool temp = true;
-        for (auto & elem : this->rewards_)
-            temp = temp && (elem)->reward(player);
+        for (Rewardable* reward : this->rewards_)
+            temp = temp && reward->reward(player);
 
         orxout(verbose, context::quests) << "Rewardable successfully added to player." << player << " ." << endl;

code/branches/cpp11_v2/src/modules/tetris/Tetris.cc

@@ -104 +104 @@
         }
 
-        for (auto & elem : this->stones_)
-            (elem)->destroy();
+        for (TetrisStone* stone : this->stones_)
+            stone->destroy();
         this->stones_.clear();
     }
@@ -341 +341 @@
     {
         // Spawn a human player.
-        for (auto & elem : this->players_)
-            if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
     }
     
@@ -502 +502 @@
         }
       // adjust height of stones above the deleted row //TODO: check if this could be a source of a bug.
-        for(auto & elem : this->stones_)
-        {
-            if(static_cast<unsigned int>(((elem)->getPosition().y - 5)/this->center_->getStoneSize()) > row)
-                (elem)->setPosition((elem)->getPosition()-Vector3(0,10,0));
+        for(TetrisStone* stone : this->stones_)
+        {
+            if(static_cast<unsigned int>((stone->getPosition().y - 5)/this->center_->getStoneSize()) > row)
+                stone->setPosition(stone->getPosition()-Vector3(0,10,0));
         }
 

code/branches/cpp11_v2/src/modules/tetris/TetrisBrick.cc

@@ -239 +239 @@
     {
         assert(this->tetris_);
-        for(auto & elem : this->brickStones_)
-        {
-            elem->detachFromParent();
-            elem->attachToParent(center);
-            elem->setPosition(this->getPosition()+this->tetris_->rotateVector(elem->getPosition(),this->rotationCount_ ));
+        for(TetrisStone* stone : this->brickStones_)
+        {
+            stone->detachFromParent();
+            stone->attachToParent(center);
+            stone->setPosition(this->getPosition()+this->tetris_->rotateVector(stone->getPosition(),this->rotationCount_ ));
         }
         this->brickStones_.clear();

code/branches/cpp11_v2/src/modules/towerdefense/TowerDefense.cc

@@ -183 +183 @@
             en1->lookAt(waypoints_.at(1)->getPosition() + offset_);
 
-            for (auto & elem : waypoints_)
+            for (TowerDefenseField* field : waypoints_)
             {
                 orxonox::WeakPtr<MovableEntity> waypoint = new MovableEntity(this->center_->getContext());
-                waypoint->setPosition(elem->getPosition() + offset_);
+                waypoint->setPosition(field->getPosition() + offset_);
                 controller->addWaypoint(waypoint);
             }