Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 2706 was 2662, checked in by rgrieder, 16 years ago

Merged presentation branch back to trunk.

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