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

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/src/libraries

Files:

• core/ClassTreeMask.h (modified) (2 diffs)
• core/ConfigurablePaths.cc (modified) (1 diff)
• core/EventIncludes.h (modified) (1 diff)
• core/GUIManager.cc (modified) (1 diff)
• core/Game.cc (modified) (7 diffs)
• core/Game.h (modified) (3 diffs)
• core/Loader.cc (modified) (2 diffs)
• core/Loader.h (modified) (1 diff)
• core/LuaState.cc (modified) (2 diffs)
• core/LuaState.h (modified) (2 diffs)
• core/class/Identifiable.h (modified) (1 diff)
• core/class/Identifier.h (modified) (1 diff)
• core/class/IdentifierManager.h (modified) (1 diff)
• core/command/ArgumentCompletionFunctions.cc (modified) (3 diffs)
• core/command/CommandEvaluation.cc (modified) (3 diffs)
• core/command/ConsoleCommandManager.cc (modified) (4 diffs)
• core/command/ConsoleCommandManager.h (modified) (2 diffs)
• core/command/ExecutorPtr.h (modified) (1 diff)
• core/command/FunctorPtr.h (modified) (2 diffs)
• core/command/Shell.h (modified) (1 diff)
• core/config/SettingsConfigFile.h (modified) (1 diff)
• core/input/InputManager.h (modified) (1 diff)
• core/input/KeyBinder.h (modified) (3 diffs)
• core/module/ModuleInstance.cc (modified) (1 diff)
• core/module/ModuleInstance.h (modified) (1 diff)
• core/object/DestroyLaterManager.h (modified) (1 diff)
• core/object/Iterator.h (modified) (3 diffs)
• core/object/ObjectListIterator.h (modified) (4 diffs)
• core/singleton/ScopeManager.h (modified) (1 diff)
• network/FunctionCallManager.cc (modified) (2 diffs)
• network/FunctionCallManager.h (modified) (1 diff)
• network/GamestateManager.cc (modified) (1 diff)
• network/GamestateManager.h (modified) (1 diff)
• network/TrafficControl.cc (modified) (2 diffs)
• network/TrafficControl.h (modified) (2 diffs)
• network/packet/ClassID.cc (modified) (1 diff)
• network/packet/FunctionIDs.cc (modified) (1 diff)
• network/synchronisable/Serialise.h (modified) (2 diffs)
• network/synchronisable/Synchronisable.h (modified) (2 diffs)
• tools/TextureGenerator.cc (modified) (1 diff)
• tools/TextureGenerator.h (modified) (1 diff)
• util/SharedPtr.h (modified) (2 diffs)

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