Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/netp3/src/core/Identifier.h @ 2996

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