Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/core5/src/libraries/core/Identifier.h @ 5783

Last change on this file since 5783 was 5783, checked in by landauf, 15 years ago
some cleanup
Property svn:eol-style set to `native`
File size: 30.5 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 class, definition and implementation of the ClassIdentifier class.
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
49	#ifndef _Identifier_H__
50	#define _Identifier_H__
51
52	#include "CorePrereqs.h"
53
54	#include <cassert>
55	#include <map>
56	#include <set>
57	#include <string>
58	#include <typeinfo>
59
60	#include "util/Debug.h"
61	#include "util/TypeTraits.h"
62	#include "MetaObjectList.h"
63	#include "ObjectList.h"
64	#include "ObjectListBase.h"
65	#include "Super.h"
66
67	namespace orxonox
68	{
69	// ###############################
70	// ### Identifier ###
71	// ###############################
72	//! The Identifier is used to identify the class of an object and to store information about the class.
73	/**
74	The Identifier contains all needed information about the class it belongs to:
75	- the name
76	- a list with all objects
77	- parents and children
78	- the factory (if available)
79	- the networkID that can be synchronised with the server
80	- all configurable variables (if available)
81
82	Every object has a pointer to the Identifier of its class. This allows the use isA(...),
83	isExactlyA(...), isChildOf(...) and isParentOf(...).
84
85	You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
86	*/
87	class _CoreExport Identifier
88	{
89	public:
90	/** @brief Returns the name of the class the Identifier belongs to. @return The name */
91	inline const std::string& getName() const { return this->name_; }
92	void setName(const std::string& name);
93
94	/** @brief Returns the network ID to identify a class through the network. @return the network ID */
95	inline const uint32_t getNetworkID() const { return this->networkID_; }
96	void setNetworkID(uint32_t id);
97
98	/** @brief Returns the unique ID of the class */
99	FORCEINLINE unsigned int getClassID() const { return this->classID_; }
100
101	/** @brief Returns the list of all existing objects of this class. @return The list */
102	inline ObjectListBase* getObjects() const { return this->objects_; }
103
104	/** @brief Sets the Factory. @param factory The factory to assign */
105	inline void addFactory(Factory* factory) { this->factory_ = factory; }
106	/** @brief Returns true if the Identifier has a Factory. */
107	inline bool hasFactory() const { return (this->factory_ != 0); }
108
109	BaseObject* fabricate(BaseObject* creator);
110
111	/** @brief Returns true if the class can be loaded through XML. */
112	inline bool isLoadable() const { return this->bLoadable_; }
113	/** @brief Set the class to be loadable through XML or not. */
114	inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
115
116	bool isA(const Identifier* identifier) const;
117	bool isExactlyA(const Identifier* identifier) const;
118	bool isChildOf(const Identifier* identifier) const;
119	bool isDirectChildOf(const Identifier* identifier) const;
120	bool isParentOf(const Identifier* identifier) const;
121	bool isDirectParentOf(const Identifier* identifier) const;
122
123
124	/////////////////////////////
125	////// Class Hierarchy //////
126	/////////////////////////////
127	static void createClassHierarchy();
128
129	/** @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 */
130	inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
131
132	/** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
133	inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
134	/** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
135	inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
136	/** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
137	inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
138
139	/** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
140	inline const std::set<const Identifier*>& getChildren() const { return this->children_; }
141	/** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
142	inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_.begin(); }
143	/** @brief Returns the end-iterator of the children-list. @return The end-iterator */
144	inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_.end(); }
145
146	/** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
147	inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
148	/** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
149	inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
150	/** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
151	inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
152
153	/** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
154	inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
155	/** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
156	inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_.begin(); }
157	/** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
158	inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
159
160
161	//////////////////////////
162	///// Identifier Map /////
163	//////////////////////////
164	static void destroyAllIdentifiers();
165
166	static Identifier* getIdentifierByString(const std::string& name);
167	static Identifier* getIdentifierByLowercaseString(const std::string& name);
168	static Identifier* getIdentifierByID(uint32_t id);
169
170	static void clearNetworkIDs();
171
172	/** @brief Returns the map that stores all Identifiers with their names. @return The map */
173	static inline const std::map<std::string, Identifier*>& getStringIdentifierMap() { return Identifier::getStringIdentifierMapIntern(); }
174	/** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names. @return The const_iterator */
175	static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin() { return Identifier::getStringIdentifierMap().begin(); }
176	/** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names. @return The const_iterator */
177	static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd() { return Identifier::getStringIdentifierMap().end(); }
178
179	/** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
180	static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap() { return Identifier::getLowercaseStringIdentifierMapIntern(); }
181	/** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
182	static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin() { return Identifier::getLowercaseStringIdentifierMap().begin(); }
183	/** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
184	static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd() { return Identifier::getLowercaseStringIdentifierMap().end(); }
185
186	/** @brief Returns the map that stores all Identifiers with their IDs. @return The map */
187	static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap() { return Identifier::getIDIdentifierMapIntern(); }
188	/** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs. @return The const_iterator */
189	static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin() { return Identifier::getIDIdentifierMap().begin(); }
190	/** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their IDs. @return The const_iterator */
191	static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd() { return Identifier::getIDIdentifierMap().end(); }
192
193
194	/////////////////////////
195	///// Config Values /////
196	/////////////////////////
197	virtual void updateConfigValues(bool updateChildren = true) const = 0;
198
199	/** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
200	inline bool hasConfigValues() const { return this->bHasConfigValues_; }
201
202	/** @brief Returns the map that stores all config values. @return The const_iterator */
203	inline const std::map<std::string, ConfigValueContainer*>& getConfigValueMap() const { return this->configValues_; }
204	/** @brief Returns a const_iterator to the beginning of the map that stores all config values. @return The const_iterator */
205	inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapBegin() const { return this->configValues_.begin(); }
206	/** @brief Returns a const_iterator to the end of the map that stores all config values. @return The const_iterator */
207	inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapEnd() const { return this->configValues_.end(); }
208
209	/** @brief Returns the map that stores all config values with their names in lowercase. @return The const_iterator */
210	inline const std::map<std::string, ConfigValueContainer*>& getLowercaseConfigValueMap() const { return this->configValues_LC_; }
211	/** @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 */
212	inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapBegin() const { return this->configValues_LC_.begin(); }
213	/** @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 */
214	inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
215
216	void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
217	ConfigValueContainer* getConfigValueContainer(const std::string& varname);
218	ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
219
220
221	////////////////////////////
222	///// Console Commands /////
223	////////////////////////////
224	/** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
225	inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
226
227	/** @brief Returns the map that stores all console commands. @return The const_iterator */
228	inline const std::map<std::string, ConsoleCommand*>& getConsoleCommandMap() const { return this->consoleCommands_; }
229	/** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
230	inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
231	/** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
232	inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
233
234	/** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
235	inline const std::map<std::string, ConsoleCommand*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
236	/** @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 */
237	inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
238	/** @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 */
239	inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
240
241	ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
242	ConsoleCommand* getConsoleCommand(const std::string& name) const;
243	ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
244
245
246	///////////////////
247	///// XMLPort /////
248	///////////////////
249	/** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
250	inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
251	/** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort params. @return The const_iterator */
252	inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
253	/** @brief Returns a const_iterator to the end of the map that stores all XMLPort params. @return The const_iterator */
254	inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
255
256	/** @brief Returns the map that stores all XMLPort objects. @return The const_iterator */
257	inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
258	/** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort objects. @return The const_iterator */
259	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
260	/** @brief Returns a const_iterator to the end of the map that stores all XMLPort objects. @return The const_iterator */
261	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
262
263	/** @brief Returns the map that stores all XMLPort events. @return The const_iterator */
264	inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortEventMap() const { return this->xmlportEventContainers_; }
265	/** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort events. @return The const_iterator */
266	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapBegin() const { return this->xmlportEventContainers_.begin(); }
267	/** @brief Returns a const_iterator to the end of the map that stores all XMLPort events. @return The const_iterator */
268	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapEnd() const { return this->xmlportEventContainers_.end(); }
269
270	void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
271	XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
272
273	void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
274	XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
275
276	void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
277	XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
278
279
280	protected:
281	Identifier();
282	Identifier(const Identifier& identifier); // don't copy
283	virtual ~Identifier();
284
285	static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
286	virtual void createSuperFunctionCaller() const = 0;
287
288	void initializeClassHierarchy(std::set<const Identifier> parents, bool bRootClass);
289
290	/** @brief Returns the map that stores all Identifiers with their names. @return The map */
291	static std::map<std::string, Identifier*>& getStringIdentifierMapIntern();
292	/** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
293	static std::map<std::string, Identifier*>& getLowercaseStringIdentifierMapIntern();
294	/** @brief Returns the map that stores all Identifiers with their network IDs. @return The map */
295	static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
296
297	/** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
298	inline std::set<const Identifier*>& getChildrenIntern() const { return this->children_; }
299	/** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
300	inline std::set<const Identifier*>& getDirectChildrenIntern() const { return this->directChildren_; }
301
302	ObjectListBase* objects_; //!< The list of all objects of this class
303
304	private:
305	/** @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents. */
306	inline static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; }
307	/** @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents. */
308	inline static void stopCreatingHierarchy() { hierarchyCreatingCounter_s--; }
309
310	static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
311
312	void initialize(std::set<const Identifier> parents);
313
314	std::set<const Identifier*> parents_; //!< The parents of the class the Identifier belongs to
315	mutable std::set<const Identifier*> children_; //!< The children of the class the Identifier belongs to
316
317	std::set<const Identifier*> directParents_; //!< The direct parents of the class the Identifier belongs to
318	mutable std::set<const Identifier*> directChildren_; //!< The direct children of the class the Identifier belongs to
319
320	bool bCreatedOneObject_; //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
321	bool bSetName_; //!< True if the name is set
322	bool bLoadable_; //!< False = it's not permitted to load the object through XML
323	std::string name_; //!< The name of the class the Identifier belongs to
324	Factory* factory_; //!< The Factory, able to create new objects of the given class (if available)
325	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)
326	uint32_t networkID_; //!< The network ID to identify a class through the network
327	const unsigned int classID_; //!< Uniquely identifies a class (might not be the same as the networkID_)
328	static unsigned int classIDCounter_s; //!< Static counter for the unique classIDs
329
330	bool bHasConfigValues_; //!< True if this class has at least one assigned config value
331	std::map<std::string, ConfigValueContainer*> configValues_; //!< A map to link the string of configurable variables with their ConfigValueContainer
332	std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
333
334	bool bHasConsoleCommands_; //!< True if this class has at least one assigned console command
335	std::map<std::string, ConsoleCommand*> consoleCommands_; //!< All console commands of this class
336	std::map<std::string, ConsoleCommand*> consoleCommands_LC_; //!< All console commands of this class with their names in lowercase
337
338	std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_; //!< All loadable parameters
339	std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_; //!< All attachable objects
340	std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_; //!< All events
341	};
342
343	_CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
344
345
346	// ###############################
347	// ### ClassIdentifier ###
348	// ###############################
349	//! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
350	/**
351	ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
352	This makes it possible to store information about a class, sharing them with all
353	objects of that class without defining static variables in every class.
354
355	To be really sure that not more than exactly one object exists (even with libraries),
356	ClassIdentifiers are stored in the Identifier Singleton.
357	*/
358	template <class T>
359	class ClassIdentifier : public Identifier
360	{
361	#define SUPER_INTRUSIVE_DECLARATION_INCLUDE
362	#include "Super.h"
363
364	public:
365	static ClassIdentifier<T>* getIdentifier();
366	static ClassIdentifier<T>* getIdentifier(const std::string& name);
367
368	bool initialiseObject(T* object, const std::string& className, bool bRootClass);
369
370	void updateConfigValues(bool updateChildren = true) const;
371
372	private:
373	static void initialiseIdentifier();
374	ClassIdentifier(const ClassIdentifier<T>& identifier) {} // don't copy
375	ClassIdentifier()
376	{
377	SuperFunctionInitialization<0, T>::initialize(this);
378	}
379	~ClassIdentifier()
380	{
381	SuperFunctionDestruction<0, T>::destroy(this);
382	}
383
384	static ClassIdentifier<T>* classIdentifier_s;
385	};
386
387	template <class T>
388	ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
389
390	/**
391	@brief Returns the only instance of this class.
392	@return The unique Identifier
393	*/
394	template <class T>
395	inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
396	{
397	// check if the Identifier already exists
398	if (!ClassIdentifier<T>::classIdentifier_s)
399	ClassIdentifier<T>::initialiseIdentifier();
400
401	return ClassIdentifier<T>::classIdentifier_s;
402	}
403
404	/**
405	@brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
406	@param name The name of this Identifier
407	@return The Identifier
408	*/
409	template <class T>
410	inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
411	{
412	ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
413	identifier->setName(name);
414	return identifier;
415	}
416
417	/**
418	@brief Assigns the static field for the identifier singleton.
419	*/
420	template <class T>
421	void ClassIdentifier<T>::initialiseIdentifier()
422	{
423	// Get the name of the class
424	std::string name = typeid(T).name();
425
426	// create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
427	ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
428
429	// Get the entry from the map
430	ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
431
432	if (ClassIdentifier<T>::classIdentifier_s == proposal)
433	{
434	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
435	}
436	else
437	{
438	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
439	}
440	}
441
442	/**
443	@brief Adds an object of the given type to the ObjectList.
444	@param object The object to add
445	*/
446	template <class T>
447	bool ClassIdentifier<T>::initialiseObject(T* object, const std::string& className, bool bRootClass)
448	{
449	if (bRootClass)
450	COUT(5) << "*** Register Root-Object: " << className << std::endl;
451	else
452	COUT(5) << "*** Register Object: " << className << std::endl;
453
454	object->identifier_ = this;
455	if (Identifier::isCreatingHierarchy())
456	{
457	if (bRootClass && !object->parents_)
458	object->parents_ = new std::set<const Identifier*>();
459
460	if (object->parents_)
461	{
462	this->initializeClassHierarchy(object->parents_, bRootClass);
463	object->parents_->insert(object->parents_->end(), this);
464	}
465
466	object->setConfigValues();
467	return true;
468	}
469	else
470	{
471	COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
472	object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
473
474	// Add pointer of type T to the map in the OrxonoxClass instance that enables "dynamic_casts"
475	object->objectPointers_.push_back(std::make_pair(this->getClassID(), static_cast<void*>(object)));
476	return false;
477	}
478	}
479
480	/**
481	@brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
482	*/
483	template <class T>
484	void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
485	{
486	if (!this->hasConfigValues())
487	return;
488
489	for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
490	it->setConfigValues();
491
492	if (updateChildren)
493	for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
494	(*it)->updateConfigValues(false);
495	}
496
497
498	// ###############################
499	// ### orxonox_cast ###
500	// ###############################
501	/**
502	@brief
503	Casts on object of type OrxonoxClass to any derived type that is
504	registered in the class hierarchy.
505	@return
506	Returns NULL if the cast is not possible
507	@note
508	In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
509	a class forgot to register its objects.
510	Also note that the function is implemented differently for GCC/MSVC.
511	*/
512	template <class T, class U>
513	FORCEINLINE T orxonox_cast(U source)
514	{
515	#ifdef ORXONOX_COMPILER_MSVC
516	typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
517	if (source != NULL)
518	return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
519	else
520	return NULL;
521	#else
522	return dynamic_cast<T>(source);
523	#endif
524	}
525	}
526
527	#endif /* _Identifier_H__ */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: