Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 2, 2015, 11:22:03 PM (8 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
Files:
130 edited

Legend:

Unmodified
Added
Removed

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

    r10821 r10916  
    234234    {
    235235        unsigned int i = 0;
    236         for (const auto & elem : this->templates_)
     236        for (Template* temp : this->templates_)
    237237        {
    238238            if (i == index)
    239                 return (elem);
     239                return temp;
    240240            i++;
    241241        }
    … …  
    269269    {
    270270        unsigned int i = 0;
    271         for (const auto & elem : this->eventSources_)
    272         {
    273             if (elem.second != state)
     271        for (const auto& mapEntry : this->eventSources_)
     272        {
     273            if (mapEntry.second != state)
    274274                continue;
    275275
    276276            if (i == index)
    277                 return elem.first;
     277                return mapEntry.first;
    278278            ++i;
    279279        }
    … …  
    296296    {
    297297        unsigned int i = 0;
    298         for (const auto & elem : this->eventListenersXML_)
     298        for (BaseObject* listener : this->eventListenersXML_)
    299299        {
    300300            if (i == index)
    301                 return elem;
     301                return listener;
    302302            ++i;
    303303        }
    … …  
    358358        Event event(activate, originator, name);
    359359
    360         for (const auto & elem : this->eventListeners_)
    361         {
    362             event.statename_ = (elem)->eventSources_[this];
    363             (elem)->processEvent(event);
     360        for (BaseObject* listener : this->eventListeners_)
     361        {
     362            event.statename_ = listener->eventSources_[this];
     363            listener->processEvent(event);
    364364        }
    365365    }
    … …  
    370370    void BaseObject::fireEvent(Event& event)
    371371    {
    372         for (const auto & elem : this->eventListeners_)
    373             (elem)->processEvent(event);
     372        for (BaseObject* listener : this->eventListeners_)
     373            listener->processEvent(event);
    374374    }
    375375
    … …  
    474474
    475475            // iterate through all states and get the event sources
    476             for (auto & statename : eventnames)
    477             {
    478                
    479 
     476            for (const std::string& statename : eventnames)
     477            {
    480478                // if the event state is already known, continue with the next state
    481479                orxonox::EventState* eventstate = object->getEventState(statename);

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

    r10821 r10916  
    293293        {
    294294            // No it's not: Search for classes inheriting from the given class and add the rules for them
    295             for (const auto & elem : subclass->getDirectChildren())
    296                 if ((elem)->isA(this->root_->getClass()))
    297                     if (overwrite || (!this->nodeExists(elem))) // If we don't want to overwrite, only add nodes that don't already exist
    298                         this->add(this->root_, elem, bInclude, overwrite);
     295            for (const Identifier* directChild : subclass->getDirectChildren())
     296                if (directChild->isA(this->root_->getClass()))
     297                    if (overwrite || (!this->nodeExists(directChild))) // If we don't want to overwrite, only add nodes that don't already exist
     298                        this->add(this->root_, directChild, bInclude, overwrite);
    299299        }
    300300
    … …  
    325325        {
    326326            // Search for an already existing node, containing the subclass we want to add
    327             for (auto & elem : node->subnodes_)
     327            for (ClassTreeMaskNode* subnode : node->subnodes_)
    328328            {
    329                 if (subclass->isA((elem)->getClass()))
     329                if (subclass->isA(subnode->getClass()))
    330330                {
    331331                    // We've found an existing node -> delegate the work with a recursive function-call and return
    332                     this->add(elem, subclass, bInclude, overwrite);
     332                    this->add(subnode, subclass, bInclude, overwrite);
    333333                    return;
    334334                }
    … …  
    392392        if (!subclass)
    393393            return;
    394         for (const auto & elem : subclass->getDirectChildren())
    395             this->add(elem, this->isIncluded(elem), false, false);
     394        for (const Identifier* directChild : subclass->getDirectChildren())
     395            this->add(directChild, this->isIncluded(directChild), false, false);
    396396
    397397        this->add(subclass, bInclude, false, clean);
    … …  
    435435
    436436            // Go through the list of subnodes and look for a node containing the searched subclass and delegate the request by a recursive function-call.
    437             for (auto & elem : node->subnodes_)
    438                 if (subclass->isA((elem)->getClass()))
    439                     return isIncluded(elem, subclass);
     437            for (ClassTreeMaskNode* subnode : node->subnodes_)
     438                if (subclass->isA(subnode->getClass()))
     439                    return isIncluded(subnode, subclass);
    440440
    441441            // There is no subnode containing our class -> the rule of the current node takes in effect
    … …  
    957957            // The bool is "false", meaning they have no subnodes and therefore need no further checks
    958958            if (node->isIncluded())
    959                 for (const auto & elem : directChildren)
    960                     this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(elem, false));
     959                for (const Identifier* directChild : directChildren)
     960                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(directChild, false));
    961961        }
    962962    }

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

    r10821 r10916  
    279279
    280280        const std::vector<std::string>& modulePaths = ApplicationPaths::getInstance().getModulePaths();
    281         for (const auto & modulePath : modulePaths)
     281        for (const std::string& modulePath : modulePaths)
    282282        {
    283283            ModuleInstance* module = new ModuleInstance(modulePath);
    … …  
    309309    void Core::unloadModules()
    310310    {
    311         for (auto module : this->modules_)
    312         {
    313            
     311        for (ModuleInstance* module : this->modules_)
     312        {
    314313            this->unloadModule(module);
    315314            delete module;

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

    r10821 r10916  
    9999        std::set<Identifier*> identifiers;
    100100        const std::set<StaticallyInitializedInstance*>& instances = module->getInstances(StaticInitialization::IDENTIFIER);
    101         for (const auto & instance : instances)
     101        for (StaticallyInitializedInstance* instance : instances)
    102102            identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(instance)->getIdentifier());
    103103
    … …  
    106106        // that objects within one module may reference each other by strong pointers. but it is not allowed that objects from another
    107107        // module (which is not unloaded) uses strong pointers to point at objects inside the unloaded module. this will lead to a crash.
    108         for (const auto & identifier : identifiers)
    109             (identifier)->destroyObjects();
     108        for (Identifier* identifier : identifiers)
     109            identifier->destroyObjects();
    110110
    111111        // check if all objects were really destroyed. this is not the case if an object is referenced by a strong pointer from another
    112112        // module (or if two objects inside this module reference each other). this will lead to a crash and must be fixed (e.g. by
    113113        // changing object dependencies; or by changing the logic that allows modules to be unloaded).
    114         for (const auto & identifier : identifiers)
     114        for (Identifier* identifier : identifiers)
    115115        {
    116116            ObjectListBase* objectList = Context::getRootContext()->getObjectList(identifier);
    117117            if (objectList->size() > 0)
    118118            {
    119                 orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (identifier)->getName()
     119                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << identifier->getName()
    120120                    << " after unloading the Identifier. This may lead to a crash" << endl;
    121121            }
    … …  
    123123
    124124        // destroy object-lists in all contexts
    125         for (const auto & identifier : identifiers)
     125        for (Identifier* identifier : identifiers)
    126126        {
    127127            // only do this if the Identifier is not a Context itself; otherwise we delete the list we're iterating over
    128             if (!(identifier)->isExactlyA(Class(Context)))
     128            if (!identifier->isExactlyA(Class(Context)))
    129129            {
    130130                // iterate over all contexts
    131131                for (ObjectList<Context>::iterator it_context = ObjectList<Context>::begin(); it_context != ObjectList<Context>::end(); ++it_context)
    132                     it_context->destroyObjectList((identifier));
     132                    it_context->destroyObjectList(identifier);
    133133            }
    134134        }

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

    r10821 r10916  
    612612        // Check if graphics is still required
    613613        bool graphicsRequired = false;
    614         for (auto & elem : loadedStates_)
    615             graphicsRequired |= elem->getInfo().bGraphicsMode;
     614        for (const std::shared_ptr<GameState>& state : loadedStates_)
     615            graphicsRequired |= state->getInfo().bGraphicsMode;
    616616        if (!graphicsRequired)
    617617            this->unloadGraphics(!this->bAbort_); // if abort is false, that means the game is still running while unloading graphics. in this case we load a graphics manager without renderer (to keep all necessary ogre instances alive)

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

    r10821 r10916  
    107107    Language::~Language()
    108108    {
    109         for (auto & elem : this->languageEntries_)
    110             delete (elem.second);
     109        for (auto& mapEntry : this->languageEntries_)
     110            delete (mapEntry.second);
    111111    }
    112112
    … …  
    319319
    320320        // Iterate through the list an write the lines into the file
    321         for (const auto & elem : this->languageEntries_)
    322         {
    323             file << elem.second->getLabel() << '=' << elem.second->getDefault() << endl;
     321        for (const auto& mapEntry : this->languageEntries_)
     322        {
     323            file << mapEntry.second->getLabel() << '=' << mapEntry.second->getDefault() << endl;
    324324        }
    325325

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

    r10821 r10916  
    165165                        std::ostringstream message;
    166166                        message << "Possible sources of error:" << endl;
    167                         for (auto & linesource : linesources)
     167                        for (const std::pair<std::string, size_t>& pair : linesources)
    168168                        {
    169                             message << linesource.first << ", Line " << linesource.second << endl;
     169                            message << pair.first << ", Line " << pair.second << endl;
    170170                        }
    171171                        orxout(user_error, context::loader) << message.str() << endl;
    … …  
    261261        {
    262262            bool expectedValue = true;
    263             for (auto & luaTag : luaTags)
    264             {
    265                 if (luaTag.second == expectedValue)
     263            for (auto& mapEntry : luaTags)
     264            {
     265                if (mapEntry.second == expectedValue)
    266266                    expectedValue = !expectedValue;
    267267                else

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

    r10852 r10916  
    326326    /*static*/ bool LuaState::addToluaInterface(int (*function)(lua_State*), const std::string& name)
    327327    {
    328         for (const auto & interface : getToluaInterfaces())
    329         {
    330             if (interface.first == name || interface.second == function)
     328        for (const auto& mapEntry : getToluaInterfaces())
     329        {
     330            if (mapEntry.first == name || mapEntry.second == function)
    331331            {
    332332                orxout(internal_warning, context::lua) << "Trying to add a Tolua interface with the same name or function." << endl;
    … …  
    337337
    338338        // Open interface in all LuaStates
    339         for (const auto & state : getInstances())
     339        for (LuaState* state : getInstances())
    340340            (*function)(state->luaState_);
    341341
    … …  
    354354
    355355        // Close interface in all LuaStates
    356         for (const auto & state : getInstances())
     356        for (LuaState* state : getInstances())
    357357        {
    358358            lua_pushnil(state->luaState_);
    … …  
    369369    /*static*/ void LuaState::openToluaInterfaces(lua_State* state)
    370370    {
    371         for (const auto & interface : getToluaInterfaces())
    372             (interface.second)(state);
     371        for (const auto& mapEntry : getToluaInterfaces())
     372            (mapEntry.second)(state);
    373373    }
    374374
    375375    /*static*/ void LuaState::closeToluaInterfaces(lua_State* state)
    376376    {
    377         for (const auto & interface : getToluaInterfaces())
     377        for (const auto& mapEntry : getToluaInterfaces())
    378378        {
    379379            lua_pushnil(state);
    380             lua_setglobal(state, interface.first.c_str());
     380            lua_setglobal(state, mapEntry.first.c_str());
    381381        }
    382382    }

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

    r10821 r10916  
    5353    {
    5454        if (this->bRoot_)
    55             for (auto & elem : this->representingNamespaces_)
    56                 delete elem;
     55            for (NamespaceNode* node : this->representingNamespaces_)
     56                delete node;
    5757    }
    5858
    … …  
    8080            for (unsigned int i = 0; i < tokens.size(); i++)
    8181            {
    82                 for (auto & elem : this->getNamespace()->representingNamespaces_)
     82                for (NamespaceNode* node : this->getNamespace()->representingNamespaces_)
    8383                {
    84                     std::set<NamespaceNode*> temp = elem->getNodeRelative(tokens[i]);
     84                    std::set<NamespaceNode*> temp = node->getNodeRelative(tokens[i]);
    8585                    this->representingNamespaces_.insert(temp.begin(), temp.end());
    8686                }
    … …  
    9393        if (this->bAutogeneratedFileRootNamespace_)
    9494        {
    95             for (auto & elem : this->representingNamespaces_)
     95            for (NamespaceNode* node : this->representingNamespaces_)
    9696            {
    97                 elem->setRoot(true);
    98                 elem->setHidden(true);
     97                node->setRoot(true);
     98                node->setHidden(true);
    9999            }
    100100        }
    … …  
    114114    bool Namespace::includes(const Namespace* ns) const
    115115    {
    116         for (const auto & elem1 : this->representingNamespaces_)
     116        for (NamespaceNode* node1 : this->representingNamespaces_)
    117117        {
    118             for (const auto & elem2 : ns->representingNamespaces_)
     118            for (NamespaceNode* node2 : ns->representingNamespaces_)
    119119            {
    120                 if (elem1->includes(elem2))
     120                if (node1->includes(node2))
    121121                {
    122122                    if (this->operator_ == "or")
    … …  
    149149
    150150        int i = 0;
    151         for (const auto & elem : this->representingNamespaces_)
     151        for (NamespaceNode* node : this->representingNamespaces_)
    152152        {
    153153            if (i > 0)
    154154                output += " / ";
    155155
    156             output += elem->toString();
     156            output += node->toString();
    157157            i++;
    158158        }
    … …  
    166166
    167167        int i = 0;
    168         for (const auto & elem : this->representingNamespaces_)
     168        for (NamespaceNode* node : this->representingNamespaces_)
    169169        {
    170170            if (i > 0)
    171171                output += '\n';
    172172
    173             output += elem->toString(indentation);
     173            output += node->toString(indentation);
    174174            i++;
    175175        }

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

    r10821 r10916  
    103103                bool bFoundMatchingNamespace = false;
    104104
    105                 for (auto & elem : this->subnodes_)
     105                for (auto& mapEntry : this->subnodes_)
    106106                {
    107                     if (elem.first.find(firstPart) == (elem.first.size() - firstPart.size()))
     107                    if (mapEntry.first.find(firstPart) == (mapEntry.first.size() - firstPart.size()))
    108108                    {
    109                         std::set<NamespaceNode*> temp2 = elem.second->getNodeRelative(secondPart);
     109                        std::set<NamespaceNode*> temp2 = mapEntry.second->getNodeRelative(secondPart);
    110110                        nodes.insert(temp2.begin(), temp2.end());
    111111                        bFoundMatchingNamespace = true;
    … …  
    132132        else
    133133        {
    134             for (const auto & elem : this->subnodes_)
    135                 if (elem.second->includes(ns))
     134            for (const auto& mapEntry : this->subnodes_)
     135                if (mapEntry.second->includes(ns))
    136136                    return true;
    137137        }
    … …  
    167167        std::string output = (indentation + this->name_ + '\n');
    168168
    169         for (const auto & elem : this->subnodes_)
    170             output += elem.second->toString(indentation + "  ");
     169        for (const auto& mapEntry : this->subnodes_)
     170            output += mapEntry.second->toString(indentation + "  ");
    171171
    172172        return output;

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

    r10821 r10916  
    5858        DataStreamListPtr resources(new Ogre::DataStreamList());
    5959        const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
    60         for (const auto & group : groups)
     60        for (const std::string& group : groups)
    6161        {
    6262            DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
    … …  
    121121        StringVectorPtr resourceNames(new Ogre::StringVector());
    122122        const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
    123         for (const auto & group : groups)
     123        for (const std::string& group : groups)
    124124        {
    125125            StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(group, pattern);

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

    r10821 r10916  
    8787        for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
    8888            const_cast<Identifier*>(*it)->directChildren_.erase(this);
    89         for (const auto & elem : this->children_)
    90             const_cast<Identifier*>(elem)->parents_.remove(this);
    91         for (const auto & elem : this->directChildren_)
    92             const_cast<Identifier*>(elem)->directParents_.remove(this);
    93 
    94         for (auto & elem : this->configValues_)
    95             delete (elem.second);
    96         for (auto & elem : this->xmlportParamContainers_)
    97             delete (elem.second);
    98         for (auto & elem : this->xmlportObjectContainers_)
    99             delete (elem.second);
     89        for (const Identifier* child : this->children_)
     90            const_cast<Identifier*>(child)->parents_.remove(this);
     91        for (const Identifier* directChild : this->directChildren_)
     92            const_cast<Identifier*>(directChild)->directParents_.remove(this);
     93
     94        for (auto& mapEntry : this->configValues_)
     95            delete (mapEntry.second);
     96        for (auto& mapEntry : this->xmlportParamContainers_)
     97            delete (mapEntry.second);
     98        for (auto& mapEntry : this->xmlportObjectContainers_)
     99            delete (mapEntry.second);
    100100    }
    101101
    … …  
    157157        if (this->directParents_.empty())
    158158        {
    159             for (const auto & elem : initializationTrace)
    160                 if (elem != this)
    161                     this->parents_.push_back(elem);
     159            for (const Identifier* identifier : initializationTrace)
     160                if (identifier != this)
     161                    this->parents_.push_back(identifier);
    162162        }
    163163        else
    … …  
    261261
    262262        // if any parent class is virtual, it will be instantiated first, so we need to add them first.
    263         for (const auto & elem : this->parents_)
    264         {
    265             if ((elem)->isVirtualBase())
     263        for (const Identifier* parent : this->parents_)
     264        {
     265            if (parent->isVirtualBase())
    266266            {
    267                 for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(elem)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(elem)->parents_.end(); ++it_parent_parent)
     267                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)
    268268                    this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
    269                 this->addIfNotExists(expectedIdentifierTrace, elem);
     269                this->addIfNotExists(expectedIdentifierTrace, parent);
    270270            }
    271271        }
    272272
    273273        // now all direct parents get created recursively. already added identifiers (e.g. virtual base classes) are not added again.
    274         for (const auto & elem : this->directParents_)
    275         {
    276             for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(elem)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(elem)->parents_.end(); ++it_parent_parent)
     274        for (const Identifier* directParent : this->directParents_)
     275        {
     276            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)
    277277                this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
    278             this->addIfNotExists(expectedIdentifierTrace, elem);
     278            this->addIfNotExists(expectedIdentifierTrace, directParent);
    279279        }
    280280
    … …  
    285285
    286286            orxout(internal_warning) << "  Actual trace (after creating a sample instance):" << endl << "    ";
    287             for (const auto & elem : this->parents_)
    288                 orxout(internal_warning) << " " << (elem)->getName();
     287            for (const Identifier* parent : this->parents_)
     288                orxout(internal_warning) << " " << parent->getName();
    289289            orxout(internal_warning) << endl;
    290290
    … …  
    295295
    296296            orxout(internal_warning) << "  Direct parents (according to class hierarchy definitions):" << endl << "    ";
    297             for (const auto & elem : this->directParents_)
    298                 orxout(internal_warning) << " " << (elem)->getName();
     297            for (const Identifier* directParent : this->directParents_)
     298                orxout(internal_warning) << " " << directParent->getName();
    299299            orxout(internal_warning) << endl;
    300300        }

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

    r10821 r10916  
    462462
    463463        if (updateChildren)
    464             for (const auto & elem : this->getChildren())
    465                 (elem)->updateConfigValues(false);
     464            for (const Identifier* child : this->getChildren())
     465                child->updateConfigValues(false);
    466466    }
    467467

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

    r10821 r10916  
    9393        {
    9494            Context temporaryContext(nullptr);
    95             for (auto identifier : this->identifiers_)
     95            for (Identifier* identifier : this->identifiers_)
    9696            {
    97                
    9897                if (identifier->isInitialized())
    9998                    continue;
    … …  
    127126
    128127        // finish the initialization of all identifiers
    129         for (const auto & initializedIdentifier : initializedIdentifiers)
    130             (initializedIdentifier)->finishInitialization();
     128        for (Identifier* initializedIdentifier : initializedIdentifiers)
     129            initializedIdentifier->finishInitialization();
    131130
    132131        // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
    … …  
    144143    {
    145144        // check if there are any uninitialized identifiers remaining
    146         for (const auto & elem : this->identifiers_)
    147             if (!(elem)->isInitialized())
    148                 orxout(internal_error) << "Identifier was registered late and is not initialized: " << (elem)->getName() << " / " << (elem)->getTypeInfo().name() << endl;
     145        for (Identifier* identifier : this->identifiers_)
     146            if (!identifier->isInitialized())
     147                orxout(internal_error) << "Identifier was registered late and is not initialized: " << identifier->getName() << " / " << identifier->getTypeInfo().name() << endl;
    149148
    150149        // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
    151150        Context temporaryContext(nullptr);
    152         for (const auto & initializedIdentifier : initializedIdentifiers)
     151        for (Identifier* initializedIdentifier : initializedIdentifiers)
    153152        {
    154             if (!(initializedIdentifier)->hasFactory())
     153            if (!initializedIdentifier->hasFactory())
    155154                continue;
    156155
    157             Identifiable* temp = (initializedIdentifier)->fabricate(&temporaryContext);
    158 
    159             for (const auto & elem : this->identifiers_)
     156            Identifiable* temp = initializedIdentifier->fabricate(&temporaryContext);
     157
     158            for (Identifier* identifier : this->identifiers_)
    160159            {
    161                 bool isA_AccordingToRtti = (elem)->canDynamicCastObjectToIdentifierClass(temp);
    162                 bool isA_AccordingToClassHierarchy = temp->isA((elem));
     160                bool isA_AccordingToRtti = identifier->canDynamicCastObjectToIdentifierClass(temp);
     161                bool isA_AccordingToClassHierarchy = temp->isA(identifier);
    163162
    164163                if (isA_AccordingToRtti != isA_AccordingToClassHierarchy)
    165164                {
    166                     orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << (initializedIdentifier)->getName() <<
    167                         (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << (elem)->getName() << " but RTTI says the opposite." << endl;
     165                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << initializedIdentifier->getName() <<
     166                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << identifier->getName() << " but RTTI says the opposite." << endl;
    168167                }
    169168            }
    … …  
    184183    {
    185184        orxout(internal_status) << "Destroy class-hierarchy" << endl;
    186         for (const auto & elem : this->identifiers_)
    187             (elem)->reset();
     185        for (Identifier* identifier : this->identifiers_)
     186            identifier->reset();
    188187    }
    189188
    … …  
    260259    {
    261260        // TODO: use std::type_index and a map to find identifiers by type_info (only with c++11)
    262         for (const auto & elem : this->identifiers_)
    263             if ((elem)->getTypeInfo() == typeInfo)
    264                 return (elem);
     261        for (Identifier* identifer : this->identifiers_)
     262            if (identifer->getTypeInfo() == typeInfo)
     263                return identifer;
    265264        return nullptr;
    266265    }

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

    r10821 r10916  
    7777            bool groupIsVisible(const std::map<std::string, ConsoleCommand*>& group, bool bOnlyShowHidden)
    7878            {
    79                 for (const auto & elem : group)
    80                     if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden)
     79                for (const auto& mapEntry : group)
     80                    if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden)
    8181                        return true;
    8282
    … …  
    100100                // get all the groups that are visible (except the shortcut group "")
    101101                const std::map<std::string, std::map<std::string, ConsoleCommand*>>& commands = ConsoleCommandManager::getInstance().getCommands();
    102                 for (const auto & command : commands)
    103                     if (groupIsVisible(command.second, bOnlyShowHidden) && command.first != "" && (fragmentLC == "" || getLowercase(command.first).find(fragmentLC) == 0))
    104                         groupList.push_back(ArgumentCompletionListElement(command.first, getLowercase(command.first)));
     102                for (const auto& mapEntry : commands)
     103                    if (groupIsVisible(mapEntry.second, bOnlyShowHidden) && mapEntry.first != "" && (fragmentLC == "" || getLowercase(mapEntry.first).find(fragmentLC) == 0))
     104                        groupList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
    105105
    106106                // now add all shortcuts (in group "")
    … …  
    113113
    114114                    // add the shortcuts
    115                     for (const auto & elem : it_group->second)
    116                         if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(elem.first).find(fragmentLC) == 0))
    117                             groupList.push_back(ArgumentCompletionListElement(elem.first, getLowercase(elem.first)));
     115                    for (const auto& mapEntry : it_group->second)
     116                        if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(mapEntry.first).find(fragmentLC) == 0))
     117                            groupList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
    118118                }
    119119
    … …  
    146146                if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
    147147                {
    148                     for (const auto & elem : it_group->second)
    149                         if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden)
    150                             commandList.push_back(ArgumentCompletionListElement(elem.first, getLowercase(elem.first)));
     148                    for (const auto& mapEntry : it_group->second)
     149                        if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden)
     150                            commandList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
    151151                }
    152152
    … …  
    281281
    282282            const std::set<std::string>& names = SettingsConfigFile::getInstance().getSectionNames();
    283             for (const auto & name : names)
     283            for (const std::string& name : names)
    284284                sectionList.push_back(ArgumentCompletionListElement(name, getLowercase(name)));
    285285

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

    r10821 r10916  
    306306                // the user typed 1-2 arguments, check what he tried to type and print a suitable error
    307307                std::string groupLC = getLowercase(this->getToken(0));
    308                 for (const auto & elem : ConsoleCommandManager::getInstance().getCommandsLC())
    309                     if (elem.first == groupLC)
     308                for (const auto& mapEntry : ConsoleCommandManager::getInstance().getCommandsLC())
     309                    if (mapEntry.first == groupLC)
    310310                        return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
    311311
    … …  
    328328
    329329        // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
    330         for (const auto & elem : ConsoleCommandManager::getInstance().getCommandsLC())
    331         {
    332             if (elem.first != "")
    333             {
    334                 for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = elem.second.begin(); it_name != elem.second.end(); ++it_name)
    335                 {
    336                     std::string command = elem.first + " " + it_name->first;
     330        for (const auto& mapEntry : ConsoleCommandManager::getInstance().getCommandsLC())
     331        {
     332            if (mapEntry.first != "")
     333            {
     334                for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = mapEntry.second.begin(); it_name != mapEntry.second.end(); ++it_name)
     335                {
     336                    std::string command = mapEntry.first + " " + it_name->first;
    337337                    unsigned int distance = getLevenshteinDistance(command, token0_LC + " " + token1_LC);
    338338                    if (distance < nearestDistance)
    … …  
    349349        if (it_group !=  ConsoleCommandManager::getInstance().getCommandsLC().end())
    350350        {
    351             for (const auto & elem : it_group->second)
    352             {
    353                 std::string command = elem.first;
     351            for (const auto& mapEntry : it_group->second)
     352            {
     353                std::string command = mapEntry.first;
    354354                unsigned int distance = getLevenshteinDistance(command, token0_LC);
    355355                if (distance < nearestDistance)
    … …  
    429429    {
    430430        size_t count = 0;
    431         for (const auto & elem : list)
    432             if (elem.getComparable() != "")
     431        for (const ArgumentCompletionListElement& element : list)
     432            if (element.getComparable() != "")
    433433                ++count;
    434434        return count;
    … …  
    495495        {
    496496            // only one (non-empty) value in the list - search it and return it
    497             for (const auto & elem : list)
    498             {
    499                 if (elem.getComparable() != "")
     497            for (const ArgumentCompletionListElement& element : list)
     498            {
     499                if (element.getComparable() != "")
    500500                {
    501501                    // arguments that have a separate string to be displayed need a little more care - just return them without modification. add a space character to the others.
    502                     if (elem.hasDisplay())
    503                         return (elem.getString());
     502                    if (element.hasDisplay())
     503                        return (element.getString());
    504504                    else
    505                         return (elem.getString() + ' ');
     505                        return (element.getString() + ' ');
    506506                }
    507507            }
    … …  
    517517                char tempComparable = '\0';
    518518                char temp = '\0';
    519                 for (const auto & elem : list)
    520                 {
    521                     const std::string& argumentComparable = elem.getComparable();
    522                     const std::string& argument = elem.getString();
     519                for (const ArgumentCompletionListElement& element : list)
     520                {
     521                    const std::string& argumentComparable = element.getComparable();
     522                    const std::string& argument = element.getString();
    523523
    524524                    // ignore empty arguments
    … …  
    560560    {
    561561        std::string output;
    562         for (const auto & elem : list)
    563         {
    564             output += elem.getDisplay();
     562        for (const ArgumentCompletionListElement& element : list)
     563        {
     564            output += element.getDisplay();
    565565
    566566            // add a space character between two elements for all non-empty arguments
    567             if (elem.getComparable() != "")
     567            if (element.getComparable() != "")
    568568                output += ' ';
    569569        }

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

    r10825 r10916  
    7575        this->baseFunctor_ = executor->getFunctor();
    7676
    77         for (auto & elem : this->argumentCompleter_)
    78             elem = nullptr;
     77        for (ArgumentCompleter*& completer : this->argumentCompleter_)
     78            completer = nullptr;
    7979
    8080        this->keybindMode_ = KeybindMode::OnPress;

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

    r10821 r10916  
    258258        vectorize(text, '\n', &lines);
    259259
    260         for (auto & line : lines)
     260        for (const std::string& line : lines)
    261261            this->addLine(line, type);
    262262    }

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

    r10821 r10916  
    262262        boost::shared_lock<boost::shared_mutex> lock(this->mutex_);
    263263
    264         for (const auto & elem : this->list_)
    265             if (elem == value)
     264        for (const T& element : this->list_)
     265            if (element == value)
    266266                return true;
    267267

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

    r10821 r10916  
    551551
    552552        std::list<unsigned int> threads;
    553         for (const auto & elem : this->interpreterBundles_)
    554             if (elem.first > 0 && elem.first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
    555                 threads.push_back(elem.first);
     553        for (const auto& mapEntry : this->interpreterBundles_)
     554            if (mapEntry.first > 0 && mapEntry.first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
     555                threads.push_back(mapEntry.first);
    556556        return threads;
    557557    }

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

    r10821 r10916  
    124124            std::string shortcut;
    125125            std::string value;
    126             for (auto & argument : arguments)
     126            for (const std::string& argument : arguments)
    127127            {
    128128                if (argument.size() != 0)

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

    r10821 r10916  
    234234        }
    235235
    236         for (const auto & elem : this->sections_)
    237         {
    238             file << (elem)->getFileEntry() << endl;
    239 
    240             for (std::list<ConfigFileEntry*>::const_iterator it_entries = (elem)->getEntriesBegin(); it_entries != (elem)->getEntriesEnd(); ++it_entries)
     236        for (ConfigFileSection* section : this->sections_)
     237        {
     238            file << section->getFileEntry() << endl;
     239
     240            for (std::list<ConfigFileEntry*>::const_iterator it_entries = section->getEntriesBegin(); it_entries != section->getEntriesEnd(); ++it_entries)
    241241                file << (*it_entries)->getFileEntry() << endl;
    242242
    … …  
    278278        @brief Returns a pointer to the section with given name (or nullptr if the section doesn't exist).
    279279    */
    280     ConfigFileSection* ConfigFile::getSection(const std::string& section) const
    281     {
    282         for (const auto & elem : this->sections_)
    283             if ((elem)->getName() == section)
    284                 return (elem);
     280    ConfigFileSection* ConfigFile::getSection(const std::string& sectionName) const
     281    {
     282        for (ConfigFileSection* section : this->sections_)
     283            if (section->getName() == sectionName)
     284                return section;
    285285        return nullptr;
    286286    }
    … …  
    289289        @brief Returns a pointer to the section with given name. If it doesn't exist, the section is created.
    290290    */
    291     ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& section)
    292     {
    293         for (auto & elem : this->sections_)
    294             if ((elem)->getName() == section)
    295                 return (elem);
     291    ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& sectionName)
     292    {
     293        for (ConfigFileSection* section : this->sections_)
     294            if (section->getName() == sectionName)
     295                return section;
    296296
    297297        this->bUpdated_ = true;
    298298
    299         return (*this->sections_.insert(this->sections_.end(), new ConfigFileSection(section)));
     299        return (*this->sections_.insert(this->sections_.end(), new ConfigFileSection(sectionName)));
    300300    }
    301301
    … …  
    307307        bool sectionsUpdated = false;
    308308
    309         for (auto & elem : this->sections_)
    310         {
    311             if ((elem)->bUpdated_)
     309        for (ConfigFileSection* section : this->sections_)
     310        {
     311            if (section->bUpdated_)
    312312            {
    313313                sectionsUpdated = true;
    314                 (elem)->bUpdated_ = false;
     314                section->bUpdated_ = false;
    315315            }
    316316        }

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

    r10821 r10916  
    5353    ConfigFileManager::~ConfigFileManager()
    5454    {
    55         for (const auto & elem : this->configFiles_)
    56             if (elem)
    57                 delete (elem);
     55        for (ConfigFile* configFile : this->configFiles_)
     56            if (configFile)
     57                delete configFile;
    5858    }
    5959

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

    r10821 r10916  
    8080    {
    8181        unsigned int size = 0;
    82         for (const auto & elem : this->entries_)
    83             if ((elem)->getName() == name)
    84                 if ((elem)->getIndex() >= size)
    85                     size = (elem)->getIndex() + 1;
     82        for (ConfigFileEntry* entry : this->entries_)
     83            if (entry->getName() == name)
     84                if (entry->getIndex() >= size)
     85                    size = entry->getIndex() + 1;
    8686        return size;
    8787    }
    … …  
    105105    ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name) const
    106106    {
    107         for (const auto & elem : this->entries_)
     107        for (ConfigFileEntry* entry : this->entries_)
    108108        {
    109             if ((elem)->getName() == name)
    110                 return elem;
     109            if (entry->getName() == name)
     110                return entry;
    111111        }
    112112        return nullptr;
    … …  
    121121    ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name, unsigned int index) const
    122122    {
    123         for (const auto & elem : this->entries_)
     123        for (ConfigFileEntry* entry : this->entries_)
    124124        {
    125             if (((elem)->getName() == name) && ((elem)->getIndex() == index))
    126                 return elem;
     125            if ((entry->getName() == name) && (entry->getIndex() == index))
     126                return entry;
    127127        }
    128128        return nullptr;

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

    r10845 r10916  
    130130
    131131                this->value_ = V();
    132                 for (auto & elem : defvalue)
    133                     this->valueVector_.push_back(MultiType(elem));
     132                for (const D& defvalueElement : defvalue)
     133                    this->valueVector_.push_back(MultiType(defvalueElement));
    134134
    135135                this->initVector();
    … …  
    183183                    std::vector<T> temp = *value;
    184184                    value->clear();
    185                     for (auto & elem : this->valueVector_)
    186                         value->push_back(elem);
     185                    for (const MultiType& vectorEntry : this->valueVector_)
     186                        value->push_back(vectorEntry);
    187187
    188188                    if (value->size() != temp.size())
    … …  
    211211                {
    212212                    value->clear();
    213                     for (auto & elem : this->valueVector_)
    214                         value->push_back(elem);
     213                    for (const MultiType& vectorEntry : this->valueVector_)
     214                        value->push_back(vectorEntry);
    215215                }
    216216                return *this;

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

    r10821 r10916  
    196196
    197197                    // add command to the buffer if not yet existing
    198                     for (auto & elem : *paramCommandBuffer_)
    199                     {
    200                         if (elem->evaluation_.getConsoleCommand()
     198                    for (BufferedParamCommand* command : *paramCommandBuffer_)
     199                    {
     200                        if (command->evaluation_.getConsoleCommand()
    201201                            == eval.getConsoleCommand())
    202202                        {
    203203                            // already in list
    204                             cmd->paramCommand_ = elem;
     204                            cmd->paramCommand_ = command;
    205205                            break;
    206206                        }

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

    r10821 r10916  
    110110    void InputBuffer::insert(const std::string& input, bool update)
    111111    {
    112         for (auto & elem : input)
    113         {
    114             this->insert(elem, false);
     112        for (const char& inputChar : input)
     113        {
     114            this->insert(inputChar, false);
    115115
    116116            if (update)
    117                 this->updated(elem, false);
     117                this->updated(inputChar, false);
    118118        }
    119119
    … …  
    170170    void InputBuffer::updated()
    171171    {
    172         for (auto & elem : this->listeners_)
    173         {
    174             if ((elem)->bListenToAllChanges_)
    175                 (elem)->callFunction();
     172        for (BaseInputBufferListenerTuple* listener : this->listeners_)
     173        {
     174            if (listener->bListenToAllChanges_)
     175                listener->callFunction();
    176176        }
    177177    }
    … …  
    179179    void InputBuffer::updated(const char& update, bool bSingleInput)
    180180    {
    181         for (auto & elem : this->listeners_)
    182         {
    183             if ((!(elem)->trueKeyFalseChar_) && ((elem)->bListenToAllChanges_ || ((elem)->char_ == update)) && (!(elem)->bOnlySingleInput_ || bSingleInput))
    184                 (elem)->callFunction();
     181        for (BaseInputBufferListenerTuple* listener : this->listeners_)
     182        {
     183            if ((!listener->trueKeyFalseChar_) && (listener->bListenToAllChanges_ || (listener->char_ == update)) && (!listener->bOnlySingleInput_ || bSingleInput))
     184                listener->callFunction();
    185185        }
    186186    }
    … …  
    201201            return;
    202202
    203         for (auto & elem : this->listeners_)
    204         {
    205             if ((elem)->trueKeyFalseChar_ && ((elem)->key_ == evt.getKeyCode()))
    206                 (elem)->callFunction();
     203        for (BaseInputBufferListenerTuple* listener : this->listeners_)
     204        {
     205            if (listener->trueKeyFalseChar_ && (listener->key_ == evt.getKeyCode()))
     206                listener->callFunction();
    207207        }
    208208

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

    r10845 r10916  
    158158
    159159            // Call all the states with the held button event
    160             for (auto & button : pressedButtons_)
    161                 for (auto & state : inputStates_)
     160            for (ButtonType& button : pressedButtons_)
     161                for (InputState* state : inputStates_)
    162162                    state->template buttonEvent<ButtonEvent::THold, typename Traits::ButtonTypeParam>(
    163163                        this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
    164164
    165165            // Call states with device update events
    166             for (auto & elem : inputStates_)
    167                 elem->update(time.getDeltaTime(), this->getDeviceID());
     166            for (InputState* state : inputStates_)
     167                state->update(time.getDeltaTime(), this->getDeviceID());
    168168
    169169            static_cast<DeviceClass*>(this)->updateImpl(time);
    … …  
    196196
    197197            // Call states
    198             for (auto & elem : inputStates_)
    199                 elem->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
     198            for (InputState* state : inputStates_)
     199                state->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
    200200        }
    201201
    … …  
    218218
    219219            // Call states
    220             for (auto & elem : inputStates_)
    221                 elem->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
     220            for (InputState* state : inputStates_)
     221                state->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
    222222        }
    223223

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

    r10821 r10916  
    373373        // check whether a state has changed its EMPTY situation
    374374        bool bUpdateRequired = false;
    375         for (auto & elem : activeStates_)
    376         {
    377             if (elem.second->hasExpired())
    378             {
    379                 elem.second->resetExpiration();
     375        for (auto& mapEntry : activeStates_)
     376        {
     377            if (mapEntry.second->hasExpired())
     378            {
     379                mapEntry.second->resetExpiration();
    380380                bUpdateRequired = true;
    381381            }
    … …  
    391391
    392392        // Collect function calls for the update
    393         for (auto & elem : activeStatesTicked_)
    394             elem->update(time.getDeltaTime());
     393        for (InputState* state : activeStatesTicked_)
     394            state->update(time.getDeltaTime());
    395395
    396396        // Execute all cached function calls in order
    … …  
    401401        // If we delay the calls, then OIS and and the InputStates are not anymore
    402402        // in the call stack and can therefore be edited.
    403         for (auto & elem : this->callBuffer_)
    404             elem();
     403        for (auto& function : this->callBuffer_)
     404            function();
    405405
    406406        this->callBuffer_.clear();
    … …  
    437437        // Using an std::set to avoid duplicates
    438438        std::set<InputState*> tempSet;
    439         for (auto & elem : devices_)
    440             if (elem != nullptr)
    441                 for (unsigned int iState = 0; iState < elem->getStateListRef().size(); ++iState)
    442                     tempSet.insert(elem->getStateListRef()[iState]);
     439        for (InputDevice* device : devices_)
     440            if (device != nullptr)
     441                for (unsigned int iState = 0; iState < device->getStateListRef().size(); ++iState)
     442                    tempSet.insert(device->getStateListRef()[iState]);
    443443
    444444        // Copy the content of the std::set back to the actual vector
    445445        activeStatesTicked_.clear();
    446         for (const auto & elem : tempSet)
    447             activeStatesTicked_.push_back(elem);
     446        for (InputState* state : tempSet)
     447            activeStatesTicked_.push_back(state);
    448448
    449449        // Check whether we have to change the mouse mode

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

    r10821 r10916  
    186186    void JoyStick::clearBuffersImpl()
    187187    {
    188         for (auto & elem : povStates_)
    189             elem = 0;
     188        for (int& state : povStates_)
     189            state = 0;
    190190    }
    191191

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

    r10821 r10916  
    153153    void KeyBinder::buttonThresholdChanged()
    154154    {
    155         for (auto & elem : allHalfAxes_)
    156             if (!elem->bButtonThresholdUser_)
    157                 elem->buttonThreshold_ = this->buttonThreshold_;
     155        for (HalfAxis* halfAxis : allHalfAxes_)
     156            if (!halfAxis->bButtonThresholdUser_)
     157                halfAxis->buttonThreshold_ = this->buttonThreshold_;
    158158    }
    159159
    … …  
    383383            it->second->clear();
    384384
    385         for (auto & elem : paramCommandBuffer_)
    386             delete elem;
     385        for (BufferedParamCommand* command : paramCommandBuffer_)
     386            delete command;
    387387        paramCommandBuffer_.clear();
    388388    }
    … …  
    394394    {
    395395        // iterate over all buttons
    396         for (const auto & elem : this->allButtons_)
    397         {
    398             Button* button = elem.second;
     396        for (const auto& mapEntry : this->allButtons_)
     397        {
     398            Button* button = mapEntry.second;
    399399
    400400            // iterate over all modes
    … …  
    465465        this->mousePosition_[1] = 0.0f;
    466466
    467         for (auto & elem : mouseAxes_)
    468             elem.reset();
     467        for (HalfAxis& axis : mouseAxes_)
     468            axis.reset();
    469469    }
    470470
    … …  
    505505        }
    506506
    507         for (auto & elem : mouseAxes_)
     507        for (HalfAxis& axis : mouseAxes_)
    508508        {
    509509            // Why dividing relative value by dt? The reason lies in the simple fact, that when you
    … …  
    515515            {
    516516                // just ignore if dt == 0.0 because we have multiplied by 0.0 anyway..
    517                 elem.relVal_ /= dt;
    518             }
    519 
    520             tickHalfAxis(elem);
     517                axis.relVal_ /= dt;
     518            }
     519
     520            tickHalfAxis(axis);
    521521        }
    522522    }

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

    r10845 r10916  
    226226    {
    227227        // execute all buffered bindings (additional parameter)
    228         for (auto & elem : paramCommandBuffer_)
     228        for (BufferedParamCommand* command : paramCommandBuffer_)
    229229        {
    230             elem->rel_ *= dt;
    231             elem->execute();
     230            command->rel_ *= dt;
     231            command->execute();
    232232        }
    233233
    234234        // always reset the relative movement of the mouse
    235         for (auto & elem : mouseAxes_)
    236             elem.relVal_ = 0.0f;
     235        for (HalfAxis& axis : mouseAxes_)
     236            axis.relVal_ = 0.0f;
    237237    }
    238238}// tolua_export

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

    r10821 r10916  
    8282            IntVector2 rel(e.state.X.rel, e.state.Y.rel);
    8383            IntVector2 clippingSize(e.state.width, e.state.height);
    84             for (auto & elem : inputStates_)
    85                 elem->mouseMoved(abs, rel, clippingSize);
     84            for (InputState* state : inputStates_)
     85                state->mouseMoved(abs, rel, clippingSize);
    8686        }
    8787
    … …  
    8989        if (e.state.Z.rel != 0)
    9090        {
    91             for (auto & elem : inputStates_)
    92                 elem->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
     91            for (InputState* state : inputStates_)
     92                state->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
    9393        }
    9494

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

    r10821 r10916  
    7575    {
    7676        // Unload & delete resources in turn
    77         for (auto & elem : mLibList)
     77        for (auto& mapEntry : mLibList)
    7878        {
    79             elem.second->unload();
    80             delete elem.second;
     79            mapEntry.second->unload();
     80            delete mapEntry.second;
    8181        }
    8282

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

    r10821 r10916  
    5959    {
    6060        const std::set<StaticallyInitializedInstance*>& instances = this->staticallyInitializedInstancesByType_[type];
    61         for (const auto & instance : instances)
    62             (instance)->load();
     61        for (StaticallyInitializedInstance* instance : instances)
     62            instance->load();
    6363    }
    6464
    … …  
    7575        std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
    7676        this->staticallyInitializedInstancesByType_.clear();
    77         for (auto & elem : copy)
    78             for (std::set<StaticallyInitializedInstance*>::iterator it2 = elem.second.begin(); it2 != elem.second.end(); ++it2)
     77        for (auto& mapEntry : copy)
     78            for (std::set<StaticallyInitializedInstance*>::iterator it2 = mapEntry.second.begin(); it2 != mapEntry.second.end(); ++it2)
    7979                delete (*it2);
    8080    }

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

    r10821 r10916  
    5959        ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(nullptr);
    6060
    61         for (auto & elem : this->references_)
    62             delete elem.second;
    63         for (auto & elem : this->plugins_)
    64             delete elem.second;
     61        for (auto& mapEntry : this->references_)
     62            delete mapEntry.second;
     63        for (auto& mapEntry : this->plugins_)
     64            delete mapEntry.second;
    6565    }
    6666
    … …  
    6868    {
    6969        const std::vector<std::string>& pluginPaths = ApplicationPaths::getInstance().getPluginPaths();
    70         for (auto libraryName : pluginPaths)
     70        for (const std::string& libraryName : pluginPaths)
    7171        {
    7272            std::string name;
    73            
    7473            std::string filename = libraryName +  + specialConfig::pluginExtension;
    7574            std::ifstream infile(filename.c_str());

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

    r10821 r10916  
    5050    {
    5151        // attention: loading a module may add new handlers to the list
    52         for (auto & elem : this->handlers_)
    53             (elem)->loadModule(module);
     52        for (StaticInitializationHandler* handler : this->handlers_)
     53            handler->loadModule(module);
    5454    }
    5555

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

    r10821 r10916  
    7070        // unregister context from object lists before object lists are destroyed
    7171        this->unregisterObject();
    72         for (auto & elem : this->objectLists_)
    73             delete elem;
     72        for (ObjectListBase* objectList : this->objectLists_)
     73            delete objectList;
    7474    }
    7575

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

    r10821 r10916  
    7676    void Listable::unregisterObject()
    7777    {
    78         for (auto & elem : this->elements_)
    79             Listable::deleteObjectListElement(elem);
     78        for (ObjectListBaseElement* element : this->elements_)
     79            Listable::deleteObjectListElement(element);
    8080        this->elements_.clear();
    8181    }
    … …  
    9191        this->elements_.clear();
    9292
    93         for (auto & elem : copy)
     93        for (ObjectListBaseElement* element : copy)
    9494        {
    95             elem->changeContext(this->context_, context);
    96             Listable::deleteObjectListElement(elem);
     95            element->changeContext(this->context_, context);
     96            Listable::deleteObjectListElement(element);
    9797        }
    9898

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

    r10821 r10916  
    9292    void ObjectListBase::notifyRemovalListeners(ObjectListBaseElement* element) const
    9393    {
    94         for (const auto & elem : this->listeners_)
    95             (elem)->removedElement(element);
     94        for (ObjectListElementRemovalListener* listener : this->listeners_)
     95            listener->removedElement(element);
    9696    }
    9797

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

    r10821 r10916  
    7373    void ScopeManager::activateListenersForScope(ScopeID::Value scope)
    7474    {
    75         for (const auto & elem : this->listeners_[scope])
    76             this->activateListener(elem);
     75        for (ScopeListener* listener : this->listeners_[scope])
     76            this->activateListener(listener);
    7777    }
    7878
    7979    void ScopeManager::deactivateListenersForScope(ScopeID::Value scope)
    8080    {
    81         for (const auto & elem : this->listeners_[scope])
    82             this->deactivateListener(elem);
     81        for (ScopeListener* listener : this->listeners_[scope])
     82            this->deactivateListener(listener);
    8383    }
    8484

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

    r10821 r10916  
    131131  *(uint32_t*)(mem+2*sizeof(uint32_t)) = this->objectID_;
    132132  mem += 3*sizeof(uint32_t);
    133   for(auto & elem : this->arguments_)
     133  for(const MultiType& argument : this->arguments_)
    134134  {
    135     elem.exportData( mem );
     135    argument.exportData( mem );
    136136  }
    137137}

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

    r10821 r10916  
    8080  void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
    8181  {
    82     for(auto & instances_ : instances_s)
     82    for(Host* host : instances_s)
    8383    {
    84       if( (instances_)->isActive() )
     84      if( host->isActive() )
    8585      {
    86         (instances_)->queuePacket(packet, clientID, channelID);
     86        host->queuePacket(packet, clientID, channelID);
    8787      }
    8888    }
    … …  
    9797  void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
    9898  {
    99     for(auto & instances_ : instances_s)
    100       if( (instances_)->isActive() )
    101         (instances_)->doSendChat(message, sourceID, targetID);
     99    for(Host* host : instances_s)
     100      if( host->isActive() )
     101        host->doSendChat(message, sourceID, targetID);
    102102  }
    103103
    … …  
    114114  bool Host::isServer()
    115115  {
    116     for (auto & instances_ : instances_s)
     116    for (Host* host : instances_s)
    117117    {
    118       if( (instances_)->isActive() )
     118      if( host->isActive() )
    119119      {
    120         if( (instances_)->isServer_() )
     120        if( host->isServer_() )
    121121          return true;
    122122      }

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

    r10821 r10916  
    8888    }
    8989    // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ )
    90     for(auto & elem : syncList_)
    91       delete (elem);
     90    for(SynchronisableVariableBase* variable : syncList_)
     91      delete variable;
    9292    syncList_.clear();
    9393    stringList_.clear();

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

    r10821 r10916  
    392392            manualObject->estimateVertexCount(lineVertices.size());
    393393            manualObject->estimateIndexCount(lineIndices.size());
    394             for (auto & elem : lineVertices)
     394            for (const VertexPair& pair : lineVertices)
    395395            {
    396                 manualObject->position(elem.first);
    397                 manualObject->colour(elem.second);
     396                manualObject->position(pair.first);
     397                manualObject->colour(pair.second);
    398398            }
    399             for (auto & elem : lineIndices)
    400                 manualObject->index(elem);
     399            for (int lineIndex : lineIndices)
     400                manualObject->index(lineIndex);
    401401        }
    402402        else
    … …  
    409409            manualObject->estimateVertexCount(triangleVertices.size());
    410410            manualObject->estimateIndexCount(triangleIndices.size());
    411             for (auto & elem : triangleVertices)
     411            for (const VertexPair& pair : triangleVertices)
    412412            {
    413                 manualObject->position(elem.first);
    414                 manualObject->colour(elem.second.r, elem.second.g, elem.second.b, fillAlpha);
     413                manualObject->position(pair.first);
     414                manualObject->colour(pair.second.r, pair.second.g, pair.second.b, fillAlpha);
    415415            }
    416             for (auto & elem : triangleIndices)
    417                 manualObject->index(elem);
     416            for (int triangleIndex : triangleIndices)
     417                manualObject->index(triangleIndex);
    418418        }
    419419        else

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

    r10821 r10916  
    116116            std::list<TriangleIndices> faces2;
    117117
    118             for (auto f : faces)
     118            for (const TriangleIndices& f : faces)
    119119            {
    120                
    121120                int a = getMiddlePoint(f.v1, f.v2);
    122121                int b = getMiddlePoint(f.v2, f.v3);
    … …  
    194193    void IcoSphere::addToLineIndices(int baseIndex, std::list<int>* target) const
    195194    {
    196         for (const auto & elem : lineIndices)
     195        for (const LineIndices& line : lineIndices)
    197196        {
    198             target->push_back(baseIndex + (elem).v1);
    199             target->push_back(baseIndex + (elem).v2);
     197            target->push_back(baseIndex + line.v1);
     198            target->push_back(baseIndex + line.v2);
    200199        }
    201200    }
    … …  
    203202    void IcoSphere::addToTriangleIndices(int baseIndex, std::list<int>* target) const
    204203    {
    205         for (const auto & elem : faces)
     204        for (const TriangleIndices& triangle : faces)
    206205        {
    207             target->push_back(baseIndex + (elem).v1);
    208             target->push_back(baseIndex + (elem).v2);
    209             target->push_back(baseIndex + (elem).v3);
     206            target->push_back(baseIndex + triangle.v1);
     207            target->push_back(baseIndex + triangle.v2);
     208            target->push_back(baseIndex + triangle.v3);
    210209        }
    211210    }
    … …  
    217216        transform.setScale(Ogre::Vector3(scale, scale, scale));
    218217
    219         for (auto & elem : vertices)
    220             target->push_back(VertexPair(transform * elem, colour));
     218        for (const Ogre::Vector3& vertex : vertices)
     219            target->push_back(VertexPair(transform * vertex, colour));
    221220
    222221        return vertices.size();

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

    r10821 r10916  
    197197    {
    198198        // iterate through the list of parameters
    199         for (auto & elem : this->parameters_)
    200         {
    201             Ogre::Technique* techniquePtr = materialPtr->getTechnique(elem.technique_);
     199        for (const ParameterContainer& parameter : this->parameters_)
     200        {
     201            Ogre::Technique* techniquePtr = materialPtr->getTechnique(parameter.technique_);
    202202            if (techniquePtr)
    203203            {
    204                 Ogre::Pass* passPtr = techniquePtr->getPass(elem.pass_);
     204                Ogre::Pass* passPtr = techniquePtr->getPass(parameter.pass_);
    205205                if (passPtr)
    206206                {
    207207                    // change the value of the parameter depending on its type
    208                     if (elem.value_.isType<int>())
    209                         passPtr->getFragmentProgramParameters()->setNamedConstant(elem.parameter_, elem.value_.get<int>());
    210                     else if (elem.value_.isType<float>())
    211                         passPtr->getFragmentProgramParameters()->setNamedConstant(elem.parameter_, elem.value_.get<float>());
     208                    if (parameter.value_.isType<int>())
     209                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<int>());
     210                    else if (parameter.value_.isType<float>())
     211                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<float>());
    212212                }
    213213                else
    214                     orxout(internal_warning) << "No pass " << elem.pass_ << " in technique " << elem.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
     214                    orxout(internal_warning) << "No pass " << parameter.pass_ << " in technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
    215215            }
    216216            else
    217                 orxout(internal_warning) << "No technique " << elem.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
     217                orxout(internal_warning) << "No technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
    218218        }
    219219        this->parameters_.clear();
    … …  
    228228        {
    229229            const Ogre::Root::PluginInstanceList& plugins = Ogre::Root::getSingleton().getInstalledPlugins();
    230             for (auto & plugin : plugins)
     230            for (Ogre::Plugin* plugin : plugins)
    231231                if (plugin->getName() == "Cg Program Manager")
    232232                    return true;

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

    r10821 r10916  
    5151            {
    5252                Ogre::UTFString::code_point cp;
    53                 for (auto & elem : input)
     53                for (const char& character : input)
    5454                {
    55                   cp = elem;
     55                  cp = character;
    5656                  cp &= 0xFF;
    5757                  output->append(1, cp);

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

    r10821 r10916  
    672672    {
    673673        uint32_t tempsize = sizeof(uint32_t); // for the number of entries
    674         for(const auto & elem : *((std::set<T>*)(&variable)))
    675             tempsize += returnSize( elem );
     674        for(const T& element : *((std::set<T>*)(&variable)))
     675            tempsize += returnSize( element );
    676676        return tempsize;
    677677    }

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

    r10821 r10916  
    8181    void SignalHandler::dontCatch()
    8282    {
    83       for (auto & elem : sigRecList)
    84       {
    85         signal( elem.signal, elem.handler );
     83      for (const SignalRec& sigRec : sigRecList)
     84      {
     85        signal( sigRec.signal, sigRec.handler );
    8686      }
    8787
    … …  
    133133      }
    134134
    135       for (auto & elem : SignalHandler::getInstance().callbackList)
    136       {
    137         (*(elem.cb))( elem.someData );
     135      for (const SignalCallbackRec& callback : SignalHandler::getInstance().callbackList)
     136      {
     137        (*(callback.cb))( callback.someData );
    138138      }
    139139

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

    r10821 r10916  
    5353    SmallObjectAllocator::~SmallObjectAllocator()
    5454    {
    55         for (auto & elem : this->blocks_)
    56             delete[] elem;
     55        for (char* block : this->blocks_)
     56            delete[] block;
    5757    }
    5858

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

    r10821 r10916  
    262262        std::string output(str.size() * 2, ' ');
    263263        size_t i = 0;
    264         for (auto & elem : str)
    265         {
    266             switch (elem)
     264        for (const char& character : str)
     265        {
     266            switch (character)
    267267            {
    268268            case '\\': output[i] = '\\'; output[i + 1] = '\\'; break;
    … …  
    276276            case  '"': output[i] = '\\'; output[i + 1] =  '"'; break;
    277277            case '\0': output[i] = '\\'; output[i + 1] =  '0'; break;
    278             default  : output[i] = elem; ++i; continue;
     278            default  : output[i] = character; ++i; continue;
    279279            }
    280280            i += 2;
    … …  
    336336    void lowercase(std::string* str)
    337337    {
    338         for (auto & elem : *str)
    339         {
    340             elem = static_cast<char>(tolower(elem));
     338        for (char& character : *str)
     339        {
     340            character = static_cast<char>(tolower(character));
    341341        }
    342342    }
    … …  
    353353    void uppercase(std::string* str)
    354354    {
    355         for (auto & elem : *str)
    356         {
    357             elem = static_cast<char>(toupper(elem));
     355        for (char& character : *str)
     356        {
     357            character = static_cast<char>(toupper(character));
    358358        }
    359359    }
    … …  
    460460    {
    461461        size_t j = 0;
    462         for (auto & elem : str)
    463         {
    464             if (elem == target)
     462        for (char& character : str)
     463        {
     464            if (character == target)
    465465            {
    466                 elem = replacement;
     466                character = replacement;
    467467                ++j;
    468468            }

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

    r10821 r10916  
    116116
    117117        // iterate over all strings in the config-vector
    118         for (auto & full_name : this->configurableAdditionalContexts_)
     118        for (const std::string& full_name : this->configurableAdditionalContexts_)
    119119        {
    120            
    121 
    122120            // split the name into main-name and sub-name (if given; otherwise sub-name remains empty). both names are separated by ::
    123121            std::string name = full_name;

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

    r10821 r10916  
    6565    void MemoryWriter::resendOutput(OutputListener* listener) const
    6666    {
    67         for (auto & message : this->messages_)
     67        for (const Message& message : this->messages_)
    6868        {
    69            
    7069            listener->unfilteredOutput(message.level, *message.context, message.lines);
    7170        }

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

    r10821 r10916  
    111111        this->levelMask_ = mask;
    112112
    113         for (auto & elem : this->listeners_)
    114             elem->updatedLevelMask(this);
     113        for (AdditionalContextListener* listener : this->listeners_)
     114            listener->updatedLevelMask(this);
    115115    }
    116116
    … …  
    142142        this->additionalContextsLevelMask_ = mask;
    143143
    144         for (auto & elem : this->listeners_)
    145             elem->updatedAdditionalContextsLevelMask(this);
     144        for (AdditionalContextListener* listener : this->listeners_)
     145            listener->updatedAdditionalContextsLevelMask(this);
    146146    }
    147147
    … …  
    153153        this->additionalContextsMask_ = mask;
    154154
    155         for (auto & elem : this->listeners_)
    156             elem->updatedAdditionalContextsMask(this);
     155        for (AdditionalContextListener* listener : this->listeners_)
     156            listener->updatedAdditionalContextsMask(this);
    157157    }
    158158

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

    r10829 r10916  
    131131        vectorize(message, '\n', &lines);
    132132
    133         for (auto & elem : this->listeners_)
    134             elem->unfilteredOutput(level, context, lines);
     133        for (OutputListener* listener : this->listeners_)
     134            listener->unfilteredOutput(level, context, lines);
    135135    }
    136136
    … …  
    178178    {
    179179        int mask = 0;
    180         for (auto & elem : this->listeners_)
    181             mask |= elem->getLevelMask();
     180        for (OutputListener* listener : this->listeners_)
     181            mask |= listener->getLevelMask();
    182182        this->combinedLevelMask_ = static_cast<OutputLevel>(mask);
    183183    }
    … …  
    189189    {
    190190        int mask = 0;
    191         for (auto & elem : this->listeners_)
    192             mask |= elem->getAdditionalContextsLevelMask();
     191        for (OutputListener* listener : this->listeners_)
     192            mask |= listener->getAdditionalContextsLevelMask();
    193193        this->combinedAdditionalContextsLevelMask_ = static_cast<OutputLevel>(mask);
    194194    }
    … …  
    200200    {
    201201        this->combinedAdditionalContextsMask_ = 0;
    202         for (auto & elem : this->listeners_)
    203             this->combinedAdditionalContextsMask_ |= elem->getAdditionalContextsMask();
     202        for (OutputListener* listener : this->listeners_)
     203            this->combinedAdditionalContextsMask_ |= listener->getAdditionalContextsMask();
    204204    }
    205205

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

    r10821 r10916  
    7979
    8080        // compose the mask of subcontexts and build the set of sub-context-IDs
    81         for (const auto & subcontext : subcontexts)
     81        for (const OutputContextContainer* subcontext : subcontexts)
    8282        {
    83             this->subcontextsCheckMask_ |= (subcontext)->mask;
    84             this->subcontexts_.insert((subcontext)->sub_id);
     83            this->subcontextsCheckMask_ |= subcontext->mask;
     84            this->subcontexts_.insert(subcontext->sub_id);
    8585        }
    8686

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

    r10821 r10916  
    327327    const DockingEffect* Dock::getEffect(unsigned int i) const
    328328    {
    329         for (const auto & elem : this->effects_)
     329        for (DockingEffect* effect : this->effects_)
    330330        {
    331331            if(i == 0)
    332                return elem;
     332               return effect;
    333333            i--;
    334334        }
    … …  
    346346    const DockingAnimation* Dock::getAnimation(unsigned int i) const
    347347    {
    348         for (const auto & elem : this->animations_)
     348        for (DockingAnimation* animation : this->animations_)
    349349        {
    350350            if(i == 0)
    351                return elem;
     351               return animation;
    352352            i--;
    353353        }

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

    r10821 r10916  
    5757        bool check = true;
    5858
    59         for (auto & animations_animation : animations)
     59        for (DockingAnimation* animation : animations)
    6060        {
    6161            if(dock)
    62                 check &= (animations_animation)->docking(player);
     62                check &= animation->docking(player);
    6363            else
    64                 check &= (animations_animation)->release(player);
     64                check &= animation->release(player);
    6565        }
    6666

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

    r10821 r10916  
    5353        bool check = true;
    5454
    55         for (auto & effects_effect : effects)
     55        for (DockingEffect* effect : effects)
    5656        {
    5757            if (dock)
    58                 check &= (effects_effect)->docking(player);
     58                check &= effect->docking(player);
    5959            else
    60                 check &= (effects_effect)->release(player);
     60                check &= effect->release(player);
    6161        }
    6262

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

    r10821 r10916  
    146146    {
    147147        Vector3 checkpoints(-1,-1,-1); int count=0;
    148         for (const auto & elem : nextCheckpoints_)
     148        for (int nextCheckpoint : nextCheckpoints_)
    149149        {
    150150            switch (count)
    151151            {
    152                 case 0: checkpoints.x = static_cast<Ogre::Real>(elem); break;
    153                 case 1: checkpoints.y = static_cast<Ogre::Real>(elem); break;
    154                 case 2: checkpoints.z = static_cast<Ogre::Real>(elem); break;
     152                case 0: checkpoints.x = static_cast<Ogre::Real>(nextCheckpoint); break;
     153                case 1: checkpoints.y = static_cast<Ogre::Real>(nextCheckpoint); break;
     154                case 2: checkpoints.z = static_cast<Ogre::Real>(nextCheckpoint); break;
    155155            }
    156156            ++count;

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

    r10821 r10916  
    154154    {
    155155        std::map<RaceCheckPoint*, int> zaehler; // counts how many times the checkpoint was reached (for simulation)
    156         for (auto & allCheckpoint : allCheckpoints)
    157         {
    158             zaehler.insert(std::pair<RaceCheckPoint*, int>(allCheckpoint,0));
     156        for (RaceCheckPoint* checkpoint : allCheckpoints)
     157        {
     158            zaehler.insert(std::pair<RaceCheckPoint*, int>(checkpoint,0));
    159159        }
    160160        int maxWays = rekSimulationCheckpointsReached(currentCheckpoint, zaehler);
    161161
    162162        std::vector<RaceCheckPoint*> returnVec;
    163         for (auto & elem : zaehler)
    164         {
    165             if (elem.second == maxWays)
    166             {
    167                 returnVec.push_back(elem.first);
     163        for (auto& mapEntry : zaehler)
     164        {
     165            if (mapEntry.second == maxWays)
     166            {
     167                returnVec.push_back(mapEntry.first);
    168168            }
    169169        }
    … …  
    226226
    227227        // find the next checkpoint with the minimal distance
    228         for (auto elem : raceCheckpoint->getNextCheckpoints())
    229         {
    230             RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(elem);
     228        for (int checkpointIndex : raceCheckpoint->getNextCheckpoints())
     229        {
     230            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(checkpointIndex);
    231231            float distance = recCalculateDistance(nextRaceCheckPoint, this->getControllableEntity()->getPosition());
    232232
    … …  
    289289    RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
    290290    {
    291         for (auto & elem : this->checkpoints_)
    292             if (elem->getCheckpointIndex() == index)
    293                 return elem;
     291        for (RaceCheckPoint* checkpoint : this->checkpoints_)
     292            if (checkpoint->getCheckpointIndex() == index)
     293                return checkpoint;
    294294        return nullptr;
    295295    }
    … …  
    414414        btScalar radiusObject;
    415415
    416         for (const auto & allObject : allObjects)
    417         {
    418             for (int everyShape=0; (allObject)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
    419             {
    420                 btCollisionShape* currentShape = (allObject)->getAttachedCollisionShape(everyShape)->getCollisionShape();
     416        for (StaticEntity* object : allObjects)
     417        {
     418            for (int everyShape=0; object->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
     419            {
     420                btCollisionShape* currentShape = object->getAttachedCollisionShape(everyShape)->getCollisionShape();
    421421                if(currentShape == nullptr)
    422422                continue;

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

    r10821 r10916  
    5454    SpaceRaceManager::~SpaceRaceManager()
    5555    {
    56         for (auto & elem : this->checkpoints_)
    57         elem->destroy();
     56        for (RaceCheckPoint* checkpoint : this->checkpoints_)
     57        checkpoint->destroy();
    5858    }
    5959
    … …  
    7777        }
    7878
    79         for (auto & elem : players_)
     79        for (auto& mapEntry : players_)
    8080        {
    8181
    82             for (auto & _i : this->checkpoints_)
     82            for (RaceCheckPoint* checkpoint : this->checkpoints_)
    8383            {
    84                 if (_i->playerWasHere(elem.first)){
    85                 this->checkpointReached(_i, elem.first /*this->checkpoints_[i]->getPlayer()*/);
     84                if (checkpoint->playerWasHere(mapEntry.first)){
     85                this->checkpointReached(checkpoint, mapEntry.first /*this->checkpoints_[i]->getPlayer()*/);
    8686                }
    8787            }
    … …  
    113113    RaceCheckPoint* SpaceRaceManager::findCheckpoint(int index) const
    114114    {
    115         for (auto & elem : this->checkpoints_)
    116         if (elem->getCheckpointIndex() == index)
    117         return elem;
     115        for (RaceCheckPoint* checkpoint : this->checkpoints_)
     116        if (checkpoint->getCheckpointIndex() == index)
     117        return checkpoint;
    118118        return nullptr;
    119119    }
    … …  
    125125            // the player already visited an old checkpoint; see which checkpoints are possible now
    126126            const std::set<int>& possibleCheckpoints = oldCheckpoint->getNextCheckpoints();
    127             for (const auto & possibleCheckpoint : possibleCheckpoints)
     127            for (int possibleCheckpoint : possibleCheckpoints)
    128128            if (this->findCheckpoint(possibleCheckpoint) == newCheckpoint)
    129129            return true;
    … …  
    179179        {
    180180            const std::set<int>& oldVisible = oldCheckpoint->getNextCheckpoints();
    181             for (const auto & elem : oldVisible)
    182             this->findCheckpoint(elem)->setRadarVisibility(false);
     181            for (int checkpointIndex : oldVisible)
     182            this->findCheckpoint(checkpointIndex)->setRadarVisibility(false);
    183183        }
    184184
    … …  
    188188
    189189            const std::set<int>& newVisible = newCheckpoint->getNextCheckpoints();
    190             for (const auto & elem : newVisible)
    191             this->findCheckpoint(elem)->setRadarVisibility(true);
     190            for (int checkpointIndex : newVisible)
     191            this->findCheckpoint(checkpointIndex)->setRadarVisibility(true);
    192192        }
    193193    }

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

    r10821 r10916  
    633633
    634634
    635         for (auto & elem : matrix)
     635        for (int i = 0; i < numI; ++i)
    636636        {
    637637            for (int j = 0; j < numJ; ++j)
    638638            {
    639                 elem[j].type = PLATFORM_EMPTY;
    640                 elem[j].done = false;
     639                matrix[i][j].type = PLATFORM_EMPTY;
     640                matrix[i][j].done = false;
    641641            }
    642642        }
    … …  
    795795
    796796        // Fill matrix with selected platform types
    797         for (auto & elem : matrix)
     797        for (int i = 0; i < numI; ++ i)
    798798        {
    799799            for (int j = 0; j < numJ; ++ j)
    … …  
    801801                if (rand()%3 == 0)
    802802                {
    803                     elem[j].type = platformtype1;
     803                    matrix[i][j].type = platformtype1;
    804804                }
    805805                else
    806806                {
    807                     elem[j].type = platformtype2;
     807                    matrix[i][j].type = platformtype2;
    808808                }
    809                 elem[j].done = false;
     809                matrix[i][j].done = false;
    810810            }
    811811        }

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

    r10821 r10916  
    155155    {
    156156        // first spawn human players to assign always the left bat to the player in singleplayer
    157         for (auto & elem : this->players_)
    158             if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
    159                 this->spawnPlayer(elem.first);
     157        for (auto& mapEntry : this->players_)
     158            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
     159                this->spawnPlayer(mapEntry.first);
    160160        // now spawn bots
    161         for (auto & elem : this->players_)
    162             if (!elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
    163                 this->spawnPlayer(elem.first);
     161        for (auto& mapEntry : this->players_)
     162            if (!mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
     163                this->spawnPlayer(mapEntry.first);
    164164    }
    165165

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

    r10821 r10916  
    6969    {
    7070        // Destroys all Notifications.
    71         for(auto & elem : this->allNotificationsList_)
    72             elem.second->destroy();
     71        for(auto& mapEntry : this->allNotificationsList_)
     72            mapEntry.second->destroy();
    7373        this->allNotificationsList_.clear();
    7474
    … …  
    152152        bool executed = false;
    153153        // Clear all NotificationQueues that have the input sender as target.
    154         for(auto & elem : this->queues_) // Iterate through all NotificationQueues.
    155         {
    156             const std::set<std::string>& set = elem.second->getTargetsSet();
     154        for(auto& mapEntry : this->queues_) // Iterate through all NotificationQueues.
     155        {
     156            const std::set<std::string>& set = mapEntry.second->getTargetsSet();
    157157            // If either the sender is 'all', the NotificationQueue has as target all or the NotificationQueue has the input sender as a target.
    158158            if(all || set.find(NotificationListener::ALL) != set.end() || set.find(sender) != set.end())
    159                 executed = elem.second->tidy() || executed;
     159                executed = mapEntry.second->tidy() || executed;
    160160        }
    161161
    … …  
    187187
    188188        // Insert the Notification in all NotificationQueues that have its sender as target.
    189         for(auto & elem : this->queues_) // Iterate through all NotificationQueues.
    190         {
    191             const std::set<std::string>& set = elem.second->getTargetsSet();
     189        for(auto& mapEntry : this->queues_) // Iterate through all NotificationQueues.
     190        {
     191            const std::set<std::string>& set = mapEntry.second->getTargetsSet();
    192192            bool bAll = set.find(NotificationListener::ALL) != set.end();
    193193            // If either the Notification has as sender 'all', the NotificationQueue displays all Notifications or the NotificationQueue has the sender of the Notification as target.
    … …  
    195195            {
    196196                if(!bAll)
    197                     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.
    198                 elem.second->update(notification, time); // Update the NotificationQueue.
     197                    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.
     198                mapEntry.second->update(notification, time); // Update the NotificationQueue.
    199199            }
    200200        }
    … …  
    345345
    346346        // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
    347         for(auto & elem : this->allNotificationsList_)
    348         {
    349             if(!bAll && set.find(elem.second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
    350                 map->insert(std::pair<std::time_t, Notification*>(elem.first, elem.second));
     347        for(auto& mapEntry : this->allNotificationsList_)
     348        {
     349            if(!bAll && set.find(mapEntry.second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
     350                map->insert(std::pair<std::time_t, Notification*>(mapEntry.first, mapEntry.second));
    351351        }
    352352

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

    r10821 r10916  
    206206        {
    207207            // Add all Notifications that have been created after this NotificationQueue was created.
    208             for(auto & notification : *notifications)
     208            for(auto& mapEntry : *notifications)
    209209            {
    210                 if(notification.first >= this->creationTime_)
    211                     this->push(notification.second, notification.first);
     210                if(mapEntry.first >= this->creationTime_)
     211                    this->push(mapEntry.second, mapEntry.first);
    212212            }
    213213        }
    … …  
    336336        this->ordering_.clear();
    337337        // Delete all NotificationContainers in the list.
    338         for(auto & elem : this->notifications_)
    339             delete elem;
     338        for(NotificationContainer* notification : this->notifications_)
     339            delete notification;
    340340
    341341        this->notifications_.clear();
    … …  
    426426        bool first = true;
    427427        // Iterate through the set of targets.
    428         for(const auto & elem : this->targets_)
     428        for(const std::string& target : this->targets_)
    429429        {
    430430            if(!first)
    … …  
    432432            else
    433433                first = false;
    434             stream << elem;
     434            stream << target;
    435435        }
    436436

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

    r10821 r10916  
    6161        SUPER(Attacher, changedActivity);
    6262
    63         for (auto & elem : this->objects_)
    64             (elem)->setActive(this->isActive());
     63        for (WorldEntity* object : this->objects_)
     64            object->setActive(this->isActive());
    6565    }
    6666
    … …  
    6969        SUPER(Attacher, changedVisibility);
    7070
    71         for (auto & elem : this->objects_)
    72             (elem)->setVisible(this->isVisible());
     71        for (WorldEntity* object : this->objects_)
     72            object->setVisible(this->isVisible());
    7373    }
    7474
    … …  
    8383    {
    8484        unsigned int i = 0;
    85         for (const auto & elem : this->objects_)
     85        for (WorldEntity* object : this->objects_)
    8686        {
    8787            if (i == index)
    88                 return (elem);
     88                return object;
    8989
    9090            ++i;

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

    r10821 r10916  
    196196            {
    197197                const std::map<unsigned int, PlayerInfo*> clients = PlayerManager::getInstance().getClients();
    198                 for(const auto & client : clients)
     198                for(const auto& mapEntry : clients)
    199199                {
    200                     callStaticNetworkFunction(&Script::executeHelper, client.first, this->getCode(), this->getMode(), this->getNeedsGraphics());
     200                    callStaticNetworkFunction(&Script::executeHelper, mapEntry.first, this->getCode(), this->getMode(), this->getNeedsGraphics());
    201201                    if(this->times_ != Script::INF) // Decrement the number of remaining executions.
    202202                    {

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

    r10821 r10916  
    5959            this->pawnsIn_.clear();
    6060
    61             for(auto & elem : this->billboards_)
     61            for(BillboardAdministration& billboard : this->billboards_)
    6262            {
    63                 if( elem.billy != nullptr)
    64                 {
    65                     delete elem.billy;
     63                if( billboard.billy != nullptr)
     64                {
     65                    delete billboard.billy;
    6666                }
    6767            }
    … …  
    138138    void SpaceBoundaries::removeAllBillboards()
    139139    {
    140         for(auto & elem : this->billboards_)
    141         {
    142             elem.usedYet = false;
    143             elem.billy->setVisible(false);
     140        for(BillboardAdministration& billboard : this->billboards_)
     141        {
     142            billboard.usedYet = false;
     143            billboard.billy->setVisible(false);
    144144        }
    145145    }
    … …  
    208208        float distance;
    209209        bool humanItem;
    210         for(auto currentPawn : pawnsIn_)
    211         {
    212            
     210        for(Pawn* currentPawn : pawnsIn_)
     211        {
    213212            if( currentPawn && currentPawn->getNode() )
    214213            {

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

    r10821 r10916  
    4545    {
    4646        if (this->isInitialized())
    47             for (auto & elem : this->targets_)
    48                 (elem)->destroy();
     47            for (BaseObject* target : this->targets_)
     48                target->destroy();
    4949    }
    5050
    … …  
    6161    void EventDispatcher::processEvent(Event& event)
    6262    {
    63         for (auto & elem : this->targets_)
    64             (elem)->processEvent(event);
     63        for (BaseObject* target : this->targets_)
     64            target->processEvent(event);
    6565    }
    6666
    … …  
    7373    {
    7474        unsigned int i = 0;
    75         for (const auto & elem : this->targets_)
     75        for (BaseObject* target : this->targets_)
    7676        {
    7777            if (i == index)
    78                 return (elem);
     78                return target;
    7979            ++i;
    8080        }

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

    r10821 r10916  
    9696    {
    9797        unsigned int i = 0;
    98         for (const auto & elem : this->sources_)
     98        for (BaseObject* source : this->sources_)
    9999        {
    100100            if (i == index)
    101                 return (elem);
     101                return source;
    102102            ++i;
    103103        }
    … …  
    113113    {
    114114        unsigned int i = 0;
    115         for (const auto & elem : this->names_)
     115        for (EventName* name : this->names_)
    116116        {
    117117            if (i == index)
    118                 return (elem);
     118                return name;
    119119            ++i;
    120120        }

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

    r10821 r10916  
    158158            {
    159159               
    160                 const std::set<WorldEntity*> attached = entity->getAttachedObjects();
     160                const std::set<WorldEntity*> attachedObjects = entity->getAttachedObjects();
    161161                bool found = false;
    162                 for(const auto & elem : attached)
     162                for(WorldEntity* attachedObject : attachedObjects)
    163163                {
    164                     if((elem)->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(elem)->getName() == this->targetName_)
     164                    if(attachedObject->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(attachedObject)->getName() == this->targetName_)
    165165                    {
    166166                        found = true;

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

    r10821 r10916  
    180180            {
    181181
    182                 const std::set<WorldEntity*> attached = entity->getAttachedObjects();
     182                const std::set<WorldEntity*> attachedObjects = entity->getAttachedObjects();
    183183                bool found = false;
    184                 for(const auto & elem : attached)
     184                for(WorldEntity* attachedObject : attachedObjects)
    185185                {
    186                     if((elem)->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(elem)->getName() == this->targetName_)
     186                    if(attachedObject->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(attachedObject)->getName() == this->targetName_)
    187187                    {
    188188                        found = true;

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

    r10821 r10916  
    504504    bool MultiTrigger::checkAnd(BaseObject* triggerer)
    505505    {
    506         for(auto trigger : this->children_)
    507         {
    508            
     506        for(TriggerBase* trigger : this->children_)
     507        {
    509508            if(trigger->isMultiTrigger())
    510509            {
    … …  
    531530    bool MultiTrigger::checkOr(BaseObject* triggerer)
    532531    {
    533         for(auto trigger : this->children_)
    534         {
    535            
     532        for(TriggerBase* trigger : this->children_)
     533        {
    536534            if(trigger->isMultiTrigger())
    537535            {
    … …  
    559557    {
    560558        bool triggered = false;
    561         for(auto trigger : this->children_)
    562         {
    563            
     559        for(TriggerBase* trigger : this->children_)
     560        {
    564561            if(triggered)
    565562            {

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

    r10821 r10916  
    234234    {
    235235        // Iterate over all sub-triggers.
    236         for (const auto & elem : this->children_)
    237         {
    238             if (!(elem)->isActive())
     236        for (TriggerBase* child : this->children_)
     237        {
     238            if (!child->isActive())
    239239                return false;
    240240        }
    … …  
    252252    {
    253253        // Iterate over all sub-triggers.
    254         for (const auto & elem : this->children_)
    255         {
    256             if ((elem)->isActive())
     254        for (TriggerBase* child : this->children_)
     255        {
     256            if (child->isActive())
    257257                return true;
    258258        }
    … …  
    270270    {
    271271        bool test = false;
    272         for (const auto & elem : this->children_)
    273         {
    274             if (test && (elem)->isActive())
     272        for (TriggerBase* child : this->children_)
     273        {
     274            if (test && child->isActive())
    275275                return false;
    276             if ((elem)->isActive())
     276            if (child->isActive())
    277277                test = true;
    278278        }

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

    r10821 r10916  
    5858    ChatOverlay::~ChatOverlay()
    5959    {
    60         for (const auto & elem : this->timers_)
    61             delete (elem);
     60        for (Timer* timer : this->timers_)
     61            delete timer;
    6262    }
    6363
    … …  
    9292        this->text_->setCaption("");
    9393
    94         for (auto & elem : this->messages_)
     94        for (const Ogre::DisplayString& message : this->messages_)
    9595        {
    96             this->text_->setCaption(this->text_->getCaption() + "\n" + (elem));
     96            this->text_->setCaption(this->text_->getCaption() + "\n" + message);
    9797        }
    9898    }

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

    r10821 r10916  
    131131        }
    132132        this->fontName_ = font;
    133         for (auto & elem : this->activeObjectList_)
    134         {
    135             if (elem.second.text_ != nullptr)
    136                 elem.second.text_->setFontName(this->fontName_);
     133        for (auto& mapEntry : this->activeObjectList_)
     134        {
     135            if (mapEntry.second.text_ != nullptr)
     136                mapEntry.second.text_->setFontName(this->fontName_);
    137137        }
    138138    }
    … …  
    151151        }
    152152        this->textSize_ = size;
    153         for (auto & elem : this->activeObjectList_)
    154         {
    155             if (elem.second.text_)
    156                 elem.second.text_->setCharHeight(size);
     153        for (auto& mapEntry : this->activeObjectList_)
     154        {
     155            if (mapEntry.second.text_)
     156                mapEntry.second.text_->setCharHeight(size);
    157157        }
    158158    }
    … …  
    186186        const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
    187187
    188         for (auto & elem : this->sortedObjectList_)
    189         elem.second = (int)((elem.first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
     188        for (std::pair<RadarViewable*, unsigned int>& pair : this->sortedObjectList_)
     189        pair.second = (int)((pair.first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
    190190
    191191        this->sortedObjectList_.sort(compareDistance);
    … …  
    531531        float yScale = this->getActualSize().y;
    532532
    533         for (auto & elem : this->activeObjectList_)
    534         {
    535             if (elem.second.health_ != nullptr)
    536                 elem.second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
    537             if (elem.second.healthLevel_ != nullptr)
    538                 elem.second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
    539             if (elem.second.panel_ != nullptr)
    540                 elem.second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
    541             if (elem.second.text_ != nullptr)
    542                 elem.second.text_->setCharHeight(this->textSize_ * yScale);
    543             if (elem.second.target_ != nullptr)
    544                 elem.second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
     533        for (auto& mapEntry : this->activeObjectList_)
     534        {
     535            if (mapEntry.second.health_ != nullptr)
     536                mapEntry.second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
     537            if (mapEntry.second.healthLevel_ != nullptr)
     538                mapEntry.second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
     539            if (mapEntry.second.panel_ != nullptr)
     540                mapEntry.second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
     541            if (mapEntry.second.text_ != nullptr)
     542                mapEntry.second.text_->setCharHeight(this->textSize_ * yScale);
     543            if (mapEntry.second.target_ != nullptr)
     544                mapEntry.second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
    545545        }
    546546    }
    … …  
    670670    {
    671671        const std::set<RadarViewable*>& respawnObjects = this->getOwner()->getScene()->getRadar()->getRadarObjects();
    672         for (const auto & respawnObject : respawnObjects)
    673         {
    674             if (!(respawnObject)->isHumanShip_)
     672        for (RadarViewable* respawnObject : respawnObjects)
     673        {
     674            if (!respawnObject->isHumanShip_)
    675675            this->addObject(respawnObject);
    676676        }

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

    r10821 r10916  
    9292            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->map3DBack_);
    9393
    94             for (auto & elem : this->radarObjects_)
    95             {
    96                 Ogre::OverlayManager::getSingleton().destroyOverlayElement(elem.second);
     94            for (auto& mapEntry : this->radarObjects_)
     95            {
     96                Ogre::OverlayManager::getSingleton().destroyOverlayElement(mapEntry.second);
    9797            }
    9898        }

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

    r10821 r10916  
    6060        SUPER(Scoreboard, changedVisibility);
    6161
    62         for (auto & elem : this->lines_)
    63             elem->changedVisibility();
     62        for (CreateLines* line : this->lines_)
     63            line->changedVisibility();
    6464    }
    6565
    … …  
    9494
    9595        unsigned int index = 0;
    96         for (const auto & elem : playerList)
     96        for (const auto& mapEntry : playerList)
    9797        {
    98             this->lines_[index]->setPlayerName(multi_cast<std::string>(elem.first->getName()));
    99             this->lines_[index]->setScore(multi_cast<std::string>(elem.second.frags_));
    100             this->lines_[index]->setDeaths(multi_cast<std::string>(elem.second.killed_));
     98            this->lines_[index]->setPlayerName(multi_cast<std::string>(mapEntry.first->getName()));
     99            this->lines_[index]->setScore(multi_cast<std::string>(mapEntry.second.frags_));
     100            this->lines_[index]->setDeaths(multi_cast<std::string>(mapEntry.second.killed_));
    101101            index++;
    102102        }

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

    r10821 r10916  
    6868    {
    6969        // Destroy all Pickupables constructing this PickupCollection.
    70         for(auto & elem : this->pickups_)
    71         {
    72             (elem)->wasRemovedFromCollection();
    73             (elem)->destroy();
     70        for(CollectiblePickup* pickup : this->pickups_)
     71        {
     72            pickup->wasRemovedFromCollection();
     73            pickup->destroy();
    7474        }
    7575        this->pickups_.clear();
    … …  
    9999        this->processingUsed_ = true;
    100100        // Change used for all Pickupables this PickupCollection consists of.
    101         for(auto & elem : this->pickups_)
    102             (elem)->setUsed(this->isUsed());
     101        for(CollectiblePickup* pickup : this->pickups_)
     102            pickup->setUsed(this->isUsed());
    103103
    104104        this->processingUsed_ = false;
    … …  
    119119        size_t numPickupsEnabled = 0;
    120120        size_t numPickupsInUse = 0;
    121         for(auto & elem : this->pickups_)
    122         {
    123             if ((elem)->isEnabled())
     121        for(CollectiblePickup* pickup : this->pickups_)
     122        {
     123            if (pickup->isEnabled())
    124124                ++numPickupsEnabled;
    125             if ((elem)->isUsed())
     125            if (pickup->isUsed())
    126126                ++numPickupsInUse;
    127127        }
    … …  
    146146
    147147        // Change the PickupCarrier for all Pickupables this PickupCollection consists of.
    148         for(auto & elem : this->pickups_)
     148        for(CollectiblePickup* pickup : this->pickups_)
    149149        {
    150150            if(this->getCarrier() == nullptr)
    151                 (elem)->setCarrier(nullptr);
     151                pickup->setCarrier(nullptr);
    152152            else
    153                 (elem)->setCarrier(this->getCarrier()->getTarget(elem));
     153                pickup->setCarrier(this->getCarrier()->getTarget(pickup));
    154154        }
    155155    }
    … …  
    186186        // If at least all the enabled pickups of this PickupCollection are no longer picked up.
    187187        bool isOnePickupEnabledAndPickedUp = false;
    188         for(auto & elem : this->pickups_)
    189         {
    190             if ((elem)->isEnabled() && (elem)->isPickedUp())
     188        for(CollectiblePickup* pickup : this->pickups_)
     189        {
     190            if (pickup->isEnabled() && pickup->isPickedUp())
    191191            {
    192192                isOnePickupEnabledAndPickedUp = true;
    … …  
    208208    bool PickupCollection::isTarget(const PickupCarrier* carrier) const
    209209    {
    210         for(const auto & elem : this->pickups_)
    211         {
    212             if(!carrier->isTarget(elem))
     210        for(CollectiblePickup* pickup : this->pickups_)
     211        {
     212            if(!carrier->isTarget(pickup))
    213213                return false;
    214214        }

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

    r10821 r10916  
    9191
    9292        // Destroying all the PickupInventoryContainers that are still there.
    93         for(auto & elem : this->pickupInventoryContainers_)
    94             delete elem.second;
     93        for(auto& mapEntry : this->pickupInventoryContainers_)
     94            delete mapEntry.second;
    9595        this->pickupInventoryContainers_.clear();
    9696

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

    r10821 r10916  
    118118                std::set<Pickupable*> pickups = carrier->getPickups();
    119119                // Iterate over all Pickupables of the PickupCarrier.
    120                 for(auto pickup : pickups)
     120                for(Pickupable* pickup : pickups)
    121121                {
    122                    
    123122                    if(pickup == nullptr || pickup == this)
    124123                        continue;

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

    r10821 r10916  
    145145
    146146            // If one of the bats is missing, create it. Apply the template for the bats as specified in the centerpoint.
    147             for (auto & elem : this->bat_)
     147            for (WeakPtr<orxonox::PongBat>& bat : this->bat_)
    148148            {
    149                 if (elem == nullptr)
     149                if (bat == nullptr)
    150150                {
    151                     elem = new PongBat(this->center_->getContext());
    152                     elem->addTemplate(this->center_->getBattemplate());
     151                    bat = new PongBat(this->center_->getContext());
     152                    bat->addTemplate(this->center_->getBattemplate());
    153153                }
    154154            }
    … …  
    211211    {
    212212        // first spawn human players to assign always the left bat to the player in singleplayer
    213         for (auto & elem : this->players_)
    214             if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
    215                 this->spawnPlayer(elem.first);
     213        for (auto& mapEntry : this->players_)
     214            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
     215                this->spawnPlayer(mapEntry.first);
    216216        // now spawn bots
    217         for (auto & elem : this->players_)
    218             if (!elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
    219                 this->spawnPlayer(elem.first);
     217        for (auto& mapEntry : this->players_)
     218            if (!mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
     219                this->spawnPlayer(mapEntry.first);
    220220    }
    221221

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

    r10821 r10916  
    7777    PongAI::~PongAI()
    7878    {
    79         for (auto & elem : this->reactionTimers_)
    80             elem.first->destroy();
     79        for (std::pair<Timer*, char>& pair : this->reactionTimers_)
     80            pair.first->destroy();
    8181    }
    8282

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

    r10821 r10916  
    9494
    9595        // Iterate through all players possessing this Quest.
    96         for(const auto & elem : players_)
    97             QuestEffect::invokeEffects(elem, this->getFailEffectList());
     96        for(PlayerInfo* questPlayer : players_)
     97            QuestEffect::invokeEffects(questPlayer, this->getFailEffectList());
    9898
    9999        return true;
    … …  
    119119
    120120        // Iterate through all players possessing the Quest.
    121         for(const auto & elem : players_)
    122             QuestEffect::invokeEffects(elem, this->getCompleteEffectList());
     121        for(PlayerInfo* questPlayer : players_)
     122            QuestEffect::invokeEffects(questPlayer, this->getCompleteEffectList());
    123123
    124124        Quest::complete(player);
    … …  
    242242    {
    243243        int i = index;
    244         for (const auto & elem : this->rewards_)
     244        for (QuestEffect* reward : this->rewards_)
    245245        {
    246246            if(i == 0)
    247                return elem;
     247               return reward;
    248248
    249249            i--;

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

    r10821 r10916  
    190190
    191191        // Iterate through all subquests.
    192         for (const auto & elem : this->subQuests_)
     192        for (Quest* quest : this->subQuests_)
    193193        {
    194194            if(i == 0) // We're counting down...
    195                return elem;
     195               return quest;
    196196
    197197            i--;
    … …  
    214214
    215215        // Iterate through all QuestHints.
    216         for (const auto & elem : this->hints_)
     216        for (QuestHint* hint : this->hints_)
    217217        {
    218218            if(i == 0) // We're counting down...
    219                return elem;
     219               return hint;
    220220
    221221            i--;
    … …  
    237237
    238238        // Iterate through all fail QuestEffects.
    239         for (const auto & elem : this->failEffects_)
     239        for (QuestEffect* effect : this->failEffects_)
    240240        {
    241241            if(i == 0) // We're counting down...
    242                return elem;
     242               return effect;
    243243
    244244            i--;
    … …  
    260260
    261261        // Iterate through all complete QuestEffects.
    262         for (const auto & elem : this->completeEffects_)
     262        for (QuestEffect* effect : this->completeEffects_)
    263263        {
    264264            if(i == 0) // We're counting down...
    265                return elem;
     265               return effect;
    266266
    267267            i--;

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

    r10821 r10916  
    7474        orxout(verbose, context::quests) << "Invoking QuestEffects on player: " << player << " ."  << endl;
    7575
    76         for (auto & effects_effect : effects)
    77             temp = temp && (effects_effect)->invoke(player);
     76        for (QuestEffect* effect : effects)
     77            temp = temp && effect->invoke(player);
    7878
    7979        return temp;

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

    r10821 r10916  
    236236    {
    237237        int i = index;
    238         for (const auto & elem : this->effects_)
     238        for (QuestEffect* effect : this->effects_)
    239239        {
    240240            if(i == 0)
    241                return elem;
     241               return effect;
    242242
    243243            i--;

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

    r10821 r10916  
    9797    /* static */ void QuestListener::advertiseStatusChange(std::list<QuestListener*> & listeners, const std::string & status)
    9898    {
    99         for (auto listener : listeners) // Iterate through all QuestListeners
    100         {
    101            
     99        for (QuestListener* listener : listeners) // Iterate through all QuestListeners
     100        {
    102101            if(listener->getMode() == status || listener->getMode() == QuestListener::ALL) // Check whether the status change affects the give QuestListener.
    103102                listener->execute();

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

    r10821 r10916  
    235235    {
    236236        int numQuests = 0;
    237         for(auto & elem : this->questMap_)
    238         {
    239             if(elem.second->getParentQuest() == nullptr && !elem.second->isInactive(player))
     237        for(auto& mapEntry : this->questMap_)
     238        {
     239            if(mapEntry.second->getParentQuest() == nullptr && !mapEntry.second->isInactive(player))
    240240                numQuests++;
    241241        }
    … …  
    255255    Quest* QuestManager::getRootQuest(PlayerInfo* player, int index)
    256256    {
    257         for(auto & elem : this->questMap_)
    258         {
    259             if(elem.second->getParentQuest() == nullptr && !elem.second->isInactive(player) && index-- == 0)
    260                 return elem.second;
     257        for(auto& mapEntry : this->questMap_)
     258        {
     259            if(mapEntry.second->getParentQuest() == nullptr && !mapEntry.second->isInactive(player) && index-- == 0)
     260                return mapEntry.second;
    261261        }
    262262        return nullptr;
    … …  
    280280        std::list<Quest*> quests = quest->getSubQuestList();
    281281        int numQuests = 0;
    282         for(auto & quest : quests)
    283         {
    284             if(!(quest)->isInactive(player))
     282        for(Quest* subquest : quests)
     283        {
     284            if(!subquest->isInactive(player))
    285285                numQuests++;
    286286        }
    … …  
    304304
    305305        std::list<Quest*> quests = quest->getSubQuestList();
    306         for(auto & quest : quests)
    307         {
    308             if(!(quest)->isInactive(player) && index-- == 0)
     306        for(Quest* subquest : quests)
     307        {
     308            if(!subquest->isInactive(player) && index-- == 0)
    309309                return quest;
    310310        }
    … …  
    326326        std::list<QuestHint*> hints = quest->getHintsList();
    327327        int numHints = 0;
    328         for(auto & hint : hints)
    329         {
    330             if((hint)->isActive(player))
     328        for(QuestHint* hint : hints)
     329        {
     330            if(hint->isActive(player))
    331331                numHints++;
    332332        }
    … …  
    349349    {
    350350        std::list<QuestHint*> hints = quest->getHintsList();
    351         for(auto & hint : hints)
    352         {
    353             if((hint)->isActive(player) && index-- == 0)
     351        for(QuestHint* hint : hints)
     352        {
     353            if(hint->isActive(player) && index-- == 0)
    354354                return hint;
    355355        }

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

    r10821 r10916  
    8484    {
    8585        int i = index;
    86         for (const auto & elem : this->rewards_)
     86        for (Rewardable* reward : this->rewards_)
    8787        {
    8888            if(i == 0)
    89                return elem;
     89               return reward;
    9090            i--;
    9191        }
    … …  
    106106
    107107        bool temp = true;
    108         for (auto & elem : this->rewards_)
    109             temp = temp && (elem)->reward(player);
     108        for (Rewardable* reward : this->rewards_)
     109            temp = temp && reward->reward(player);
    110110
    111111        orxout(verbose, context::quests) << "Rewardable successfully added to player." << player << " ." << endl;

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

    r10821 r10916  
    104104        }
    105105
    106         for (auto & elem : this->stones_)
    107             (elem)->destroy();
     106        for (TetrisStone* stone : this->stones_)
     107            stone->destroy();
    108108        this->stones_.clear();
    109109    }
    … …  
    341341    {
    342342        // Spawn a human player.
    343         for (auto & elem : this->players_)
    344             if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
    345                 this->spawnPlayer(elem.first);
     343        for (auto& mapEntry : this->players_)
     344            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
     345                this->spawnPlayer(mapEntry.first);
    346346    }
    347347   
    … …  
    502502        }
    503503      // adjust height of stones above the deleted row //TODO: check if this could be a source of a bug.
    504         for(auto & elem : this->stones_)
    505         {
    506             if(static_cast<unsigned int>(((elem)->getPosition().y - 5)/this->center_->getStoneSize()) > row)
    507                 (elem)->setPosition((elem)->getPosition()-Vector3(0,10,0));
     504        for(TetrisStone* stone : this->stones_)
     505        {
     506            if(static_cast<unsigned int>((stone->getPosition().y - 5)/this->center_->getStoneSize()) > row)
     507                stone->setPosition(stone->getPosition()-Vector3(0,10,0));
    508508        }
    509509

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

    r10821 r10916  
    239239    {
    240240        assert(this->tetris_);
    241         for(auto & elem : this->brickStones_)
    242         {
    243             elem->detachFromParent();
    244             elem->attachToParent(center);
    245             elem->setPosition(this->getPosition()+this->tetris_->rotateVector(elem->getPosition(),this->rotationCount_ ));
     241        for(TetrisStone* stone : this->brickStones_)
     242        {
     243            stone->detachFromParent();
     244            stone->attachToParent(center);
     245            stone->setPosition(this->getPosition()+this->tetris_->rotateVector(stone->getPosition(),this->rotationCount_ ));
    246246        }
    247247        this->brickStones_.clear();

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

    r10821 r10916  
    183183            en1->lookAt(waypoints_.at(1)->getPosition() + offset_);
    184184
    185             for (auto & elem : waypoints_)
     185            for (TowerDefenseField* field : waypoints_)
    186186            {
    187187                orxonox::WeakPtr<MovableEntity> waypoint = new MovableEntity(this->center_->getContext());
    188                 waypoint->setPosition(elem->getPosition() + offset_);
     188                waypoint->setPosition(field->getPosition() + offset_);
    189189                controller->addWaypoint(waypoint);
    190190            }

  • code/branches/cpp11_v2/src/orxonox/Level.cc

    r10821 r10916  
    106106    void Level::networkCallbackTemplatesChanged()
    107107    {
    108         for(const auto & elem : this->networkTemplateNames_)
    109         {
    110             assert(Template::getTemplate(elem));
    111             Template::getTemplate(elem)->applyOn(this);
     108        for(const std::string& name : this->networkTemplateNames_)
     109        {
     110            assert(Template::getTemplate(name));
     111            Template::getTemplate(name)->applyOn(this);
    112112        }
    113113    }
    … …  
    135135        //       objects alive when ~Level is called. This is the reason why we cannot directly destroy() the Plugins - instead we need
    136136        //       to call destroyLater() to ensure that no instances from this plugin exist anymore.
    137         for (auto & elem : this->plugins_)
    138             (elem)->destroyLater();
     137        for (PluginReference* plugin : this->plugins_)
     138            plugin->destroyLater();
    139139        this->plugins_.clear();
    140140    }
    … …  
    173173    {
    174174        unsigned int i = 0;
    175         for (const auto & elem : this->objects_)
     175        for (BaseObject* object : this->objects_)
    176176        {
    177177            if (i == index)
    178                 return (elem);
     178                return object;
    179179            ++i;
    180180        }

  • code/branches/cpp11_v2/src/orxonox/LevelInfo.cc

    r10821 r10916  
    106106    {
    107107        SubString substr = SubString(tags, ",", " "); // Split the string into tags.
    108         const std::vector<std::string>& strings = substr.getAllStrings();
    109         for (const auto & strings_it : strings)
    110             this->addTag(strings_it, false);
     108        const std::vector<std::string>& tokens = substr.getAllStrings();
     109        for (const std::string& token : tokens)
     110            this->addTag(token, false);
    111111
    112112        this->tagsUpdated();
    … …  
    121121    {
    122122        SubString substr = SubString(ships, ",", " "); // Split the string into tags.
    123         const std::vector<std::string>& strings = substr.getAllStrings();
    124         for(const auto & strings_it : strings)
    125             this->addStartingShip(strings_it, false);
     123        const std::vector<std::string>& tokens = substr.getAllStrings();
     124        for(const std::string& token : tokens)
     125            this->addStartingShip(token, false);
    126126
    127127        this->startingshipsUpdated();

  • code/branches/cpp11_v2/src/orxonox/LevelManager.cc

    r10821 r10916  
    175175            this->levels_.front()->setActive(true);
    176176            // Make every player enter the newly activated level.
    177             for (const auto & elem : PlayerManager::getInstance().getClients())
    178                 this->levels_.front()->playerEntered(elem.second);
     177            for (const auto& mapEntry : PlayerManager::getInstance().getClients())
     178                this->levels_.front()->playerEntered(mapEntry.second);
    179179        }
    180180    }

  • code/branches/cpp11_v2/src/orxonox/Scene.cc

    r10821 r10916  
    220220        {
    221221            // Remove all WorldEntities and shove them to the queue since they would still like to be in a physical world.
    222             for (const auto & elem : this->physicalObjects_)
     222            for (WorldEntity* object : this->physicalObjects_)
    223223            {
    224                 this->physicalWorld_->removeRigidBody((elem)->physicalBody_);
    225                 this->physicalObjectQueue_.insert(elem);
     224                this->physicalWorld_->removeRigidBody(object->physicalBody_);
     225                this->physicalObjectQueue_.insert(object);
    226226            }
    227227            this->physicalObjects_.clear();
    … …  
    255255            {
    256256                // Add all scheduled WorldEntities
    257                 for (const auto & elem : this->physicalObjectQueue_)
     257                for (WorldEntity* object : this->physicalObjectQueue_)
    258258                {
    259                     this->physicalWorld_->addRigidBody((elem)->physicalBody_);
    260                     this->physicalObjects_.insert(elem);
     259                    this->physicalWorld_->addRigidBody(object->physicalBody_);
     260                    this->physicalObjects_.insert(object);
    261261                }
    262262                this->physicalObjectQueue_.clear();
    … …  
    319319    {
    320320        unsigned int i = 0;
    321         for (const auto & elem : this->objects_)
     321        for (BaseObject* object : this->objects_)
    322322        {
    323323            if (i == index)
    324                 return (elem);
     324                return object;
    325325            ++i;
    326326        }

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc

    r10821 r10916  
    6565        {
    6666            // Delete all children
    67             for (auto & elem : this->attachedShapes_)
     67            for (auto& mapEntry : this->attachedShapes_)
    6868            {
    6969                // make sure that the child doesn't want to detach itself --> speedup because of the missing update
    70                 elem.first->notifyDetached();
    71                 elem.first->destroy();
    72                 if (this->collisionShape_ == elem.second)
     70                mapEntry.first->notifyDetached();
     71                mapEntry.first->destroy();
     72                if (this->collisionShape_ == mapEntry.second)
    7373                    this->collisionShape_ = nullptr; // don't destroy it twice
    7474            }
    … …  
    246246    {
    247247        unsigned int i = 0;
    248         for (const auto & elem : this->attachedShapes_)
     248        for (const auto& mapEntry : this->attachedShapes_)
    249249        {
    250250            if (i == index)
    251                 return elem.first;
     251                return mapEntry.first;
    252252            ++i;
    253253        }
    … …  
    266266        std::vector<CollisionShape*> shapes;
    267267        // Iterate through all attached CollisionShapes and add them to the list of shapes.
    268         for(auto & elem : this->attachedShapes_)
    269             shapes.push_back(elem.first);
     268        for(auto& mapEntry : this->attachedShapes_)
     269            shapes.push_back(mapEntry.first);
    270270
    271271        // Delete the compound shape and create a new one.
    … …  
    274274
    275275        // Re-attach all CollisionShapes.
    276         for(auto shape : shapes)
    277         {
    278            
     276        for(CollisionShape* shape : shapes)
     277        {
    279278            shape->setScale3D(this->getScale3D());
    280279            // Only actually attach if we didn't pick a CompoundCollisionShape with no content.

  • code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.cc

    r10768 r10916  
    231231    int ArtificialController::getFiremode(std::string name)
    232232    {
    233         for (auto firemode : this->weaponModes_)
    234         {
    235             if (firemode.first == name)
    236                 return firemode.second;
     233        for (auto& mapEntry : this->weaponModes_)
     234        {
     235            if (mapEntry.first == name)
     236                return mapEntry.second;
    237237        }
    238238        return -1;

  • code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc

    r10821 r10916  
    440440                if(newMaster->slaves_.size() > this->maxFormationSize_) continue;
    441441
    442                 for(auto & elem : this->slaves_)
     442                for(FormationController* slave : this->slaves_)
    443443                {
    444                     (elem)->myMaster_ = newMaster;
    445                     newMaster->slaves_.push_back(elem);
     444                    slave->myMaster_ = newMaster;
     445                    newMaster->slaves_.push_back(slave);
    446446                }
    447447                this->slaves_.clear();
    … …  
    486486            int i = 1;
    487487
    488             for(auto & elem : slaves_)
     488            for(FormationController* slave : slaves_)
    489489            {
    490490                pos = Vector3::ZERO;
    … …  
    497497                    dest+=FORMATION_LENGTH*(orient*WorldEntity::BACK);
    498498                }
    499                 (elem)->setTargetOrientation(orient);
    500                 (elem)->setTargetPosition(pos);
     499                slave->setTargetOrientation(orient);
     500                slave->setTargetPosition(pos);
    501501                left=!left;
    502502            }
    … …  
    569569        if(this->state_ != MASTER) return;
    570570
    571         for(auto & elem : slaves_)
    572         {
    573             (elem)->state_ = FREE;
    574             (elem)->myMaster_ = nullptr;
     571        for(FormationController* slave : slaves_)
     572        {
     573            slave->state_ = FREE;
     574            slave->myMaster_ = nullptr;
    575575        }
    576576        this->slaves_.clear();
    … …  
    584584        if(this->state_ != MASTER) return;
    585585
    586         for(auto & elem : slaves_)
    587         {
    588             (elem)->state_ = FREE;
    589             (elem)->forceFreedom();
    590             (elem)->targetPosition_ = this->targetPosition_;
    591             (elem)->bShooting_ = true;
     586        for(FormationController* slave : slaves_)
     587        {
     588            slave->state_ = FREE;
     589            slave->forceFreedom();
     590            slave->targetPosition_ = this->targetPosition_;
     591            slave->bShooting_ = true;
    592592//             (*it)->getControllableEntity()->fire(0);// fire once for fun
    593593        }
    … …  
    650650            this->slaves_.push_back(this->myMaster_);
    651651            //set this as new master
    652             for(auto & elem : slaves_)
    653             {
    654                  (elem)->myMaster_=this;
     652            for(FormationController* slave : slaves_)
     653            {
     654                 slave->myMaster_=this;
    655655            }
    656656            this->myMaster_=nullptr;
    … …  
    694694        if (this->state_ == MASTER)
    695695        {
    696             for(auto & elem : slaves_)
    697             {
    698                  (elem)->formationMode_ = val;
     696            for(FormationController* slave : slaves_)
     697            {
     698                 slave->formationMode_ = val;
    699699                 if (val == ATTACK)
    700                      (elem)->forgetTarget();
     700                     slave->forgetTarget();
    701701            }
    702702        }

  • code/branches/cpp11_v2/src/orxonox/controllers/WaypointController.cc

    r10821 r10916  
    4444    WaypointController::~WaypointController()
    4545    {
    46         for (auto & elem : this->waypoints_)
     46        for (WorldEntity* waypoint : this->waypoints_)
    4747        {
    48             if(elem)
    49                 elem->destroy();
     48            if(waypoint)
     49                waypoint->destroy();
    5050        }
    5151    }

  • code/branches/cpp11_v2/src/orxonox/gamestates/GSLevel.cc

    r10821 r10916  
    251251
    252252        // delete states
    253         for (auto & state : states)
     253        for (GSLevelMementoState* state : states)
    254254            delete state;
    255255    }

  • code/branches/cpp11_v2/src/orxonox/gametypes/Dynamicmatch.cc

    r10821 r10916  
    405405    void Dynamicmatch::rewardPig()
    406406    {
    407         for (auto & elem : this->playerParty_) //durch alle Spieler iterieren und alle piggys finden
    408         {
    409             if (elem.second==piggy)//Spieler mit der Pig-party frags++
    410             {
    411                  this->playerScored(elem.first);
     407        for (auto& mapEntry : this->playerParty_) //durch alle Spieler iterieren und alle piggys finden
     408        {
     409            if (mapEntry.second==piggy)//Spieler mit der Pig-party frags++
     410            {
     411                 this->playerScored(mapEntry.first);
    412412            }
    413413        }
    … …  
    422422
    423423                std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
    424                 for (const auto & pawnAttachment : pawnAttachments)
    425                 {
    426                     if ((pawnAttachment)->isA(Class(TeamColourable)))
     424                for (WorldEntity* pawnAttachment : pawnAttachments)
     425                {
     426                    if (pawnAttachment->isA(Class(TeamColourable)))
    427427                    {
    428428                        TeamColourable* tc = orxonox_cast<TeamColourable*>(pawnAttachment);
    … …  
    441441            if (tutorial) // Announce selectionphase
    442442            {
    443              for (auto & elem : this->playerParty_)
    444                 {
    445                     if (!elem.first)//in order to catch nullpointer
     443             for (auto& mapEntry : this->playerParty_)
     444                {
     445                    if (!mapEntry.first)//in order to catch nullpointer
    446446                        continue;
    447                     if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     447                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    448448                        continue;
    449                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",elem.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
     449                    this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
    450450                }
    451451            }
    … …  
    456456             if(tutorial&&(!notEnoughKillers)&&(!notEnoughChasers)) //Selection phase over
    457457             {
    458                   for (auto & elem : this->playerParty_)
     458                  for (auto& mapEntry : this->playerParty_)
    459459                  {
    460                        if (!elem.first)//in order to catch nullpointer
     460                       if (!mapEntry.first)//in order to catch nullpointer
    461461                           continue;
    462                        if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     462                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    463463                           continue;
    464                        else if (elem.second==chaser)
     464                       else if (mapEntry.second==chaser)
    465465                       {
    466466                           if (numberOf[killer]>0)
    467                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",elem.first->getClientID(),partyColours_[piggy]);
     467                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",mapEntry.first->getClientID(),partyColours_[piggy]);
    468468                           else
    469                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",elem.first->getClientID(),partyColours_[piggy]);
     469                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",mapEntry.first->getClientID(),partyColours_[piggy]);
    470470                           //this->gtinfo_->sendFadingMessage("You're now a chaser.",it->first->getClientID());
    471471                       }
    472                        else if (elem.second==piggy)
    473                        {
    474                            this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",elem.first->getClientID(),partyColours_[chaser]);
     472                       else if (mapEntry.second==piggy)
     473                       {
     474                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",mapEntry.first->getClientID(),partyColours_[chaser]);
    475475                           //this->gtinfo_->sendFadingMessage("You're now a victim.",it->first->getClientID());
    476476                       }
    477                        else if (elem.second==killer)
    478                        {
    479                            this->gtinfo_->sendStaticMessage("Take the chasers down.",elem.first->getClientID(),partyColours_[chaser]);
     477                       else if (mapEntry.second==killer)
     478                       {
     479                           this->gtinfo_->sendStaticMessage("Take the chasers down.",mapEntry.first->getClientID(),partyColours_[chaser]);
    480480                           //this->gtinfo_->sendFadingMessage("You're now a killer.",it->first->getClientID());
    481481                       }
    … …  
    490490            if (tutorial) // Announce selectionphase
    491491            {
    492              for (auto & elem : this->playerParty_)
    493                 {
    494                     if (!elem.first)//in order to catch nullpointer
     492             for (auto& mapEntry : this->playerParty_)
     493                {
     494                    if (!mapEntry.first)//in order to catch nullpointer
    495495                        continue;
    496                     if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     496                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    497497                        continue;
    498                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",elem.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
     498                    this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
    499499                }
    500500            }
    … …  
    505505            if(tutorial&&(!notEnoughPigs)&&(!notEnoughChasers)) //Selection phase over
    506506             {
    507                   for (auto & elem : this->playerParty_)
     507                  for (auto& mapEntry : this->playerParty_)
    508508                  {
    509                        if (!elem.first)
     509                       if (!mapEntry.first)
    510510                           continue;
    511                        if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     511                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    512512                           continue;
    513                        else if (elem.second==chaser)
     513                       else if (mapEntry.second==chaser)
    514514                       {
    515515                           if (numberOf[killer]>0)
    516                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",elem.first->getClientID(),partyColours_[piggy]);
     516                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",mapEntry.first->getClientID(),partyColours_[piggy]);
    517517                           else
    518                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",elem.first->getClientID(),partyColours_[piggy]);
     518                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",mapEntry.first->getClientID(),partyColours_[piggy]);
    519519                           //this->gtinfo_->sendFadingMessage("You're now a chaser.",it->first->getClientID());
    520520                       }
    521                        else if (elem.second==piggy)
    522                        {
    523                            this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",elem.first->getClientID(),partyColours_[piggy]);
     521                       else if (mapEntry.second==piggy)
     522                       {
     523                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",mapEntry.first->getClientID(),partyColours_[piggy]);
    524524                           //this->gtinfo_->sendFadingMessage("You're now a victim.",it->first->getClientID());
    525525                       }
    526                        else if (elem.second==killer)
    527                        {
    528                            this->gtinfo_->sendStaticMessage("Take the chasers down.",elem.first->getClientID(),partyColours_[piggy]);
     526                       else if (mapEntry.second==killer)
     527                       {
     528                           this->gtinfo_->sendStaticMessage("Take the chasers down.",mapEntry.first->getClientID(),partyColours_[piggy]);
    529529                           //this->gtinfo_->sendFadingMessage("You're now a killer.",it->first->getClientID());
    530530                       }
    … …  
    540540            if (tutorial) // Announce selectionphase
    541541            {
    542              for (auto & elem : this->playerParty_)
    543                 {
    544                     if (!elem.first)//in order to catch nullpointer
     542             for (auto& mapEntry : this->playerParty_)
     543                {
     544                    if (!mapEntry.first)//in order to catch nullpointer
    545545                        continue;
    546                     if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     546                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    547547                        continue;
    548                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",elem.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
     548                    this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
    549549                }
    550550            }
    … …  
    555555             if(tutorial&&(!notEnoughPigs)&&(!notEnoughKillers)) //Selection phase over
    556556             {
    557                   for (auto & elem : this->playerParty_)
     557                  for (auto& mapEntry : this->playerParty_)
    558558                  {
    559                        if (!elem.first)
     559                       if (!mapEntry.first)
    560560                           continue;
    561                        if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     561                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    562562                           continue;
    563                        else if (elem.second==chaser)
     563                       else if (mapEntry.second==chaser)
    564564                       {
    565565                           if (numberOf[killer]>0)
    566                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",elem.first->getClientID(),partyColours_[piggy]);
     566                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",mapEntry.first->getClientID(),partyColours_[piggy]);
    567567                           else
    568                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",elem.first->getClientID(),partyColours_[piggy]);
     568                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",mapEntry.first->getClientID(),partyColours_[piggy]);
    569569                           //this->gtinfo_->sendFadingMessage("You're now a chaser.",it->first->getClientID());
    570570                       }
    571                        else if (elem.second==piggy)
    572                        {
    573                            this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",elem.first->getClientID(),partyColours_[chaser]);
     571                       else if (mapEntry.second==piggy)
     572                       {
     573                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",mapEntry.first->getClientID(),partyColours_[chaser]);
    574574                           //this->gtinfo_->sendFadingMessage("You're now a victim.",it->first->getClientID());
    575575                       }
    576                        else if (elem.second==killer)
    577                        {
    578                            this->gtinfo_->sendStaticMessage("Take the chasers down.",elem.first->getClientID(),partyColours_[chaser]);
     576                       else if (mapEntry.second==killer)
     577                       {
     578                           this->gtinfo_->sendStaticMessage("Take the chasers down.",mapEntry.first->getClientID(),partyColours_[chaser]);
    579579                           //this->gtinfo_->sendFadingMessage("You're now a killer.",it->first->getClientID());
    580580                       }
    … …  
    620620        else if(tutorial) // Announce selectionphase
    621621        {
    622             for (auto & elem : this->playerParty_)
    623             {
    624                 if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     622            for (auto& mapEntry : this->playerParty_)
     623            {
     624                if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    625625                    continue;
    626                 this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",elem.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
     626                this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
    627627            }
    628628        }
    … …  
    676676            unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
    677677            unsigned int index = 0;
    678             for (const auto & teamSpawnPoint : teamSpawnPoints)
     678            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
    679679            {
    680680                if (index == randomspawn)
    681                     return (teamSpawnPoint);
     681                    return teamSpawnPoint;
    682682
    683683                ++index;

  • code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc

    r10821 r10916  
    139139        if (!this->gtinfo_->hasStarted())
    140140        {
    141             for (auto & elem : this->players_)
     141            for (auto& mapEntry : this->players_)
    142142            {
    143143                // Inform the GametypeInfo that the player is ready to spawn.
    144                 if(elem.first->isHumanPlayer() && elem.first->isReadyToSpawn())
    145                     this->gtinfo_->playerReadyToSpawn(elem.first);
     144                if(mapEntry.first->isHumanPlayer() && mapEntry.first->isReadyToSpawn())
     145                    this->gtinfo_->playerReadyToSpawn(mapEntry.first);
    146146            }
    147147
    … …  
    169169        }
    170170
    171         for (auto & elem : this->players_)
    172         {
    173             if (elem.first->getControllableEntity())
    174             {
    175                 ControllableEntity* oldentity = elem.first->getControllableEntity();
     171        for (auto& mapEntry : this->players_)
     172        {
     173            if (mapEntry.first->getControllableEntity())
     174            {
     175                ControllableEntity* oldentity = mapEntry.first->getControllableEntity();
    176176
    177177                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity->getContext());
    … …  
    186186                    entity->setOrientation(oldentity->getWorldOrientation());
    187187                }
    188                 elem.first->startControl(entity);
     188                mapEntry.first->startControl(entity);
    189189            }
    190190            else
    191                 this->spawnPlayerAsDefaultPawn(elem.first);
     191                this->spawnPlayerAsDefaultPawn(mapEntry.first);
    192192        }
    193193    }
    … …  
    341341            unsigned int index = 0;
    342342            std::vector<SpawnPoint*> activeSpawnPoints;
    343             for (const auto & elem : this->spawnpoints_)
     343            for (SpawnPoint* spawnpoint : this->spawnpoints_)
    344344            {
    345345                if (index == randomspawn)
    346                     fallbackSpawnPoint = (elem);
    347 
    348                 if (elem != nullptr && (elem)->isActive())
    349                     activeSpawnPoints.push_back(elem);
     346                    fallbackSpawnPoint = spawnpoint;
     347
     348                if (spawnpoint != nullptr && spawnpoint->isActive())
     349                    activeSpawnPoints.push_back(spawnpoint);
    350350
    351351                ++index;
    … …  
    366366    void Gametype::assignDefaultPawnsIfNeeded()
    367367    {
    368         for (auto & elem : this->players_)
    369         {
    370             if (!elem.first->getControllableEntity())
    371             {
    372                 elem.second.state_ = PlayerState::Dead;
    373 
    374                 if (!elem.first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
    375                 {
    376                     this->spawnPlayerAsDefaultPawn(elem.first);
    377                     elem.second.state_ = PlayerState::Dead;
     368        for (auto& mapEntry : this->players_)
     369        {
     370            if (!mapEntry.first->getControllableEntity())
     371            {
     372                mapEntry.second.state_ = PlayerState::Dead;
     373
     374                if (!mapEntry.first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
     375                {
     376                    this->spawnPlayerAsDefaultPawn(mapEntry.first);
     377                    mapEntry.second.state_ = PlayerState::Dead;
    378378                }
    379379            }
    … …  
    404404                    bool allplayersready = true;
    405405                    bool hashumanplayers = false;
    406                     for (auto & elem : this->players_)
     406                    for (auto& mapEntry : this->players_)
    407407                    {
    408                         if (!elem.first->isReadyToSpawn())
     408                        if (!mapEntry.first->isReadyToSpawn())
    409409                            allplayersready = false;
    410                         if (elem.first->isHumanPlayer())
     410                        if (mapEntry.first->isHumanPlayer())
    411411                            hashumanplayers = true;
    412412                    }
    … …  
    430430    void Gametype::spawnPlayersIfRequested()
    431431    {
    432         for (auto & elem : this->players_)
    433         {
    434             if (elem.first->isReadyToSpawn() || this->bForceSpawn_)
    435                 this->spawnPlayer(elem.first);
     432        for (auto& mapEntry : this->players_)
     433        {
     434            if (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_)
     435                this->spawnPlayer(mapEntry.first);
    436436        }
    437437    }
    … …  
    439439    void Gametype::spawnDeadPlayersIfRequested()
    440440    {
    441         for (auto & elem : this->players_)
    442             if (elem.second.state_ == PlayerState::Dead)
    443                 if (elem.first->isReadyToSpawn() || this->bForceSpawn_)
    444                     this->spawnPlayer(elem.first);
     441        for (auto& mapEntry : this->players_)
     442            if (mapEntry.second.state_ == PlayerState::Dead)
     443                if (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_)
     444                    this->spawnPlayer(mapEntry.first);
    445445    }
    446446
    … …  
    538538    GSLevelMementoState* Gametype::exportMementoState()
    539539    {
    540         for (auto & elem : this->players_)
    541         {
    542             if (elem.first->isHumanPlayer() && elem.first->getControllableEntity() && elem.first->getControllableEntity()->getCamera())
    543             {
    544                 Camera* camera = elem.first->getControllableEntity()->getCamera();
     540        for (auto& mapEntry : this->players_)
     541        {
     542            if (mapEntry.first->isHumanPlayer() && mapEntry.first->getControllableEntity() && mapEntry.first->getControllableEntity()->getCamera())
     543            {
     544                Camera* camera = mapEntry.first->getControllableEntity()->getCamera();
    545545
    546546                GametypeMementoState* state = new GametypeMementoState();
    … …  
    559559        // find correct memento state
    560560        GametypeMementoState* state = nullptr;
    561         for (auto & states_i : states)
    562         {
    563             state = dynamic_cast<GametypeMementoState*>(states_i);
     561        for (GSLevelMementoState* temp : states)
     562        {
     563            state = dynamic_cast<GametypeMementoState*>(temp);
    564564            if (state)
    565565                break;
    … …  
    587587
    588588        // find correct player and assign default entity with original position & orientation
    589         for (auto & elem : this->players_)
    590         {
    591             if (elem.first->isHumanPlayer())
     589        for (auto& mapEntry : this->players_)
     590        {
     591            if (mapEntry.first->isHumanPlayer())
    592592            {
    593593                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(scene->getContext());
    594594                entity->setPosition(state->cameraPosition_);
    595595                entity->setOrientation(state->cameraOrientation_);
    596                 elem.first->startControl(entity);
     596                mapEntry.first->startControl(entity);
    597597                break;
    598598            }

  • code/branches/cpp11_v2/src/orxonox/gametypes/LastManStanding.cc

    r10821 r10916  
    5656    void LastManStanding::spawnDeadPlayersIfRequested()
    5757    {
    58         for (auto & elem : this->players_)
    59             if (elem.second.state_ == PlayerState::Dead)
    60             {
    61                 bool alive = (0<playerLives_[elem.first]&&(inGame_[elem.first]));
    62                 if (alive&&(elem.first->isReadyToSpawn() || this->bForceSpawn_))
    63                 {
    64                     this->spawnPlayer(elem.first);
     58        for (auto& mapEntry : this->players_)
     59            if (mapEntry.second.state_ == PlayerState::Dead)
     60            {
     61                bool alive = (0<playerLives_[mapEntry.first]&&(inGame_[mapEntry.first]));
     62                if (alive&&(mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
     63                {
     64                    this->spawnPlayer(mapEntry.first);
    6565                }
    6666            }
    … …  
    114114    {
    115115        int min=lives;
    116         for (auto & elem : this->playerLives_)
    117         {
    118             if (elem.second<=0)
     116        for (auto& mapEntry : this->playerLives_)
     117        {
     118            if (mapEntry.second<=0)
    119119                continue;
    120             if (elem.second<lives)
    121                 min=elem.second;
     120            if (mapEntry.second<lives)
     121                min=mapEntry.second;
    122122        }
    123123        return min;
    … …  
    128128        Gametype::end();
    129129
    130         for (auto & elem : this->playerLives_)
    131         {
    132             if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     130        for (auto& mapEntry : this->playerLives_)
     131        {
     132            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    133133                continue;
    134134
    135             if (elem.second > 0)
    136                 this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.first->getClientID());
     135            if (mapEntry.second > 0)
     136                this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
    137137            else
    138                 this->gtinfo_->sendAnnounceMessage("You have lost the match!", elem.first->getClientID());
     138                this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
    139139        }
    140140    }
    … …  
    237237                this->end();
    238238            }
    239             for (auto & elem : this->timeToAct_)
    240             {
    241                 if (playerGetLives(elem.first)<=0)//Players without lives shouldn't be affected by time.
     239            for (auto& mapEntry : this->timeToAct_)
     240            {
     241                if (playerGetLives(mapEntry.first)<=0)//Players without lives shouldn't be affected by time.
    242242                    continue;
    243                 elem.second-=dt;//Decreases punishment time.
    244                 if (!inGame_[elem.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
    245                 {
    246                     playerDelayTime_[elem.first]-=dt;
    247                     if (playerDelayTime_[elem.first]<=0)
    248                     this->inGame_[elem.first]=true;
    249 
    250                     if (elem.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
     243                mapEntry.second-=dt;//Decreases punishment time.
     244                if (!inGame_[mapEntry.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
     245                {
     246                    playerDelayTime_[mapEntry.first]-=dt;
     247                    if (playerDelayTime_[mapEntry.first]<=0)
     248                    this->inGame_[mapEntry.first]=true;
     249
     250                    if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
    251251                        continue;
    252                     int output=1+(int)playerDelayTime_[elem.first];
     252                    int output=1+(int)playerDelayTime_[mapEntry.first];
    253253                    const std::string& message = "Respawn in " +multi_cast<std::string>(output)+ " seconds." ;//Countdown
    254                     this->gtinfo_->sendFadingMessage(message,elem.first->getClientID());
    255                 }
    256                 else if (elem.second<0.0f)
    257                 {
    258                     elem.second=timeRemaining+3.0f;//reset punishment-timer
    259                     if (playerGetLives(elem.first)>0)
     254                    this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
     255                }
     256                else if (mapEntry.second<0.0f)
     257                {
     258                    mapEntry.second=timeRemaining+3.0f;//reset punishment-timer
     259                    if (playerGetLives(mapEntry.first)>0)
    260260                    {
    261                         this->punishPlayer(elem.first);
    262                         if (elem.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
     261                        this->punishPlayer(mapEntry.first);
     262                        if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
    263263                            return;
    264264                        const std::string& message = ""; // resets Camper-Warning-message
    265                         this->gtinfo_->sendFadingMessage(message,elem.first->getClientID());
     265                        this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
    266266                    }
    267267                }
    268                 else if (elem.second<timeRemaining/5)//Warning message
    269                 {
    270                     if (elem.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
     268                else if (mapEntry.second<timeRemaining/5)//Warning message
     269                {
     270                    if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
    271271                        continue;
    272272                    const std::string& message = "Camper Warning! Don't forget to shoot.";
    273                     this->gtinfo_->sendFadingMessage(message,elem.first->getClientID());
     273                    this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
    274274                }
    275275            }

  • code/branches/cpp11_v2/src/orxonox/gametypes/LastTeamStanding.cc

    r10821 r10916  
    145145    void LastTeamStanding::spawnDeadPlayersIfRequested()
    146146    {
    147         for (auto & elem : this->players_)
    148             if (elem.second.state_ == PlayerState::Dead)
    149             {
    150                 bool alive = (0 < playerLives_[elem.first]&&(inGame_[elem.first]));
    151                 if (alive&&(elem.first->isReadyToSpawn() || this->bForceSpawn_))
    152                 {
    153                     this->spawnPlayer(elem.first);
     147        for (auto& mapEntry : this->players_)
     148            if (mapEntry.second.state_ == PlayerState::Dead)
     149            {
     150                bool alive = (0 < playerLives_[mapEntry.first]&&(inGame_[mapEntry.first]));
     151                if (alive&&(mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
     152                {
     153                    this->spawnPlayer(mapEntry.first);
    154154                }
    155155            }
    … …  
    184184                this->end();
    185185            }
    186             for (auto & elem : this->timeToAct_)
    187             {
    188                 if (playerGetLives(elem.first) <= 0)//Players without lives shouldn't be affected by time.
     186            for (auto& mapEntry : this->timeToAct_)
     187            {
     188                if (playerGetLives(mapEntry.first) <= 0)//Players without lives shouldn't be affected by time.
    189189                    continue;
    190                 elem.second -= dt;//Decreases punishment time.
    191                 if (!inGame_[elem.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
    192                 {
    193                     playerDelayTime_[elem.first] -= dt;
    194                     if (playerDelayTime_[elem.first] <= 0)
    195                     this->inGame_[elem.first] = true;
    196 
    197                     if (elem.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
     190                mapEntry.second -= dt;//Decreases punishment time.
     191                if (!inGame_[mapEntry.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
     192                {
     193                    playerDelayTime_[mapEntry.first] -= dt;
     194                    if (playerDelayTime_[mapEntry.first] <= 0)
     195                    this->inGame_[mapEntry.first] = true;
     196
     197                    if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
    198198                        continue;
    199                     int output = 1 + (int)playerDelayTime_[elem.first];
     199                    int output = 1 + (int)playerDelayTime_[mapEntry.first];
    200200                    const std::string& message = "Respawn in " +multi_cast<std::string>(output)+ " seconds." ;//Countdown
    201                     this->gtinfo_->sendFadingMessage(message,elem.first->getClientID());
    202                 }
    203                 else if (elem.second < 0.0f)
    204                 {
    205                     elem.second = timeRemaining + 3.0f;//reset punishment-timer
    206                     if (playerGetLives(elem.first) > 0)
     201                    this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
     202                }
     203                else if (mapEntry.second < 0.0f)
     204                {
     205                    mapEntry.second = timeRemaining + 3.0f;//reset punishment-timer
     206                    if (playerGetLives(mapEntry.first) > 0)
    207207                    {
    208                         this->punishPlayer(elem.first);
    209                         if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     208                        this->punishPlayer(mapEntry.first);
     209                        if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    210210                            return;
    211211                        const std::string& message = ""; // resets Camper-Warning-message
    212                         this->gtinfo_->sendFadingMessage(message, elem.first->getClientID());
     212                        this->gtinfo_->sendFadingMessage(message, mapEntry.first->getClientID());
    213213                    }
    214214                }
    215                 else if (elem.second < timeRemaining/5)//Warning message
    216                 {
    217                   if (elem.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
     215                else if (mapEntry.second < timeRemaining/5)//Warning message
     216                {
     217                  if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
    218218                        continue;
    219219                    const std::string& message = "Camper Warning! Don't forget to shoot.";
    220                     this->gtinfo_->sendFadingMessage(message, elem.first->getClientID());
     220                    this->gtinfo_->sendFadingMessage(message, mapEntry.first->getClientID());
    221221                }
    222222            }
    … …  
    229229        int party = -1;
    230230        //find a player who survived
    231         for (auto & elem : this->playerLives_)
    232         {
    233           if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     231        for (auto& mapEntry : this->playerLives_)
     232        {
     233          if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    234234                continue;
    235235
    236             if (elem.second > 0)//a player that is alive
     236            if (mapEntry.second > 0)//a player that is alive
    237237            {
    238238                //which party has survived?
    239                 std::map<PlayerInfo*, int>::iterator it2 = this->teamnumbers_.find(elem.first);
     239                std::map<PlayerInfo*, int>::iterator it2 = this->teamnumbers_.find(mapEntry.first);
    240240                if (it2 != this->teamnumbers_.end())
    241241                {
    … …  
    255255    {
    256256        int min = lives;
    257         for (auto & elem : this->playerLives_)
    258         {
    259             if (elem.second <= 0)
     257        for (auto& mapEntry : this->playerLives_)
     258        {
     259            if (mapEntry.second <= 0)
    260260                continue;
    261             if (elem.second < lives)
    262                 min = elem.second;
     261            if (mapEntry.second < lives)
     262                min = mapEntry.second;
    263263        }
    264264        return min;

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamBaseMatch.cc

    r10821 r10916  
    152152        int amountControlled2 = 0;
    153153
    154         for (const auto & elem : this->bases_)
    155         {
    156             if((elem)->getState() == BaseState::ControlTeam1)
     154        for (TeamBaseMatchBase* base : this->bases_)
     155        {
     156            if(base->getState() == BaseState::ControlTeam1)
    157157            {
    158158                amountControlled++;
    159159            }
    160             if((elem)->getState() == BaseState::ControlTeam2)
     160            if(base->getState() == BaseState::ControlTeam2)
    161161            {
    162162                amountControlled2++;
    … …  
    187187            }
    188188
    189             for (auto & elem : this->teamnumbers_)
    190             {
    191                 if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     189            for (auto& mapEntry : this->teamnumbers_)
     190            {
     191                if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    192192                    continue;
    193193
    194                 if (elem.second == winningteam)
    195                     this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.first->getClientID());
     194                if (mapEntry.second == winningteam)
     195                    this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
    196196                else
    197                     this->gtinfo_->sendAnnounceMessage("You have lost the match!", elem.first->getClientID());
     197                    this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
    198198            }
    199199
    … …  
    238238        int count = 0;
    239239
    240         for (const auto & elem : this->bases_)
    241         {
    242             if ((elem)->getState() == BaseState::ControlTeam1 && team == 0)
     240        for (TeamBaseMatchBase* base : this->bases_)
     241        {
     242            if (base->getState() == BaseState::ControlTeam1 && team == 0)
    243243                count++;
    244             if ((elem)->getState() == BaseState::ControlTeam2 && team == 1)
     244            if (base->getState() == BaseState::ControlTeam2 && team == 1)
    245245                count++;
    246246        }
    … …  
    258258    {
    259259        unsigned int i = 0;
    260         for (const auto & elem : this->bases_)
     260        for (TeamBaseMatchBase* base : this->bases_)
    261261        {
    262262            i++;
    263263            if (i > index)
    264                 return (elem);
     264                return base;
    265265        }
    266266        return nullptr;

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamDeathmatch.cc

    r10821 r10916  
    6969        int winnerTeam = 0;
    7070        int highestScore = 0;
    71         for (auto & elem : this->players_)
     71        for (auto& mapEntry : this->players_)
    7272        {
    73             if ( this->getTeamScore(elem.first) > highestScore )
     73            if ( this->getTeamScore(mapEntry.first) > highestScore )
    7474            {
    75                 winnerTeam = this->getTeam(elem.first);
    76                 highestScore = this->getTeamScore(elem.first);
     75                winnerTeam = this->getTeam(mapEntry.first);
     76                highestScore = this->getTeamScore(mapEntry.first);
    7777            }
    7878        }

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamGametype.cc

    r10821 r10916  
    9999        std::vector<unsigned int> playersperteam(this->teams_, 0);
    100100
    101         for (auto & elem : this->teamnumbers_)
    102             if (elem.second < static_cast<int>(this->teams_) && elem.second >= 0)
    103                 playersperteam[elem.second]++;
     101        for (auto& mapEntry : this->teamnumbers_)
     102            if (mapEntry.second < static_cast<int>(this->teams_) && mapEntry.second >= 0)
     103                playersperteam[mapEntry.second]++;
    104104
    105105        unsigned int minplayers = static_cast<unsigned int>(-1);
    … …  
    123123        if( (this->players_.size() >= maxPlayers_) && (allowedInGame_[player] == true) ) // if there's a "waiting list"
    124124        {
    125             for (auto & elem : this->allowedInGame_)
    126             {
    127                  if(elem.second == false) // waiting player found
    128                  {elem.second = true; break;} // allow player to enter
     125            for (auto& mapEntry : this->allowedInGame_)
     126            {
     127                 if(mapEntry.second == false) // waiting player found
     128                 {mapEntry.second = true; break;} // allow player to enter
    129129            }
    130130        }
    … …  
    141141    void TeamGametype::spawnDeadPlayersIfRequested()
    142142    {
    143         for (auto & elem : this->players_)\
    144         {
    145             if(allowedInGame_[elem.first] == false)//check if dead player is allowed to enter
     143        for (auto& mapEntry : this->players_)\
     144        {
     145            if(allowedInGame_[mapEntry.first] == false)//check if dead player is allowed to enter
    146146            {
    147147                continue;
    148148            }
    149             if (elem.second.state_ == PlayerState::Dead)
    150             {
    151                 if ((elem.first->isReadyToSpawn() || this->bForceSpawn_))
     149            if (mapEntry.second.state_ == PlayerState::Dead)
     150            {
     151                if ((mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
    152152                {
    153                    this->spawnPlayer(elem.first);
     153                   this->spawnPlayer(mapEntry.first);
    154154                }
    155155            }
    … …  
    178178        if(!player || this->getTeam(player) == -1)
    179179            return 0;
    180         for (auto & elem : this->players_)
    181         {
    182             if ( this->getTeam(elem.first) ==  this->getTeam(player) )
    183             {
    184                 teamscore += elem.second.frags_;
     180        for (auto& mapEntry : this->players_)
     181        {
     182            if ( this->getTeam(mapEntry.first) ==  this->getTeam(player) )
     183            {
     184                teamscore += mapEntry.second.frags_;
    185185            }
    186186        }
    … …  
    191191    {
    192192        int teamSize = 0;
    193         for (auto & elem : this->teamnumbers_)
    194         {
    195             if (elem.second == team)
     193        for (auto& mapEntry : this->teamnumbers_)
     194        {
     195            if (mapEntry.second == team)
    196196                teamSize++;
    197197        }
    … …  
    202202    {
    203203        int teamSize = 0;
    204         for (auto & elem : this->teamnumbers_)
    205         {
    206             if (elem.second == team  && elem.first->isHumanPlayer())
     204        for (auto& mapEntry : this->teamnumbers_)
     205        {
     206            if (mapEntry.second == team  && mapEntry.first->isHumanPlayer())
    207207                teamSize++;
    208208        }
    … …  
    241241            unsigned int index = 0;
    242242            // Get random fallback spawnpoint in case there is no active SpawnPoint.
    243             for (const auto & teamSpawnPoint : teamSpawnPoints)
     243            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
    244244            {
    245245                if (index == randomspawn)
    246246                {
    247                     fallbackSpawnPoint = (teamSpawnPoint);
     247                    fallbackSpawnPoint = teamSpawnPoint;
    248248                    break;
    249249                }
    … …  
    266266            randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
    267267            index = 0;
    268             for (const auto & teamSpawnPoint : teamSpawnPoints)
     268            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
    269269            {
    270270                if (index == randomspawn)
    271                     return (teamSpawnPoint);
     271                    return teamSpawnPoint;
    272272
    273273                ++index;
    … …  
    364364
    365365        std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
    366         for (const auto & pawnAttachment : pawnAttachments)
    367         {
    368             if ((pawnAttachment)->isA(Class(TeamColourable)))
     366        for (WorldEntity* pawnAttachment : pawnAttachments)
     367        {
     368            if (pawnAttachment->isA(Class(TeamColourable)))
    369369            {
    370370                TeamColourable* tc = orxonox_cast<TeamColourable*>(pawnAttachment);
    … …  
    376376    void TeamGametype::announceTeamWin(int winnerTeam)
    377377    {
    378         for (auto & elem : this->teamnumbers_)
    379         {
    380             if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     378        for (auto& mapEntry : this->teamnumbers_)
     379        {
     380            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    381381                continue;
    382             if (elem.second == winnerTeam)
    383             {
    384                 this->gtinfo_->sendAnnounceMessage("Your team has won the match!", elem.first->getClientID());
     382            if (mapEntry.second == winnerTeam)
     383            {
     384                this->gtinfo_->sendAnnounceMessage("Your team has won the match!", mapEntry.first->getClientID());
    385385            }
    386386            else
    387387            {
    388                 this->gtinfo_->sendAnnounceMessage("Your team has lost the match!", elem.first->getClientID());
     388                this->gtinfo_->sendAnnounceMessage("Your team has lost the match!", mapEntry.first->getClientID());
    389389            }
    390390        }   

  • code/branches/cpp11_v2/src/orxonox/gametypes/UnderAttack.cc

    r10821 r10916  
    7474        this->gameEnded_ = true;
    7575
    76         for (auto & elem : this->teamnumbers_)
    77         {
    78             if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     76        for (auto& mapEntry : this->teamnumbers_)
     77        {
     78            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    7979                continue;
    8080
    81             if (elem.second == attacker_)
    82                 this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.first->getClientID());
     81            if (mapEntry.second == attacker_)
     82                this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
    8383            else
    84                 this->gtinfo_->sendAnnounceMessage("You have lost the match!", elem.first->getClientID());
     84                this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
    8585        }
    8686    }
    … …  
    155155                ChatManager::message(message);
    156156
    157                 for (auto & elem : this->teamnumbers_)
    158                 {
    159                     if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
     157                for (auto& mapEntry : this->teamnumbers_)
     158                {
     159                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
    160160                        continue;
    161161
    162                     if (elem.second == 1)
    163                         this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.first->getClientID());
     162                    if (mapEntry.second == 1)
     163                        this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
    164164                    else
    165                         this->gtinfo_->sendAnnounceMessage("You have lost the match!", elem.first->getClientID());
     165                        this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
    166166                }
    167167            }

  • code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc

    r10821 r10916  
    135135        // Go recursively through all children to check whether they are the target.
    136136        std::vector<PickupCarrier*>* children = this->getCarrierChildren();
    137         for(auto & elem : *children)
     137        for(PickupCarrier* child : *children)
    138138        {
    139             if(pickup->isTarget(elem))
     139            if(pickup->isTarget(child))
    140140            {
    141                 target = elem;
     141                target = child;
    142142                break;
    143143            }

  • code/branches/cpp11_v2/src/orxonox/interfaces/Pickupable.cc

    r10821 r10916  
    160160    {
    161161        // Iterate through all targets of this Pickupable.
    162         for(const auto & elem : this->targets_)
     162        for(Identifier* target : this->targets_)
    163163        {
    164             if(identifier->isA(elem))
     164            if(identifier->isA(target))
    165165                return true;
    166166        }

  • code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc

    r10821 r10916  
    219219    {
    220220        unsigned int i = 0;
    221         for (const auto & elem : this->effectContainers_)
     221        for (EffectContainer* effectContainer : this->effectContainers_)
    222222        {
    223223            if (i == index)
    224                 return (elem);
     224                return effectContainer;
    225225            i++;
    226226        }

  • code/branches/cpp11_v2/src/orxonox/items/ShipPart.cc

    r10821 r10916  
    143143    @brief
    144144        Check whether the ShipPart has a particular Entity.
    145     @param engine
     145    @param search
    146146        A pointer to the Entity to be checked.
    147147    */
    148     bool ShipPart::hasEntity(StaticEntity* entity) const
    149     {
    150         for(auto & elem : this->entityList_)
    151         {
    152             if(elem == entity)
     148    bool ShipPart::hasEntity(StaticEntity* search) const
     149    {
     150        for(StaticEntity* entity : this->entityList_)
     151        {
     152            if(entity == search)
    153153                return true;
    154154        }

  • code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc

    r10821 r10916  
    6262    OverlayGroup::~OverlayGroup()
    6363    {
    64         for (const auto & elem : hudElements_)
    65             (elem)->destroy();
     64        for (OrxonoxOverlay* hudElement : hudElements_)
     65            hudElement->destroy();
    6666        this->hudElements_.clear();
    6767    }
    … …  
    8686    void OverlayGroup::setScale(const Vector2& scale)
    8787    {
    88         for (const auto & elem : hudElements_)
    89             (elem)->scale(scale / this->scale_);
     88        for (OrxonoxOverlay* hudElement : hudElements_)
     89            hudElement->scale(scale / this->scale_);
    9090        this->scale_ = scale;
    9191    }
    … …  
    9494    void OverlayGroup::setScroll(const Vector2& scroll)
    9595    {
    96         for (const auto & elem : hudElements_)
    97             (elem)->scroll(scroll - this->scroll_);
     96        for (OrxonoxOverlay* hudElement : hudElements_)
     97            hudElement->scroll(scroll - this->scroll_);
    9898        this->scroll_ = scroll;
    9999    }
    … …  
    147147        SUPER( OverlayGroup, changedVisibility );
    148148
    149         for (const auto & elem : hudElements_)
    150             (elem)->changedVisibility(); //inform all Child Overlays that our visibility has changed
     149        for (OrxonoxOverlay* hudElement : hudElements_)
     150            hudElement->changedVisibility(); //inform all Child Overlays that our visibility has changed
    151151    }
    152152
    … …  
    155155        this->owner_ = owner;
    156156
    157         for (const auto & elem : hudElements_)
    158             (elem)->setOwner(owner);
     157        for (OrxonoxOverlay* hudElement : hudElements_)
     158            hudElement->setOwner(owner);
    159159    }
    160160

  • code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc

    r10821 r10916  
    407407        if (ambient != nullptr)
    408408        {
    409             for (auto & elem : this->ambientSounds_)
    410             {
    411                 if (elem.first == ambient)
     409            for (std::pair<AmbientSound*, bool>& pair : this->ambientSounds_)
     410            {
     411                if (pair.first == ambient)
    412412                {
    413                     elem.second = true;
    414                     this->fadeOut(elem.first);
     413                    pair.second = true;
     414                    this->fadeOut(pair.first);
    415415                    return;
    416416                }

  • code/branches/cpp11_v2/src/orxonox/sound/SoundStreamer.cc

    r10821 r10916  
    6868        int current_section;
    6969
    70         for(auto & initbuffer : initbuffers)
     70        for(ALuint& initbuffer : initbuffers)
    7171        {
    7272            long ret = ov_read(&vf, inbuffer, sizeof(inbuffer), 0, 2, 1, &current_section);

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/Munition.cc

    r10821 r10916  
    5555    Munition::~Munition()
    5656    {
    57         for (auto & elem : this->currentMagazines_)
    58             delete elem.second;
     57        for (auto& mapEntry : this->currentMagazines_)
     58            delete mapEntry.second;
    5959    }
    6060
    … …  
    268268        {
    269269            // Return true if any of the current magazines is not full (loading counts as full although it returns 0 munition)
    270             for (const auto & elem : this->currentMagazines_)
    271                 if (elem.second->munition_ < this->maxMunitionPerMagazine_ && elem.second->bLoaded_)
     270            for (const auto& mapEntry : this->currentMagazines_)
     271                if (mapEntry.second->munition_ < this->maxMunitionPerMagazine_ && mapEntry.second->bLoaded_)
    272272                    return true;
    273273        }
    … …  
    316316            {
    317317                bool change = false;
    318                 for (auto & elem : this->currentMagazines_)
     318                for (auto& mapEntry : this->currentMagazines_)
    319319                {
    320320                    // Add munition if the magazine isn't full (but only to loaded magazines)
    321                     if (amount > 0 && elem.second->munition_ < this->maxMunitionPerMagazine_ && elem.second->bLoaded_)
     321                    if (amount > 0 && mapEntry.second->munition_ < this->maxMunitionPerMagazine_ && mapEntry.second->bLoaded_)
    322322                    {
    323                         elem.second->munition_++;
     323                        mapEntry.second->munition_++;
    324324                        amount--;
    325325                        change = true;

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/Weapon.cc

    r10821 r10916  
    6161                this->weaponPack_->removeWeapon(this);
    6262
    63             for (auto & elem : this->weaponmodes_)
    64                 elem.second->destroy();
     63            for (auto& mapEntry : this->weaponmodes_)
     64                mapEntry.second->destroy();
    6565        }
    6666    }
    … …  
    8585    {
    8686        unsigned int i = 0;
    87         for (const auto & elem : this->weaponmodes_)
     87        for (const auto& mapEntry : this->weaponmodes_)
    8888        {
    8989            if (i == index)
    90                 return elem.second;
     90                return mapEntry.second;
    9191
    9292            ++i;
    … …  
    136136    void Weapon::reload()
    137137    {
    138         for (auto & elem : this->weaponmodes_)
    139             elem.second->reload();
     138        for (auto& mapEntry : this->weaponmodes_)
     139            mapEntry.second->reload();
    140140    }
    141141
    … …  
    148148    void Weapon::notifyWeaponModes()
    149149    {
    150         for (auto & elem : this->weaponmodes_)
    151             elem.second->setWeapon(this);
     150        for (auto& mapEntry : this->weaponmodes_)
     151            mapEntry.second->setWeapon(this);
    152152    }
    153153}

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc

    r10821 r10916  
    7676    void WeaponPack::fire(unsigned int weaponmode)
    7777    {
    78         for (auto & elem : this->weapons_)
    79             (elem)->fire(weaponmode);
     78        for (Weapon* weapon : this->weapons_)
     79            weapon->fire(weaponmode);
    8080    }
    8181
    … …  
    8686    void WeaponPack::reload()
    8787    {
    88         for (auto & elem : this->weapons_)
    89             (elem)->reload();
     88        for (Weapon* weapon : this->weapons_)
     89            weapon->reload();
    9090    }
    9191
    … …  
    114114        unsigned int i = 0;
    115115
    116         for (const auto & elem : this->weapons_)
     116        for (Weapon* weapon : this->weapons_)
    117117        {
    118118            if (i == index)
    119                 return (elem);
     119                return weapon;
    120120            ++i;
    121121        }
    … …  
    132132    {
    133133        unsigned int i = 0;
    134         for (const auto & elem : this->links_)
     134        for (DefaultWeaponmodeLink* link : this->links_)
    135135        {
    136136            if (i == index)
    137                 return (elem);
     137                return link;
    138138
    139139            ++i;
    … …  
    144144    unsigned int WeaponPack::getDesiredWeaponmode(unsigned int firemode) const
    145145    {
    146         for (const auto & elem : this->links_)
    147             if ((elem)->getFiremode() == firemode)
    148                 return (elem)->getWeaponmode();
     146        for (DefaultWeaponmodeLink* link : this->links_)
     147            if (link->getFiremode() == firemode)
     148                return link->getWeaponmode();
    149149
    150150        return WeaponSystem::WEAPON_MODE_UNASSIGNED;

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSet.cc

    r10821 r10916  
    6363    {
    6464        // Fire all WeaponPacks with their defined weaponmode
    65         for (auto & elem : this->weaponpacks_)
    66             if (elem.second != WeaponSystem::WEAPON_MODE_UNASSIGNED)
    67                 elem.first->fire(elem.second);
     65        for (auto& mapEntry : this->weaponpacks_)
     66            if (mapEntry.second != WeaponSystem::WEAPON_MODE_UNASSIGNED)
     67                mapEntry.first->fire(mapEntry.second);
    6868    }
    6969
    … …  
    7171    {
    7272        // Reload all WeaponPacks with their defined weaponmode
    73         for (auto & elem : this->weaponpacks_)
    74             elem.first->reload();
     73        for (auto& mapEntry : this->weaponpacks_)
     74            mapEntry.first->reload();
    7575    }
    7676

  • code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSystem.cc

    r10821 r10916  
    106106    {
    107107        unsigned int i = 0;
    108         for (const auto & elem : this->weaponSlots_)
     108        for (WeaponSlot* weaponSlot : this->weaponSlots_)
    109109        {
    110110            ++i;
    111111            if (i > index)
    112                 return (elem);
     112                return weaponSlot;
    113113        }
    114114        return nullptr;
    … …  
    153153    {
    154154        unsigned int i = 0;
    155         for (const auto & elem : this->weaponSets_)
     155        for (const auto& mapEntry : this->weaponSets_)
    156156        {
    157157            ++i;
    158158            if (i > index)
    159                 return elem.second;
     159                return mapEntry.second;
    160160        }
    161161        return nullptr;
    … …  
    168168
    169169        unsigned int freeSlots = 0;
    170         for (auto & elem : this->weaponSlots_)
    171         {
    172             if (!(elem)->isOccupied())
     170        for (WeaponSlot* weaponSlot : this->weaponSlots_)
     171        {
     172            if (!weaponSlot->isOccupied())
    173173                ++freeSlots;
    174174        }
    … …  
    184184        // Attach all weapons to the first free slots (and to the Pawn)
    185185        unsigned int i = 0;
    186         for (auto & elem : this->weaponSlots_)
    187         {
    188             if (!(elem)->isOccupied() && i < wPack->getNumWeapons())
     186        for (WeaponSlot* weaponSlot : this->weaponSlots_)
     187        {
     188            if (!weaponSlot->isOccupied() && i < wPack->getNumWeapons())
    189189            {
    190190                Weapon* weapon = wPack->getWeapon(i);
    191                 (elem)->attachWeapon(weapon);
     191                weaponSlot->attachWeapon(weapon);
    192192                this->getPawn()->attach(weapon);
    193193                ++i;
    … …  
    196196
    197197        // Assign the desired weaponmode to the firemodes
    198         for (auto & elem : this->weaponSets_)
    199         {
    200             unsigned int weaponmode = wPack->getDesiredWeaponmode(elem.first);
     198        for (auto& mapEntry : this->weaponSets_)
     199        {
     200            unsigned int weaponmode = wPack->getDesiredWeaponmode(mapEntry.first);
    201201            if (weaponmode != WeaponSystem::WEAPON_MODE_UNASSIGNED)
    202                 elem.second->setWeaponmodeLink(wPack, weaponmode);
     202                mapEntry.second->setWeaponmodeLink(wPack, weaponmode);
    203203        }
    204204
    … …  
    219219
    220220        // Remove all added links from the WeaponSets
    221         for (auto & elem : this->weaponSets_)
    222             elem.second->removeWeaponmodeLink(wPack);
     221        for (auto& mapEntry : this->weaponSets_)
     222            mapEntry.second->removeWeaponmodeLink(wPack);
    223223
    224224        // Remove the WeaponPack from the WeaponSystem
    … …  
    231231    {
    232232        unsigned int i = 0;
    233         for (const auto & elem : this->weaponPacks_)
     233        for (WeaponPack* weaponPack : this->weaponPacks_)
    234234        {
    235235            ++i;
    236236            if (i > index)
    237                 return (elem);
     237                return weaponPack;
    238238        }
    239239        return nullptr;
    … …  
    268268        // Check if the WeaponSet belongs to this WeaponSystem
    269269        bool foundWeaponSet = false;
    270         for (auto & elem : this->weaponSets_)
    271         {
    272             if (elem.second == wSet)
     270        for (auto& mapEntry : this->weaponSets_)
     271        {
     272            if (mapEntry.second == wSet)
    273273            {
    274274                foundWeaponSet = true;
    … …  
    296296    void WeaponSystem::reload()
    297297    {
    298         for (auto & elem : this->weaponSets_)
    299             elem.second->reload();
     298        for (auto& mapEntry : this->weaponSets_)
     299            mapEntry.second->reload();
    300300    }
    301301

  • code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc

    r10821 r10916  
    165165    {
    166166        unsigned int i = 0;
    167         for (const auto & elem : this->cameraPositions_)
     167        for (CameraPosition* cameraPosition : this->cameraPositions_)
    168168        {
    169169            if (i == index)
    170                 return (elem);
     170                return cameraPosition;
    171171            ++i;
    172172        }
    … …  
    180180
    181181        unsigned int counter = 0;
    182         for (const auto & elem : this->cameraPositions_)
    183         {
    184             if ((elem) == this->currentCameraPosition_)
     182        for (CameraPosition* cameraPosition : this->cameraPositions_)
     183        {
     184            if (cameraPosition == this->currentCameraPosition_)
    185185                break;
    186186            counter++;
    … …  
    477477        if (parent)
    478478        {
    479             for (auto & elem : this->cameraPositions_)
    480                 if ((elem)->getIsAbsolute())
    481                     parent->attach((elem));
     479            for (CameraPosition* cameraPosition : this->cameraPositions_)
     480                if (cameraPosition->getIsAbsolute())
     481                    parent->attach(cameraPosition);
    482482        }
    483483    }

  • code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc

    r10821 r10916  
    8989    {
    9090        unsigned int i = 0;
    91         for (const auto & elem : this->effects_)
     91        for (WorldEntity* effect : this->effects_)
    9292            if (i == index)
    93                 return (elem);
     93                return effect;
    9494        return nullptr;
    9595    }

  • code/branches/cpp11_v2/src/orxonox/worldentities/WorldEntity.cc

    r10821 r10916  
    233233
    234234            // iterate over all children and change their activity as well
    235             for (const auto & elem : this->getAttachedObjects())
     235            for (WorldEntity* object : this->getAttachedObjects())
    236236            {
    237237                if(!this->isActive())
    238238                {
    239                     (elem)->bActiveMem_ = (elem)->isActive();
    240                     (elem)->setActive(this->isActive());
     239                    object->bActiveMem_ = object->isActive();
     240                    object->setActive(this->isActive());
    241241                }
    242242                else
    243243                {
    244                     (elem)->setActive((elem)->bActiveMem_);
     244                    object->setActive(object->bActiveMem_);
    245245                }
    246246            }
    … …  
    259259        {
    260260            // iterate over all children and change their visibility as well
    261             for (const auto & elem : this->getAttachedObjects())
     261            for (WorldEntity* object : this->getAttachedObjects())
    262262            {
    263263                if(!this->isVisible())
    264264                {
    265                     (elem)->bVisibleMem_ = (elem)->isVisible();
    266                     (elem)->setVisible(this->isVisible());
     265                    object->bVisibleMem_ = object->isVisible();
     266                    object->setVisible(this->isVisible());
    267267                }
    268268                else
    269269                {
    270                     (elem)->setVisible((elem)->bVisibleMem_);
     270                    object->setVisible(object->bVisibleMem_);
    271271                }
    272272            }
    … …  
    518518    {
    519519        unsigned int i = 0;
    520         for (const auto & elem : this->children_)
     520        for (WorldEntity* child : this->children_)
    521521        {
    522522            if (i == index)
    523                 return (elem);
     523                return child;
    524524            ++i;
    525525        }
    … …  
    938938        // Recalculate mass
    939939        this->childrenMass_ = 0.0f;
    940         for (const auto & elem : this->children_)
    941             this->childrenMass_ += (elem)->getMass();
     940        for (WorldEntity* child : this->children_)
     941            this->childrenMass_ += child->getMass();
    942942        recalculateMassProps();
    943943        // Notify parent WE

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc

    r10821 r10916  
    9999            }
    100100            // iterate through all attached parts
    101             for(auto & elem : this->partList_)
     101            for(ShipPart* part : this->partList_)
    102102            {
    103103                // if the name of the part matches the name of the object, add the object to that parts entitylist (unless it was already done).
    104                 if((elem->getName() == this->getAttachedObject(i)->getName()) && !elem->hasEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i))))
     104                if((part->getName() == this->getAttachedObject(i)->getName()) && !part->hasEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i))))
    105105                {
    106106                    // The Entity is added to the part's entityList_
    107                     elem->addEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i)));
     107                    part->addEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i)));
    108108                    // An entry in the partMap_ is created, assigning the part to the entity.
    109                     this->addPartEntityAssignment((StaticEntity*)(this->getAttachedObject(i)), elem);
     109                    this->addPartEntityAssignment((StaticEntity*)(this->getAttachedObject(i)), part);
    110110                }
    111111            }
    … …  
    146146    ShipPart* ModularSpaceShip::getPartOfEntity(StaticEntity* entity) const
    147147    {
    148         for (const auto & elem : this->partMap_)
    149         {
    150             if (elem.first == entity)
    151                 return elem.second;
     148        for (const auto& mapEntry : this->partMap_)
     149        {
     150            if (mapEntry.first == entity)
     151                return mapEntry.second;
    152152        }
    153153        return nullptr;
    … …  
    242242    ShipPart* ModularSpaceShip::getShipPartByName(std::string name)
    243243    {
    244         for(auto & elem : this->partList_)
    245         {
    246             if(orxonox_cast<ShipPart*>(elem)->getName() == name)
    247             {
    248                 return orxonox_cast<ShipPart*>(elem);
     244        for(ShipPart* part : this->partList_)
     245        {
     246            if(orxonox_cast<ShipPart*>(part)->getName() == name)
     247            {
     248                return orxonox_cast<ShipPart*>(part);
    249249            }
    250250        }
    … …  
    256256    @brief
    257257        Check whether the SpaceShip has a particular Engine.
    258     @param engine
     258    @param search
    259259        A pointer to the Engine to be checked.
    260260    */
    261     bool ModularSpaceShip::hasShipPart(ShipPart* part) const
    262     {
    263         for(auto & elem : this->partList_)
    264         {
    265             if(elem == part)
     261    bool ModularSpaceShip::hasShipPart(ShipPart* search) const
     262    {
     263        for(ShipPart* part : this->partList_)
     264        {
     265            if(part == search)
    266266                return true;
    267267        }

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/SpaceShip.cc

    r10821 r10916  
    158158
    159159        // Run the engines
    160         for(auto & elem : this->engineList_)
    161             (elem)->run(dt);
     160        for(Engine* engine : this->engineList_)
     161            engine->run(dt);
    162162
    163163        if (this->hasLocalController())
    … …  
    313313    @brief
    314314        Check whether the SpaceShip has a particular Engine.
    315     @param engine
     315    @param search
    316316        A pointer to the Engine to be checked.
    317317    */
    318     bool SpaceShip::hasEngine(Engine* engine) const
    319     {
    320         for(auto & elem : this->engineList_)
    321         {
    322             if(elem == engine)
     318    bool SpaceShip::hasEngine(Engine* search) const
     319    {
     320        for(Engine* engine : this->engineList_)
     321        {
     322            if(engine == search)
    323323                return true;
    324324        }
    … …  
    350350    Engine* SpaceShip::getEngineByName(const std::string& name)
    351351    {
    352         for(auto & elem : this->engineList_)
    353             if(elem->getName() == name)
    354                 return elem;
     352        for(Engine* engine : this->engineList_)
     353            if(engine->getName() == name)
     354                return engine;
    355355
    356356        orxout(internal_warning) << "Couldn't find Engine with name \"" << name << "\"." << endl;
    … …  
    396396    void SpaceShip::addSpeedFactor(float factor)
    397397    {
    398         for(auto & elem : this->engineList_)
    399             elem->addSpeedMultiply(factor);
     398        for(Engine* engine : this->engineList_)
     399            engine->addSpeedMultiply(factor);
    400400    }
    401401
    … …  
    408408    void SpaceShip::addSpeed(float speed)
    409409    {
    410         for(auto & elem : this->engineList_)
    411             elem->addSpeedAdd(speed);
     410        for(Engine* engine : this->engineList_)
     411            engine->addSpeedAdd(speed);
    412412    }
    413413
    … …  
    436436    {
    437437        float speed=0;
    438         for(auto & elem : this->engineList_)
    439         {
    440             if(elem->getMaxSpeedFront() > speed)
    441                 speed = elem->getMaxSpeedFront();
     438        for(Engine* engine : this->engineList_)
     439        {
     440            if(engine->getMaxSpeedFront() > speed)
     441                speed = engine->getMaxSpeedFront();
    442442        }
    443443        return speed;

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc

    r10821 r10916  
    8080
    8181        std::set<WorldEntity*> attachments = this->getAttachedObjects();
    82         for (const auto & attachment : attachments)
     82        for (WorldEntity* attachment : attachments)
    8383        {
    84             if ((attachment)->isA(Class(TeamColourable)))
     84            if (attachment->isA(Class(TeamColourable)))
    8585            {
    8686                TeamColourable* tc = orxonox_cast<TeamColourable*>(attachment);
Note: See TracChangeset for help on using the changeset viewer.