Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/core/Identifier.h @ 2804

Last change on this file since 2804 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
RevLine 
[790]1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
[1505]3 *                    > www.orxonox.net <
[790]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
[871]29/**
[2171]30    @file
[790]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
[1024]36     - parents and children
[790]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(...),
[871]42    isExactlyA(...), isChildOf(...) and isParentOf(...).
[790]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__
[1052]54
[1062]55#include "CorePrereqs.h"
56
[1052]57#include <set>
[790]58#include <map>
[2087]59#include <vector>
[790]60#include <string>
61#include <utility>
[1639]62#include <typeinfo>
[2710]63#include <cstdlib>
[2087]64#include <cassert>
[790]65
[1747]66#include "MetaObjectList.h"
[1052]67#include "Iterator.h"
[1747]68#include "Super.h"
[2087]69#include "Functor.h"
[1747]70#include "util/Debug.h"
[1505]71#include "util/String.h"
[790]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
[1755]83         - parents and children
[790]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(...),
[871]89        isExactlyA(...), isChildOf(...) and isParentOf(...).
[790]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>
[871]96        friend class SubclassIdentifier;
[790]97
[1052]98        friend class Factory;
[790]99
100        public:
101            /** @brief Sets the Factory. @param factory The factory to assign */
102            inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
103
[2087]104            BaseObject* fabricate(BaseObject* creator);
[790]105            bool isA(const Identifier* identifier) const;
[871]106            bool isExactlyA(const Identifier* identifier) const;
[1052]107            bool isChildOf(const Identifier* identifier) const;
[871]108            bool isDirectChildOf(const Identifier* identifier) const;
[1052]109            bool isParentOf(const Identifier* identifier) const;
[871]110            bool isDirectParentOf(const Identifier* identifier) const;
[790]111
[2087]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
[1747]117            /** @brief Returns the list of all existing objects of this class. @return The list */
118            inline ObjectListBase* getObjects() const
119                { return this->objects_; }
[790]120
[871]121            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
[790]122            inline const std::string& getName() const { return this->name_; }
[1747]123            void setName(const std::string& name);
[790]124
[1747]125            virtual void updateConfigValues(bool updateChildren = true) const = 0;
[1052]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 */
[1502]187            inline const std::map<std::string, ConsoleCommand*>& getConsoleCommandMap() const { return this->consoleCommands_; }
[1052]188            /** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
[1502]189            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
[1052]190            /** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
[1502]191            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
[1052]192
193            /** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
[1502]194            inline const std::map<std::string, ConsoleCommand*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
[1052]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 */
[1502]196            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
[1052]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 */
[1502]198            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
[1052]199
[1856]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(); }
[1052]206
[1856]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
[2087]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
[1052]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_; }
[2087]225            /** @brief Returns true if this class has at least one construction callback Functor registered. */
226            inline bool hasConstructionCallback() const { return this->bHasConstructionCallback_; }
[1052]227
[871]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 */
[790]229            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
230
[871]231            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
[2662]232            inline const uint32_t getNetworkID() const { return this->classID_; }
[790]233
234            /** @brief Sets the network ID to a new value. @param id The new value */
[2662]235            void setNetworkID(uint32_t id);
[790]236
[1052]237            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
[871]238            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
[1052]239            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
240
[1747]241            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
242            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
[1052]243
[1747]244            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
245            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
[1052]246
[2087]247            void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
248            XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
249
[1502]250            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
251            ConsoleCommand* getConsoleCommand(const std::string& name) const;
252            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
[1052]253
[2087]254            void addConstructionCallback(Functor* functor);
255            void removeConstructionCallback(Functor* functor);
256
[1856]257            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
258
[2662]259            static void destroyAllIdentifiers();
260
[1052]261        protected:
[1747]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
[1052]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
[2087]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
[1747]282            ObjectListBase* objects_;                                      //!< The list of all objects of this class
283
284        private:
[790]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++;
[871]291                COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
[790]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--;
[871]300                COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
[1052]301            }
[790]302
[2662]303            static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
304
[1856]305            void initialize(std::set<const Identifier*>* parents);
306
[1052]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
[790]309
[1052]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
[1856]313            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
[1747]314            bool bSetName_;                                                //!< True if the name is set
[2087]315            bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
[1052]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)
[2662]319            uint32_t classID_;                                             //!< The network ID to identify a class through the network
[1052]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
[1502]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
[1747]328
329            std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
330            std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
[2087]331            std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_;    //!< All events
[790]332    };
333
[1052]334    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
[790]335
[1052]336
[790]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
[1052]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),
[1543]347        ClassIdentifiers are stored in the Identifier Singleton.
[790]348    */
349    template <class T>
350    class ClassIdentifier : public Identifier
[1052]351    {
[1747]352        #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
353        #include "Super.h"
354
[790]355        public:
[1747]356            static ClassIdentifier<T> *getIdentifier();
357            static ClassIdentifier<T> *getIdentifier(const std::string& name);
[1856]358            void addObject(T* object);
[1052]359
[1747]360            void updateConfigValues(bool updateChildren = true) const;
[1052]361
[790]362        private:
[2784]363            static void initialiseIdentifier();
[790]364            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
[1747]365            ClassIdentifier()
366            {
367                SuperFunctionInitialization<0, T>::initialize(this);
368            }
369            ~ClassIdentifier()
370            {
371                SuperFunctionDestruction<0, T>::destroy(this);
372            }
[790]373
[1856]374            static ClassIdentifier<T>* classIdentifier_s;
[790]375    };
376
[1543]377    template <class T>
[2784]378    ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
[1543]379
[790]380    /**
[1747]381        @brief Returns the only instance of this class.
[1543]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
[2784]388        if (ClassIdentifier<T>::classIdentifier_s == 0)
389            ClassIdentifier<T>::initialiseIdentifier();
[1543]390
391        return ClassIdentifier<T>::classIdentifier_s;
392    }
393
394    /**
[1747]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
[790]398    */
399    template <class T>
[1747]400    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
[790]401    {
[1747]402        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
403        identifier->setName(name);
404        return identifier;
[790]405    }
406
407    /**
[2784]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    /**
[790]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    {
[871]439        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
[1747]440        object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
[2087]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        }
[790]448    }
449
450    /**
[1052]451        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
[790]452    */
453    template <class T>
[1747]454    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
[790]455    {
[1747]456        if (!this->hasConfigValues())
457            return;
[790]458
[1747]459        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
460            it->setConfigValues();
[1052]461
[1747]462        if (updateChildren)
463            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
464                (*it)->updateConfigValues(false);
[1052]465    }
466
467
[790]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.
[2103]475        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
[790]476    */
477    template <class T>
478    class SubclassIdentifier
479    {
480        public:
481            /**
482                @brief Constructor: Automaticaly assigns the Identifier of the given class.
[1052]483            */
[790]484            SubclassIdentifier()
[1052]485            {
[1543]486                this->identifier_ = ClassIdentifier<T>::getIdentifier();
[790]487            }
488
489            /**
[1052]490                @brief Copyconstructor: Assigns the given Identifier.
491                @param identifier The Identifier
492            */
493            SubclassIdentifier(Identifier* identifier)
494            {
[1856]495                this->operator=(identifier);
[1052]496            }
497
498            /**
[790]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            {
[2087]505                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
[1052]506                {
507                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
[2087]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                    }
[790]517                }
[2087]518                else
519                {
520                    this->identifier_ = identifier;
521                }
[790]522                return *this;
523            }
524
525            /**
526                @brief Overloading of the * operator: returns the assigned identifier.
527            */
[2087]528            inline Identifier* operator*() const
[790]529            {
530                return this->identifier_;
531            }
532
533            /**
534                @brief Overloading of the -> operator: returns the assigned identifier.
535            */
[1856]536            inline Identifier* operator->() const
[790]537            {
538                return this->identifier_;
539            }
540
541            /**
[1856]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            /**
[790]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            */
[2087]553            T* fabricate(BaseObject* creator) const
[790]554            {
[2087]555                BaseObject* newObject = this->identifier_->fabricate(creator);
[790]556
557                // Check if the creation was successful
558                if (newObject)
559                {
[1856]560                    return dynamic_cast<T*>(newObject);
[790]561                }
562                else
563                {
564                    // Something went terribly wrong
565                    if (this->identifier_)
566                    {
[1052]567                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
[1543]568                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
[790]569                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
570                        COUT(1) << "Aborting..." << std::endl;
571                    }
572                    else
573                    {
[1052]574                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
[790]575                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
576                        COUT(1) << "Aborting..." << std::endl;
577                    }
578
[2087]579                    assert(false);
580                    return 0;
[790]581                }
582            }
583
[871]584            /** @brief Returns the assigned identifier. @return The identifier */
[1856]585            inline Identifier* getIdentifier() const
[790]586                { return this->identifier_; }
587
[1856]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); }
[790]611
612        private:
[1052]613            Identifier* identifier_;            //!< The assigned identifier
[790]614    };
615}
616
617#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.