Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: sandbox/src/libraries/core/Identifier.h @ 5910

Last change on this file since 5910 was 5782, checked in by rgrieder, 15 years ago

Applied changes to the real sandbox this time.

  • Property svn:eol-style set to native
File size: 27.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
31    @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
32
33    The Identifier contains all needed information 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 <cassert>
58#include <map>
59#include <set>
60#include <string>
61#include <typeinfo>
62
63#include "util/Debug.h"
64#include "util/TypeTraits.h"
65#include "MetaObjectList.h"
66#include "ObjectList.h"
67#include "ObjectListBase.h"
68
69namespace orxonox
70{
71    // ###############################
72    // ###       Identifier        ###
73    // ###############################
74    //! The Identifier is used to identify the class of an object and to store information about the class.
75    /**
76        The Identifier contains all needed information about the class it belongs to:
77         - the name
78         - a list with all objects
79         - parents and children
80         - the factory (if available)
81         - the networkID that can be synchronised with the server
82         - all configurable variables (if available)
83
84        Every object has a pointer to the Identifier of its class. This allows the use isA(...),
85        isExactlyA(...), isChildOf(...) and isParentOf(...).
86
87        You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
88    */
89    class _CoreExport Identifier
90    {
91        template <class T>
92        friend class SubclassIdentifier;
93
94        friend class Factory;
95
96        public:
97            /** @brief Sets the Factory. @param factory The factory to assign */
98            inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
99
100            BaseObject* fabricate(BaseObject* creator);
101            bool isA(const Identifier* identifier) const;
102            bool isExactlyA(const Identifier* identifier) const;
103            bool isChildOf(const Identifier* identifier) const;
104            bool isDirectChildOf(const Identifier* identifier) const;
105            bool isParentOf(const Identifier* identifier) const;
106            bool isDirectParentOf(const Identifier* identifier) const;
107
108            /** @brief Returns the list of all existing objects of this class. @return The list */
109            inline ObjectListBase* getObjects() const
110                { return this->objects_; }
111
112            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
113            inline const std::string& getName() const { return this->name_; }
114            void setName(const std::string& name);
115
116            virtual void updateConfigValues(bool updateChildren = true) const = 0;
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 true if this class has at least one config value. @return True if this class has at least one config value */
178            inline bool hasConfigValues() const { return this->bHasConfigValues_; }
179
180            /** @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 */
181            inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
182
183            /** @brief Returns the unique ID of the class */
184            FORCEINLINE unsigned int getClassID() const { return this->classID_; }
185
186            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
187            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
188            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
189
190            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
191
192            static void destroyAllIdentifiers();
193
194        protected:
195            Identifier();
196            Identifier(const Identifier& identifier); // don't copy
197            virtual ~Identifier();
198
199            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
200
201            /** @brief Returns the map that stores all Identifiers. @return The map */
202            static std::map<std::string, Identifier*>& getIdentifierMapIntern();
203            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
204            static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
205
206            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
207            inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
208            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
209            inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
210
211            ObjectListBase* objects_;                                      //!< The list of all objects of this class
212
213        private:
214            /**
215                @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
216            */
217            inline static void startCreatingHierarchy()
218            {
219                hierarchyCreatingCounter_s++;
220                COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
221            }
222
223            /**
224                @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
225            */
226            inline static void stopCreatingHierarchy()
227            {
228                hierarchyCreatingCounter_s--;
229                COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
230            }
231
232            static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
233
234            void initialize(std::set<const Identifier*>* parents);
235
236            std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
237            std::set<const Identifier*>* children_;                        //!< The children of the class the Identifier belongs to
238
239            std::set<const Identifier*> directParents_;                    //!< The direct parents of the class the Identifier belongs to
240            std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
241
242            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
243            bool bSetName_;                                                //!< True if the name is set
244            std::string name_;                                             //!< The name of the class the Identifier belongs to
245            BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
246            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)
247            const unsigned int classID_;                                   //!< Uniquely identifies a class (might not be the same as the networkID_)
248            static unsigned int classIDCounter_s;                          //!< Static counter for the unique classIDs
249
250            bool bHasConfigValues_;                                        //!< True if this class has at least one assigned config value
251            std::map<std::string, ConfigValueContainer*> configValues_;    //!< A map to link the string of configurable variables with their ConfigValueContainer
252            std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
253    };
254
255    _CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
256
257
258    // ###############################
259    // ###     ClassIdentifier     ###
260    // ###############################
261    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
262    /**
263        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
264        This makes it possible to store information about a class, sharing them with all
265        objects of that class without defining static variables in every class.
266
267        To be really sure that not more than exactly one object exists (even with libraries),
268        ClassIdentifiers are stored in the Identifier Singleton.
269    */
270    template <class T>
271    class ClassIdentifier : public Identifier
272    {
273        public:
274            static ClassIdentifier<T> *getIdentifier();
275            static ClassIdentifier<T> *getIdentifier(const std::string& name);
276
277            bool initialiseObject(T* object, const std::string& className, bool bRootClass);
278
279            void updateConfigValues(bool updateChildren = true) const;
280
281        private:
282            static void initialiseIdentifier();
283            ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
284            ClassIdentifier()
285            {
286            }
287            ~ClassIdentifier()
288            {
289            }
290
291            static ClassIdentifier<T>* classIdentifier_s;
292    };
293
294    template <class T>
295    ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
296
297    /**
298        @brief Returns the only instance of this class.
299        @return The unique Identifier
300    */
301    template <class T>
302    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
303    {
304        // check if the static field has already been filled
305        if (ClassIdentifier<T>::classIdentifier_s == 0)
306            ClassIdentifier<T>::initialiseIdentifier();
307
308        return ClassIdentifier<T>::classIdentifier_s;
309    }
310
311    /**
312        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
313        @param name The name of this Identifier
314        @return The Identifier
315    */
316    template <class T>
317    inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
318    {
319        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
320        identifier->setName(name);
321        return identifier;
322    }
323
324    /**
325        @brief Assigns the static field for the identifier singleton.
326    */
327    template <class T>
328    void ClassIdentifier<T>::initialiseIdentifier()
329    {
330        // Get the name of the class
331        std::string name = typeid(T).name();
332
333        // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
334        ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
335
336        // Get the entry from the map
337        ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
338
339        if (ClassIdentifier<T>::classIdentifier_s == proposal)
340        {
341            COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
342        }
343        else
344        {
345            COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
346        }
347    }
348
349    /**
350        @brief Adds an object of the given type to the ObjectList.
351        @param object The object to add
352    */
353    template <class T>
354    bool ClassIdentifier<T>::initialiseObject(T* object, const std::string& className, bool bRootClass)
355    {
356        if (bRootClass)
357            COUT(5) << "*** Register Root-Object: " << className << std::endl;
358        else
359            COUT(5) << "*** Register Object: " << className << std::endl;
360
361        object->identifier_ = this;
362        if (Identifier::isCreatingHierarchy())
363        {
364            if (bRootClass && !object->parents_)
365                object->parents_ = new std::set<const Identifier*>();
366
367            if (object->parents_)
368            {
369                this->initializeClassHierarchy(object->parents_, bRootClass);
370                object->parents_->insert(object->parents_->end(), this);
371            }
372
373            object->setConfigValues();
374            return true;
375        }
376        else
377        {
378            COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
379            object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
380
381            // Add pointer of type T to the map in the OrxonoxClass instance that enables "dynamic_casts"
382            object->objectPointers_.push_back(std::make_pair(this->getClassID(), static_cast<void*>(object)));
383            return false;
384        }
385    }
386
387    /**
388        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
389    */
390    template <class T>
391    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
392    {
393        if (!this->hasConfigValues())
394            return;
395
396        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
397            it->setConfigValues();
398
399        if (updateChildren)
400            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
401                (*it)->updateConfigValues(false);
402    }
403
404
405    // ###############################
406    // ###      orxonox_cast       ###
407    // ###############################
408    /**
409    @brief
410        Casts on object of type OrxonoxClass to any derived type that is
411        registered in the class hierarchy.
412    @return
413        Returns NULL if the cast is not possible
414    @note
415        In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
416        a class forgot to register its objects.
417        Also note that the function is implemented differently for GCC/MSVC.
418    */
419    template <class T, class U>
420    FORCEINLINE T orxonox_cast(U source)
421    {
422#ifdef ORXONOX_COMPILER_MSVC
423        typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
424        if (source != NULL)
425            return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
426        else
427            return NULL;
428#else
429        return dynamic_cast<T>(source);
430#endif
431    }
432
433
434    // ###############################
435    // ###   SubclassIdentifier    ###
436    // ###############################
437    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
438    /**
439        You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
440        If you assign something else, the program aborts.
441        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
442    */
443    template <class T>
444    class SubclassIdentifier
445    {
446        public:
447            /**
448                @brief Constructor: Automaticaly assigns the Identifier of the given class.
449            */
450            SubclassIdentifier()
451            {
452                this->identifier_ = ClassIdentifier<T>::getIdentifier();
453            }
454
455            /**
456                @brief Copyconstructor: Assigns the given Identifier.
457                @param identifier The Identifier
458            */
459            SubclassIdentifier(Identifier* identifier)
460            {
461                this->operator=(identifier);
462            }
463
464            /**
465                @brief Overloading of the = operator: assigns the identifier and checks its type.
466                @param identifier The Identifier to assign
467                @return The SubclassIdentifier itself
468            */
469            SubclassIdentifier<T>& operator=(Identifier* identifier)
470            {
471                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
472                {
473                    COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
474                    if (identifier)
475                    {
476                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
477                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
478                    }
479                    else
480                    {
481                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
482                    }
483                }
484                else
485                {
486                    this->identifier_ = identifier;
487                }
488                return *this;
489            }
490
491            /**
492                @brief Overloading of the * operator: returns the assigned identifier.
493            */
494            inline Identifier* operator*() const
495            {
496                return this->identifier_;
497            }
498
499            /**
500                @brief Overloading of the -> operator: returns the assigned identifier.
501            */
502            inline Identifier* operator->() const
503            {
504                return this->identifier_;
505            }
506
507            /**
508                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
509            */
510            inline operator Identifier*() const
511            {
512                return this->identifier_;
513            }
514
515            /**
516                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
517                @return The new object
518            */
519            T* fabricate(BaseObject* creator) const
520            {
521                BaseObject* newObject = this->identifier_->fabricate(creator);
522
523                // Check if the creation was successful
524                if (newObject)
525                {
526                    return orxonox_cast<T*>(newObject);
527                }
528                else
529                {
530                    // Something went terribly wrong
531                    if (this->identifier_)
532                    {
533                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
534                        COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
535                        COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
536                        COUT(1) << "Aborting..." << std::endl;
537                    }
538                    else
539                    {
540                        COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
541                        COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
542                        COUT(1) << "Aborting..." << std::endl;
543                    }
544
545                    assert(false);
546                    return 0;
547                }
548            }
549
550            /** @brief Returns the assigned identifier. @return The identifier */
551            inline Identifier* getIdentifier() const
552                { return this->identifier_; }
553
554        private:
555            Identifier* identifier_;            //!< The assigned identifier
556    };
557}
558
559#endif /* _Identifier_H__ */
Note: See TracBrowser for help on using the repository browser.