Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 10769


Ignore:
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:
72 edited

Legend:

Unmodified
Added
Removed
  • code/branches/cpp11_v2/src/OrxonoxConfig.h.in

    r9675 r10769  
    213213    template<class _Ty>   class  allocator;
    214214    template<class _Elem, class _Traits, class _Ax> class basic_string;
    215     typedef basic_string<char, char_traits<char>, allocator<char> > string;
     215    typedef basic_string<char, char_traits<char>, allocator<char>> string;
    216216}
    217217
  • code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.h

    r10768 r10769  
    157157
    158158        private:
    159             std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator> > nodes_;    ///< A stack to store list-iterators
     159            std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator>> nodes_;    ///< A stack to store list-iterators
    160160            std::list<ClassTreeMaskNode*> rootlist_;                                                                            ///< A list for internal use (it only stores the root-node)
    161161    };
     
    298298            void create(ClassTreeMaskNode* node);
    299299
    300             std::list<std::pair<const Identifier*, bool> >           subclasses_;       ///< A list of all Identifiers through which objects the iterator should iterate
    301             std::list<std::pair<const Identifier*, bool> >::iterator subclassIterator_; ///< The current class of the iterator
    302             Iterator<BaseObject>                                     objectIterator_;   ///< The current object of the iterator
     300            std::list<std::pair<const Identifier*, bool>>           subclasses_;       ///< A list of all Identifiers through which objects the iterator should iterate
     301            std::list<std::pair<const Identifier*, bool>>::iterator subclassIterator_; ///< The current class of the iterator
     302            Iterator<BaseObject>                                    objectIterator_;   ///< The current object of the iterator
    303303    };
    304304}
  • code/branches/cpp11_v2/src/libraries/core/ConfigurablePaths.cc

    r10768 r10769  
    143143
    144144        // Create directories to avoid problems when opening files in non existent folders.
    145         std::vector<std::pair<bf::path, std::string> > directories;
     145        std::vector<std::pair<bf::path, std::string>> directories;
    146146        directories.push_back(std::make_pair(bf::path(configPath_), std::string("config")));
    147147        directories.push_back(std::make_pair(bf::path(logPath_), std::string("log")));
    148148
    149         for (std::vector<std::pair<bf::path, std::string> >::iterator it = directories.begin();
     149        for (std::vector<std::pair<bf::path, std::string>>::iterator it = directories.begin();
    150150            it != directories.end(); ++it)
    151151        {
  • code/branches/cpp11_v2/src/libraries/core/EventIncludes.h

    r8729 r10769  
    8686
    8787#define XMLPortEventStateIntern(name, classname, statename, xmlelement, mode) \
    88     static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname> >(); \
    89     static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname> >(); \
     88    static orxonox::ExecutorMemberPtr<classname> xmlsetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname>>(); \
     89    static orxonox::ExecutorMemberPtr<classname> xmlgetfunctor##name = orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')').cast<orxonox::ExecutorMember<classname>>(); \
    9090    xmlsetfunctor##name->setDefaultValue(1, statename); \
    9191    xmlgetfunctor##name->setDefaultValue(1, statename); \
  • code/branches/cpp11_v2/src/libraries/core/GUIManager.cc

    r10768 r10769  
    165165                d_caching = false;
    166166
    167                 std::vector<std::pair<CEGUI::String, CEGUI::LoggingLevel> >::iterator it = d_cache.begin();
     167                std::vector<std::pair<CEGUI::String, CEGUI::LoggingLevel>>::iterator it = d_cache.begin();
    168168
    169169                while (it != d_cache.end())
  • code/branches/cpp11_v2/src/libraries/core/Game.cc

    r10768 r10769  
    7373        std::string name_;
    7474        weak_ptr<GameStateTreeNode> parent_;
    75         std::vector<shared_ptr<GameStateTreeNode> > children_;
     75        std::vector<shared_ptr<GameStateTreeNode>> children_;
    7676    };
    7777
     
    384384
    385385        // Check children first
    386         std::vector<shared_ptr<GameStateTreeNode> > requestedNodes;
     386        std::vector<shared_ptr<GameStateTreeNode>> requestedNodes;
    387387        for (unsigned int i = 0; i < lastRequestedNode->children_.size(); ++i)
    388388        {
     
    454454    {
    455455        // Split string into pieces of the form whitespacesText
    456         std::vector<std::pair<std::string, int> > stateStrings;
     456        std::vector<std::pair<std::string, int>> stateStrings;
    457457        size_t pos = 0;
    458458        size_t startPos = 0;
     
    473473
    474474        // Parse elements recursively
    475         std::vector<std::pair<std::string, int> >::const_iterator begin = stateStrings.begin();
     475        std::vector<std::pair<std::string, int>>::const_iterator begin = stateStrings.begin();
    476476        parseStates(begin, this->rootStateNode_);
    477477    }
     
    479479    /*** Internal ***/
    480480
    481     void Game::parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
     481    void Game::parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode)
    482482    {
    483483        SubString tokens(it->first, ",");
    484         std::vector<std::pair<std::string, int> >::const_iterator startIt = it;
     484        std::vector<std::pair<std::string, int>>::const_iterator startIt = it;
    485485
    486486        for (unsigned int i = 0; i < tokens.size(); ++i)
     
    620620    }
    621621
    622     /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory> >& Game::GameStateFactory::getFactories()
    623     {
    624         static std::map<std::string, shared_ptr<GameStateFactory> > factories;
     622    /*static*/ std::map<std::string, shared_ptr<Game::GameStateFactory>>& Game::GameStateFactory::getFactories()
     623    {
     624        static std::map<std::string, shared_ptr<GameStateFactory>> factories;
    625625        return factories;
    626626    }
     
    628628    /*static*/ shared_ptr<GameState> Game::GameStateFactory::fabricate(const GameStateInfo& info)
    629629    {
    630         std::map<std::string, shared_ptr<Game::GameStateFactory> >::const_iterator it = getFactories().find(info.className);
     630        std::map<std::string, shared_ptr<Game::GameStateFactory>>::const_iterator it = getFactories().find(info.className);
    631631        assert(it != getFactories().end());
    632632        return it->second->fabricateInternal(info);
  • code/branches/cpp11_v2/src/libraries/core/Game.h

    r10624 r10769  
    8484    { // tolua_export
    8585        friend class Singleton<Game>;
    86         typedef std::vector<shared_ptr<GameState> > GameStateVector;
    87         typedef std::map<std::string, shared_ptr<GameState> > GameStateMap;
     86        typedef std::vector<shared_ptr<GameState>> GameStateVector;
     87        typedef std::map<std::string, shared_ptr<GameState>> GameStateMap;
    8888        typedef shared_ptr<GameStateTreeNode> GameStateTreeNodePtr;
    8989
     
    129129
    130130            virtual shared_ptr<GameState> fabricateInternal(const GameStateInfo& info) = 0;
    131             static std::map<std::string, shared_ptr<GameStateFactory> >& getFactories();
     131            static std::map<std::string, shared_ptr<GameStateFactory>>& getFactories();
    132132        };
    133133        template <class T>
     
    150150        void unloadGraphics(bool loadGraphicsManagerWithoutRenderer = true);
    151151
    152         void parseStates(std::vector<std::pair<std::string, int> >::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
     152        void parseStates(std::vector<std::pair<std::string, int>>::const_iterator& it, shared_ptr<GameStateTreeNode> currentNode);
    153153        bool checkState(const std::string& name) const;
    154154        void loadState(const std::string& name);
  • code/branches/cpp11_v2/src/libraries/core/Loader.cc

    r10768 r10769  
    7373        std::string xmlInput;
    7474
    75         shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > lineTrace(new std::vector<std::vector<std::pair<std::string, size_t> > >());
     75        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> lineTrace(new std::vector<std::vector<std::pair<std::string, size_t>>>());
    7676        lineTrace->reserve(1000); //arbitrary number
    7777
     
    163163                    if (line <= lineTrace->size())
    164164                    {
    165                         std::vector<std::pair<std::string, size_t> > linesources = lineTrace->at(line - 1);
     165                        std::vector<std::pair<std::string, size_t>> linesources = lineTrace->at(line - 1);
    166166                        std::ostringstream message;
    167167                        message << "Possible sources of error:" << endl;
    168                         for (std::vector<std::pair<std::string, size_t> >::iterator it = linesources.begin(); it != linesources.end(); ++it)
     168                        for (std::vector<std::pair<std::string, size_t>>::iterator it = linesources.begin(); it != linesources.end(); ++it)
    169169                        {
    170170                            message << it->first << ", Line " << it->second << endl;
  • code/branches/cpp11_v2/src/libraries/core/Loader.h

    r10624 r10769  
    6767            static bool getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags);
    6868
    69             std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_;
     69            std::vector<std::pair<const XMLFile*, ClassTreeMask>> files_;
    7070
    7171            static Loader* singletonPtr_s;
  • code/branches/cpp11_v2/src/libraries/core/LuaState.cc

    r10765 r10769  
    245245            //Note: due to newlines etc., it's possible that one line consists of parts of
    246246            //      multiple, different files
    247             std::vector<std::vector<std::pair<std::string, size_t> > >::reverse_iterator it = lineTrace_->rbegin();
     247            std::vector<std::vector<std::pair<std::string, size_t>>>::reverse_iterator it = lineTrace_->rbegin();
    248248            std::pair<std::string, size_t> temppair = std::make_pair(filename, line);
    249249            //Avoid duplicate entries. This could happen if there were lua blocks on the same line
     
    259259            {
    260260                //Add the new line to the trace map
    261                 lineTrace_->push_back(std::vector<std::pair<std::string, size_t> >());
     261                lineTrace_->push_back(std::vector<std::pair<std::string, size_t>>());
    262262                //Add the source of the line at the end
    263263                lineTrace_->rbegin()->push_back(std::make_pair(filename, line + i));
  • code/branches/cpp11_v2/src/libraries/core/LuaState.h

    r10265 r10769  
    9494        void clearOutput() { output_.clear(); } // tolua_export
    9595
    96         void setTraceMap(shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > map)
    97             { map->push_back(std::vector<std::pair<std::string, size_t> >()); lineTrace_ = map; }
     96        void setTraceMap(shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> map)
     97            { map->push_back(std::vector<std::pair<std::string, size_t>>()); lineTrace_ = map; }
    9898
    9999        void setIncludeParser(std::string (*function)(const std::string&)) { includeParseFunction_ = function; }
     
    116116    private:
    117117        shared_ptr<ResourceInfo> getFileInfo(const std::string& filename);
    118         shared_ptr<std::vector<std::vector<std::pair<std::string, size_t> > > > lineTrace_;
     118        shared_ptr<std::vector<std::vector<std::pair<std::string, size_t>>>> lineTrace_;
    119119       
    120120        std::stringstream output_;
  • code/branches/cpp11_v2/src/libraries/core/class/Identifiable.h

    r10765 r10769  
    121121
    122122            /// 'Fast map' that holds this-pointers of all derived types
    123             std::vector<std::pair<unsigned int, void*> > objectPointers_;
     123            std::vector<std::pair<unsigned int, void*>> objectPointers_;
    124124    };
    125125}
  • code/branches/cpp11_v2/src/libraries/core/class/Identifier.h

    r10768 r10769  
    321321            void updateConfigValues(bool updateChildren, Identifiable*) const;
    322322
    323             static WeakPtr<ClassIdentifier<T> > classIdentifier_s;
     323            static WeakPtr<ClassIdentifier<T>> classIdentifier_s;
    324324    };
    325325
    326326    template <class T>
    327     WeakPtr<ClassIdentifier<T> > ClassIdentifier<T>::classIdentifier_s;
     327    WeakPtr<ClassIdentifier<T>> ClassIdentifier<T>::classIdentifier_s;
    328328
    329329    /**
  • code/branches/cpp11_v2/src/libraries/core/class/IdentifierManager.h

    r10624 r10769  
    111111            /// 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
    112112            /// a consequence of this, e.g. nested member objects).
    113             std::map<Identifiable*, std::list<const Identifier*> > identifierTraceOfNewObject_;
     113            std::map<Identifiable*, std::list<const Identifier*>> identifierTraceOfNewObject_;
    114114            Identifier* recordTraceForIdentifier_; //!< The identifier for which we want to record the trace of identifiers during object creation. If null, no trace is recorded.
    115115
  • code/branches/cpp11_v2/src/libraries/core/command/ArgumentCompletionFunctions.cc

    r10624 r10769  
    9999
    100100                // get all the groups that are visible (except the shortcut group "")
    101                 const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommandManager::getInstance().getCommands();
    102                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
     101                const std::map<std::string, std::map<std::string, ConsoleCommand*>>& commands = ConsoleCommandManager::getInstance().getCommands();
     102                for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
    103103                    if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find(fragmentLC) == 0))
    104104                        groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
    105105
    106106                // now add all shortcuts (in group "")
    107                 std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.find("");
     107                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = commands.find("");
    108108                if (it_group != commands.end())
    109109                {
     
    138138
    139139                // find the iterator of the given group
    140                 std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
     140                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().begin();
    141141                for ( ; it_group != ConsoleCommandManager::getInstance().getCommands().end(); ++it_group)
    142142                    if (getLowercase(it_group->first) == groupLC)
     
    212212            if (tokens.size() == 1)
    213213            {
    214                 std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
     214                std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommands().find(tokens[0]);
    215215                if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
    216216                    return detail::_subcommands(fragment, tokens[0], true);
  • code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc

    r10768 r10769  
    306306                // the user typed 1-2 arguments, check what he tried to type and print a suitable error
    307307                std::string groupLC = getLowercase(this->getToken(0));
    308                 for (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)
     308                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)
    309309                    if (it_group->first == groupLC)
    310310                        return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
     
    328328
    329329        // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
    330         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)
     330        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)
    331331        {
    332332            if (it_group->first != "")
     
    346346
    347347        // now also iterate through all shortcuts and keep the best if it's better than the one found above.
    348         std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
     348        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = ConsoleCommandManager::getInstance().getCommandsLC().find("");
    349349        if (it_group !=  ConsoleCommandManager::getInstance().getCommandsLC().end())
    350350        {
  • code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommandManager.cc

    r10768 r10769  
    5050    {
    5151        // find the group
    52         std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMap_.find(group);
     52        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMap_.find(group);
    5353        if (it_group != this->commandMap_.end())
    5454        {
     
    8383
    8484        // find the group
    85         std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = this->commandMapLC_.find(groupLC);
     85        std::map<std::string, std::map<std::string, ConsoleCommand*>>::const_iterator it_group = this->commandMapLC_.find(groupLC);
    8686        if (it_group != this->commandMapLC_.end())
    8787        {
     
    146146    {
    147147        // iterate through all groups
    148         for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
     148        for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMap_.begin(); it_group != this->commandMap_.end(); )
    149149        {
    150150            // iterate through all commands of each group
     
    168168
    169169        // iterate through all groups
    170         for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
     170        for (std::map<std::string, std::map<std::string, ConsoleCommand*>>::iterator it_group = this->commandMapLC_.begin(); it_group != this->commandMapLC_.end(); )
    171171        {
    172172            // iterate through all commands of each group
  • code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommandManager.h

    r10624 r10769  
    5454
    5555            /// Returns the map with all groups and commands.
    56             inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
     56            inline const std::map<std::string, std::map<std::string, ConsoleCommand*>>& getCommands()
    5757                { return this->commandMap_; }
    5858            /// Returns the map with all groups and commands in lowercase.
    59             inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
     59            inline const std::map<std::string, std::map<std::string, ConsoleCommand*>>& getCommandsLC()
    6060                { return this->commandMapLC_; }
    6161
     
    7171
    7272        private:
    73             std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMap_;
    74             std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMapLC_;
     73            std::map<std::string, std::map<std::string, ConsoleCommand*>> commandMap_;
     74            std::map<std::string, std::map<std::string, ConsoleCommand*>> commandMapLC_;
    7575
    7676            static ConsoleCommandManager* singletonPtr_s;
  • code/branches/cpp11_v2/src/libraries/core/command/ExecutorPtr.h

    r7401 r10769  
    6666            inline ExecutorMemberPtr() : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>() {}
    6767            inline ExecutorMemberPtr(ExecutorMember<T>* pointer) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(pointer) {}
    68             inline ExecutorMemberPtr(const SharedPtr<ExecutorMember<T> >& other) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(other) {}
     68            inline ExecutorMemberPtr(const SharedPtr<ExecutorMember<T>>& other) : SharedChildPtr<ExecutorMember<T>, ExecutorPtr>(other) {}
    6969    };
    7070}
  • code/branches/cpp11_v2/src/libraries/core/command/FunctorPtr.h

    r7401 r10769  
    6565            inline FunctorMemberPtr() : SharedChildPtr<FunctorMember<T>, FunctorPtr>() {}
    6666            inline FunctorMemberPtr(FunctorMember<T>* pointer) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(pointer) {}
    67             inline FunctorMemberPtr(const SharedPtr<FunctorMember<T> >& other) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(other) {}
     67            inline FunctorMemberPtr(const SharedPtr<FunctorMember<T>>& other) : SharedChildPtr<FunctorMember<T>, FunctorPtr>(other) {}
    6868    };
    6969
     
    7373    /// 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.
    7474    template <class F, class T>
    75     class FunctorPointerPtr : public SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >
     75    class FunctorPointerPtr : public SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>
    7676    {
    7777        public:
    78             inline FunctorPointerPtr() : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >() {}
    79             inline FunctorPointerPtr(FunctorPointer<F, T>* pointer) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(pointer) {}
    80             inline FunctorPointerPtr(const SharedPtr<FunctorPointer<F, T> >& other) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >(other) {}
     78            inline FunctorPointerPtr() : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>() {}
     79            inline FunctorPointerPtr(FunctorPointer<F, T>* pointer) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>(pointer) {}
     80            inline FunctorPointerPtr(const SharedPtr<FunctorPointer<F, T>>& other) : SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T>>(other) {}
    8181    };
    8282}
  • code/branches/cpp11_v2/src/libraries/core/command/Shell.h

    r10624 r10769  
    128128            const std::string& getInput() const;
    129129
    130             typedef std::list<std::pair<std::string, LineType> > LineList;
     130            typedef std::list<std::pair<std::string, LineType>> LineList;
    131131            LineList::const_iterator getNewestLineIterator() const;
    132132            LineList::const_iterator getEndIterator() const;
  • code/branches/cpp11_v2/src/libraries/core/config/SettingsConfigFile.h

    r9684 r10769  
    6363
    6464        public:
    65             typedef std::multimap<std::string, std::pair<std::string, ConfigValueContainer*> > ContainerMap;
     65            typedef std::multimap<std::string, std::pair<std::string, ConfigValueContainer*>> ContainerMap;
    6666
    6767            SettingsConfigFile(const std::string& filename);
  • code/branches/cpp11_v2/src/libraries/core/input/InputManager.h

    r10765 r10769  
    225225        std::vector<InputState*>            activeStatesTicked_;   //!< Like activeStates_, but only contains the ones that currently receive events
    226226
    227         std::vector<boost::function<void ()> > callBuffer_;        //!< Caches all calls from InputStates to be executed afterwards (see preUpdate)
     227        std::vector<boost::function<void ()>> callBuffer_;        //!< Caches all calls from InputStates to be executed afterwards (see preUpdate)
    228228
    229229        static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton
  • code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.h

    r10765 r10769  
    127127        };
    128128        //! Actual key bindings for joy stick buttons
    129         std::vector<shared_ptr<JoyStickButtonVector> > joyStickButtons_;
     129        std::vector<shared_ptr<JoyStickButtonVector>> joyStickButtons_;
    130130        //! Helper class to use something like std:vector<HalfAxis[48]>
    131131        struct JoyStickAxisVector
     
    135135        };
    136136        //! Actual key bindings for joy stick axes (and sliders)
    137         std::vector<shared_ptr<JoyStickAxisVector> > joyStickAxes_;
     137        std::vector<shared_ptr<JoyStickAxisVector>> joyStickAxes_;
    138138
    139139        //! Pointer map with all Buttons, including half axes
     
    142142        std::vector<HalfAxis*> allHalfAxes_;
    143143        //! Maps input commands to all Button names, including half axes
    144         std::map< std::string, std::vector<std::string> > allCommands_;
     144        std::map< std::string, std::vector<std::string>> allCommands_;
    145145
    146146        /**
  • code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.cc

    r10765 r10769  
    7373    void ModuleInstance::deleteAllStaticallyInitializedInstances()
    7474    {
    75         std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > copy(this->staticallyInitializedInstancesByType_);
     75        std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
    7676        this->staticallyInitializedInstancesByType_.clear();
    77         for (std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> >::iterator it1 = copy.begin(); it1 != copy.end(); ++it1)
     77        for (std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>>::iterator it1 = copy.begin(); it1 != copy.end(); ++it1)
    7878            for (std::set<StaticallyInitializedInstance*>::iterator it2 = it1->second.begin(); it2 != it1->second.end(); ++it2)
    7979                delete (*it2);
  • code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.h

    r10549 r10769  
    6969
    7070        private:
    71             std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*> > staticallyInitializedInstancesByType_;
     71            std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> staticallyInitializedInstancesByType_;
    7272            std::string libraryName_;
    7373            DynLib* dynLib_;
  • code/branches/cpp11_v2/src/libraries/core/object/DestroyLaterManager.h

    r10624 r10769  
    5252
    5353        private:
    54             std::vector<StrongPtr<Destroyable> > retainedInstances_;
     54            std::vector<StrongPtr<Destroyable>> retainedInstances_;
    5555
    5656            static DestroyLaterManager* singletonPtr_s;
  • code/branches/cpp11_v2/src/libraries/core/object/Iterator.h

    r10736 r10769  
    7070    */
    7171    template <class T>
    72     class Iterator : public IteratorBase<T, Iterator<T> >
     72    class Iterator : public IteratorBase<T, Iterator<T>>
    7373    {
    7474        public:
     
    7676                @brief Constructor: Sets the element, whereon the iterator points, to zero.
    7777            */
    78             inline Iterator() : IteratorBase<T, Iterator<T> >() {}
     78            inline Iterator() : IteratorBase<T, Iterator<T>>() {}
    7979
    8080            /**
     
    8383            */
    8484            template <class OT, class OI>
    85             inline Iterator(const IteratorBase<OT, OI>& other) : IteratorBase<T, Iterator<T> >(other) {}
     85            inline Iterator(const IteratorBase<OT, OI>& other) : IteratorBase<T, Iterator<T>>(other) {}
    8686
    8787            /**
  • code/branches/cpp11_v2/src/libraries/core/object/ObjectListIterator.h

    r10736 r10769  
    6868    */
    6969    template <class T>
    70     class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T> >
     70    class ObjectListIterator : public IteratorBase<T, ObjectListIterator<T>>
    7171    {
    7272        public:
     
    7474                @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
    7575            */
    76             inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T> >() {}
     76            inline ObjectListIterator() : IteratorBase<T, ObjectListIterator<T>>() {}
    7777
    7878            /**
     
    8080                @param element The element to start with
    8181            */
    82             inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T> >(element) {}
     82            inline ObjectListIterator(ObjectListElement<T>* element) : IteratorBase<T, ObjectListIterator<T>>(element) {}
    8383
    8484            /**
     
    8787            */
    8888            template <class OI>
    89             inline ObjectListIterator(const IteratorBase<T, OI>& other) : IteratorBase<T, ObjectListIterator<T> >(other) {}
     89            inline ObjectListIterator(const IteratorBase<T, OI>& other) : IteratorBase<T, ObjectListIterator<T>>(other) {}
    9090
    9191            /**
  • code/branches/cpp11_v2/src/libraries/core/singleton/ScopeManager.h

    r10542 r10769  
    7979
    8080            std::set<ScopeID::Value> activeScopes_;
    81             std::map<ScopeID::Value, std::set<ScopeListener*> > listeners_; //!< Stores all listeners for a scope
     81            std::map<ScopeID::Value, std::set<ScopeListener*>> listeners_; //!< Stores all listeners for a scope
    8282
    8383            static ScopeManager* singletonPtr_s;
  • code/branches/cpp11_v2/src/libraries/network/FunctionCallManager.cc

    r10624 r10769  
    3737
    3838std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sPeerMap_;
    39 std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > > FunctionCallManager::sIncomingFunctionCallBuffer_;
     39std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>> FunctionCallManager::sIncomingFunctionCallBuffer_;
    4040
    4141
     
    7070void FunctionCallManager::processBufferedFunctionCalls()
    7171{
    72   std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > >::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
     72  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
    7373  while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
    7474  {
  • code/branches/cpp11_v2/src/libraries/network/FunctionCallManager.h

    r10624 r10769  
    5454
    5555  static std::map<uint32_t, packet::FunctionCalls*>                           sPeerMap_;
    56   static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t> > > sIncomingFunctionCallBuffer_;
     56  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t>>> sIncomingFunctionCallBuffer_;
    5757protected:
    5858  FunctionCallManager();
  • code/branches/cpp11_v2/src/libraries/network/GamestateManager.cc

    r10768 r10769  
    351351//   void GamestateManager::removeClient(ClientInformation* client){
    352352//     assert(client);
    353 //     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
     353//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>>::iterator clientMap = gamestateMap_.find(client->getID());
    354354//     // first delete all remained gamestates
    355355//     std::map<unsigned int, packet::Gamestate*>::iterator it;
  • code/branches/cpp11_v2/src/libraries/network/GamestateManager.h

    r10622 r10769  
    108108    bool processGamestate(packet::Gamestate *gs);
    109109
    110 //     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> > gamestateMap_;
     110//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*>> gamestateMap_;
    111111    std::map<unsigned int, packet::Gamestate*> gamestateQueue;
    112112//     std::map<unsigned int, uint32_t> lastProcessedGamestateID_;
  • code/branches/cpp11_v2/src/libraries/network/TrafficControl.cc

    r10768 r10769  
    148148    // shortcut for maps
    149149    std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
    150     std::map<unsigned int, std::list<obj> >& objectListTemp = clientListTemp_[clientID];
     150    std::map<unsigned int, std::list<obj>>& objectListTemp = clientListTemp_[clientID];
    151151
    152152    for(itvec = objectListTemp[gamestateID].begin(); itvec != objectListTemp[gamestateID].end(); itvec++)
     
    180180    void TrafficControl::insertinClientListPerm(unsigned int clientID, obj objinf)
    181181    {
    182       std::map<unsigned int,std::map<unsigned int, objInfo> >::iterator itperm;//iterator clientListPerm over clientIDs
     182      std::map<unsigned int,std::map<unsigned int, objInfo>>::iterator itperm;//iterator clientListPerm over clientIDs
    183183    unsigned int gsid=GAMESTATEID_INITIAL, gsdiff=currentGamestateID, prioperm=Synchronisable::getSynchronisable(objinf.objID)->getPriority(), priomom=0;
    184184    clientListPerm_[clientID][objinf.objID] = objInfo(objinf.objID, objinf.objCreatorID,gsid,gsdiff, objinf.objSize,prioperm,priomom);
  • code/branches/cpp11_v2/src/libraries/network/TrafficControl.h

    r6746 r10769  
    8282    *permanent client list: contains client ids, object ids and objectInfos (in this order)
    8383    */
    84     std::map<unsigned int, std::map<unsigned int, objInfo > > clientListPerm_;
     84    std::map<unsigned int, std::map<unsigned int, objInfo >> clientListPerm_;
    8585    //has to be created with constructor and then needs to be updated by evaluateList().
    8686
     
    8888    *temporary client list: contains client ids, gamestate ids and object ids (in this order)
    8989    */
    90     std::map<unsigned int, std::map<unsigned int, std::list<obj> > > clientListTemp_;
     90    std::map<unsigned int, std::map<unsigned int, std::list<obj>>> clientListTemp_;
    9191
    9292    /**updateReferenceList
  • code/branches/cpp11_v2/src/libraries/network/packet/ClassID.cc

    r10765 r10769  
    5252  uint32_t network_id;
    5353  flags_ = flags_ | PACKET_FLAGS_CLASSID;
    54   std::queue<std::pair<uint32_t, std::string> > tempQueue;
     54  std::queue<std::pair<uint32_t, std::string>> tempQueue;
    5555
    5656  //calculate total needed size (for all strings and integers)
  • code/branches/cpp11_v2/src/libraries/network/packet/FunctionIDs.cc

    r10624 r10769  
    5353  uint32_t networkID;
    5454  flags_ = flags_ | PACKET_FLAGS_FUNCTIONIDS;
    55   std::queue<std::pair<uint32_t, std::string> > tempQueue;
     55  std::queue<std::pair<uint32_t, std::string>> tempQueue;
    5656
    5757  //calculate total needed size (for all strings and integers)
  • code/branches/cpp11_v2/src/libraries/network/synchronisable/Serialise.h

    r10624 r10769  
    9090    {
    9191//         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
    92         *const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
     92        *const_cast<typename Loki::TypeTraits<StrongPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
    9393        mem += returnSize( variable );
    9494    }
     
    125125    {
    126126        //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
    127         *const_cast<typename Loki::TypeTraits<WeakPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
     127        *const_cast<typename Loki::TypeTraits<WeakPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
    128128        mem += returnSize( variable );
    129129    }
  • code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.h

    r10768 r10769  
    242242    SynchronisableVariableBase* sv;
    243243    if (bidirectional)
    244       sv = new SynchronisableVariableBidirectional<std::set<T> >(variable, mode, cb);
     244      sv = new SynchronisableVariableBidirectional<std::set<T>>(variable, mode, cb);
    245245    else
    246       sv = new SynchronisableVariable<std::set<T> >(variable, mode, cb);
     246      sv = new SynchronisableVariable<std::set<T>>(variable, mode, cb);
    247247    syncList_.push_back(sv);
    248248    stringList_.push_back(sv);
     
    250250
    251251  template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
    252 //   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T> >( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
     252//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T>>( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
    253253  template <> _NetworkExport void Synchronisable::unregisterVariable( std::string& variable );
    254254
  • code/branches/cpp11_v2/src/libraries/tools/TextureGenerator.cc

    r10546 r10769  
    7171namespace orxonox
    7272{
    73     std::map<std::string, std::map<ColourValue, std::string> > TextureGenerator::materials_s;
     73    std::map<std::string, std::map<ColourValue, std::string>> TextureGenerator::materials_s;
    7474    unsigned int TextureGenerator::materialCount_s = 0;
    7575
  • code/branches/cpp11_v2/src/libraries/tools/TextureGenerator.h

    r5781 r10769  
    5353        ~TextureGenerator();
    5454
    55         static std::map<std::string, std::map<ColourValue, std::string> > materials_s;
     55        static std::map<std::string, std::map<ColourValue, std::string>> materials_s;
    5656        static unsigned int materialCount_s;
    5757    };
  • code/branches/cpp11_v2/src/libraries/util/SharedPtr.h

    r10768 r10769  
    343343        For example the @c Functor classes: While a @c Functor* pointer would be managed by
    344344        @c SharedPtr<Functor>, the child class @c FunctorStatic is managed by the class
    345         <tt>SharedChildPtr<FunctorStatic, SharedPtr<Functor> ></tt>.
     345        <tt>SharedChildPtr<FunctorStatic, SharedPtr<Functor>></tt>.
    346346
    347347        The second template argument @a Parent is used as the parent class of
     
    351351        So for example this works:
    352352        @code
    353         SharedChildPtr<FunctorStatic, SharedPtr<Functor> > functorStatic = createFunctor(&MyClass::myStaticFunction);
     353        SharedChildPtr<FunctorStatic, SharedPtr<Functor>> functorStatic = createFunctor(&MyClass::myStaticFunction);
    354354        SharedPtr<Functor> functor = functorStatic;
    355355        @endcode
  • code/branches/cpp11_v2/src/modules/designtools/SkyboxGenerator.h

    r9667 r10769  
    106106           
    107107            std::vector<std::string> names_; //!< The names of the image files for the skybox faces to be generated.
    108             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.
     108            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.
    109109           
    110110            // Storage variables
  • code/branches/cpp11_v2/src/modules/mini4dgame/Mini4DgameAI.h

    r10230 r10769  
    8181        protected:
    8282
    83             std::list<std::pair<Timer*, char> > reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
     83            std::list<std::pair<Timer*, char>> reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
    8484            Mini4DgameCenterpoint* center_;
    8585
  • code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc

    r10765 r10769  
    208208        float distance;
    209209        bool humanItem;
    210         for( std::list<WeakPtr<Pawn> >::iterator current = pawnsIn_.begin(); current != pawnsIn_.end(); current++ )
     210        for( std::list<WeakPtr<Pawn>>::iterator current = pawnsIn_.begin(); current != pawnsIn_.end(); current++ )
    211211        {
    212212            Pawn* currentPawn = *current;
  • code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.h

    r9667 r10769  
    101101
    102102            // Variabeln::
    103             std::list<WeakPtr<Pawn> > pawnsIn_; //!< List of the pawns that this instance of SpaceBoundaries has to handle.
     103            std::list<WeakPtr<Pawn>> pawnsIn_; //!< List of the pawns that this instance of SpaceBoundaries has to handle.
    104104
    105105            std::vector<BillboardAdministration> billboards_;
  • code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.cc

    r10765 r10769  
    100100
    101101        // Check for objects that were in range but no longer are. Iterate through all objects, that are in range.
    102         for(std::set<WeakPtr<WorldEntity> >::iterator it = this->range_.begin(); it != this->range_.end(); )
     102        for(std::set<WeakPtr<WorldEntity>>::iterator it = this->range_.begin(); it != this->range_.end(); )
    103103        {
    104104            WorldEntity* entity = *it;
     
    261261    bool DistanceMultiTrigger::addToRange(WorldEntity* entity)
    262262    {
    263         std::pair<std::set<WeakPtr<WorldEntity> >::iterator, bool> pair = this->range_.insert(entity);
     263        std::pair<std::set<WeakPtr<WorldEntity>>::iterator, bool> pair = this->range_.insert(entity);
    264264        return pair.second;
    265265    }
  • code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.h

    r10624 r10769  
    153153            ClassTreeMask beaconMask_; //!< A mask, that only accepts DistanceTriggerBeacons.
    154154
    155             std::set<WeakPtr<WorldEntity> > range_; //!< The set of entities that currently are in range of the DistanceMultiTrigger.
     155            std::set<WeakPtr<WorldEntity>> range_; //!< The set of entities that currently are in range of the DistanceMultiTrigger.
    156156
    157157    };
  • code/branches/cpp11_v2/src/modules/objects/triggers/MultiTrigger.h

    r10765 r10769  
    192192            std::set<BaseObject*> triggered_; //!< The set of all objects the MultiTrigger is triggered for.
    193193
    194             std::deque< std::pair<float, MultiTriggerState*> > stateQueue_; //!< The queue of states waiting to become active.
     194            std::deque<std::pair<float, MultiTriggerState*>> stateQueue_; //!< The queue of states waiting to become active.
    195195
    196196            ClassTreeMask targetMask_; //!< The target mask, masking all objects that can trigger this MultiTrigger.
  • code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.h

    r9667 r10769  
    127127            BillboardSet debugBillboard_; //!< A set of debug billboards to visualize the state of the trigger.
    128128
    129             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.
     129            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.
    130130    };
    131131
  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.cc

    r10768 r10769  
    187187        const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
    188188
    189         for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
     189        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
    190190        listIt->second = (int)((listIt->first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
    191191
     
    209209        bool nextHasToBeSelected = false;
    210210
    211         for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++markerCount, ++listIt)
     211        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++markerCount, ++listIt)
    212212        {
    213213
     
    641641        }
    642642
    643         for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
     643        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
    644644        {
    645645            if ((listIt->first) == viewable)
  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.h

    r10291 r10769  
    141141
    142142            std::map<RadarViewable*, ObjectInfo> activeObjectList_;
    143             std::list<std::pair<RadarViewable*, unsigned int> > sortedObjectList_;
     143            std::list<std::pair<RadarViewable*, unsigned int>> sortedObjectList_;
    144144
    145145            float healthMarkerSize_;
  • code/branches/cpp11_v2/src/modules/pickup/PickupManager.h

    r10624 r10769  
    161161            std::map<uint32_t, PickupInventoryContainer*>::iterator pickupsIterator_; //!< An iterator pointing to the current Pickupable in pickupsList_.
    162162
    163             std::map<uint32_t, WeakPtr<Pickupable> > pickups_; //!< Map linking a number identifying a Pickupable to a weak pointer of a Pickupable.
     163            std::map<uint32_t, WeakPtr<Pickupable>> pickups_; //!< Map linking a number identifying a Pickupable to a weak pointer of a Pickupable.
    164164            std::map<Pickupable*, uint32_t> indexes_;//!< Map linking Pickupable to the number identifying it.
    165165
  • code/branches/cpp11_v2/src/modules/pickup/items/ShrinkPickup.cc

    r10765 r10769  
    182182
    183183                // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
    184                 const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
     184                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
    185185                int size = cameraPositions.size();
    186186                for(int index = 0; index < size; index++)
     
    208208
    209209                // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
    210                 const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
     210                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
    211211                int size = cameraPositions.size();
    212212                for(int index = 0; index < size; index++)
     
    263263
    264264                // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
    265                 const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
     265                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
    266266                int size = cameraPositions.size();
    267267                for(int index = 0; index < size; index++)
     
    304304
    305305                // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
    306                 const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
     306                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
    307307                int size = cameraPositions.size();
    308308                for(int index = 0; index < size; index++)
  • code/branches/cpp11_v2/src/modules/pong/PongAI.cc

    r10768 r10769  
    7777    PongAI::~PongAI()
    7878    {
    79         for (std::list<std::pair<Timer*, char> >::iterator it = this->reactionTimers_.begin(); it != this->reactionTimers_.end(); ++it)
     79        for (std::list<std::pair<Timer*, char>>::iterator it = this->reactionTimers_.begin(); it != this->reactionTimers_.end(); ++it)
    8080            it->first->destroy();
    8181    }
  • code/branches/cpp11_v2/src/modules/pong/PongAI.h

    r9667 r10769  
    8989            float strength_; //!< The strength of the AI. Ranging from 0 to 1.
    9090
    91             std::list<std::pair<Timer*, char> > reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
     91            std::list<std::pair<Timer*, char>> reactionTimers_; //!< A list of reaction timers and the directions that take effect when their timer expires.
    9292            char movement_; //!< The planned movement.
    9393            char oldMove_; //!< The previous movement.
  • code/branches/cpp11_v2/src/modules/tetris/Tetris.cc

    r10768 r10769  
    104104        }
    105105
    106         for (std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
     106        for (std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
    107107            (*it)->destroy();
    108108        this->stones_.clear();
     
    136136            return false;
    137137
    138         for(std::list<StrongPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
     138        for(std::list<StrongPtr<TetrisStone>>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
    139139        {
    140140            const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
     
    192192
    193193        // check for collisions with all stones
    194         for(std::list<StrongPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
     194        for(std::list<StrongPtr<TetrisStone>>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
    195195        {
    196196            //Vector3 currentStonePosition = rotateVector((*it)->getPosition(), this->activeBrick_->getRotationCount());
     
    469469        {
    470470            stonesPerRow = 0;
    471             for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
    472             {
    473                 std::list<StrongPtr<TetrisStone> >::iterator it_temp = it++;
     471            for(std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); )
     472            {
     473                std::list<StrongPtr<TetrisStone>>::iterator it_temp = it++;
    474474                correctPosition = static_cast<unsigned int>(((*it_temp)->getPosition().y - 5)/this->center_->getStoneSize());
    475475                if(correctPosition == row)
     
    491491    void Tetris::clearRow(unsigned int row)
    492492    {// clear the full row
    493         for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
     493        for(std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); )
    494494        {
    495495            if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) == row)
     
    502502        }
    503503      // adjust height of stones above the deleted row //TODO: check if this could be a source of a bug.
    504         for(std::list<StrongPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
     504        for(std::list<StrongPtr<TetrisStone>>::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
    505505        {
    506506            if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) > row)
  • code/branches/cpp11_v2/src/modules/tetris/Tetris.h

    r10624 r10769  
    9393
    9494            WeakPtr<TetrisCenterpoint> center_; //!< The playing field.
    95             std::list<StrongPtr<TetrisStone> > stones_; //!< A list of all stones in play.
     95            std::list<StrongPtr<TetrisStone>> stones_; //!< A list of all stones in play.
    9696            WeakPtr<TetrisBrick> activeBrick_;
    9797            WeakPtr<TetrisBrick> futureBrick_;
  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefense.cc

    r10765 r10769  
    287287        }
    288288       
    289         for (std::list<WeakPtr<TowerDefenseEnemy> >::iterator it = enemies_.begin(); it != enemies_.end(); )
     289        for (std::list<WeakPtr<TowerDefenseEnemy>>::iterator it = enemies_.begin(); it != enemies_.end(); )
    290290        {
    291291            if (*it == nullptr)
  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefense.h

    r10629 r10769  
    8787        int waveNumber_;
    8888        int lifes_;
    89         std::list<orxonox::WeakPtr<TowerDefenseEnemy> > enemies_;
     89        std::list<orxonox::WeakPtr<TowerDefenseEnemy>> enemies_;
    9090        TowerDefenseField* fields_[16][16];
    91         std::vector<orxonox::WeakPtr<TowerDefenseField> > waypoints_;
     91        std::vector<orxonox::WeakPtr<TowerDefenseField>> waypoints_;
    9292        Vector3 endpoint_;
    9393        Vector3 offset_;       
  • code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.h

    r9667 r10769  
    8989
    9090            //WAYPOINT DATA
    91             std::vector<WeakPtr<WorldEntity> > waypoints_;
     91            std::vector<WeakPtr<WorldEntity>> waypoints_;
    9292            size_t currentWaypoint_;
    9393            float squaredaccuracy_;
  • code/branches/cpp11_v2/src/orxonox/infos/PlayerInfo.h

    r10624 r10769  
    9999            Controller* controller_;
    100100            ControllableEntity* controllableEntity_;
    101             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.
     101            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.
    102102            unsigned int controllableEntityID_;
    103103
  • code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc

    r10768 r10769  
    6262    OverlayGroup::~OverlayGroup()
    6363    {
    64         for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
     64        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
    6565            (*it)->destroy();
    6666        this->hudElements_.clear();
     
    8686    void OverlayGroup::setScale(const Vector2& scale)
    8787    {
    88         for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
     88        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
    8989            (*it)->scale(scale / this->scale_);
    9090        this->scale_ = scale;
     
    9494    void OverlayGroup::setScroll(const Vector2& scroll)
    9595    {
    96         for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
     96        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
    9797            (*it)->scroll(scroll - this->scroll_);
    9898        this->scroll_ = scroll;
     
    133133        if (index < this->hudElements_.size())
    134134        {
    135             std::set< StrongPtr<OrxonoxOverlay> >::const_iterator it = hudElements_.begin();
     135            std::set<StrongPtr<OrxonoxOverlay>>::const_iterator it = hudElements_.begin();
    136136            for (unsigned int i = 0; i != index; ++it, ++i)
    137137                ;
     
    147147        SUPER( OverlayGroup, changedVisibility );
    148148
    149         for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
     149        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
    150150            (*it)->changedVisibility(); //inform all Child Overlays that our visibility has changed
    151151    }
     
    155155        this->owner_ = owner;
    156156
    157         for (std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
     157        for (std::set<StrongPtr<OrxonoxOverlay>>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
    158158            (*it)->setOwner(owner);
    159159    }
  • code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.h

    r10624 r10769  
    6565        static void scrollGroup(const std::string& name, const Vector2& scroll);
    6666
    67         inline const std::set< StrongPtr<OrxonoxOverlay> >& getOverlays() const
     67        inline const std::set<StrongPtr<OrxonoxOverlay>>& getOverlays() const
    6868            { return this->hudElements_; }
    6969
     
    9191
    9292    private:
    93         std::set< StrongPtr<OrxonoxOverlay> > hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
     93        std::set<StrongPtr<OrxonoxOverlay>> hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
    9494        Vector2 scale_;                            //!< Current scale (independent of the elements).
    9595        Vector2 scroll_;                           //!< Current scrolling offset.
  • code/branches/cpp11_v2/src/orxonox/sound/SoundBuffer.cc

    r10765 r10769  
    3939namespace orxonox
    4040{
    41     SoundBuffer::SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer> >::iterator poolIterator)
     41    SoundBuffer::SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer>>::iterator poolIterator)
    4242        : filename_(filename)
    4343        , audioBuffer_(AL_NONE)
  • code/branches/cpp11_v2/src/orxonox/sound/SoundBuffer.h

    r10624 r10769  
    6464
    6565    private:
    66         SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer> >::iterator poolIterator);
     66        SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer>>::iterator poolIterator);
    6767#if !defined(_MSC_VER) || _MSC_VER >= 1500
    6868        ~SoundBuffer();
     
    7373        std::string filename_;
    7474        ALuint audioBuffer_;
    75         std::list<shared_ptr<SoundBuffer> >::iterator poolIterator_;
     75        std::list<shared_ptr<SoundBuffer>>::iterator poolIterator_;
    7676    };
    7777}
  • code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc

    r10765 r10769  
    422422    {
    423423        // If we're already fading out --> remove that
    424         for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
     424        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
    425425        {
    426426            if (*it == sound)
     
    438438    {
    439439        // If we're already fading in --> remove that
    440         for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
     440        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
    441441        {
    442442            if (*it == sound)
     
    461461
    462462        // FADE IN
    463         for (std::list<StrongPtr<AmbientSound> >::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
     463        for (std::list<StrongPtr<AmbientSound>>::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
    464464        {
    465465            if ((*it)->getVolume() + this->crossFadeStep_*dt > 1.0f)
     
    476476
    477477        // FADE OUT
    478         for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
     478        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
    479479        {
    480480            if ((*it)->getVolume() - this->crossFadeStep_*dt < 0.0f)
     
    606606#endif
    607607        this->availableSoundSources_.push_back(source);
    608         for (std::vector<std::pair<ALuint, BaseSound*> >::iterator it = this->usedSoundSources_.begin();
     608        for (std::vector<std::pair<ALuint, BaseSound*>>::iterator it = this->usedSoundSources_.begin();
    609609            it != this->usedSoundSources_.end(); ++it)
    610610        {
  • code/branches/cpp11_v2/src/orxonox/sound/SoundManager.h

    r10624 r10769  
    125125
    126126        // Ambient sound related
    127         typedef std::list<std::pair<AmbientSound*, bool> > AmbientList;
     127        typedef std::list<std::pair<AmbientSound*, bool>> AmbientList;
    128128        AmbientList                        ambientSounds_;
    129129        //! Absolute change per second (0.1 means 10% of the nominal volume) for cross fading
    130130        float                              crossFadeStep_;
    131         std::list<StrongPtr<AmbientSound> > fadeInList_;
    132         std::list<StrongPtr<AmbientSound> > fadeOutList_;
     131        std::list<StrongPtr<AmbientSound>> fadeInList_;
     132        std::list<StrongPtr<AmbientSound>> fadeOutList_;
    133133
    134134        // Volume related
     
    139139        static const unsigned int maxEffectsPoolSize_s = 40 * 1024 * 1024;
    140140        unsigned int effectsPoolSize_;
    141         typedef std::list<shared_ptr<SoundBuffer> > EffectsPoolList;
     141        typedef std::list<shared_ptr<SoundBuffer>> EffectsPoolList;
    142142        EffectsPoolList effectsPool_;
    143         typedef std::map<std::string, shared_ptr<SoundBuffer> > SoundBufferMap;
     143        typedef std::map<std::string, shared_ptr<SoundBuffer>> SoundBufferMap;
    144144        SoundBufferMap soundBuffers_;
    145145
     
    148148        unsigned int maxSources_;
    149149        std::vector<ALuint> availableSoundSources_;
    150         std::vector<std::pair<ALuint, BaseSound*> > usedSoundSources_;
     150        std::vector<std::pair<ALuint, BaseSound*>> usedSoundSources_;
    151151
    152152        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

    r10768 r10769  
    108108                this->camera_->destroy();
    109109
    110             for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
     110            for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
    111111                (*it)->destroy();
    112112
     
    165165    {
    166166        unsigned int i = 0;
    167         for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
     167        for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
    168168        {
    169169            if (i == index)
     
    180180
    181181        unsigned int counter = 0;
    182         for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
     182        for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
    183183        {
    184184            if ((*it) == this->currentCameraPosition_)
     
    219219            else if (this->cameraPositions_.size() > 0)
    220220            {
    221                 for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
     221                for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
    222222                {
    223223                    if ((*it) == this->camera_->getParent())
     
    477477        if (parent)
    478478        {
    479             for (std::list<StrongPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
     479            for (std::list<StrongPtr<CameraPosition>>::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
    480480                if ((*it)->getIsAbsolute())
    481481                    parent->attach((*it));
  • code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.h

    r10624 r10769  
    121121            void addCameraPosition(CameraPosition* position);
    122122            CameraPosition* getCameraPosition(unsigned int index) const;
    123             inline const std::list<StrongPtr<CameraPosition> >& getCameraPositions() const
     123            inline const std::list<StrongPtr<CameraPosition>>& getCameraPositions() const
    124124                { return this->cameraPositions_; }
    125125            unsigned int getCurrentCameraIndex() const;
     
    242242            bool bMouseLook_;
    243243            float mouseLookSpeed_;
    244             std::list<StrongPtr<CameraPosition> > cameraPositions_;
     244            std::list<StrongPtr<CameraPosition>> cameraPositions_;
    245245            CameraPosition* currentCameraPosition_;
    246246            std::string cameraPositionTemplate_;
  • code/branches/cpp11_v2/test/util/SharedPtrTest.cc

    r10768 r10769  
    178178
    179179        SharedPtr<TestClass> test = pointer;
    180         std::vector<SharedPtr<TestClass> > tests;
     180        std::vector<SharedPtr<TestClass>> tests;
    181181        for (size_t i = 0; i < 100; ++i)
    182182            tests.push_back(SharedPtr<TestClass>(test));
Note: See TracChangeset for help on using the changeset viewer.