Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/weaponsystem/src/core/Identifier.h @ 2984

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

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

Download in other formats: