Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/script_trigger/src/core/Identifier.h @ 2175

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