Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/gui/src/core/Identifier.h @ 1636

Last change on this file since 1636 was 1543, checked in by rgrieder, 16 years ago
  • applied patch to remove ClassManager (wouldn't wanna maintain it anymore ;))
  • sorted core CMLs a little bit
  • updated OrxonoxStableHeaders.h
  • Property svn:eol-style set to native
File size: 33.1 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            static Identifier* getIdentifier(std::string &name, Identifier *proposal);
256
257            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
258            std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
259
260            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
261            std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
262
263            std::string name_;                                             //!< The name of the class the Identifier belongs to
264
265            BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
266            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
267            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)
268            unsigned int classID_;                                         //!< The network ID to identify a class through the network
269
270            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
271            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
272            std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
273
274            bool bHasConsoleCommands_;                                     //!< True if this class has at least one assigned console command
275            std::map<std::string, ConsoleCommand*> consoleCommands_;       //!< All console commands of this class
276            std::map<std::string, ConsoleCommand*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
277    };
278
279    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
280
281
282    // ###############################
283    // ###     ClassIdentifier     ###
284    // ###############################
285    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
286    /**
287        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
288        This makes it possible to store informations about a class, sharing them with all
289        objects of that class without defining static variables in every class.
290
291        To be really sure that not more than exactly one object exists (even with libraries),
292        ClassIdentifiers are stored in the Identifier Singleton.
293    */
294    template <class T>
295    class ClassIdentifier : public Identifier
296    {
297        public:
298            ClassIdentifier<T>* registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass);
299            void addObject(T* object);
300            void setName(const std::string& name);
301            /** @brief Returns the list of all existing objects of this class. @return The list */
302            inline ObjectList<T>* getObjects() const { return this->objects_; }
303            /** @brief Returns a list of all existing objects of this class. @return The list */
304            inline ObjectList<BaseObject>* getObjectList() const { return (ObjectList<BaseObject>*)this->objects_; }
305
306            void updateConfigValues() const;
307
308            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
309            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
310
311            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
312            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
313
314            static ClassIdentifier<T> *getIdentifier();
315
316        private:
317            ClassIdentifier();
318            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
319            ~ClassIdentifier() {}                                       // don't delete
320
321            ObjectList<T>* objects_;                                                                    //!< The ObjectList, containing all objects of type T
322            bool bSetName_;                                                                             //!< True if the name is set
323            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;              //!< All loadable parameters
324            std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;   //!< All attachable objects
325
326            static ClassIdentifier<T> *classIdentifier_s;
327    };
328
329    template <class T>
330    ClassIdentifier<T> *ClassIdentifier<T>::classIdentifier_s = 0;
331
332    /**
333        @brief Constructor: Creates the ObjectList.
334    */
335    template <class T>
336    ClassIdentifier<T>::ClassIdentifier()
337    {
338//        this->objects_ = ObjectList<T>::getList();
339        this->objects_ = new ObjectList<T>();
340        this->bSetName_ = false;
341    }
342
343    /**
344        @brief Registers a class, which means that the name and the parents get stored.
345        @param parents A list, containing the Identifiers of all parents of the class
346        @param name A string, containing exactly the name of the class
347        @param bRootClass True if the class is either an Interface or the BaseObject itself
348        @return The ClassIdentifier itself
349    */
350    template <class T>
351    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass)
352    {
353        this->setName(name);
354
355        // Check if at least one object of the given type was created
356        if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
357        {
358            // If no: We have to store the informations and initialize the Identifier
359            COUT(4) << "*** ClassIdentifier: Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
360            if (bRootClass)
361                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.
362            else
363                this->initialize(parents);
364        }
365
366        return this;
367    }
368
369    /**
370        @brief Creates the only instance of this class for the template class T and retrieves a unique Identifier for the given name.
371        @return The unique Identifier
372    */
373    template <class T>
374    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
375    {
376        // check if the static field has already been filled
377        if (ClassIdentifier<T>::classIdentifier_s == 0)
378        {
379            // Get the name of the class
380            std::string name = typeid(T).name();
381
382            // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
383            ClassIdentifier<T> *proposal = new ClassIdentifier<T>();
384
385            // Get the entry from the map
386            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifier(name, proposal);
387        }
388
389        // Finally return the unique ClassIdentifier
390        return ClassIdentifier<T>::classIdentifier_s;
391    }
392
393    /**
394        @brief Sets the name of the class.
395        @param name The name
396    */
397    template <class T>
398    void ClassIdentifier<T>::setName(const std::string& name)
399    {
400        if (!this->bSetName_)
401        {
402            this->name_ = name;
403            this->bSetName_ = true;
404            Identifier::getIdentifierMapIntern()[name] = this;
405            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
406        }
407    }
408
409    /**
410        @brief Adds an object of the given type to the ObjectList.
411        @param object The object to add
412    */
413    template <class T>
414    void ClassIdentifier<T>::addObject(T* object)
415    {
416        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
417        object->getMetaList().add(this->objects_, this->objects_->add(object));
418    }
419
420    /**
421        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
422    */
423    template <class T>
424    void ClassIdentifier<T>::updateConfigValues() const
425    {
426        for (Iterator<T> it = this->objects_->start(); it; ++it)
427            ((T*)*it)->setConfigValues();
428    }
429
430    /**
431        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
432        @param paramname The name of the parameter
433        @return The container
434    */
435    template <class T>
436    XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
437    {
438        typename std::map<std::string, XMLPortClassParamContainer<T>*>::const_iterator it = xmlportParamContainers_.find(paramname);
439        if (it != xmlportParamContainers_.end())
440            return (XMLPortParamContainer*)((*it).second);
441        else
442            return 0;
443    }
444
445    /**
446        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
447        @param paramname The name of the parameter
448        @param container The container
449    */
450    template <class T>
451    void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
452    {
453        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<T>*)container;
454    }
455
456    /**
457        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
458        @param sectionname The name of the section that contains the attachable objects
459        @return The container
460    */
461    template <class T>
462    XMLPortObjectContainer* ClassIdentifier<T>::getXMLPortObjectContainer(const std::string& sectionname)
463    {
464        typename std::map<std::string, XMLPortClassObjectContainer<T, class O>*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
465        if (it != xmlportObjectContainers_.end())
466            return (XMLPortObjectContainer*)((*it).second);
467        else
468            return 0;
469    }
470
471    /**
472        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
473        @param sectionname The name of the section that contains the attachable objects
474        @param container The container
475    */
476    template <class T>
477    void ClassIdentifier<T>::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
478    {
479        this->xmlportObjectContainers_[sectionname] = (XMLPortClassObjectContainer<T, class O>*)container;
480    }
481
482
483    // ###############################
484    // ###   SubclassIdentifier    ###
485    // ###############################
486    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
487    /**
488        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
489        If you assign something else, the program aborts.
490        Because we know the minimal type, a dynamic_cast is done, which makes it easier to create a new object.
491    */
492    template <class T>
493    class SubclassIdentifier
494    {
495        public:
496            /**
497                @brief Constructor: Automaticaly assigns the Identifier of the given class.
498            */
499            SubclassIdentifier()
500            {
501                this->identifier_ = ClassIdentifier<T>::getIdentifier();
502            }
503
504            /**
505                @brief Copyconstructor: Assigns the given Identifier.
506                @param identifier The Identifier
507            */
508            SubclassIdentifier(Identifier* identifier)
509            {
510                this->identifier_ = identifier;
511            }
512
513            /**
514                @brief Overloading of the = operator: assigns the identifier and checks its type.
515                @param identifier The Identifier to assign
516                @return The SubclassIdentifier itself
517            */
518            SubclassIdentifier<T>& operator=(Identifier* identifier)
519            {
520                if (!identifier->isA(ClassIdentifier<T>::getIdentifier()))
521                {
522                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
523                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
524                    COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
525                    COUT(1) << "Aborting..." << std::endl;
526                    abort();
527                }
528                this->identifier_ = identifier;
529                return *this;
530            }
531
532            /**
533                @brief Overloading of the * operator: returns the assigned identifier.
534                @return The assigned identifier
535            */
536            Identifier* operator*()
537            {
538                return this->identifier_;
539            }
540
541            /**
542                @brief Overloading of the -> operator: returns the assigned identifier.
543                @return The assigned identifier
544            */
545            Identifier* operator->() const
546            {
547                return this->identifier_;
548            }
549
550            /**
551                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
552                @return The new object
553            */
554            T* fabricate()
555            {
556                BaseObject* newObject = this->identifier_->fabricate();
557
558                // Check if the creation was successful
559                if (newObject)
560                {
561                    // Do a dynamic_cast, because an object of type T is much better than of type BaseObject
562                    return (T*)(newObject);
563                }
564                else
565                {
566                    // Something went terribly wrong
567                    if (this->identifier_)
568                    {
569                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
570                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
571                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
572                        COUT(1) << "Aborting..." << std::endl;
573                    }
574                    else
575                    {
576                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
577                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
578                        COUT(1) << "Aborting..." << std::endl;
579                    }
580
581                    abort();
582                }
583            }
584
585            /** @brief Returns the assigned identifier. @return The identifier */
586            inline const Identifier* getIdentifier() const
587                { return this->identifier_; }
588
589            /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
590            inline bool isA(const Identifier* identifier) const
591                { return this->identifier_->isA(identifier); }
592
593            /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
594            inline bool isExactlyA(const Identifier* identifier) const
595                { return this->identifier_->isExactlyA(identifier); }
596
597            /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
598            inline bool isChildOf(const Identifier* identifier) const
599                { return this->identifier_->isChildOf(identifier); }
600
601            /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
602            inline bool isDirectChildOf(const Identifier* identifier) const
603                { return this->identifier_->isDirectChildOf(identifier); }
604
605            /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
606            inline bool isParentOf(const Identifier* identifier) const
607                { return this->identifier_->isParentOf(identifier); }
608
609            /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
610            inline bool isDirectParentOf(const Identifier* identifier) const
611                { return this->identifier_->isDirectParentOf(identifier); }
612
613        private:
614            Identifier* identifier_;            //!< The assigned identifier
615    };
616}
617
618#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.