Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 3222 was 3196, checked in by rgrieder, 15 years ago

Merged pch branch back to trunk.

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