Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/shader/src/core/Identifier.h @ 2173

Last change on this file since 2173 was 1505, checked in by rgrieder, 16 years ago

f* svn: It doesn't even inform you if you attempt to set a non existing property. It is svn:eol-style and not eol-style when using the command by the way…

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