Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/libraries2/src/core/Identifier.h @ 5704

Last change on this file since 5704 was 5695, checked in by rgrieder, 15 years ago

Merged resource2 branch back to trunk.

IMPORTANT NOTE:
Upon this merge you need to specifically call your data directory "data_extern" when checking it out (when you don't provide a name, it will be just called 'trunk').
The new CMake variable is EXTERNAL_DATA_DIRECTORY. DATA_DIRECTORY now points to the one the source part of the repository.
UPDATE YOUR DATA DIRECTORY AS WELL!!!

  • Property svn:eol-style set to native
File size: 35.9 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, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
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    SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
49    You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
50*/
51
52#ifndef _Identifier_H__
53#define _Identifier_H__
54
55#include "CorePrereqs.h"
56
57#include <cassert>
58#include <map>
59#include <set>
60#include <string>
61#include <typeinfo>
62
63#include "util/Debug.h"
64#include "util/TypeTraits.h"
65#include "MetaObjectList.h"
66#include "ObjectList.h"
67#include "ObjectListBase.h"
68#include "Super.h"
69
70namespace orxonox
71{
72    // ###############################
73    // ###       Identifier        ###
74    // ###############################
75    //! The Identifier is used to identify the class of an object and to store information about the class.
76    /**
77        The Identifier contains all needed information about the class it belongs to:
78         - the name
79         - a list with all objects
80         - parents and children
81         - the factory (if available)
82         - the networkID that can be synchronised with the server
83         - all configurable variables (if available)
84
85        Every object has a pointer to the Identifier of its class. This allows the use isA(...),
86        isExactlyA(...), isChildOf(...) and isParentOf(...).
87
88        You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
89    */
90    class _CoreExport Identifier
91    {
92        template <class T>
93        friend class SubclassIdentifier;
94
95        friend class Factory;
96
97        public:
98            /** @brief Sets the Factory. @param factory The factory to assign */
99            inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
100
101            BaseObject* fabricate(BaseObject* creator);
102            bool isA(const Identifier* identifier) const;
103            bool isExactlyA(const Identifier* identifier) const;
104            bool isChildOf(const Identifier* identifier) const;
105            bool isDirectChildOf(const Identifier* identifier) const;
106            bool isParentOf(const Identifier* identifier) const;
107            bool isDirectParentOf(const Identifier* identifier) const;
108
109            /** @brief Returns true if the class can be loaded through XML. */
110            inline bool isLoadable() const { return this->bLoadable_; }
111            /** @brief Set the class to be loadable through XML or not. */
112            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
113
114            /** @brief Returns the list of all existing objects of this class. @return The list */
115            inline ObjectListBase* getObjects() const
116                { return this->objects_; }
117
118            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
119            inline const std::string& getName() const { return this->name_; }
120            void setName(const std::string& name);
121
122            virtual void updateConfigValues(bool updateChildren = true) const = 0;
123
124            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
125            inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
126            /** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
127            inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
128            /** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
129            inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
130
131            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
132            inline const std::set<const Identifier*>& getChildren() const { return (*this->children_); }
133            /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
134            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
135            /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
136            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
137
138            /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
139            inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
140            /** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
141            inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
142            /** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
143            inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
144
145            /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
146            inline const std::set<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
147            /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
148            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
149            /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
150            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
151
152
153            /** @brief Returns the map that stores all Identifiers. @return The map */
154            static inline const std::map<std::string, Identifier*>& getIdentifierMap() { return Identifier::getIdentifierMapIntern(); }
155            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers. @return The const_iterator */
156            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapBegin() { return Identifier::getIdentifierMap().begin(); }
157            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers. @return The const_iterator */
158            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapEnd() { return Identifier::getIdentifierMap().end(); }
159
160            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
161            static inline const std::map<std::string, Identifier*>& getLowercaseIdentifierMap() { return Identifier::getLowercaseIdentifierMapIntern(); }
162            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
163            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapBegin() { return Identifier::getLowercaseIdentifierMap().begin(); }
164            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
165            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapEnd() { return Identifier::getLowercaseIdentifierMap().end(); }
166
167
168            /** @brief Returns the map that stores all config values. @return The const_iterator */
169            inline const std::map<std::string, ConfigValueContainer*>& getConfigValueMap() const { return this->configValues_; }
170            /** @brief Returns a const_iterator to the beginning of the map that stores all config values. @return The const_iterator */
171            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapBegin() const { return this->configValues_.begin(); }
172            /** @brief Returns a const_iterator to the end of the map that stores all config values. @return The const_iterator */
173            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapEnd() const { return this->configValues_.end(); }
174
175            /** @brief Returns the map that stores all config values with their names in lowercase. @return The const_iterator */
176            inline const std::map<std::string, ConfigValueContainer*>& getLowercaseConfigValueMap() const { return this->configValues_LC_; }
177            /** @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 */
178            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapBegin() const { return this->configValues_LC_.begin(); }
179            /** @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 */
180            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
181
182
183            /** @brief Returns the map that stores all console commands. @return The const_iterator */
184            inline const std::map<std::string, ConsoleCommand*>& getConsoleCommandMap() const { return this->consoleCommands_; }
185            /** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
186            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
187            /** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
188            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
189
190            /** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
191            inline const std::map<std::string, ConsoleCommand*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
192            /** @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 */
193            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
194            /** @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 */
195            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
196
197            /** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
198            inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
199            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort params. @return The const_iterator */
200            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
201            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort params. @return The const_iterator */
202            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
203
204            /** @brief Returns the map that stores all XMLPort objects. @return The const_iterator */
205            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
206            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort objects. @return The const_iterator */
207            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
208            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort objects. @return The const_iterator */
209            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
210
211            /** @brief Returns the map that stores all XMLPort events. @return The const_iterator */
212            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortEventMap() const { return this->xmlportEventContainers_; }
213            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort events. @return The const_iterator */
214            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapBegin() const { return this->xmlportEventContainers_.begin(); }
215            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort events. @return The const_iterator */
216            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapEnd() const { return this->xmlportEventContainers_.end(); }
217
218            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
219            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
220            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
221            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
222
223            /** @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 */
224            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
225
226            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
227            inline const uint32_t getNetworkID() const { return this->networkID_; }
228
229            /** @brief Sets the network ID to a new value. @param id The new value */
230            void setNetworkID(uint32_t id);
231
232            /** @brief Returns the unique ID of the class */
233            FORCEINLINE unsigned int getClassID() const { return this->classID_; }
234
235            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
236            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
237            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
238
239            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
240            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
241
242            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
243            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
244
245            void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
246            XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
247
248            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
249            ConsoleCommand* getConsoleCommand(const std::string& name) const;
250            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
251
252            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
253
254            static void destroyAllIdentifiers();
255
256        protected:
257            Identifier();
258            Identifier(const Identifier& identifier); // don't copy
259            virtual ~Identifier();
260
261            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
262            virtual void createSuperFunctionCaller() const = 0;
263
264            /** @brief Returns the map that stores all Identifiers. @return The map */
265            static std::map<std::string, Identifier*>& getIdentifierMapIntern();
266            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
267            static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
268
269            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
270            inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
271            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
272            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
273
274            ObjectListBase* objects_;                                      //!< The list of all objects of this class
275
276        private:
277            /**
278                @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
279            */
280            inline static void startCreatingHierarchy()
281            {
282                hierarchyCreatingCounter_s++;
283                COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
284            }
285
286            /**
287                @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
288            */
289            inline static void stopCreatingHierarchy()
290            {
291                hierarchyCreatingCounter_s--;
292                COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
293            }
294
295            static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
296
297            void initialize(std::set<const Identifier*>* parents);
298
299            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
300            std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
301
302            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
303            std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
304
305            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
306            bool bSetName_;                                                //!< True if the name is set
307            bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
308            std::string name_;                                             //!< The name of the class the Identifier belongs to
309            BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
310            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)
311            uint32_t networkID_;                                           //!< The network ID to identify a class through the network
312            const unsigned int classID_;                                   //!< Uniquely identifies a class (might not be the same as the networkID_)
313            static unsigned int classIDCounter_s;                          //!< Static counter for the unique classIDs
314
315            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
316            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
317            std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
318
319            bool bHasConsoleCommands_;                                     //!< True if this class has at least one assigned console command
320            std::map<std::string, ConsoleCommand*> consoleCommands_;       //!< All console commands of this class
321            std::map<std::string, ConsoleCommand*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
322
323            std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
324            std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
325            std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_;    //!< All events
326    };
327
328    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
329
330
331    // ###############################
332    // ###     ClassIdentifier     ###
333    // ###############################
334    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
335    /**
336        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
337        This makes it possible to store information about a class, sharing them with all
338        objects of that class without defining static variables in every class.
339
340        To be really sure that not more than exactly one object exists (even with libraries),
341        ClassIdentifiers are stored in the Identifier Singleton.
342    */
343    template <class T>
344    class ClassIdentifier : public Identifier
345    {
346        #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
347        #include "Super.h"
348
349        public:
350            static ClassIdentifier<T> *getIdentifier();
351            static ClassIdentifier<T> *getIdentifier(const std::string& name);
352
353            bool initialiseObject(T* object, const std::string& className, bool bRootClass);
354
355            void updateConfigValues(bool updateChildren = true) const;
356
357        private:
358            static void initialiseIdentifier();
359            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
360            ClassIdentifier()
361            {
362                SuperFunctionInitialization<0, T>::initialize(this);
363            }
364            ~ClassIdentifier()
365            {
366                SuperFunctionDestruction<0, T>::destroy(this);
367            }
368
369            static ClassIdentifier<T>* classIdentifier_s;
370    };
371
372    template <class T>
373    ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
374
375    /**
376        @brief Returns the only instance of this class.
377        @return The unique Identifier
378    */
379    template <class T>
380    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
381    {
382        // check if the static field has already been filled
383        if (ClassIdentifier<T>::classIdentifier_s == 0)
384            ClassIdentifier<T>::initialiseIdentifier();
385
386        return ClassIdentifier<T>::classIdentifier_s;
387    }
388
389    /**
390        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
391        @param name The name of this Identifier
392        @return The Identifier
393    */
394    template <class T>
395    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
396    {
397        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
398        identifier->setName(name);
399        return identifier;
400    }
401
402    /**
403        @brief Assigns the static field for the identifier singleton.
404    */
405    template <class T>
406    void ClassIdentifier<T>::initialiseIdentifier()
407    {
408        // Get the name of the class
409        std::string name = typeid(T).name();
410
411        // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
412        ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
413
414        // Get the entry from the map
415        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
416
417        if (ClassIdentifier<T>::classIdentifier_s == proposal)
418        {
419            COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
420        }
421        else
422        {
423            COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
424        }
425    }
426
427    /**
428        @brief Adds an object of the given type to the ObjectList.
429        @param object The object to add
430    */
431    template <class T>
432    bool ClassIdentifier<T>::initialiseObject(T* object, const std::string& className, bool bRootClass)
433    {
434        if (bRootClass)
435            COUT(5) << "*** Register Root-Object: " << className << std::endl;
436        else
437            COUT(5) << "*** Register Object: " << className << std::endl;
438
439        object->identifier_ = this;
440        if (Identifier::isCreatingHierarchy())
441        {
442            if (bRootClass && !object->parents_)
443                object->parents_ = new std::set<const Identifier*>();
444
445            if (object->parents_)
446            {
447                this->initializeClassHierarchy(object->parents_, bRootClass);
448                object->parents_->insert(object->parents_->end(), this);
449            }
450
451            object->setConfigValues();
452            return true;
453        }
454        else
455        {
456            COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
457            object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
458
459            // Add pointer of type T to the map in the OrxonoxClass instance that enables "dynamic_casts"
460            object->objectPointers_.push_back(std::make_pair(this->getClassID(), static_cast<void*>(object)));
461            return false;
462        }
463    }
464
465    /**
466        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
467    */
468    template <class T>
469    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
470    {
471        if (!this->hasConfigValues())
472            return;
473
474        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
475            it->setConfigValues();
476
477        if (updateChildren)
478            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
479                (*it)->updateConfigValues(false);
480    }
481
482
483    // ###############################
484    // ###      orxonox_cast       ###
485    // ###############################
486    /**
487    @brief
488        Casts on object of type OrxonoxClass to any derived type that is
489        registered in the class hierarchy.
490    @return
491        Returns NULL if the cast is not possible
492    @note
493        In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
494        a class forgot to register its objects.
495        Also note that the function is implemented differently for GCC/MSVC.
496    */
497    template <class T, class U>
498    FORCEINLINE T orxonox_cast(U source)
499    {
500#ifdef ORXONOX_COMPILER_MSVC
501        typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
502        if (source != NULL)
503            return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
504        else
505            return NULL;
506#else
507        return dynamic_cast<T>(source);
508#endif
509    }
510
511
512    // ###############################
513    // ###   SubclassIdentifier    ###
514    // ###############################
515    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
516    /**
517        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
518        If you assign something else, the program aborts.
519        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
520    */
521    template <class T>
522    class SubclassIdentifier
523    {
524        public:
525            /**
526                @brief Constructor: Automaticaly assigns the Identifier of the given class.
527            */
528            SubclassIdentifier()
529            {
530                this->identifier_ = ClassIdentifier<T>::getIdentifier();
531            }
532
533            /**
534                @brief Copyconstructor: Assigns the given Identifier.
535                @param identifier The Identifier
536            */
537            SubclassIdentifier(Identifier* identifier)
538            {
539                this->operator=(identifier);
540            }
541
542            /**
543                @brief Overloading of the = operator: assigns the identifier and checks its type.
544                @param identifier The Identifier to assign
545                @return The SubclassIdentifier itself
546            */
547            SubclassIdentifier<T>& operator=(Identifier* identifier)
548            {
549                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
550                {
551                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
552                    if (identifier)
553                    {
554                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
555                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
556                    }
557                    else
558                    {
559                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
560                    }
561                }
562                else
563                {
564                    this->identifier_ = identifier;
565                }
566                return *this;
567            }
568
569            /**
570                @brief Overloading of the * operator: returns the assigned identifier.
571            */
572            inline Identifier* operator*() const
573            {
574                return this->identifier_;
575            }
576
577            /**
578                @brief Overloading of the -> operator: returns the assigned identifier.
579            */
580            inline Identifier* operator->() const
581            {
582                return this->identifier_;
583            }
584
585            /**
586                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
587            */
588            inline operator Identifier*() const
589            {
590                return this->identifier_;
591            }
592
593            /**
594                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
595                @return The new object
596            */
597            T* fabricate(BaseObject* creator) const
598            {
599                BaseObject* newObject = this->identifier_->fabricate(creator);
600
601                // Check if the creation was successful
602                if (newObject)
603                {
604                    return orxonox_cast<T*>(newObject);
605                }
606                else
607                {
608                    // Something went terribly wrong
609                    if (this->identifier_)
610                    {
611                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
612                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
613                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
614                        COUT(1) << "Aborting..." << std::endl;
615                    }
616                    else
617                    {
618                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
619                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
620                        COUT(1) << "Aborting..." << std::endl;
621                    }
622
623                    assert(false);
624                    return 0;
625                }
626            }
627
628            /** @brief Returns the assigned identifier. @return The identifier */
629            inline Identifier* getIdentifier() const
630                { return this->identifier_; }
631
632//            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
633//            inline bool isA(const Identifier* identifier) const
634//                { return this->identifier_->isA(identifier); }
635//
636//            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
637//            inline bool isExactlyA(const Identifier* identifier) const
638//                { return this->identifier_->isExactlyA(identifier); }
639//
640//            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
641//            inline bool isChildOf(const Identifier* identifier) const
642//                { return this->identifier_->isChildOf(identifier); }
643//
644//            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
645//            inline bool isDirectChildOf(const Identifier* identifier) const
646//                { return this->identifier_->isDirectChildOf(identifier); }
647//
648//            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
649//            inline bool isParentOf(const Identifier* identifier) const
650//                { return this->identifier_->isParentOf(identifier); }
651//
652//            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
653//            inline bool isDirectParentOf(const Identifier* identifier) const
654//                { return this->identifier_->isDirectParentOf(identifier); }
655
656        private:
657            Identifier* identifier_;            //!< The assigned identifier
658    };
659}
660
661#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.