Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/questsystem5/src/core/Identifier.h @ 2941

Last change on this file since 2941 was 2908, checked in by dafrick, 16 years ago

Reverted to revision 2906 (because I'm too stupid to merge correctly, 2nd try will follow shortly. ;))

  • Property svn:eol-style set to native
File size: 34.8 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            static bool isFirstCall();
360
361            void updateConfigValues(bool updateChildren = true) const;
362
363        private:
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;
379
380    /**
381        @brief Returns true if the function gets called the first time, false otherwise.
382        @return True if this function got called the first time.
383    */
384    template <class T>
385    bool ClassIdentifier<T>::isFirstCall()
386    {
387        static bool bFirstCall = true;
388
389        if (bFirstCall)
390        {
391            bFirstCall = false;
392            return true;
393        }
394        else
395        {
396            return false;
397        }
398    }
399
400    /**
401        @brief Returns the only instance of this class.
402        @return The unique Identifier
403    */
404    template <class T>
405    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
406    {
407        // check if the static field has already been filled
408        if (ClassIdentifier<T>::isFirstCall())
409        {
410            // Get the name of the class
411            std::string name = typeid(T).name();
412
413            // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
414            ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
415
416            // Get the entry from the map
417            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
418
419            if (ClassIdentifier<T>::classIdentifier_s == proposal)
420            {
421                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
422            }
423            else
424            {
425                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
426            }
427        }
428
429        // Finally return the unique ClassIdentifier
430        return ClassIdentifier<T>::classIdentifier_s;
431    }
432
433    /**
434        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
435        @param name The name of this Identifier
436        @return The Identifier
437    */
438    template <class T>
439    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
440    {
441        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
442        identifier->setName(name);
443        return identifier;
444    }
445
446    /**
447        @brief Adds an object of the given type to the ObjectList.
448        @param object The object to add
449    */
450    template <class T>
451    void ClassIdentifier<T>::addObject(T* object)
452    {
453        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
454        object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
455        if (this->bHasConstructionCallback_)
456        {
457            // Call all registered callbacks that a new object of type T has been created.
458            // Do NOT deliver a T* pointer here because it's way too risky (object not yet fully created).
459            for (unsigned int i = 0; i < this->constructionCallbacks_.size(); ++i)
460                (*constructionCallbacks_[i])();
461        }
462    }
463
464    /**
465        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
466    */
467    template <class T>
468    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
469    {
470        if (!this->hasConfigValues())
471            return;
472
473        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
474            it->setConfigValues();
475
476        if (updateChildren)
477            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
478                (*it)->updateConfigValues(false);
479    }
480
481
482    // ###############################
483    // ###   SubclassIdentifier    ###
484    // ###############################
485    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
486    /**
487        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
488        If you assign something else, the program aborts.
489        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
490    */
491    template <class T>
492    class SubclassIdentifier
493    {
494        public:
495            /**
496                @brief Constructor: Automaticaly assigns the Identifier of the given class.
497            */
498            SubclassIdentifier()
499            {
500                this->identifier_ = ClassIdentifier<T>::getIdentifier();
501            }
502
503            /**
504                @brief Copyconstructor: Assigns the given Identifier.
505                @param identifier The Identifier
506            */
507            SubclassIdentifier(Identifier* identifier)
508            {
509                this->operator=(identifier);
510            }
511
512            /**
513                @brief Overloading of the = operator: assigns the identifier and checks its type.
514                @param identifier The Identifier to assign
515                @return The SubclassIdentifier itself
516            */
517            SubclassIdentifier<T>& operator=(Identifier* identifier)
518            {
519                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
520                {
521                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
522                    if (identifier)
523                    {
524                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
525                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
526                    }
527                    else
528                    {
529                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
530                    }
531                }
532                else
533                {
534                    this->identifier_ = identifier;
535                }
536                return *this;
537            }
538
539            /**
540                @brief Overloading of the * operator: returns the assigned identifier.
541            */
542            inline Identifier* operator*() const
543            {
544                return this->identifier_;
545            }
546
547            /**
548                @brief Overloading of the -> operator: returns the assigned identifier.
549            */
550            inline Identifier* operator->() const
551            {
552                return this->identifier_;
553            }
554
555            /**
556                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
557            */
558            inline operator Identifier*() const
559            {
560                return this->identifier_;
561            }
562
563            /**
564                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
565                @return The new object
566            */
567            T* fabricate(BaseObject* creator) const
568            {
569                BaseObject* newObject = this->identifier_->fabricate(creator);
570
571                // Check if the creation was successful
572                if (newObject)
573                {
574                    return dynamic_cast<T*>(newObject);
575                }
576                else
577                {
578                    // Something went terribly wrong
579                    if (this->identifier_)
580                    {
581                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
582                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
583                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
584                        COUT(1) << "Aborting..." << std::endl;
585                    }
586                    else
587                    {
588                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
589                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
590                        COUT(1) << "Aborting..." << std::endl;
591                    }
592
593                    assert(false);
594                    return 0;
595                }
596            }
597
598            /** @brief Returns the assigned identifier. @return The identifier */
599            inline Identifier* getIdentifier() const
600                { return this->identifier_; }
601
602//            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
603//            inline bool isA(const Identifier* identifier) const
604//                { return this->identifier_->isA(identifier); }
605//
606//            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
607//            inline bool isExactlyA(const Identifier* identifier) const
608//                { return this->identifier_->isExactlyA(identifier); }
609//
610//            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
611//            inline bool isChildOf(const Identifier* identifier) const
612//                { return this->identifier_->isChildOf(identifier); }
613//
614//            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
615//            inline bool isDirectChildOf(const Identifier* identifier) const
616//                { return this->identifier_->isDirectChildOf(identifier); }
617//
618//            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
619//            inline bool isParentOf(const Identifier* identifier) const
620//                { return this->identifier_->isParentOf(identifier); }
621//
622//            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
623//            inline bool isDirectParentOf(const Identifier* identifier) const
624//                { return this->identifier_->isDirectParentOf(identifier); }
625
626        private:
627            Identifier* identifier_;            //!< The assigned identifier
628    };
629}
630
631#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.