Changeset 10769

Timestamp:

Nov 7, 2015, 10:23:42 AM (9 years ago)

Author:

landauf

Message:

no space needed anymore between closing template brackets ('> >' → '>>')

Location:

code/branches/cpp11_v2

Files:

• src/OrxonoxConfig.h.in (modified) (1 diff)
• src/libraries/core/ClassTreeMask.h (modified) (2 diffs)
• src/libraries/core/ConfigurablePaths.cc (modified) (1 diff)
• src/libraries/core/EventIncludes.h (modified) (1 diff)
• src/libraries/core/GUIManager.cc (modified) (1 diff)
• src/libraries/core/Game.cc (modified) (7 diffs)
• src/libraries/core/Game.h (modified) (3 diffs)
• src/libraries/core/Loader.cc (modified) (2 diffs)
• src/libraries/core/Loader.h (modified) (1 diff)
• src/libraries/core/LuaState.cc (modified) (2 diffs)
• src/libraries/core/LuaState.h (modified) (2 diffs)
• src/libraries/core/class/Identifiable.h (modified) (1 diff)
• src/libraries/core/class/Identifier.h (modified) (1 diff)
• src/libraries/core/class/IdentifierManager.h (modified) (1 diff)
• src/libraries/core/command/ArgumentCompletionFunctions.cc (modified) (3 diffs)
• src/libraries/core/command/CommandEvaluation.cc (modified) (3 diffs)
• src/libraries/core/command/ConsoleCommandManager.cc (modified) (4 diffs)
• src/libraries/core/command/ConsoleCommandManager.h (modified) (2 diffs)
• src/libraries/core/command/ExecutorPtr.h (modified) (1 diff)
• src/libraries/core/command/FunctorPtr.h (modified) (2 diffs)
• src/libraries/core/command/Shell.h (modified) (1 diff)
• src/libraries/core/config/SettingsConfigFile.h (modified) (1 diff)
• src/libraries/core/input/InputManager.h (modified) (1 diff)
• src/libraries/core/input/KeyBinder.h (modified) (3 diffs)
• src/libraries/core/module/ModuleInstance.cc (modified) (1 diff)
• src/libraries/core/module/ModuleInstance.h (modified) (1 diff)
• src/libraries/core/object/DestroyLaterManager.h (modified) (1 diff)
• src/libraries/core/object/Iterator.h (modified) (3 diffs)
• src/libraries/core/object/ObjectListIterator.h (modified) (4 diffs)
• src/libraries/core/singleton/ScopeManager.h (modified) (1 diff)
• src/libraries/network/FunctionCallManager.cc (modified) (2 diffs)
• src/libraries/network/FunctionCallManager.h (modified) (1 diff)
• src/libraries/network/GamestateManager.cc (modified) (1 diff)
• src/libraries/network/GamestateManager.h (modified) (1 diff)
• src/libraries/network/TrafficControl.cc (modified) (2 diffs)
• src/libraries/network/TrafficControl.h (modified) (2 diffs)
• src/libraries/network/packet/ClassID.cc (modified) (1 diff)
• src/libraries/network/packet/FunctionIDs.cc (modified) (1 diff)
• src/libraries/network/synchronisable/Serialise.h (modified) (2 diffs)
• src/libraries/network/synchronisable/Synchronisable.h (modified) (2 diffs)
• src/libraries/tools/TextureGenerator.cc (modified) (1 diff)
• src/libraries/tools/TextureGenerator.h (modified) (1 diff)
• src/libraries/util/SharedPtr.h (modified) (2 diffs)
• src/modules/designtools/SkyboxGenerator.h (modified) (1 diff)
• src/modules/mini4dgame/Mini4DgameAI.h (modified) (1 diff)
• src/modules/objects/SpaceBoundaries.cc (modified) (1 diff)
• src/modules/objects/SpaceBoundaries.h (modified) (1 diff)
• src/modules/objects/triggers/DistanceMultiTrigger.cc (modified) (2 diffs)
• src/modules/objects/triggers/DistanceMultiTrigger.h (modified) (1 diff)
• src/modules/objects/triggers/MultiTrigger.h (modified) (1 diff)
• src/modules/objects/triggers/Trigger.h (modified) (1 diff)
• src/modules/overlays/hud/HUDNavigation.cc (modified) (3 diffs)
• src/modules/overlays/hud/HUDNavigation.h (modified) (1 diff)
• src/modules/pickup/PickupManager.h (modified) (1 diff)
• src/modules/pickup/items/ShrinkPickup.cc (modified) (4 diffs)
• src/modules/pong/PongAI.cc (modified) (1 diff)
• src/modules/pong/PongAI.h (modified) (1 diff)
• src/modules/tetris/Tetris.cc (modified) (6 diffs)
• src/modules/tetris/Tetris.h (modified) (1 diff)
• src/modules/towerdefense/TowerDefense.cc (modified) (1 diff)
• src/modules/towerdefense/TowerDefense.h (modified) (1 diff)
• src/orxonox/controllers/ArtificialController.h (modified) (1 diff)
• src/orxonox/infos/PlayerInfo.h (modified) (1 diff)
• src/orxonox/overlays/OverlayGroup.cc (modified) (6 diffs)
• src/orxonox/overlays/OverlayGroup.h (modified) (2 diffs)
• src/orxonox/sound/SoundBuffer.cc (modified) (1 diff)
• src/orxonox/sound/SoundBuffer.h (modified) (2 diffs)
• src/orxonox/sound/SoundManager.cc (modified) (5 diffs)
• src/orxonox/sound/SoundManager.h (modified) (3 diffs)
• src/orxonox/worldentities/ControllableEntity.cc (modified) (5 diffs)
• src/orxonox/worldentities/ControllableEntity.h (modified) (2 diffs)
• test/util/SharedPtrTest.cc (modified) (1 diff)

code/branches/cpp11_v2/src/OrxonoxConfig.h.in

@@ -213 +213 @@
     template<class _Ty>   class  allocator;
     template<class _Elem, class _Traits, class _Ax> class basic_string;
-    typedef basic_string<char, char_traits<char>, allocator<char> > string;
+    typedef basic_string<char, char_traits<char>, allocator<char>> string;
 }
 

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

@@ -157 +157 @@
 
         private:
-            std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator> > nodes_;    ///< A stack to store list-iterators
+            std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator>> nodes_;    ///< A stack to store list-iterators
             std::list<ClassTreeMaskNode*> rootlist_;                                                                            ///< A list for internal use (it only stores the root-node)
     };
@@ -298 +298 @@
             void create(ClassTreeMaskNode* node);
 
-            std::list<std::pair<const Identifier*, bool> >           subclasses_;       ///< A list of all Identifiers through which objects the iterator should iterate
-            std::list<std::pair<const Identifier*, bool> >::iterator subclassIterator_; ///< The current class of the iterator
-            Iterator<BaseObject>                                     objectIterator_;   ///< The current object of the iterator
+            std::list<std::pair<const Identifier*, bool>>           subclasses_;       ///< A list of all Identifiers through which objects the iterator should iterate
+            std::list<std::pair<const Identifier*, bool>>::iterator subclassIterator_; ///< The current class of the iterator
+            Iterator<BaseObject>                                    objectIterator_;   ///< The current object of the iterator
     };
 }

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

@@ -143 +143 @@
 
         // Create directories to avoid problems when opening files in non existent folders.
-        std::vector<std::pair<bf::path, std::string> > directories;
+        std::vector<std::pair<bf::path, std::string>> directories;
         directories.push_back(std::make_pair(bf::path(configPath_), std::string("config")));
         directories.push_back(std::make_pair(bf::path(logPath_), std::string("log")));
 
-        for (std::vector<std::pair<bf::path, std::string> >::iterator it = directories.begin();
+        for (std::vector<std::pair<bf::path, std::string>>::iterator it = directories.begin();
             it != directories.end(); ++it)
         {

code/branches/cpp11_v2/src/libraries/core/EventIncludes.h

@@ -86 +86 @@
 
 #define XMLPortEventStateIntern(name, classname, statename, xmlelement, mode) \
-    static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname> >(); \
-    static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname> >(); \
+    static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname>>(); \
+    static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname>>(); \
     xmlsetfunctor##name->setDefaultValue(1, statename); \
     xmlgetfunctor##name->setDefaultValue(1, statename); \

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

@@ -165 +165 @@
                 d_caching = false;
 
-                std::vector<std::pair<CEGUI::String, CEGUI::LoggingLevel> >::iterator it = d_cache.begin();
+                std::vector<std::pair<CEGUI::String, CEGUI::LoggingLevel>>::iterator it = d_cache.begin();
 
                 while (it != d_cache.end())

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

@@ -73 +73 @@
         std::string name_;
         weak_ptr<GameStateTreeNode> parent_;
-        std::vector<shared_ptr<GameStateTreeNode> > children_;
+        std::vector<shared_ptr<GameStateTreeNode>> children_;
     };
 
@@ -384 +384 @@
 
         // Check children first
-        std::vector<shared_ptr<GameStateTreeNode> > requestedNodes;
+        std::vector<shared_ptr<GameStateTreeNode>> requestedNodes;
         for (unsigned int i = 0; i < lastRequestedNode->children_.size(); ++i)
         {
@@ -454 +454 @@
     {
         // Split string into pieces of the form whitespacesText
-        std::vector<std::pair<std::string, int> > stateStrings;
+        std::vector<std::pair<std::string, int>> stateStrings;
         size_t pos = 0;
         size_t startPos = 0;
@@ -473 +473 @@
 
         // Parse elements recursively
-        std::vector<std::pair<std::string, int> >::const_iterator begin = stateStrings.begin();
+        std::vector<std::pair<std::string, int>>::const_iterator begin = stateStrings.begin();
         parseStates(begin, this->rootStateNode_);
     }
@@ -479 +479 @@
     /*** Internal ***/
 
-    void Game::parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
+    void Game::parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
     {
         SubString tokens(it->first, ",");
-        std::vector<std::pair<std::string, int> >::const_iterator startIt = it;
+        std::vector<std::pair<std::string, int>>::const_iterator startIt = it;
 
         for (unsigned int i = 0; i < tokens.size(); ++i)
@@ -620 +620 @@
     }
 
-    /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory> >& Game::GameStateFactory::getFactories()
-    {
-        static std::map<std::string, shared_ptr<GameStateFactory> > factories;
+    /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory>>& Game::GameStateFactory::getFactories()
+    {
+        static std::map<std::string, shared_ptr<GameStateFactory>> factories;
         return factories;
     }
@@ -628 +628 @@
     /*static*/ shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
     {
-        std::map<std::string, shared_ptr<Game::GameStateFactory> >::const_iterator it = getFactories().find(info.className);
+        std::map<std::string, shared_ptr<Game::GameStateFactory>>::const_iterator it = getFactories().find(info.className);
         assert(it != getFactories().end());
         return it->second->fabricateInternal(info);

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

@@ -84 +84 @@
     { // tolua_export
         friend class Singleton<Game>;
-        typedef std::vector<shared_ptr<GameState> > GameStateVector;
-        typedef std::map<std::string, shared_ptr<GameState> > GameStateMap;
+        typedef std::vector<shared_ptr<GameState>> GameStateVector;
+        typedef std::map<std::string, shared_ptr<GameState>> GameStateMap;
         typedef shared_ptr<GameStateTreeNode> GameStateTreeNodePtr;
 
@@ -129 +129 @@
 
             virtual shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) = 0;
-            static std::map<std::string, shared_ptr<GameStateFactory> >& getFactories();
+            static std::map<std::string, shared_ptr<GameStateFactory>>& getFactories();
         };
         template <class T>
@@ -150 +150 @@
         void unloadGraphics(bool loadGraphicsManagerWithoutRenderer = true);
 
-        void parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
+        void parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
         bool checkState(const std::string& name) const;
         void loadState(const std::string& name);

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

@@ -73 +73 @@
         std::string xmlInput;
 
-        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > lineTrace(new std::vector<std::vector<std::pair<std::string, size_t> > >());
+        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> lineTrace(new std::vector<std::vector<std::pair<std::string, size_t>>>());
         lineTrace->reserve(1000); //arbitrary number
 
@@ -163 +163 @@
                     if (line <= lineTrace->size())
                     {
-                        std::vector<std::pair<std::string, size_t> > linesources = lineTrace->at(line - 1);
+                        std::vector<std::pair<std::string, size_t>> linesources = lineTrace->at(line - 1);
                         std::ostringstream message;
                         message << "Possible sources of error:" << endl;
-                        for (std::vector<std::pair<std::string, size_t> >::iterator it = linesources.begin(); it != linesources.end(); ++it)
+                        for (std::vector<std::pair<std::string, size_t>>::iterator it = linesources.begin(); it != linesources.end(); ++it)
                         {
                             message << it->first << ", Line " << it->second << endl;

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

@@ -67 +67 @@
             static bool getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags);
 
-            std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_;
+            std::vector<std::pair<const XMLFile*, ClassTreeMask>> files_;
 
             static Loader* singletonPtr_s;

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

@@ -245 +245 @@
             //Note: due to newlines etc., it's possible that one line consists of parts of
             //      multiple, different files
-            std::vector<std::vector<std::pair<std::string, size_t> > >::reverse_iterator it = lineTrace_->rbegin();
+            std::vector<std::vector<std::pair<std::string, size_t>>>::reverse_iterator it = lineTrace_->rbegin();
             std::pair<std::string, size_t> temppair = std::make_pair(filename, line);
             //Avoid duplicate entries. This could happen if there were lua blocks on the same line
@@ -259 +259 @@
             {
                 //Add the new line to the trace map
-                lineTrace_->push_back(std::vector<std::pair<std::string, size_t> >());
+                lineTrace_->push_back(std::vector<std::pair<std::string, size_t>>());
                 //Add the source of the line at the end
                 lineTrace_->rbegin()->push_back(std::make_pair(filename, line + i));

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

@@ -94 +94 @@
         void clearOutput() { output_.clear(); } // tolua_export
 
-        void setTraceMap(shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > map)
-            { map->push_back(std::vector<std::pair<std::string, size_t> >()); lineTrace_ = map; }
+        void setTraceMap(shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> map)
+            { map->push_back(std::vector<std::pair<std::string, size_t>>()); lineTrace_ = map; }
 
         void setIncludeParser(std::string (*function)(const std::string&)) { includeParseFunction_ = function; }
@@ -116 +116 @@
     private:
         shared_ptr<ResourceInfo> getFileInfo(const std::string& filename);
-        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > lineTrace_;
+        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> lineTrace_;
         
         std::stringstream output_;

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

@@ -121 +121 @@
 
             /// 'Fast map' that holds this-pointers of all derived types
-            std::vector<std::pair<unsigned int, void*> > objectPointers_;
+            std::vector<std::pair<unsigned int, void*>> objectPointers_;
     };
 }

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

@@ -321 +321 @@
             void updateConfigValues(bool updateChildren, Identifiable*) const;
 
-            static WeakPtr<ClassIdentifier<T> > classIdentifier_s;
+            static WeakPtr<ClassIdentifier<T>> classIdentifier_s;
     };
 
     template <class T>
-    WeakPtr<ClassIdentifier<T> > ClassIdentifier<T>::classIdentifier_s;
+    WeakPtr<ClassIdentifier<T>> ClassIdentifier<T>::classIdentifier_s;
 
     /**

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

@@ -111 +111 @@
             /// Used while creating the object hierarchy to keep track of the identifiers of a newly created object (and all other objects that get created as
             /// a consequence of this, e.g. nested member objects).
-            std::map<Identifiable*, std::list<const Identifier*> > identifierTraceOfNewObject_;
+            std::map<Identifiable*, std::list<const Identifier*>> identifierTraceOfNewObject_;
             Identifier* recordTraceForIdentifier_; //!< The identifier for which we want to record the trace of identifiers during object creation. If null, no trace is recorded.
 

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

@@ -99 +99 @@
 
                 // get all the groups that are visible (except the shortcut group "")
-                const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommandManager::getInstance().getCommands();
-                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
+                const std::map<std::string, std::map<std::string, ConsoleCommand*>>& commands = ConsoleCommandManager::getInstance().getCommands();
+                for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
                     if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find(fragmentLC) == 0))
                         groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
 
                 // now add all shortcuts (in group "")
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.find("");
+                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = commands.find("");
                 if (it_group != commands.end())
                 {
@@ -138 +138 @@
 
                 // find the iterator of the given group
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
+                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
                 for ( ; it_group != ConsoleCommandManager::getInstance().getCommands().end(); ++it_group)
                     if (getLowercase(it_group->first) == groupLC)
@@ -212 +212 @@
             if (tokens.size() == 1)
             {
-                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
+                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
                 if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                     return detail::_subcommands(fragment, tokens[0], true);

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

@@ -306 +306 @@
                 // the user typed 1-2 arguments, check what he tried to type and print a suitable error
                 std::string groupLC = getLowercase(this->getToken(0));
-                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
+                for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
                     if (it_group->first == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
@@ -328 +328 @@
 
         // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().begin(); it_group != ConsoleCommandManager::getInstance().getCommandsLC().end(); ++it_group)
         {
             if (it_group->first != "")
@@ -346 +346 @@
 
         // now also iterate through all shortcuts and keep the best if it's better than the one found above.
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
+        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
         if (it_group !=  ConsoleCommandManager::getInstance().getCommandsLC().end())
         {

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

@@ -50 +50 @@
     {
         // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMap_.find(group);
+        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMap_.find(group);
         if (it_group != this->commandMap_.end())
         {
@@ -83 +83 @@
 
         // find the group
-        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMapLC_.find(groupLC);
+        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMapLC_.find(groupLC);
         if (it_group != this->commandMapLC_.end())
         {
@@ -146 +146 @@
     {
         // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
         {
             // iterate through all commands of each group
@@ -168 +168 @@
 
         // iterate through all groups
-        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
         {
             // iterate through all commands of each group

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

@@ -54 +54 @@
 
             /// Returns the map with all groups and commands.
-            inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
+            inline const std::map<std::string, std::map<std::string, ConsoleCommand*>>& getCommands()
                 { return this->commandMap_; }
             /// Returns the map with all groups and commands in lowercase.
-            inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
+            inline const std::map<std::string, std::map<std::string, ConsoleCommand*>>& getCommandsLC()
                 { return this->commandMapLC_; }
 
@@ -71 +71 @@
 
         private:
-            std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMap_;
-            std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMapLC_;
+            std::map<std::string, std::map<std::string, ConsoleCommand*>> commandMap_;
+            std::map<std::string, std::map<std::string, ConsoleCommand*>> commandMapLC_;
 
             static ConsoleCommandManager* singletonPtr_s;

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

@@ -66 +66 @@
             inline ExecutorMemberPtr() : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>() {}
             inline ExecutorMemberPtr(ExecutorMember<T>* pointer) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(pointer) {}
-            inline ExecutorMemberPtr(const SharedPtr<ExecutorMember<T> >& other) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(other) {}
+            inline ExecutorMemberPtr(const SharedPtr<ExecutorMember<T>>& other) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(other) {}
     };
 }

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

@@ -65 +65 @@
             inline FunctorMemberPtr() : SharedChildPtr<FunctorMember<T>, FunctorPtr>() {}
             inline FunctorMemberPtr(FunctorMember<T>* pointer) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(pointer) {}
-            inline FunctorMemberPtr(const SharedPtr<FunctorMember<T> >& other) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(other) {}
+            inline FunctorMemberPtr(const SharedPtr<FunctorMember<T>>& other) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(other) {}
     };
 
@@ -73 +73 @@
     /// It's not possible to use a typedef for FunctorPointerPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
     template <class F, class T>
-    class FunctorPointerPtr : public SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >
+    class FunctorPointerPtr : public SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>
     {
         public:
-            inline FunctorPointerPtr() : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >() {}
-            inline FunctorPointerPtr(FunctorPointer<F, T>* pointer) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(pointer) {}
-            inline FunctorPointerPtr(const SharedPtr<FunctorPointer<F, T> >& other) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(other) {}
+            inline FunctorPointerPtr() : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>() {}
+            inline FunctorPointerPtr(FunctorPointer<F, T>* pointer) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>(pointer) {}
+            inline FunctorPointerPtr(const SharedPtr<FunctorPointer<F, T>>& other) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>(other) {}
     };
 }

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

@@ -128 +128 @@
             const std::string& getInput() const;
 
-            typedef std::list<std::pair<std::string, LineType> > LineList;
+            typedef std::list<std::pair<std::string, LineType>> LineList;
             LineList::const_iterator getNewestLineIterator() const;
             LineList::const_iterator getEndIterator() const;

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

@@ -63 +63 @@
 
         public:
-            typedef std::multimap<std::string, std::pair<std::string, ConfigValueContainer*> > ContainerMap;
+            typedef std::multimap<std::string, std::pair<std::string, ConfigValueContainer*>> ContainerMap;
 
             SettingsConfigFile(const std::string& filename);

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

@@ -225 +225 @@
         std::vector<InputState*>            activeStatesTicked_;   //!< Like activeStates_, but only contains the ones that currently receive events
 
-        std::vector<boost::function<void ()> > callBuffer_;        //!< Caches all calls from InputStates to be executed afterwards (see preUpdate)
+        std::vector<boost::function<void ()>> callBuffer_;        //!< Caches all calls from InputStates to be executed afterwards (see preUpdate)
 
         static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton

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

@@ -127 +127 @@
         };
         //! Actual key bindings for joy stick buttons
-        std::vector<shared_ptr<JoyStickButtonVector> > joyStickButtons_;
+        std::vector<shared_ptr<JoyStickButtonVector>> joyStickButtons_;
         //! Helper class to use something like std:vector<HalfAxis[48]>
         struct JoyStickAxisVector
@@ -135 +135 @@
         };
         //! Actual key bindings for joy stick axes (and sliders)
-        std::vector<shared_ptr<JoyStickAxisVector> > joyStickAxes_;
+        std::vector<shared_ptr<JoyStickAxisVector>> joyStickAxes_;
 
         //! Pointer map with all Buttons, including half axes
@@ -142 +142 @@
         std::vector<HalfAxis*> allHalfAxes_;
         //! Maps input commands to all Button names, including half axes
-        std::map< std::string, std::vector<std::string> > allCommands_;
+        std::map< std::string, std::vector<std::string>> allCommands_;
 
         /**

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

@@ -73 +73 @@
     void ModuleInstance::deleteAllStaticallyInitializedInstances()
     {
-        std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > copy(this->staticallyInitializedInstancesByType_);
+        std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
         this->staticallyInitializedInstancesByType_.clear();
-        for (std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> >::iterator it1 = copy.begin(); it1 != copy.end(); ++it1)
+        for (std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>>::iterator it1 = copy.begin(); it1 != copy.end(); ++it1)
             for (std::set<StaticallyInitializedInstance*>::iterator it2 = it1->second.begin(); it2 != it1->second.end(); ++it2)
                 delete (*it2);

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

@@ -69 +69 @@
 
         private:
-            std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > staticallyInitializedInstancesByType_;
+            std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> staticallyInitializedInstancesByType_;
             std::string libraryName_;
             DynLib* dynLib_;

code/branches/cpp11_v2/src/libraries/core/object/DestroyLaterManager.h

@@ -52 +52 @@
 
         private:
-            std::vector<StrongPtr<Destroyable> > retainedInstances_;
+            std::vector<StrongPtr<Destroyable>> retainedInstances_;
 
             static DestroyLaterManager* singletonPtr_s;

code/branches/cpp11_v2/src/libraries/core/object/Iterator.h

@@ -70 +70 @@
     */
     template <class T>
-    class Iterator : public IteratorBase<T, Iterator<T> >
+    class Iterator : public IteratorBase<T, Iterator<T>>
     {
         public:
@@ -76 +76 @@
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
-            inline Iterator() : IteratorBase<T, Iterator<T> >() {}
+            inline Iterator() : IteratorBase<T, Iterator<T>>() {}
 
             /**
@@ -83 +83 @@
             */
             template <class OT, class OI>
-            inline Iterator(const IteratorBase<OT, OI>& other) : IteratorBase<T, Iterator<T> >(other) {}
+            inline Iterator(const IteratorBase<OT, OI>& other) : IteratorBase<T, Iterator<T>>(other) {}
 
             /**

code/branches/cpp11_v2/src/libraries/core/object/ObjectListIterator.h

@@ -68 +68 @@
     */
     template <class T>
-    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T> >
+    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T>>
     {
         public:
@@ -74 +74 @@
                 @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
             */
-            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >() {}
+            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T>>() {}
 
             /**
@@ -80 +80 @@
                 @param element The element to start with
             */
-            inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T> >(element) {}
+            inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T>>(element) {}
 
             /**
@@ -87 +87 @@
             */
             template <class OI>
-            inline ObjectListIterator(const IteratorBase<T, OI>& other) : IteratorBase<T, ObjectListIterator<T> >(other) {}
+            inline ObjectListIterator(const IteratorBase<T, OI>& other) : IteratorBase<T, ObjectListIterator<T>>(other) {}
 
             /**

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

@@ -79 +79 @@
 
             std::set<ScopeID::Value> activeScopes_;
-            std::map<ScopeID::Value, std::set<ScopeListener*> > listeners_; //!< Stores all listeners for a scope
+            std::map<ScopeID::Value, std::set<ScopeListener*>> listeners_; //!< Stores all listeners for a scope
 
             static ScopeManager* singletonPtr_s;

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

@@ -37 +37 @@
 
 std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sPeerMap_;
-std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > > FunctionCallManager::sIncomingFunctionCallBuffer_;
+std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>> FunctionCallManager::sIncomingFunctionCallBuffer_;
 
 
@@ -70 +70 @@
 void FunctionCallManager::processBufferedFunctionCalls()
 {
-  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > >::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
+  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
   while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
   {

code/branches/cpp11_v2/src/libraries/network/FunctionCallManager.h

@@ -54 +54 @@
 
   static std::map<uint32_t, packet::FunctionCalls*>                           sPeerMap_;
-  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t> > > sIncomingFunctionCallBuffer_;
+  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t>>> sIncomingFunctionCallBuffer_;
 protected:
   FunctionCallManager();

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

@@ -351 +351 @@
 //   void GamestateManager::removeClient(ClientInformation* client){
 //     assert(client);
-//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>>::iterator clientMap = gamestateMap_.find(client->getID());
 //     // first delete all remained gamestates
 //     std::map<unsigned int, packet::Gamestate*>::iterator it;

code/branches/cpp11_v2/src/libraries/network/GamestateManager.h

@@ -108 +108 @@
     bool processGamestate(packet::Gamestate *gs);
 
-//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> > gamestateMap_;
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>> gamestateMap_;
     std::map<unsigned int, packet::Gamestate*> gamestateQueue;
 //     std::map<unsigned int, uint32_t> lastProcessedGamestateID_;

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

@@ -148 +148 @@
     // shortcut for maps
     std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
-    std::map<unsigned int, std::list<obj> >& objectListTemp = clientListTemp_[clientID];
+    std::map<unsigned int, std::list<obj>>& objectListTemp = clientListTemp_[clientID];
 
     for(itvec = objectListTemp[gamestateID].begin(); itvec != objectListTemp[gamestateID].end(); itvec++)
@@ -180 +180 @@
     void TrafficControl::insertinClientListPerm(unsigned int clientID, obj objinf)
     {
-      std::map<unsigned int,std::map<unsigned int, objInfo> >::iterator itperm;//iterator clientListPerm over clientIDs
+      std::map<unsigned int,std::map<unsigned int, objInfo>>::iterator itperm;//iterator clientListPerm over clientIDs
     unsigned int gsid=GAMESTATEID_INITIAL, gsdiff=currentGamestateID, prioperm=Synchronisable::getSynchronisable(objinf.objID)->getPriority(), priomom=0;
     clientListPerm_[clientID][objinf.objID] = objInfo(objinf.objID, objinf.objCreatorID,gsid,gsdiff, objinf.objSize,prioperm,priomom);

code/branches/cpp11_v2/src/libraries/network/TrafficControl.h

@@ -82 +82 @@
     *permanent client list: contains client ids, object ids and objectInfos (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, objInfo > > clientListPerm_;
+    std::map<unsigned int, std::map<unsigned int, objInfo >> clientListPerm_;
     //has to be created with constructor and then needs to be updated by evaluateList().
 
@@ -88 +88 @@
     *temporary client list: contains client ids, gamestate ids and object ids (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, std::list<obj> > > clientListTemp_;
+    std::map<unsigned int, std::map<unsigned int, std::list<obj>>> clientListTemp_;
 
     /**updateReferenceList

code/branches/cpp11_v2/src/libraries/network/packet/ClassID.cc

@@ -52 +52 @@
   uint32_t network_id;
   flags_ = flags_ | PACKET_FLAGS_CLASSID;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)

code/branches/cpp11_v2/src/libraries/network/packet/FunctionIDs.cc

@@ -53 +53 @@
   uint32_t networkID;
   flags_ = flags_ | PACKET_FLAGS_FUNCTIONIDS;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)

code/branches/cpp11_v2/src/libraries/network/synchronisable/Serialise.h

@@ -90 +90 @@
     {
 //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<StrongPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
@@ -125 +125 @@
     {
         //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<WeakPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<WeakPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }

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

@@ -242 +242 @@
     SynchronisableVariableBase* sv;
     if (bidirectional)
-      sv = new SynchronisableVariableBidirectional<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariableBidirectional<std::set<T>>(variable, mode, cb);
     else
-      sv = new SynchronisableVariable<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariable<std::set<T>>(variable, mode, cb);
     syncList_.push_back(sv);
     stringList_.push_back(sv);
@@ -250 +250 @@
 
   template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
-//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T> >( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
+//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T>>( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::unregisterVariable( std::string& variable );
 

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

@@ -71 +71 @@
 namespace orxonox
 {
-    std::map<std::string, std::map<ColourValue, std::string> > TextureGenerator::materials_s;
+    std::map<std::string, std::map<ColourValue, std::string>> TextureGenerator::materials_s;
     unsigned int TextureGenerator::materialCount_s = 0;
 

code/branches/cpp11_v2/src/libraries/tools/TextureGenerator.h

@@ -53 +53 @@
         ~TextureGenerator();
 
-        static std::map<std::string, std::map<ColourValue, std::string> > materials_s;
+        static std::map<std::string, std::map<ColourValue, std::string>> materials_s;
         static unsigned int materialCount_s;
     };

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

@@ -343 +343 @@
         For example the @c Functor classes: While a @c Functor* pointer would be managed by
         @c SharedPtr<Functor>, the child class @c FunctorStatic is managed by the class
-        <tt>SharedChildPtr<FunctorStatic, SharedPtr<Functor> ></tt>.
+        <tt>SharedChildPtr<FunctorStatic, SharedPtr<Functor>></tt>.
 
         The second template argument @a Parent is used as the parent class of
@@ -351 +351 @@
         So for example this works:
         @code
-        SharedChildPtr<FunctorStatic, SharedPtr<Functor> > functorStatic = createFunctor(&MyClass::myStaticFunction);
+        SharedChildPtr<FunctorStatic, SharedPtr<Functor>> functorStatic = createFunctor(&MyClass::myStaticFunction);
         SharedPtr<Functor> functor = functorStatic;
         @endcode

code/branches/cpp11_v2/src/modules/designtools/SkyboxGenerator.h

@@ -106 +106 @@
             
             std::vector<std::string> names_; //!< The names of the image files for the skybox faces to be generated.
-            std::vector< std::pair<int, int> > rotations_; //!< The rotation in yaw an pitch direction that is applied to the camera after a specific face has been generated.
+            std::vector< std::pair<int, int>> rotations_; //!< The rotation in yaw an pitch direction that is applied to the camera after a specific face has been generated.
             
             // Storage variables

code/branches/cpp11_v2/src/modules/mini4dgame/Mini4DgameAI.h

@@ -81 +81 @@
         protected:
 
-            std::list<std::pair<Timer*, char> > reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
+            std::list<std::pair<Timer*, char>> reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
             Mini4DgameCenterpoint* center_;
 

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

@@ -208 +208 @@
         float distance;
         bool humanItem;
-        for( std::list<WeakPtr<Pawn> >::iterator current = pawnsIn_.begin(); current != pawnsIn_.end(); current++ )
+        for( std::list<WeakPtr<Pawn>>::iterator current = pawnsIn_.begin(); current != pawnsIn_.end(); current++ )
         {
             Pawn* currentPawn = *current;

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

@@ -101 +101 @@
 
             // Variabeln::
-            std::list<WeakPtr<Pawn> > pawnsIn_; //!< List of the pawns that this instance of SpaceBoundaries has to handle.
+            std::list<WeakPtr<Pawn>> pawnsIn_; //!< List of the pawns that this instance of SpaceBoundaries has to handle.
 
             std::vector<BillboardAdministration> billboards_;

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

@@ -100 +100 @@
 
         // Check for objects that were in range but no longer are. Iterate through all objects, that are in range.
-        for(std::set<WeakPtr<WorldEntity> >::iterator it = this->range_.begin(); it != this->range_.end(); )
+        for(std::set<WeakPtr<WorldEntity>>::iterator it = this->range_.begin(); it != this->range_.end(); )
         {
             WorldEntity* entity = *it;
@@ -261 +261 @@
     bool DistanceMultiTrigger::addToRange(WorldEntity* entity)
     {
-        std::pair<std::set<WeakPtr<WorldEntity> >::iterator, bool> pair = this->range_.insert(entity);
+        std::pair<std::set<WeakPtr<WorldEntity>>::iterator, bool> pair = this->range_.insert(entity);
         return pair.second;
     }

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

@@ -153 +153 @@
             ClassTreeMask beaconMask_; //!< A mask, that only accepts DistanceTriggerBeacons.
 
-            std::set<WeakPtr<WorldEntity> > range_; //!< The set of entities that currently are in range of the DistanceMultiTrigger.
+            std::set<WeakPtr<WorldEntity>> range_; //!< The set of entities that currently are in range of the DistanceMultiTrigger.
 
     };

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

@@ -192 +192 @@
             std::set<BaseObject*> triggered_; //!< The set of all objects the MultiTrigger is triggered for.
 
-            std::deque< std::pair<float, MultiTriggerState*> > stateQueue_; //!< The queue of states waiting to become active.
+            std::deque<std::pair<float, MultiTriggerState*>> stateQueue_; //!< The queue of states waiting to become active.
 
             ClassTreeMask targetMask_; //!< The target mask, masking all objects that can trigger this MultiTrigger.

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

@@ -127 +127 @@
             BillboardSet debugBillboard_; //!< A set of debug billboards to visualize the state of the trigger.
 
-            std::queue<std::pair<float, char> > stateChanges_; //!< A queue of state changes (in the same format as latestState_) paired with the time they will take effect since the last state change took effect.
+            std::queue<std::pair<float, char>> stateChanges_; //!< A queue of state changes (in the same format as latestState_) paired with the time they will take effect since the last state change took effect.
     };
 

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

@@ -187 +187 @@
         const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
 
-        for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
+        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
         listIt->second = (int)((listIt->first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
 
@@ -209 +209 @@
         bool nextHasToBeSelected = false;
 
-        for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++markerCount, ++listIt)
+        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++markerCount, ++listIt)
         {
 
@@ -641 +641 @@
         }
 
-        for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
+        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
         {
             if ((listIt->first) == viewable)

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

@@ -141 +141 @@
 
             std::map<RadarViewable*, ObjectInfo> activeObjectList_;
-            std::list<std::pair<RadarViewable*, unsigned int> > sortedObjectList_;
+            std::list<std::pair<RadarViewable*, unsigned int>> sortedObjectList_;
 
             float healthMarkerSize_;

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

@@ -161 +161 @@
             std::map<uint32_t, PickupInventoryContainer*>::iterator pickupsIterator_; //!< An iterator pointing to the current Pickupable in pickupsList_.
 
-            std::map<uint32_t, WeakPtr<Pickupable> > pickups_; //!< Map linking a number identifying a Pickupable to a weak pointer of a Pickupable.
+            std::map<uint32_t, WeakPtr<Pickupable>> pickups_; //!< Map linking a number identifying a Pickupable to a weak pointer of a Pickupable.
             std::map<Pickupable*, uint32_t> indexes_;//!< Map linking Pickupable to the number identifying it.
 

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

@@ -182 +182 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
@@ -208 +208 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
@@ -263 +263 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
@@ -304 +304 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)

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

@@ -77 +77 @@
     PongAI::~PongAI()
     {
-        for (std::list<std::pair<Timer*, char> >::iterator it = this->reactionTimers_.begin(); it != this->reactionTimers_.end(); ++it)
+        for (std::list<std::pair<Timer*, char>>::iterator it = this->reactionTimers_.begin(); it != this->reactionTimers_.end(); ++it)
             it->first->destroy();
     }

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

@@ -89 +89 @@
             float strength_; //!< The strength of the AI. Ranging from 0 to 1.
 
-            std::list<std::pair<Timer*, char> > reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
+            std::list<std::pair<Timer*, char>> reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
             char movement_; //!< The planned movement.
             char oldMove_; //!< The previous movement.

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

@@ -104 +104 @@
         }
 
-        for (std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for (std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
             (*it)->destroy();
         this->stones_.clear();
@@ -136 +136 @@
             return false;
 
-        for(std::list<StrongPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for(std::list<StrongPtr<TetrisStone>>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
         {
             const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
@@ -192 +192 @@
 
         // check for collisions with all stones
-        for(std::list<StrongPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for(std::list<StrongPtr<TetrisStone>>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
         {
             //Vector3 currentStonePosition = rotateVector((*it)->getPosition(), this->activeBrick_->getRotationCount());
@@ -469 +469 @@
         {
             stonesPerRow = 0;
-            for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
-            {
-                std::list<StrongPtr<TetrisStone> >::iterator it_temp = it++;
+            for(std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); )
+            {
+                std::list<StrongPtr<TetrisStone>>::iterator it_temp = it++;
                 correctPosition = static_cast<unsigned int>(((*it_temp)->getPosition().y - 5)/this->center_->getStoneSize());
                 if(correctPosition == row)
@@ -491 +491 @@
     void Tetris::clearRow(unsigned int row)
     {// clear the full row
-        for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
+        for(std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); )
         {
             if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) == row)
@@ -502 +502 @@
         }
       // adjust height of stones above the deleted row //TODO: check if this could be a source of a bug.
-        for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        for(std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
         {
             if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) > row)

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

@@ -93 +93 @@
 
             WeakPtr<TetrisCenterpoint> center_; //!< The playing field.
-            std::list<StrongPtr<TetrisStone> > stones_; //!< A list of all stones in play.
+            std::list<StrongPtr<TetrisStone>> stones_; //!< A list of all stones in play.
             WeakPtr<TetrisBrick> activeBrick_;
             WeakPtr<TetrisBrick> futureBrick_;

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

@@ -287 +287 @@
         }
         
-        for (std::list<WeakPtr<TowerDefenseEnemy> >::iterator it = enemies_.begin(); it != enemies_.end(); )
+        for (std::list<WeakPtr<TowerDefenseEnemy>>::iterator it = enemies_.begin(); it != enemies_.end(); )
         {
             if (*it == nullptr)

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

@@ -87 +87 @@
         int waveNumber_;
         int lifes_;
-        std::list<orxonox::WeakPtr<TowerDefenseEnemy> > enemies_;
+        std::list<orxonox::WeakPtr<TowerDefenseEnemy>> enemies_;
         TowerDefenseField* fields_[16][16];
-        std::vector<orxonox::WeakPtr<TowerDefenseField> > waypoints_;
+        std::vector<orxonox::WeakPtr<TowerDefenseField>> waypoints_;
         Vector3 endpoint_;
         Vector3 offset_;        

code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.h

@@ -89 +89 @@
 
             //WAYPOINT DATA
-            std::vector<WeakPtr<WorldEntity> > waypoints_;
+            std::vector<WeakPtr<WorldEntity>> waypoints_;
             size_t currentWaypoint_;
             float squaredaccuracy_;

code/branches/cpp11_v2/src/orxonox/infos/PlayerInfo.h

@@ -99 +99 @@
             Controller* controller_;
             ControllableEntity* controllableEntity_;
-            std::vector< WeakPtr<ControllableEntity> > previousControllableEntity_; //!< List of the previous ControllableEntities if repeatedly startTemporary control was called. The ControllableEntity at the back is the most recent.
+            std::vector<WeakPtr<ControllableEntity>> previousControllableEntity_; //!< List of the previous ControllableEntities if repeatedly startTemporary control was called. The ControllableEntity at the back is the most recent.
             unsigned int controllableEntityID_;
 

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

@@ -62 +62 @@
     OverlayGroup::~OverlayGroup()
     {
-        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->destroy();
         this->hudElements_.clear();
@@ -86 +86 @@
     void OverlayGroup::setScale(const Vector2& scale)
     {
-        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->scale(scale / this->scale_);
         this->scale_ = scale;
@@ -94 +94 @@
     void OverlayGroup::setScroll(const Vector2& scroll)
     {
-        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->scroll(scroll - this->scroll_);
         this->scroll_ = scroll;
@@ -133 +133 @@
         if (index < this->hudElements_.size())
         {
-            std::set< StrongPtr<OrxonoxOverlay> >::const_iterator it = hudElements_.begin();
+            std::set<StrongPtr<OrxonoxOverlay>>::const_iterator it = hudElements_.begin();
             for (unsigned int i = 0; i != index; ++it, ++i)
                 ;
@@ -147 +147 @@
         SUPER( OverlayGroup, changedVisibility );
 
-        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->changedVisibility(); //inform all Child Overlays that our visibility has changed
     }
@@ -155 +155 @@
         this->owner_ = owner;
 
-        for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
             (*it)->setOwner(owner);
     }

code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.h

@@ -65 +65 @@
         static void scrollGroup(const std::string& name, const Vector2& scroll);
 
-        inline const std::set< StrongPtr<OrxonoxOverlay> >& getOverlays() const
+        inline const std::set<StrongPtr<OrxonoxOverlay>>& getOverlays() const
             { return this->hudElements_; }
 
@@ -91 +91 @@
 
     private:
-        std::set< StrongPtr<OrxonoxOverlay> > hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
+        std::set<StrongPtr<OrxonoxOverlay>> hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
         Vector2 scale_;                            //!< Current scale (independent of the elements).
         Vector2 scroll_;                           //!< Current scrolling offset.

code/branches/cpp11_v2/src/orxonox/sound/SoundBuffer.cc

@@ -39 +39 @@
 namespace orxonox
 {
-    SoundBuffer::SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer> >::iterator poolIterator)
+    SoundBuffer::SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer>>::iterator poolIterator)
         : filename_(filename)
         , audioBuffer_(AL_NONE)

code/branches/cpp11_v2/src/orxonox/sound/SoundBuffer.h

@@ -64 +64 @@
 
     private:
-        SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer> >::iterator poolIterator);
+        SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer>>::iterator poolIterator);
 #if !defined(_MSC_VER) || _MSC_VER >= 1500
         ~SoundBuffer();
@@ -73 +73 @@
         std::string filename_;
         ALuint audioBuffer_;
-        std::list<shared_ptr<SoundBuffer> >::iterator poolIterator_;
+        std::list<shared_ptr<SoundBuffer>>::iterator poolIterator_;
     };
 }

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

@@ -422 +422 @@
     {
         // If we're already fading out --> remove that
-        for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
+        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
         {
             if (*it == sound)
@@ -438 +438 @@
     {
         // If we're already fading in --> remove that
-        for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
+        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
         {
             if (*it == sound)
@@ -461 +461 @@
 
         // FADE IN
-        for (std::list<StrongPtr<AmbientSound> >::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
+        for (std::list<StrongPtr<AmbientSound>>::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
         {
             if ((*it)->getVolume() + this->crossFadeStep_*dt > 1.0f)
@@ -476 +476 @@
 
         // FADE OUT
-        for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
+        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
         {
             if ((*it)->getVolume() - this->crossFadeStep_*dt < 0.0f)
@@ -606 +606 @@
 #endif
         this->availableSoundSources_.push_back(source);
-        for (std::vector<std::pair<ALuint, BaseSound*> >::iterator it = this->usedSoundSources_.begin();
+        for (std::vector<std::pair<ALuint, BaseSound*>>::iterator it = this->usedSoundSources_.begin();
             it != this->usedSoundSources_.end(); ++it)
         {

code/branches/cpp11_v2/src/orxonox/sound/SoundManager.h

@@ -125 +125 @@
 
         // Ambient sound related
-        typedef std::list<std::pair<AmbientSound*, bool> > AmbientList;
+        typedef std::list<std::pair<AmbientSound*, bool>> AmbientList;
         AmbientList                        ambientSounds_;
         //! Absolute change per second (0.1 means 10% of the nominal volume) for cross fading
         float                              crossFadeStep_;
-        std::list<StrongPtr<AmbientSound> > fadeInList_;
-        std::list<StrongPtr<AmbientSound> > fadeOutList_;
+        std::list<StrongPtr<AmbientSound>> fadeInList_;
+        std::list<StrongPtr<AmbientSound>> fadeOutList_;
 
         // Volume related
@@ -139 +139 @@
         static const unsigned int maxEffectsPoolSize_s = 40 * 1024 * 1024;
         unsigned int effectsPoolSize_;
-        typedef std::list<shared_ptr<SoundBuffer> > EffectsPoolList;
+        typedef std::list<shared_ptr<SoundBuffer>> EffectsPoolList;
         EffectsPoolList effectsPool_;
-        typedef std::map<std::string, shared_ptr<SoundBuffer> > SoundBufferMap;
+        typedef std::map<std::string, shared_ptr<SoundBuffer>> SoundBufferMap;
         SoundBufferMap soundBuffers_;
 
@@ -148 +148 @@
         unsigned int maxSources_;
         std::vector<ALuint> availableSoundSources_;
-        std::vector<std::pair<ALuint, BaseSound*> > usedSoundSources_;
+        std::vector<std::pair<ALuint, BaseSound*>> usedSoundSources_;
 
         bool bDestructorCalled_; ///< Becomes true if the destructor is called - used to prevent ambient sounds from registering after the lists were cleared

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

@@ -108 +108 @@
                 this->camera_->destroy();
 
-            for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+            for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 (*it)->destroy();
 
@@ -165 +165 @@
     {
         unsigned int i = 0;
-        for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+        for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
         {
             if (i == index)
@@ -180 +180 @@
 
         unsigned int counter = 0;
-        for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+        for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
         {
             if ((*it) == this->currentCameraPosition_)
@@ -219 +219 @@
             else if (this->cameraPositions_.size() > 0)
             {
-                for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+                for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 {
                     if ((*it) == this->camera_->getParent())
@@ -477 +477 @@
         if (parent)
         {
-            for (std::list<StrongPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+            for (std::list<StrongPtr<CameraPosition>>::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 if ((*it)->getIsAbsolute())
                     parent->attach((*it));

code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.h

@@ -121 +121 @@
             void addCameraPosition(CameraPosition* position);
             CameraPosition* getCameraPosition(unsigned int index) const;
-            inline const std::list<StrongPtr<CameraPosition> >& getCameraPositions() const
+            inline const std::list<StrongPtr<CameraPosition>>& getCameraPositions() const
                 { return this->cameraPositions_; }
             unsigned int getCurrentCameraIndex() const;
@@ -242 +242 @@
             bool bMouseLook_;
             float mouseLookSpeed_;
-            std::list<StrongPtr<CameraPosition> > cameraPositions_;
+            std::list<StrongPtr<CameraPosition>> cameraPositions_;
             CameraPosition* currentCameraPosition_;
             std::string cameraPositionTemplate_;

code/branches/cpp11_v2/test/util/SharedPtrTest.cc

@@ -178 +178 @@
 
         SharedPtr<TestClass> test = pointer;
-        std::vector<SharedPtr<TestClass> > tests;
+        std::vector<SharedPtr<TestClass>> tests;
         for (size_t i = 0; i < 100; ++i)
             tests.push_back(SharedPtr<TestClass>(test));