Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/weapon/src/orxonox/core/Identifier.h @ 831

Last change on this file since 831 was 790, checked in by nicolasc, 17 years ago

merged FICN back into trunk
awaiting release.

File size: 17.5 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *
4 *
5 *   License notice:
6 *
7 *   This program is free software; you can redistribute it and/or
8 *   modify it under the terms of the GNU General Public License
9 *   as published by the Free Software Foundation; either version 2
10 *   of the License, or (at your option) any later version.
11 *
12 *   This program is distributed in the hope that it will be useful,
13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 *   GNU General Public License for more details.
16 *
17 *   You should have received a copy of the GNU General Public License
18 *   along with this program; if not, write to the Free Software
19 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20 *
21 *   Author:
22 *      Fabian 'x3n' Landau
23 *   Co-authors:
24 *      ...
25 *
26 */
27
28/*!
29    @file Identifier.h
30    @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
31
32    The Identifier contains all needed informations about the class it belongs to:
33     - the name
34     - a list with all objects
35     - parents and childs
36     - the factory (if available)
37     - the networkID that can be synchronised with the server
38     - all configurable variables (if available)
39
40    Every object has a pointer to the Identifier of its class. This allows the use isA(...),
41    isDirectlyA(...), isChildOf(...) and isParentOf(...).
42
43    To create the class-hierarchy, the Identifier has some intern functions and variables.
44
45    Every Identifier is in fact a ClassIdentifier, but they are derived from Identifier.
46
47    SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
48    You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
49*/
50
51#ifndef _Identifier_H__
52#define _Identifier_H__
53
54#include <map>
55#include <string>
56#include <utility>
57
58#include "CorePrereqs.h"
59
60#include "ObjectList.h"
61#include "IdentifierList.h"
62#include "Debug.h"
63#include "Iterator.h"
64
65namespace orxonox
66{
67    class BaseFactory; // Forward declaration
68    class BaseObject;  // Forward declaration
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        isDirectlyA(...), 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; // Forward declaration
92
93        template <class T>
94        friend class SubclassIdentifier; // Forward declaration
95
96        friend class Factory; // Forward declaration
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 isDirectlyA(const Identifier* identifier) const;
105            bool isChildOf(const Identifier* identifier) const;
106            bool isParentOf(const Identifier* identifier) const;
107
108            static std::map<std::string, Identifier*>& getIdentifierMap();
109
110            /** @brief Removes all objects of the corresponding class. */
111            virtual void removeObjects() const = 0;
112
113            /** @returns the name of the class the Identifier belongs to. */
114            inline const std::string& getName() const { return this->name_; }
115
116            /** @returns the parents of the class the Identifier belongs to. */
117            inline const IdentifierList& getParents() const { return this->parents_; }
118
119            /** @returns the children of the class the Identifier belongs to. */
120            inline IdentifierList& getChildren() const { return *this->children_; }
121
122            /** @returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. */
123            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
124
125            /** @returns the network ID to identify a class through the network. */
126            inline const unsigned int getNetworkID() const { return this->classID_; }
127
128            /** @brief Sets the network ID to a new value. @param id The new value */
129            void setNetworkID(unsigned int id);
130
131            /** @returns the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variable */
132            inline ConfigValueContainer* getConfigValueContainer(const std::string& varname)
133                { return this->configValues_[varname]; }
134
135            /** @brief Sets the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variablee @param container The container */
136            inline void setConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
137                { this->configValues_[varname] = container; }
138
139        private:
140            Identifier();
141            Identifier(const Identifier& identifier) {} // don't copy
142            virtual ~Identifier();
143            void initialize(const IdentifierList* parents);
144
145            /**
146                @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
147            */
148            inline static void startCreatingHierarchy()
149            {
150                hierarchyCreatingCounter_s++;
151                COUT(4) << "*** Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
152            }
153
154            /**
155                @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
156            */
157            inline static void stopCreatingHierarchy()
158            {
159                hierarchyCreatingCounter_s--;
160                COUT(4) << "*** Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
161            }
162
163            IdentifierList parents_;                                    //!< The Parents of the class the Identifier belongs to
164            IdentifierList* children_;                                  //!< The Children of the class the Identifier belongs to
165
166            std::string name_;                                          //!< The name of the class the Identifier belongs to
167
168            BaseFactory* factory_;                                      //!< The Factory, able to create new objects of the given class (if available)
169            bool bCreatedOneObject_;                                    //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
170            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)
171            unsigned int classID_;                                      //!< The network ID to identify a class through the network
172            std::map<std::string, ConfigValueContainer*> configValues_; //!< A map to link the string of configurable variables with their ConfigValueContainer
173    };
174
175
176    // ###############################
177    // ###     ClassIdentifier     ###
178    // ###############################
179    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
180    /**
181        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
182        This makes it possible to store informations about a class, sharing them with all
183        objects of that class without defining static variables in every class.
184    */
185    template <class T>
186    class ClassIdentifier : public Identifier
187    {
188        public:
189            static ClassIdentifier<T>* registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass);
190            static void addObject(T* object);
191            static ClassIdentifier<T>* getIdentifier();
192            void removeObjects() const;
193            void setName(const std::string& name);
194
195        private:
196            ClassIdentifier();
197            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
198            ~ClassIdentifier() {}                                       // don't delete
199
200            ObjectList<T>* objects_;    //!< The ObjectList, containing all objects of type T
201            bool bSetName_;             //!< True if the name is set
202    };
203
204    /**
205        @brief Constructor: Creates the ObjectList.
206    */
207    template <class T>
208    ClassIdentifier<T>::ClassIdentifier()
209    {
210        this->objects_ = ObjectList<T>::getList();
211        this->bSetName_ = false;
212    }
213
214    /**
215        @brief Registers a class, which means that the name and the parents get stored.
216        @param parents An IdentifierList, containing the Identifiers of all parents of the class
217        @param name A string, containing exactly the name of the class
218        @param bRootClass True if the class is either an Interface or the BaseObject itself
219        @return The ClassIdentifier itself
220    */
221    template <class T>
222    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(const IdentifierList* parents, const std::string& name, bool bRootClass)
223    {
224        COUT(4) << "*** Register Class in " << name << "-Singleton." << std::endl;
225
226        // Check if at least one object of the given type was created
227        if (!getIdentifier()->bCreatedOneObject_)
228        {
229            // If no: We have to store the informations and initialize the Identifier
230            getIdentifier()->setName(name);
231
232            COUT(4) << "*** Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
233            if (bRootClass)
234                getIdentifier()->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.
235            else
236                getIdentifier()->initialize(parents);
237        }
238
239        return getIdentifier();
240    }
241
242    /**
243        @brief Creates the only instance of this class for the template class T.
244        @return The Identifier itself
245    */
246    template <class T>
247    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
248    {
249        static ClassIdentifier<T> theOneAndOnlyInstance = ClassIdentifier<T>();
250        static bool bIdentifierCreated = false;
251
252        if (!bIdentifierCreated)
253        {
254            COUT(4) << "*** Create Identifier Singleton." << std::endl;
255            bIdentifierCreated = true;
256        }
257
258        return &theOneAndOnlyInstance;
259    }
260
261    /**
262        @brief Sets the name of the class.
263        @param name The name
264    */
265    template <class T>
266    void ClassIdentifier<T>::setName(const std::string& name)
267    {
268        // Make sure we didn't already set the name, to avoid duplicate entries in the Identifier map
269        if (!this->bSetName_)
270        {
271            this->name_ = name;
272            this->getIdentifierMap().insert(std::pair<std::string, Identifier*>(name, this));
273            this->bSetName_ = true;
274        }
275    }
276
277    /**
278        @brief Adds an object of the given type to the ObjectList.
279        @param object The object to add
280    */
281    template <class T>
282    void ClassIdentifier<T>::addObject(T* object)
283    {
284        COUT(4) << "*** Added object to " << ClassIdentifier<T>::getIdentifier()->getName() << "-list." << std::endl;
285        object->getMetaList().add(ClassIdentifier<T>::getIdentifier()->objects_, ClassIdentifier<T>::getIdentifier()->objects_->add(object));
286    }
287
288    /**
289        @brief Removes all objects of the corresponding class.
290    */
291    template <class T>
292    void ClassIdentifier<T>::removeObjects() const
293    {
294        for (Iterator<T> it = ObjectList<T>::start(); it;)
295            delete *(it++);
296    }
297
298    // ###############################
299    // ###   SubclassIdentifier    ###
300    // ###############################
301    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
302    /**
303        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
304        If you assign something else, the program aborts.
305        Because we know the minimal type, a dynamic_cast is done, which makes it easier to create a new object.
306    */
307    template <class T>
308    class SubclassIdentifier
309    {
310        public:
311            /**
312                @brief Constructor: Automaticaly assigns the Identifier of the given class.
313            */
314            SubclassIdentifier()
315            {
316                this->identifier_ = ClassIdentifier<T>::getIdentifier();
317            }
318
319            /**
320                @brief Overloading of the = operator: assigns the identifier and checks its type.
321                @param identifier The Identifier to assign
322                @return The SubclassIdentifier itself
323            */
324            SubclassIdentifier<T>& operator=(Identifier* identifier)
325            {
326                if (!identifier->isA(ClassIdentifier<T>::getIdentifier()))
327                {
328                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
329                    COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
330                    COUT(1) << "Aborting..." << std::endl;
331                    abort();
332                }
333                this->identifier_ = identifier;
334                return *this;
335            }
336
337            /**
338                @brief Overloading of the * operator: returns the assigned identifier.
339                @return The assigned identifier
340            */
341            Identifier* operator*()
342            {
343                return this->identifier_;
344            }
345
346            /**
347                @brief Overloading of the -> operator: returns the assigned identifier.
348                @return The assigned identifier
349            */
350            Identifier* operator->() const
351            {
352                return this->identifier_;
353            }
354
355            /**
356                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
357                @return The new object
358            */
359            T* fabricate()
360            {
361                BaseObject* newObject = this->identifier_->fabricate();
362
363                // Check if the creation was successful
364                if (newObject)
365                {
366                    // Do a dynamic_cast, because an object of type T is much better than of type BaseObject
367                    return (T*)(newObject);
368                }
369                else
370                {
371                    // Something went terribly wrong
372                    if (this->identifier_)
373                    {
374                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
375                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
376                        COUT(1) << "Aborting..." << std::endl;
377                    }
378                    else
379                    {
380                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
381                        COUT(1) << "Aborting..." << std::endl;
382                    }
383
384                    abort();
385                }
386            }
387
388            /** @returns the assigned identifier. */
389            inline const Identifier* getIdentifier() const
390                { return this->identifier_; }
391
392            /** @returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
393            inline bool isA(const Identifier* identifier) const
394                { return this->identifier_->isA(identifier); }
395
396            /** @returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
397            inline bool isDirectlyA(const Identifier* identifier) const
398                { return this->identifier_->isDirectlyA(identifier); }
399
400            /** @returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
401            inline bool isChildOf(const Identifier* identifier) const
402                { return this->identifier_->isChildOf(identifier); }
403
404            /** @returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
405            inline bool isParentOf(const Identifier* identifier) const
406                { return this->identifier_->isParentOf(identifier); }
407
408        private:
409            Identifier* identifier_;        //!< The assigned identifier
410    };
411}
412
413#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.