Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/trunk/src/core/Identifier.h @ 3458

Last change on this file since 3458 was 3370, checked in by rgrieder, 15 years ago

Merged resource branch back to the trunk. Changes:

Automated graphics loading by evaluating whether a GameState requires it
Using native Tcl library (x3n)

Windows users: Update your dependency package!

Property svn:eol-style set to native

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

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

Download in other formats: