Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/core4/src/core/Identifier.h @ 5712

Last change on this file since 5712 was 3239, checked in by rgrieder, 15 years ago
Found a way to write orxonox_cast<T> instead of orxonox_cast<T> so that the syntax resembles dynamic_cast<T>.
Property svn:eol-style set to `native`
File size: 36.4 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 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 <cassert>
58	#include <map>
59	#include <set>
60	#include <string>
61	#include <typeinfo>
62
63	#include "util/Debug.h"
64	#include "MetaObjectList.h"
65	#include "ObjectList.h"
66	#include "ObjectListBase.h"
67	#include "Super.h"
68
69	namespace orxonox
70	{
71	// ###############################
72	// ### Identifier ###
73	// ###############################
74	//! The Identifier is used to identify the class of an object and to store informations about the class.
75	/**
76	The Identifier contains all needed informations 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 true if the class can be loaded through XML. */
109	inline bool isLoadable() const { return this->bLoadable_; }
110	/** @brief Set the class to be loadable through XML or not. */
111	inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
112
113	/** @brief Returns the list of all existing objects of this class. @return The list */
114	inline ObjectListBase* getObjects() const
115	{ return this->objects_; }
116
117	/** @brief Returns the name of the class the Identifier belongs to. @return The name */
118	inline const std::string& getName() const { return this->name_; }
119	void setName(const std::string& name);
120
121	virtual void updateConfigValues(bool updateChildren = true) const = 0;
122
123	/** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
124	inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
125	/** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
126	inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
127	/** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
128	inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
129
130	/** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
131	inline const std::set<const Identifier>& getChildren() const { return (this->children_); }
132	/** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
133	inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_->begin(); }
134	/** @brief Returns the end-iterator of the children-list. @return The end-iterator */
135	inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_->end(); }
136
137	/** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
138	inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
139	/** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
140	inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
141	/** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
142	inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
143
144	/** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
145	inline const std::set<const Identifier>& getDirectChildren() const { return (this->directChildren_); }
146	/** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
147	inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_->begin(); }
148	/** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
149	inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_->end(); }
150
151
152	/** @brief Returns the map that stores all Identifiers. @return The map */
153	static inline const std::map<std::string, Identifier*>& getIdentifierMap() { return Identifier::getIdentifierMapIntern(); }
154	/** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers. @return The const_iterator */
155	static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapBegin() { return Identifier::getIdentifierMap().begin(); }
156	/** @brief Returns a const_iterator to the end of the map that stores all Identifiers. @return The const_iterator */
157	static inline std::map<std::string, Identifier*>::const_iterator getIdentifierMapEnd() { return Identifier::getIdentifierMap().end(); }
158
159	/** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
160	static inline const std::map<std::string, Identifier*>& getLowercaseIdentifierMap() { return Identifier::getLowercaseIdentifierMapIntern(); }
161	/** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
162	static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapBegin() { return Identifier::getLowercaseIdentifierMap().begin(); }
163	/** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
164	static inline std::map<std::string, Identifier*>::const_iterator getLowercaseIdentifierMapEnd() { return Identifier::getLowercaseIdentifierMap().end(); }
165
166
167	/** @brief Returns the map that stores all config values. @return The const_iterator */
168	inline const std::map<std::string, ConfigValueContainer*>& getConfigValueMap() const { return this->configValues_; }
169	/** @brief Returns a const_iterator to the beginning of the map that stores all config values. @return The const_iterator */
170	inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapBegin() const { return this->configValues_.begin(); }
171	/** @brief Returns a const_iterator to the end of the map that stores all config values. @return The const_iterator */
172	inline std::map<std::string, ConfigValueContainer*>::const_iterator getConfigValueMapEnd() const { return this->configValues_.end(); }
173
174	/** @brief Returns the map that stores all config values with their names in lowercase. @return The const_iterator */
175	inline const std::map<std::string, ConfigValueContainer*>& getLowercaseConfigValueMap() const { return this->configValues_LC_; }
176	/** @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 */
177	inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapBegin() const { return this->configValues_LC_.begin(); }
178	/** @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 */
179	inline std::map<std::string, ConfigValueContainer*>::const_iterator getLowercaseConfigValueMapEnd() const { return this->configValues_LC_.end(); }
180
181
182	/** @brief Returns the map that stores all console commands. @return The const_iterator */
183	inline const std::map<std::string, ConsoleCommand*>& getConsoleCommandMap() const { return this->consoleCommands_; }
184	/** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
185	inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
186	/** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
187	inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
188
189	/** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
190	inline const std::map<std::string, ConsoleCommand*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
191	/** @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 */
192	inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
193	/** @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 */
194	inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
195
196	/** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
197	inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
198	/** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort params. @return The const_iterator */
199	inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
200	/** @brief Returns a const_iterator to the end of the map that stores all XMLPort params. @return The const_iterator */
201	inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
202
203	/** @brief Returns the map that stores all XMLPort objects. @return The const_iterator */
204	inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
205	/** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort objects. @return The const_iterator */
206	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
207	/** @brief Returns a const_iterator to the end of the map that stores all XMLPort objects. @return The const_iterator */
208	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
209
210	/** @brief Returns the map that stores all XMLPort events. @return The const_iterator */
211	inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortEventMap() const { return this->xmlportEventContainers_; }
212	/** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort events. @return The const_iterator */
213	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapBegin() const { return this->xmlportEventContainers_.begin(); }
214	/** @brief Returns a const_iterator to the end of the map that stores all XMLPort events. @return The const_iterator */
215	inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapEnd() const { return this->xmlportEventContainers_.end(); }
216
217	/** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
218	inline bool hasConfigValues() const { return this->bHasConfigValues_; }
219	/** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
220	inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
221
222	/** @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 */
223	inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
224
225	/** @brief Returns the network ID to identify a class through the network. @return the network ID */
226	inline const uint32_t getNetworkID() const { return this->networkID_; }
227
228	/** @brief Sets the network ID to a new value. @param id The new value */
229	void setNetworkID(uint32_t id);
230
231	/** @brief Returns the unique ID of the class */
232	FORCEINLINE unsigned int getClassID() const { return this->classID_; }
233
234	void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
235	ConfigValueContainer* getConfigValueContainer(const std::string& varname);
236	ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
237
238	void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
239	XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
240
241	void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
242	XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
243
244	void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
245	XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
246
247	ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
248	ConsoleCommand* getConsoleCommand(const std::string& name) const;
249	ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
250
251	void initializeClassHierarchy(std::set<const Identifier> parents, bool bRootClass);
252
253	static void destroyAllIdentifiers();
254
255	protected:
256	Identifier();
257	Identifier(const Identifier& identifier); // don't copy
258	virtual ~Identifier();
259
260	static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
261	virtual void createSuperFunctionCaller() const = 0;
262
263	/** @brief Returns the map that stores all Identifiers. @return The map */
264	static std::map<std::string, Identifier*>& getIdentifierMapIntern();
265	/** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
266	static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
267
268	/** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
269	inline std::set<const Identifier>& getChildrenIntern() const { return (this->children_); }
270	/** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
271	inline std::set<const Identifier>& getDirectChildrenIntern() const { return (this->directChildren_); }
272
273	ObjectListBase* objects_; //!< The list of all objects of this class
274
275	private:
276	/**
277	@brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
278	*/
279	inline static void startCreatingHierarchy()
280	{
281	hierarchyCreatingCounter_s++;
282	COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
283	}
284
285	/**
286	@brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
287	*/
288	inline static void stopCreatingHierarchy()
289	{
290	hierarchyCreatingCounter_s--;
291	COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
292	}
293
294	static std::map<std::string, Identifier*>& getTypeIDIdentifierMap();
295
296	void initialize(std::set<const Identifier> parents);
297
298	std::set<const Identifier*> parents_; //!< The parents of the class the Identifier belongs to
299	std::set<const Identifier> children_; //!< The children of the class the Identifier belongs to
300
301	std::set<const Identifier*> directParents_; //!< The direct parents of the class the Identifier belongs to
302	std::set<const Identifier> directChildren_; //!< The direct children of the class the Identifier belongs to
303
304	bool bCreatedOneObject_; //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
305	bool bSetName_; //!< True if the name is set
306	bool bLoadable_; //!< False = it's not permitted to load the object through XML
307	std::string name_; //!< The name of the class the Identifier belongs to
308	BaseFactory* factory_; //!< The Factory, able to create new objects of the given class (if available)
309	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)
310	uint32_t networkID_; //!< The network ID to identify a class through the network
311	const unsigned int classID_; //!< Uniquely identifies a class (might not be the same as the networkID_)
312	static unsigned int classIDCounter_s; //!< Static counter for the unique classIDs
313
314	bool bHasConfigValues_; //!< True if this class has at least one assigned config value
315	std::map<std::string, ConfigValueContainer*> configValues_; //!< A map to link the string of configurable variables with their ConfigValueContainer
316	std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
317
318	bool bHasConsoleCommands_; //!< True if this class has at least one assigned console command
319	std::map<std::string, ConsoleCommand*> consoleCommands_; //!< All console commands of this class
320	std::map<std::string, ConsoleCommand*> consoleCommands_LC_; //!< All console commands of this class with their names in lowercase
321
322	std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_; //!< All loadable parameters
323	std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_; //!< All attachable objects
324	std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_; //!< All events
325	};
326
327	_CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
328
329
330	// ###############################
331	// ### ClassIdentifier ###
332	// ###############################
333	//! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
334	/**
335	ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
336	This makes it possible to store informations about a class, sharing them with all
337	objects of that class without defining static variables in every class.
338
339	To be really sure that not more than exactly one object exists (even with libraries),
340	ClassIdentifiers are stored in the Identifier Singleton.
341	*/
342	template <class T>
343	class ClassIdentifier : public Identifier
344	{
345	#define SUPER_INTRUSIVE_DECLARATION_INCLUDE
346	#include "Super.h"
347
348	public:
349	static ClassIdentifier<T> *getIdentifier();
350	static ClassIdentifier<T> *getIdentifier(const std::string& name);
351
352	bool initialiseObject(T* object, const std::string& className, bool bRootClass);
353
354	void updateConfigValues(bool updateChildren = true) const;
355
356	private:
357	static void initialiseIdentifier();
358	ClassIdentifier(const ClassIdentifier<T>& identifier) {} // don't copy
359	ClassIdentifier()
360	{
361	SuperFunctionInitialization<0, T>::initialize(this);
362	}
363	~ClassIdentifier()
364	{
365	SuperFunctionDestruction<0, T>::destroy(this);
366	}
367
368	static ClassIdentifier<T>* classIdentifier_s;
369	};
370
371	template <class T>
372	ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s = 0;
373
374	/**
375	@brief Returns the only instance of this class.
376	@return The unique Identifier
377	*/
378	template <class T>
379	inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
380	{
381	// check if the static field has already been filled
382	if (ClassIdentifier<T>::classIdentifier_s == 0)
383	ClassIdentifier<T>::initialiseIdentifier();
384
385	return ClassIdentifier<T>::classIdentifier_s;
386	}
387
388	/**
389	@brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
390	@param name The name of this Identifier
391	@return The Identifier
392	*/
393	template <class T>
394	inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
395	{
396	ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
397	identifier->setName(name);
398	return identifier;
399	}
400
401	/**
402	@brief Assigns the static field for the identifier singleton.
403	*/
404	template <class T>
405	void ClassIdentifier<T>::initialiseIdentifier()
406	{
407	// Get the name of the class
408	std::string name = typeid(T).name();
409
410	// create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
411	ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
412
413	// Get the entry from the map
414	ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
415
416	if (ClassIdentifier<T>::classIdentifier_s == proposal)
417	{
418	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
419	}
420	else
421	{
422	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
423	}
424	}
425
426	/**
427	@brief Adds an object of the given type to the ObjectList.
428	@param object The object to add
429	*/
430	template <class T>
431	bool ClassIdentifier<T>::initialiseObject(T* object, const std::string& className, bool bRootClass)
432	{
433	if (bRootClass)
434	COUT(5) << "*** Register Root-Object: " << className << std::endl;
435	else
436	COUT(5) << "*** Register Object: " << className << std::endl;
437
438	object->identifier_ = this;
439	if (Identifier::isCreatingHierarchy())
440	{
441	if (bRootClass && !object->parents_)
442	object->parents_ = new std::set<const Identifier*>();
443
444	if (object->parents_)
445	{
446	this->initializeClassHierarchy(object->parents_, bRootClass);
447	object->parents_->insert(object->parents_->end(), this);
448	}
449
450	object->setConfigValues();
451	return true;
452	}
453	else
454	{
455	COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
456	object->metaList_->add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
457
458	// Add pointer of type T to the map in the OrxonoxClass instance that enables "dynamic_casts"
459	object->objectPointers_.push_back(std::make_pair(this->getClassID(), reinterpret_cast<void*>(object)));
460	return false;
461	}
462	}
463
464	/**
465	@brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
466	*/
467	template <class T>
468	void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
469	{
470	if (!this->hasConfigValues())
471	return;
472
473	for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
474	it->setConfigValues();
475
476	if (updateChildren)
477	for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
478	(*it)->updateConfigValues(false);
479	}
480
481
482	// ###############################
483	// ### orxonox_cast ###
484	// ###############################
485	//! Helper struct to have orxonox_cast<T*> instead of orxonox_cast<T>
486	template <class T, class U>
487	struct OrxonoxCaster
488	{
489	static T* cast(U* source)
490	{
491	// If you see this function in a compiler error description, it means
492	// you were misusing orxonox_cast. You must always cast to a pointer type!
493	*****T();
494	}
495	};
496
497	//! Helper struct to have orxonox_cast<T> instead of orxonox_cast<T>
498	template <class T, class U>
499	struct OrxonoxCaster<T*, U>
500	{
501	FORCEINLINE static T* cast(U* source)
502	{
503	#ifdef ORXONOX_COMPILER_MSVC
504	return source->template getDerivedPointer<T>(ClassIdentifier<T>::getIdentifier()->getClassID());
505	#else
506	return dynamic_cast<T*>(source);
507	#endif
508	}
509	};
510
511	/**
512	@brief
513	Casts on object of type OrxonoxClass to any derived type that is
514	registered in the class hierarchy.
515	@return
516	Returns NULL if the cast is not possible
517	@note
518	In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
519	a class forgot to register its objects.
520	Also note that the function is implemented differently for GCC/MSVC.
521	*/
522	template <class T, class U>
523	FORCEINLINE T orxonox_cast(U* source)
524	{
525	return OrxonoxCaster<T, U>::cast(source);
526	}
527
528
529	// ###############################
530	// ### SubclassIdentifier ###
531	// ###############################
532	//! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
533	/**
534	You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
535	If you assign something else, the program aborts.
536	Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
537	*/
538	template <class T>
539	class SubclassIdentifier
540	{
541	public:
542	/**
543	@brief Constructor: Automaticaly assigns the Identifier of the given class.
544	*/
545	SubclassIdentifier()
546	{
547	this->identifier_ = ClassIdentifier<T>::getIdentifier();
548	}
549
550	/**
551	@brief Copyconstructor: Assigns the given Identifier.
552	@param identifier The Identifier
553	*/
554	SubclassIdentifier(Identifier* identifier)
555	{
556	this->operator=(identifier);
557	}
558
559	/**
560	@brief Overloading of the = operator: assigns the identifier and checks its type.
561	@param identifier The Identifier to assign
562	@return The SubclassIdentifier itself
563	*/
564	SubclassIdentifier<T>& operator=(Identifier* identifier)
565	{
566	if (!identifier \|\| !identifier->isA(ClassIdentifier<T>::getIdentifier()))
567	{
568	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
569	if (identifier)
570	{
571	COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
572	COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
573	}
574	else
575	{
576	COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
577	}
578	}
579	else
580	{
581	this->identifier_ = identifier;
582	}
583	return *this;
584	}
585
586	/**
587	@brief Overloading of the * operator: returns the assigned identifier.
588	*/
589	inline Identifier* operator*() const
590	{
591	return this->identifier_;
592	}
593
594	/**
595	@brief Overloading of the -> operator: returns the assigned identifier.
596	*/
597	inline Identifier* operator->() const
598	{
599	return this->identifier_;
600	}
601
602	/**
603	@brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
604	*/
605	inline operator Identifier*() const
606	{
607	return this->identifier_;
608	}
609
610	/**
611	@brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
612	@return The new object
613	*/
614	T* fabricate(BaseObject* creator) const
615	{
616	BaseObject* newObject = this->identifier_->fabricate(creator);
617
618	// Check if the creation was successful
619	if (newObject)
620	{
621	return orxonox_cast<T*>(newObject);
622	}
623	else
624	{
625	// Something went terribly wrong
626	if (this->identifier_)
627	{
628	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
629	COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
630	COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
631	COUT(1) << "Aborting..." << std::endl;
632	}
633	else
634	{
635	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
636	COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
637	COUT(1) << "Aborting..." << std::endl;
638	}
639
640	assert(false);
641	return 0;
642	}
643	}
644
645	/** @brief Returns the assigned identifier. @return The identifier */
646	inline Identifier* getIdentifier() const
647	{ return this->identifier_; }
648
649	// /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
650	// inline bool isA(const Identifier* identifier) const
651	// { return this->identifier_->isA(identifier); }
652	//
653	// /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
654	// inline bool isExactlyA(const Identifier* identifier) const
655	// { return this->identifier_->isExactlyA(identifier); }
656	//
657	// /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
658	// inline bool isChildOf(const Identifier* identifier) const
659	// { return this->identifier_->isChildOf(identifier); }
660	//
661	// /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
662	// inline bool isDirectChildOf(const Identifier* identifier) const
663	// { return this->identifier_->isDirectChildOf(identifier); }
664	//
665	// /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
666	// inline bool isParentOf(const Identifier* identifier) const
667	// { return this->identifier_->isParentOf(identifier); }
668	//
669	// /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
670	// inline bool isDirectParentOf(const Identifier* identifier) const
671	// { return this->identifier_->isDirectParentOf(identifier); }
672
673	private:
674	Identifier* identifier_; //!< The assigned identifier
675	};
676	}
677
678	#endif /* _Identifier_H__ */

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

Download in other formats: