Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 1862 was 1856, checked in by landauf, 16 years ago
  • some small adjustments in identifier and co.
  • renamed GetIdentifier to ClassByName and ClassByID
  • Property svn:eol-style set to native
File size: 31.8 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            /** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
193            inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
194            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort params. @return The const_iterator */
195            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
196            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort params. @return The const_iterator */
197            inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
198
199            /** @brief Returns the map that stores all XMLPort objects. @return The const_iterator */
200            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
201            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort objects. @return The const_iterator */
202            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
203            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort objects. @return The const_iterator */
204            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
205
206            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
207            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
208            /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
209            inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
210
211            /** @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 */
212            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
213
214            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
215            inline const unsigned int getNetworkID() const { return this->classID_; }
216
217            /** @brief Sets the network ID to a new value. @param id The new value */
218            void setNetworkID(unsigned int id);
219
220            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
221            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
222            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
223
224            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
225            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
226
227            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
228            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
229
230            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
231            ConsoleCommand* getConsoleCommand(const std::string& name) const;
232            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
233
234            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
235
236        protected:
237            Identifier();
238            Identifier(const Identifier& identifier); // don't copy
239            virtual ~Identifier();
240
241            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
242            virtual void createSuperFunctionCaller() const = 0;
243
244            /** @brief Returns the map that stores all Identifiers. @return The map */
245            static std::map<std::string, Identifier*>& getIdentifierMapIntern();
246            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
247            static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
248
249            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
250            inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
251            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
252            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
253
254            ObjectListBase* objects_;                                      //!< The list of all objects of this class
255
256        private:
257            /**
258                @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
259            */
260            inline static void startCreatingHierarchy()
261            {
262                hierarchyCreatingCounter_s++;
263                COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
264            }
265
266            /**
267                @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
268            */
269            inline static void stopCreatingHierarchy()
270            {
271                hierarchyCreatingCounter_s--;
272                COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
273            }
274
275            void initialize(std::set<const Identifier*>* parents);
276
277            static void destroyAllIdentifiers();
278
279            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
280            std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
281
282            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
283            std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
284
285            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
286            bool bSetName_;                                                //!< True if the name is set
287            std::string name_;                                             //!< The name of the class the Identifier belongs to
288            BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
289            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)
290            unsigned int classID_;                                         //!< The network ID to identify a class through the network
291
292            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
293            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
294            std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
295
296            bool bHasConsoleCommands_;                                     //!< True if this class has at least one assigned console command
297            std::map<std::string, ConsoleCommand*> consoleCommands_;       //!< All console commands of this class
298            std::map<std::string, ConsoleCommand*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
299
300            std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
301            std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
302    };
303
304    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
305
306
307    // ###############################
308    // ###     ClassIdentifier     ###
309    // ###############################
310    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
311    /**
312        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
313        This makes it possible to store informations about a class, sharing them with all
314        objects of that class without defining static variables in every class.
315
316        To be really sure that not more than exactly one object exists (even with libraries),
317        ClassIdentifiers are stored in the Identifier Singleton.
318    */
319    template <class T>
320    class ClassIdentifier : public Identifier
321    {
322        #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
323        #include "Super.h"
324
325        public:
326            static ClassIdentifier<T> *getIdentifier();
327            static ClassIdentifier<T> *getIdentifier(const std::string& name);
328            void addObject(T* object);
329            static bool isFirstCall();
330
331            void updateConfigValues(bool updateChildren = true) const;
332
333        private:
334            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
335            ClassIdentifier()
336            {
337                SuperFunctionInitialization<0, T>::initialize(this);
338            }
339            ~ClassIdentifier()
340            {
341                SuperFunctionDestruction<0, T>::destroy(this);
342            }
343
344            static ClassIdentifier<T>* classIdentifier_s;
345    };
346
347    template <class T>
348    ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s;
349
350    /**
351        @brief Returns true if the function gets called the first time, false otherwise.
352        @return True if this function got called the first time.
353    */
354    template <class T>
355    bool ClassIdentifier<T>::isFirstCall()
356    {
357        static bool bFirstCall = true;
358
359        if (bFirstCall)
360        {
361            bFirstCall = false;
362            return true;
363        }
364        else
365        {
366            return false;
367        }
368    }
369
370    /**
371        @brief Returns the only instance of this class.
372        @return The unique Identifier
373    */
374    template <class T>
375    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
376    {
377        // check if the static field has already been filled
378        if (ClassIdentifier<T>::isFirstCall())
379        {
380            // Get the name of the class
381            std::string name = typeid(T).name();
382
383            // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
384            ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
385
386            // Get the entry from the map
387            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
388
389            if (ClassIdentifier<T>::classIdentifier_s == proposal)
390            {
391                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
392            }
393            else
394            {
395                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
396            }
397        }
398
399        // Finally return the unique ClassIdentifier
400        return ClassIdentifier<T>::classIdentifier_s;
401    }
402
403    /**
404        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
405        @param name The name of this Identifier
406        @return The Identifier
407    */
408    template <class T>
409    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
410    {
411        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
412        identifier->setName(name);
413        return identifier;
414    }
415
416    /**
417        @brief Adds an object of the given type to the ObjectList.
418        @param object The object to add
419    */
420    template <class T>
421    void ClassIdentifier<T>::addObject(T* object)
422    {
423        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
424        object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
425    }
426
427    /**
428        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
429    */
430    template <class T>
431    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
432    {
433        if (!this->hasConfigValues())
434            return;
435
436        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
437            it->setConfigValues();
438
439        if (updateChildren)
440            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
441                (*it)->updateConfigValues(false);
442    }
443
444
445    // ###############################
446    // ###   SubclassIdentifier    ###
447    // ###############################
448    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
449    /**
450        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
451        If you assign something else, the program aborts.
452        Because we know the minimal type, a dynamic_cast is done, which makes it easier to create a new object.
453    */
454    template <class T>
455    class SubclassIdentifier
456    {
457        public:
458            /**
459                @brief Constructor: Automaticaly assigns the Identifier of the given class.
460            */
461            SubclassIdentifier()
462            {
463                this->identifier_ = ClassIdentifier<T>::getIdentifier();
464            }
465
466            /**
467                @brief Copyconstructor: Assigns the given Identifier.
468                @param identifier The Identifier
469            */
470            SubclassIdentifier(Identifier* identifier)
471            {
472                this->operator=(identifier);
473            }
474
475            /**
476                @brief Overloading of the = operator: assigns the identifier and checks its type.
477                @param identifier The Identifier to assign
478                @return The SubclassIdentifier itself
479            */
480            SubclassIdentifier<T>& operator=(Identifier* identifier)
481            {
482                if (!identifier->isA(ClassIdentifier<T>::getIdentifier()))
483                {
484                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
485                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
486                    COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
487                    COUT(1) << "Aborting..." << std::endl;
488                    abort();
489                }
490                this->identifier_ = identifier;
491                return *this;
492            }
493
494            /**
495                @brief Overloading of the * operator: returns the assigned identifier.
496            */
497            inline Identifier* operator*()
498            {
499                return this->identifier_;
500            }
501
502            /**
503                @brief Overloading of the -> operator: returns the assigned identifier.
504            */
505            inline Identifier* operator->() const
506            {
507                return this->identifier_;
508            }
509
510            /**
511                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
512            */
513            inline operator Identifier*() 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                    return dynamic_cast<T*>(newObject);
530                }
531                else
532                {
533                    // Something went terribly wrong
534                    if (this->identifier_)
535                    {
536                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
537                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
538                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
539                        COUT(1) << "Aborting..." << std::endl;
540                    }
541                    else
542                    {
543                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
544                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
545                        COUT(1) << "Aborting..." << std::endl;
546                    }
547
548                    abort();
549                }
550            }
551
552            /** @brief Returns the assigned identifier. @return The identifier */
553            inline Identifier* getIdentifier() const
554                { return this->identifier_; }
555
556//            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
557//            inline bool isA(const Identifier* identifier) const
558//                { return this->identifier_->isA(identifier); }
559//
560//            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
561//            inline bool isExactlyA(const Identifier* identifier) const
562//                { return this->identifier_->isExactlyA(identifier); }
563//
564//            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
565//            inline bool isChildOf(const Identifier* identifier) const
566//                { return this->identifier_->isChildOf(identifier); }
567//
568//            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
569//            inline bool isDirectChildOf(const Identifier* identifier) const
570//                { return this->identifier_->isDirectChildOf(identifier); }
571//
572//            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
573//            inline bool isParentOf(const Identifier* identifier) const
574//                { return this->identifier_->isParentOf(identifier); }
575//
576//            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
577//            inline bool isDirectParentOf(const Identifier* identifier) const
578//                { return this->identifier_->isDirectParentOf(identifier); }
579
580        private:
581            Identifier* identifier_;            //!< The assigned identifier
582    };
583}
584
585#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.