Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 1055 was 1052, checked in by landauf, 16 years ago

merged core2 back to trunk
there might be some errors, wasn't able to test it yet due to some strange g++ and linker behaviour.
File size: 32.0 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *
4 *
5 *   License notice:
6 *
7 *   This program is free software; you can redistribute it and/or
8 *   modify it under the terms of the GNU General Public License
9 *   as published by the Free Software Foundation; either version 2
10 *   of the License, or (at your option) any later version.
11 *
12 *   This program is distributed in the hope that it will be useful,
13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 *   GNU General Public License for more details.
16 *
17 *   You should have received a copy of the GNU General Public License
18 *   along with this program; if not, write to the Free Software
19 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20 *
21 *   Author:
22 *      Fabian 'x3n' Landau
23 *   Co-authors:
24 *      ...
25 *
26 */
27
28/**
29    @file Identifier.h
30    @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
31
32    The Identifier contains all needed informations about the class it belongs to:
33     - the name
34     - a list with all objects
35     - parents and children
36     - the factory (if available)
37     - the networkID that can be synchronised with the server
38     - all configurable variables (if available)
39
40    Every object has a pointer to the Identifier of its class. This allows the use isA(...),
41    isExactlyA(...), isChildOf(...) and isParentOf(...).
42
43    To create the class-hierarchy, the Identifier has some intern functions and variables.
44
45    Every Identifier is in fact a ClassIdentifier, but they are derived from Identifier.
46
47    SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
48    You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
49*/
50
51#ifndef _Identifier_H__
52#define _Identifier_H__
53
54#include <set>
55#include <map>
56#include <string>
57#include <utility>
58
59#include "CorePrereqs.h"
60
61#include "ObjectList.h"
62#include "Debug.h"
63#include "Iterator.h"
64#include "util/String.h"
65
66namespace orxonox
67{
68    // ###############################
69    // ###       Identifier        ###
70    // ###############################
71    //! The Identifier is used to identify the class of an object and to store informations about the class.
72    /**
73        The Identifier contains all needed informations about the class it belongs to:
74         - the name
75         - a list with all objects
76         - parents and childs
77         - the factory (if available)
78         - the networkID that can be synchronised with the server
79         - all configurable variables (if available)
80
81        Every object has a pointer to the Identifier of its class. This allows the use isA(...),
82        isExactlyA(...), isChildOf(...) and isParentOf(...).
83
84        You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
85    */
86    class _CoreExport Identifier
87    {
88        template <class T>
89        friend class ClassIdentifier;
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();
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            virtual const ObjectList<BaseObject>* getObjectList() const = 0;
109
110            virtual void updateConfigValues() const = 0;
111
112            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
113            inline const std::string& getName() const { return this->name_; }
114
115
116            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
117            inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
118            /** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
119            inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
120            /** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
121            inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
122
123            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
124            inline const std::set<const Identifier*>& getChildren() const { return (*this->children_); }
125            /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
126            inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
127            /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
128            inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
129
130            /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
131            inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
132            /** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
133            inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
134            /** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
135            inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
136
137            /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
138            inline const std::set<const Identifier*>& getDirectChildren() const { return (*this->directChildren_); }
139            /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
140            inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
141            /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
142            inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
143
144
145            /** @brief Returns the map that stores all Identifiers. @return The map */
146            static inline const std::map<std::string, Identifier*>& getIdentifierMap() { return Identifier::getIdentifierMapIntern(); }
147            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers. @return The const_iterator */
148            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapBegin() { return Identifier::getIdentifierMap().begin(); }
149            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers. @return The const_iterator */
150            static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapEnd() { return Identifier::getIdentifierMap().end(); }
151
152            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
153            static inline const std::map<std::string, Identifier*>& getLowercaseIdentifierMap() { return Identifier::getLowercaseIdentifierMapIntern(); }
154            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
155            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapBegin() { return Identifier::getLowercaseIdentifierMap().begin(); }
156            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
157            static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapEnd() { return Identifier::getLowercaseIdentifierMap().end(); }
158
159
160            /** @brief Returns the map that stores all config values. @return The const_iterator */
161            inline const std::map<std::string, ConfigValueContainer*>& getConfigValueMap() const { return this->configValues_; }
162            /** @brief Returns a const_iterator to the beginning of the map that stores all config values. @return The const_iterator */
163            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapBegin() const { return this->configValues_.begin(); }
164            /** @brief Returns a const_iterator to the end of the map that stores all config values. @return The const_iterator */
165            inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapEnd() const { return this->configValues_.end(); }
166
167            /** @brief Returns the map that stores all config values with their names in lowercase. @return The const_iterator */
168            inline const std::map<std::string, ConfigValueContainer*>& getLowercaseConfigValueMap() const { return this->configValues_LC_; }
169            /** @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 */
170            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapBegin() const { return this->configValues_LC_.begin(); }
171            /** @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 */
172            inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
173
174
175            /** @brief Returns the map that stores all console commands. @return The const_iterator */
176            inline const std::map<std::string, ExecutorStatic*>& getConsoleCommandMap() const { return this->consoleCommands_; }
177            /** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
178            inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
179            /** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
180            inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
181
182            /** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
183            inline const std::map<std::string, ExecutorStatic*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
184            /** @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 */
185            inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
186            /** @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 */
187            inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
188
189
190            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
191            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
192            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
193            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
194
195            /** @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 */
196            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
197
198            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
199            inline const unsigned int getNetworkID() const { return this->classID_; }
200
201            /** @brief Sets the network ID to a new value. @param id The new value */
202            void setNetworkID(unsigned int id);
203
204            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
205            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
206            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
207
208            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
209            virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
210
211            virtual void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container) = 0;
212            virtual XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname) = 0;
213
214            ExecutorStatic& addConsoleCommand(ExecutorStatic* executor, bool bCreateShortcut);
215            ExecutorStatic* getConsoleCommand(const std::string& name) const;
216            ExecutorStatic* getLowercaseConsoleCommand(const std::string& name) const;
217
218        protected:
219            /** @brief Returns the map that stores all Identifiers. @return The map */
220            static std::map<std::string, Identifier*>& getIdentifierMapIntern();
221            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
222            static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
223
224        private:
225            Identifier();
226            Identifier(const Identifier& identifier) {} // don't copy
227            virtual ~Identifier();
228            void initialize(std::set<const Identifier*>* parents);
229
230            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
231            inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
232            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
233            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
234
235            /**
236                @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
237            */
238            inline static void startCreatingHierarchy()
239            {
240                hierarchyCreatingCounter_s++;
241                COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
242            }
243
244            /**
245                @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
246            */
247            inline static void stopCreatingHierarchy()
248            {
249                hierarchyCreatingCounter_s--;
250                COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
251            }
252
253            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
254            std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
255
256            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
257            std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
258
259            std::string name_;                                             //!< The name of the class the Identifier belongs to
260
261            BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
262            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
263            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)
264            unsigned int classID_;                                         //!< The network ID to identify a class through the network
265
266            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
267            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
268            std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
269
270            bool bHasConsoleCommands_;                                     //!< True if this class has at least one assigned console command
271            std::map<std::string, ExecutorStatic*> consoleCommands_;       //!< All console commands of this class
272            std::map<std::string, ExecutorStatic*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
273    };
274
275    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
276
277
278    // ###############################
279    // ###     ClassIdentifier     ###
280    // ###############################
281    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
282    /**
283        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
284        This makes it possible to store informations about a class, sharing them with all
285        objects of that class without defining static variables in every class.
286
287        To be really sure that not more than exactly one object exists (even with libraries),
288        ClassIdentifiers are only created by IdentifierDistributor.
289
290        You can access the ClassIdentifiers created by IdentifierDistributor through the
291        ClassManager singletons.
292    */
293    template <class T>
294    class ClassIdentifier : public Identifier
295    {
296        template <class TT>
297        friend class ClassManager;
298
299        public:
300            ClassIdentifier<T>* registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass);
301            void addObject(T* object);
302            void setName(const std::string& name);
303            /** @brief Returns the list of all existing objects of this class. @return The list */
304            inline const ObjectList<T>* getObjects() const { return this->objects_; }
305            /** @brief Returns a list of all existing objects of this class. @return The list */
306            inline const ObjectList<BaseObject>* getObjectList() const { return (ObjectList<BaseObject>*)this->objects_; }
307
308            void updateConfigValues() const;
309
310            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
311            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
312
313            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
314            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
315
316        private:
317            ClassIdentifier();
318            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
319            ~ClassIdentifier() {}                                       // don't delete
320
321            ObjectList<T>* objects_;                                                                    //!< The ObjectList, containing all objects of type T
322            bool bSetName_;                                                                             //!< True if the name is set
323            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;              //!< All loadable parameters
324            std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;   //!< All attachable objects
325    };
326
327    /**
328        @brief Constructor: Creates the ObjectList.
329    */
330    template <class T>
331    ClassIdentifier<T>::ClassIdentifier()
332    {
333//        this->objects_ = ObjectList<T>::getList();
334        this->objects_ = new ObjectList<T>();
335        this->bSetName_ = false;
336    }
337
338    /**
339        @brief Registers a class, which means that the name and the parents get stored.
340        @param parents A list, containing the Identifiers of all parents of the class
341        @param name A string, containing exactly the name of the class
342        @param bRootClass True if the class is either an Interface or the BaseObject itself
343        @return The ClassIdentifier itself
344    */
345    template <class T>
346    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass)
347    {
348        this->setName(name);
349
350        // Check if at least one object of the given type was created
351        if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
352        {
353            // If no: We have to store the informations and initialize the Identifier
354            COUT(4) << "*** ClassIdentifier: Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
355            if (bRootClass)
356                this->initialize(NULL); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
357            else
358                this->initialize(parents);
359        }
360
361        return this;
362    }
363
364    /**
365        @brief Sets the name of the class.
366        @param name The name
367    */
368    template <class T>
369    void ClassIdentifier<T>::setName(const std::string& name)
370    {
371        if (!this->bSetName_)
372        {
373            this->name_ = name;
374            this->bSetName_ = true;
375            Identifier::getIdentifierMapIntern()[name] = this;
376            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
377        }
378    }
379
380    /**
381        @brief Adds an object of the given type to the ObjectList.
382        @param object The object to add
383    */
384    template <class T>
385    void ClassIdentifier<T>::addObject(T* object)
386    {
387        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
388        object->getMetaList().add(this->objects_, this->objects_->add(object));
389    }
390
391    /**
392        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
393    */
394    template <class T>
395    void ClassIdentifier<T>::updateConfigValues() const
396    {
397        for (Iterator<T> it = this->objects_->start(); it; ++it)
398            ((T*)*it)->setConfigValues();
399    }
400
401    /**
402        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
403        @param paramname The name of the parameter
404        @return The container
405    */
406    template <class T>
407    XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
408    {
409        typename std::map<std::string, XMLPortClassParamContainer<T>*>::const_iterator it = xmlportParamContainers_.find(paramname);
410        if (it != xmlportParamContainers_.end())
411            return (XMLPortParamContainer*)((*it).second);
412        else
413            return 0;
414    }
415
416    /**
417        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
418        @param paramname The name of the parameter
419        @param container The container
420    */
421    template <class T>
422    void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
423    {
424        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<T>*)container;
425    }
426
427    /**
428        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
429        @param sectionname The name of the section that contains the attachable objects
430        @return The container
431    */
432    template <class T>
433    XMLPortObjectContainer* ClassIdentifier<T>::getXMLPortObjectContainer(const std::string& sectionname)
434    {
435        typename std::map<std::string, XMLPortClassObjectContainer<T, class O>*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
436        if (it != xmlportObjectContainers_.end())
437            return (XMLPortObjectContainer*)((*it).second);
438        else
439            return 0;
440    }
441
442    /**
443        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
444        @param sectionname The name of the section that contains the attachable objects
445        @param container The container
446    */
447    template <class T>
448    void ClassIdentifier<T>::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
449    {
450        this->xmlportObjectContainers_[sectionname] = (XMLPortClassObjectContainer<T, class O>*)container;
451    }
452
453
454    // ###############################
455    // ###   SubclassIdentifier    ###
456    // ###############################
457    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
458    /**
459        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
460        If you assign something else, the program aborts.
461        Because we know the minimal type, a dynamic_cast is done, which makes it easier to create a new object.
462    */
463    template <class T>
464    class SubclassIdentifier
465    {
466        public:
467            /**
468                @brief Constructor: Automaticaly assigns the Identifier of the given class.
469            */
470            SubclassIdentifier()
471            {
472                this->identifier_ = ClassManager<T>::getIdentifier();
473            }
474
475            /**
476                @brief Copyconstructor: Assigns the given Identifier.
477                @param identifier The Identifier
478            */
479            SubclassIdentifier(Identifier* identifier)
480            {
481                this->identifier_ = identifier;
482            }
483
484            /**
485                @brief Overloading of the = operator: assigns the identifier and checks its type.
486                @param identifier The Identifier to assign
487                @return The SubclassIdentifier itself
488            */
489            SubclassIdentifier<T>& operator=(Identifier* identifier)
490            {
491                if (!identifier->isA(ClassManager<T>::getIdentifier()))
492                {
493                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
494                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassManager<T>::getIdentifier()->getName() << "!" << std::endl;
495                    COUT(1) << "Error: SubclassIdentifier<" << ClassManager<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
496                    COUT(1) << "Aborting..." << std::endl;
497                    abort();
498                }
499                this->identifier_ = identifier;
500                return *this;
501            }
502
503            /**
504                @brief Overloading of the * operator: returns the assigned identifier.
505                @return The assigned identifier
506            */
507            Identifier* operator*()
508            {
509                return this->identifier_;
510            }
511
512            /**
513                @brief Overloading of the -> operator: returns the assigned identifier.
514                @return The assigned identifier
515            */
516            Identifier* operator->() const
517            {
518                return this->identifier_;
519            }
520
521            /**
522                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
523                @return The new object
524            */
525            T* fabricate()
526            {
527                BaseObject* newObject = this->identifier_->fabricate();
528
529                // Check if the creation was successful
530                if (newObject)
531                {
532                    // Do a dynamic_cast, because an object of type T is much better than of type BaseObject
533                    return (T*)(newObject);
534                }
535                else
536                {
537                    // Something went terribly wrong
538                    if (this->identifier_)
539                    {
540                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
541                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassManager<T>::getIdentifier()->getName() << "!" << std::endl;
542                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
543                        COUT(1) << "Aborting..." << std::endl;
544                    }
545                    else
546                    {
547                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
548                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
549                        COUT(1) << "Aborting..." << std::endl;
550                    }
551
552                    abort();
553                }
554            }
555
556            /** @brief Returns the assigned identifier. @return The identifier */
557            inline const Identifier* getIdentifier() const
558                { return this->identifier_; }
559
560            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
561            inline bool isA(const Identifier* identifier) const
562                { return this->identifier_->isA(identifier); }
563
564            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
565            inline bool isExactlyA(const Identifier* identifier) const
566                { return this->identifier_->isExactlyA(identifier); }
567
568            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
569            inline bool isChildOf(const Identifier* identifier) const
570                { return this->identifier_->isChildOf(identifier); }
571
572            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
573            inline bool isDirectChildOf(const Identifier* identifier) const
574                { return this->identifier_->isDirectChildOf(identifier); }
575
576            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
577            inline bool isParentOf(const Identifier* identifier) const
578                { return this->identifier_->isParentOf(identifier); }
579
580            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
581            inline bool isDirectParentOf(const Identifier* identifier) const
582                { return this->identifier_->isDirectParentOf(identifier); }
583
584        private:
585            Identifier* identifier_;            //!< The assigned identifier
586    };
587}
588
589#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.