Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/core/Identifier.h @ 6417

Last change on this file since 6417 was 6417, checked in by rgrieder, 14 years ago

Merged presentation2 branch back to trunk.
Major new features:

  • Actual GUI with settings, etc.
  • Improved space ship steering (human interaction)
  • Rocket fire and more particle effects
  • Advanced sound framework
  • Property svn:eol-style set to native
File size: 29.4 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @file
31    @brief Definition of the Identifier class, definition and implementation of the ClassIdentifier class.
32
33    The Identifier contains all needed information about the class it belongs to:
34     - the name
35     - a list with all objects
36     - parents and children
37     - the factory (if available)
38     - the networkID that can be synchronised with the server
39     - all configurable variables (if available)
40
41    Every object has a pointer to the Identifier of its class. This allows the use isA(...),
42    isExactlyA(...), isChildOf(...) and isParentOf(...).
43
44    To create the class-hierarchy, the Identifier has some intern functions and variables.
45
46    Every Identifier is in fact a ClassIdentifier, but they are derived from Identifier.
47*/
48
49#ifndef _Identifier_H__
50#define _Identifier_H__
51
52#include "CorePrereqs.h"
53
54#include <cassert>
55#include <map>
56#include <set>
57#include <string>
58#include <typeinfo>
59
60#include "util/Debug.h"
61#include "util/TypeTraits.h"
62#include "MetaObjectList.h"
63#include "ObjectList.h"
64#include "ObjectListBase.h"
65#include "Super.h"
66
67namespace orxonox
68{
69    // ###############################
70    // ###       Identifier        ###
71    // ###############################
72    //! The Identifier is used to identify the class of an object and to store information about the class.
73    /**
74        The Identifier contains all needed information about the class it belongs to:
75         - the name
76         - a list with all objects
77         - parents and children
78         - the factory (if available)
79         - the networkID that can be synchronised with the server
80         - all configurable variables (if available)
81
82        Every object has a pointer to the Identifier of its class. This allows the use isA(...),
83        isExactlyA(...), isChildOf(...) and isParentOf(...).
84
85        You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
86    */
87    class _CoreExport Identifier
88    {
89        public:
90            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
91            inline const std::string& getName() const { return this->name_; }
92            void setName(const std::string& name);
93
94            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
95            inline const uint32_t getNetworkID() const { return this->networkID_; }
96            void setNetworkID(uint32_t id);
97
98            /** @brief Returns the unique ID of the class */
99            FORCEINLINE unsigned int getClassID() const { return this->classID_; }
100
101            /** @brief Returns the list of all existing objects of this class. @return The list */
102            inline ObjectListBase* getObjects() const { return this->objects_; }
103
104            /** @brief Sets the Factory. @param factory The factory to assign */
105            inline void addFactory(Factory* factory) { this->factory_ = factory; }
106            /** @brief Returns true if the Identifier has a Factory. */
107            inline bool hasFactory() const { return (this->factory_ != 0); }
108
109            BaseObject* fabricate(BaseObject* creator);
110
111            /** @brief Returns true if the class can be loaded through XML. */
112            inline bool isLoadable() const { return this->bLoadable_; }
113            /** @brief Set the class to be loadable through XML or not. */
114            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
115
116            bool isA(const Identifier* identifier) const;
117            bool isExactlyA(const Identifier* identifier) const;
118            bool isChildOf(const Identifier* identifier) const;
119            bool isDirectChildOf(const Identifier* identifier) const;
120            bool isParentOf(const Identifier* identifier) const;
121            bool isDirectParentOf(const Identifier* identifier) const;
122
123
124            /////////////////////////////
125            ////// Class Hierarchy //////
126            /////////////////////////////
127            static void createClassHierarchy();
128
129            /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
130            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
131
132            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
133            inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
134            /** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
135            inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
136            /** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
137            inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
138
139            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
140            inline const std::set<const Identifier*>& getChildren() const { return this->children_; }
141            /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
142            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_.begin(); }
143            /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
144            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_.end(); }
145
146            /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
147            inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
148            /** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
149            inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
150            /** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
151            inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
152
153            /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
154            inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
155            /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
156            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_.begin(); }
157            /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
158            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
159
160
161            //////////////////////////
162            ///// Identifier Map /////
163            //////////////////////////
164            static void destroyAllIdentifiers();
165
166            static Identifier* getIdentifierByString(const std::string& name);
167            static Identifier* getIdentifierByLowercaseString(const std::string& name);
168            static Identifier* getIdentifierByID(uint32_t id);
169
170            static void clearNetworkIDs();
171
172            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
173            static inline const std::map<std::string, Identifier*>& getStringIdentifierMap() { return Identifier::getStringIdentifierMapIntern(); }
174            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names. @return The const_iterator */
175            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin() { return Identifier::getStringIdentifierMap().begin(); }
176            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names. @return The const_iterator */
177            static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd() { return Identifier::getStringIdentifierMap().end(); }
178
179            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
180            static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap() { return Identifier::getLowercaseStringIdentifierMapIntern(); }
181            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
182            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin() { return Identifier::getLowercaseStringIdentifierMap().begin(); }
183            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
184            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd() { return Identifier::getLowercaseStringIdentifierMap().end(); }
185
186            /** @brief Returns the map that stores all Identifiers with their IDs. @return The map */
187            static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap() { return Identifier::getIDIdentifierMapIntern(); }
188            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs. @return The const_iterator */
189            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin() { return Identifier::getIDIdentifierMap().begin(); }
190            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their IDs. @return The const_iterator */
191            static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd() { return Identifier::getIDIdentifierMap().end(); }
192
193
194            /////////////////////////
195            ///// Config Values /////
196            /////////////////////////
197            virtual void updateConfigValues(bool updateChildren = true) const = 0;
198
199            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
200            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
201
202            /** @brief Returns the map that stores all config values. @return The const_iterator */
203            inline const std::map<std::string, ConfigValueContainer*>& getConfigValueMap() const { return this->configValues_; }
204            /** @brief Returns a const_iterator to the beginning of the map that stores all config values. @return The const_iterator */
205            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapBegin() const { return this->configValues_.begin(); }
206            /** @brief Returns a const_iterator to the end of the map that stores all config values. @return The const_iterator */
207            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapEnd() const { return this->configValues_.end(); }
208
209            /** @brief Returns the map that stores all config values with their names in lowercase. @return The const_iterator */
210            inline const std::map<std::string, ConfigValueContainer*>& getLowercaseConfigValueMap() const { return this->configValues_LC_; }
211            /** @brief Returns a const_iterator to the beginning of the map that stores all config values with their names in lowercase. @return The const_iterator */
212            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapBegin() const { return this->configValues_LC_.begin(); }
213            /** @brief Returns a const_iterator to the end of the map that stores all config values with their names in lowercase. @return The const_iterator */
214            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
215
216            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
217            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
218            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
219
220
221            ////////////////////////////
222            ///// Console Commands /////
223            ////////////////////////////
224            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
225            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
226
227            /** @brief Returns the map that stores all console commands. @return The const_iterator */
228            inline const std::map<std::string, ConsoleCommand*>& getConsoleCommandMap() const { return this->consoleCommands_; }
229            /** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
230            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
231            /** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
232            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
233
234            /** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
235            inline const std::map<std::string, ConsoleCommand*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
236            /** @brief Returns a const_iterator to the beginning of the map that stores all console commands with their names in lowercase. @return The const_iterator */
237            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
238            /** @brief Returns a const_iterator to the end of the map that stores all console commands with their names in lowercase. @return The const_iterator */
239            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
240
241            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
242            ConsoleCommand* getConsoleCommand(const std::string& name) const;
243            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
244
245
246            ///////////////////
247            ///// XMLPort /////
248            ///////////////////
249            /** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
250            inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
251            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort params. @return The const_iterator */
252            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
253            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort params. @return The const_iterator */
254            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
255
256            /** @brief Returns the map that stores all XMLPort objects. @return The const_iterator */
257            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
258            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort objects. @return The const_iterator */
259            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
260            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort objects. @return The const_iterator */
261            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
262
263            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
264            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
265
266            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
267            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
268
269
270        protected:
271            Identifier();
272            Identifier(const Identifier& identifier); // don't copy
273            virtual ~Identifier();
274
275            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
276            virtual void createSuperFunctionCaller() const = 0;
277
278            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
279
280            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
281            static std::map<std::string, Identifier*>& getStringIdentifierMapIntern();
282            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
283            static std::map<std::string, Identifier*>& getLowercaseStringIdentifierMapIntern();
284            /** @brief Returns the map that stores all Identifiers with their network IDs. @return The map */
285            static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
286
287            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
288            inline std::set<const Identifier*>& getChildrenIntern() const { return this->children_; }
289            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
290            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return this->directChildren_; }
291
292            ObjectListBase* objects_;                                      //!< The list of all objects of this class
293
294        private:
295            /** @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents. */
296            inline static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; }
297            /** @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents. */
298            inline static void stopCreatingHierarchy()  { hierarchyCreatingCounter_s--; }
299
300            static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
301
302            void initialize(std::set<const Identifier*>* parents);
303
304            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
305            mutable std::set<const Identifier*> children_;                 //!< The children of the class the Identifier belongs to
306
307            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
308            mutable std::set<const Identifier*> directChildren_;           //!< The direct children of the class the Identifier belongs to
309
310            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
311            bool bSetName_;                                                //!< True if the name is set
312            bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
313            std::string name_;                                             //!< The name of the class the Identifier belongs to
314            Factory* factory_;                                             //!< The Factory, able to create new objects of the given class (if available)
315            static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
316            uint32_t networkID_;                                           //!< The network ID to identify a class through the network
317            const unsigned int classID_;                                   //!< Uniquely identifies a class (might not be the same as the networkID_)
318            static unsigned int classIDCounter_s;                          //!< Static counter for the unique classIDs
319
320            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
321            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
322            std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
323
324            bool bHasConsoleCommands_;                                     //!< True if this class has at least one assigned console command
325            std::map<std::string, ConsoleCommand*> consoleCommands_;       //!< All console commands of this class
326            std::map<std::string, ConsoleCommand*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
327
328            std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
329            std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
330    };
331
332    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
333
334
335    // ###############################
336    // ###     ClassIdentifier     ###
337    // ###############################
338    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
339    /**
340        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
341        This makes it possible to store information about a class, sharing them with all
342        objects of that class without defining static variables in every class.
343
344        To be really sure that not more than exactly one object exists (even with libraries),
345        ClassIdentifiers are stored in the Identifier Singleton.
346    */
347    template <class T>
348    class ClassIdentifier : public Identifier
349    {
350        #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
351        #include "Super.h"
352
353        public:
354            static ClassIdentifier<T>* getIdentifier();
355            static ClassIdentifier<T>* getIdentifier(const std::string& name);
356
357            bool initialiseObject(T* object, const std::string& className, bool bRootClass);
358
359            void updateConfigValues(bool updateChildren = true) const;
360
361        private:
362            static void initialiseIdentifier();
363            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
364            ClassIdentifier()
365            {
366                SuperFunctionInitialization<0, T>::initialize(this);
367            }
368            ~ClassIdentifier()
369            {
370                SuperFunctionDestruction<0, T>::destroy(this);
371            }
372
373            static ClassIdentifier<T>* classIdentifier_s;
374    };
375
376    template <class T>
377    ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
378
379    /**
380        @brief Returns the only instance of this class.
381        @return The unique Identifier
382    */
383    template <class T>
384    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
385    {
386        // check if the Identifier already exists
387        if (!ClassIdentifier<T>::classIdentifier_s)
388            ClassIdentifier<T>::initialiseIdentifier();
389
390        return ClassIdentifier<T>::classIdentifier_s;
391    }
392
393    /**
394        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
395        @param name The name of this Identifier
396        @return The Identifier
397    */
398    template <class T>
399    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
400    {
401        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
402        identifier->setName(name);
403        return identifier;
404    }
405
406    /**
407        @brief Assigns the static field for the identifier singleton.
408    */
409    template <class T>
410    void ClassIdentifier<T>::initialiseIdentifier()
411    {
412        // Get the name of the class
413        const std::string& name = typeid(T).name();
414
415        // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
416        ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
417
418        // Get the entry from the map
419        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
420
421        if (ClassIdentifier<T>::classIdentifier_s == proposal)
422        {
423            COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
424        }
425        else
426        {
427            COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
428        }
429    }
430
431    /**
432        @brief Adds an object of the given type to the ObjectList.
433        @param object The object to add
434    */
435    template <class T>
436    bool ClassIdentifier<T>::initialiseObject(T* object, const std::string& className, bool bRootClass)
437    {
438        if (bRootClass)
439            COUT(5) << "*** Register Root-Object: " << className << std::endl;
440        else
441            COUT(5) << "*** Register Object: " << className << std::endl;
442
443        object->identifier_ = this;
444        if (Identifier::isCreatingHierarchy())
445        {
446            if (bRootClass && !object->parents_)
447                object->parents_ = new std::set<const Identifier*>();
448
449            if (object->parents_)
450            {
451                this->initializeClassHierarchy(object->parents_, bRootClass);
452                object->parents_->insert(object->parents_->end(), this);
453            }
454
455            object->setConfigValues();
456            return true;
457        }
458        else
459        {
460            COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
461            object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
462
463            // Add pointer of type T to the map in the OrxonoxClass instance that enables "dynamic_casts"
464            object->objectPointers_.push_back(std::make_pair(this->getClassID(), static_cast<void*>(object)));
465            return false;
466        }
467    }
468
469    /**
470        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
471    */
472    template <class T>
473    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
474    {
475        if (!this->hasConfigValues())
476            return;
477
478        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
479            it->setConfigValues();
480
481        if (updateChildren)
482            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
483                (*it)->updateConfigValues(false);
484    }
485
486
487    // ###############################
488    // ###      orxonox_cast       ###
489    // ###############################
490    /**
491    @brief
492        Casts on object of type OrxonoxClass to any derived type that is
493        registered in the class hierarchy.
494    @return
495        Returns NULL if the cast is not possible
496    @note
497        In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
498        a class forgot to register its objects.
499        Also note that the function is implemented differently for GCC/MSVC.
500    */
501    template <class T, class U>
502    FORCEINLINE T orxonox_cast(U source)
503    {
504#ifdef ORXONOX_COMPILER_MSVC
505        typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
506        if (source != NULL)
507            return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
508        else
509            return NULL;
510#else
511        return dynamic_cast<T>(source);
512#endif
513    }
514}
515
516#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.