Context Navigation

Identifier.h @ 2557

Last change on this file since 2557 was 2485, checked in by landauf, 16 years ago

Merged objecthierarchy2 into presentation branch

Couln't merge 2 lines in Gamestate.cc and a whole block of code in GSDedicated.cc (it seems like oli implemented in both branches something like a network-tick-limiter but with different approaches)

Not yet tested in network mode and with bots
The SpaceShips movement is also not yet fully adopted to the new physics (see Engine class)

Property svn:eol-style set to native

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

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

Context Navigation

source: code/branches/presentation/src/core/Identifier.h @ 2557

Download in other formats: