Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/ceguilua/src/core/Identifier.h @ 1952

Last change on this file since 1952 was 1755, checked in by rgrieder, 16 years ago

merged gui back to trunk.
update the media repository!

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