Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/archive/toonshader/src/core/Identifier.h

Last change on this file was 2784, checked in by rgrieder, 16 years ago
Using std::vector instead of std::list in register/unregister Iterator/ObjectListIterator. That is approximately 6 times faster because the list has very few elements. Inlined getIdentifier() for sure by exporting the heavy part to another function. Also eliminated the need of isFirstCall() because the "static initialisation chaos" only applies to variables that cannot be evaluated at compile time.
Property svn:eol-style set to `native`
File size: 34.5 KB

Line
1	/*
2	* ORXONOX - the hottest 3D action shooter ever to exist
3	* > www.orxonox.net <
4	*
5	*
6	* License notice:
7	*
8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License
10	* as published by the Free Software Foundation; either version 2
11	* of the License, or (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21	*
22	* Author:
23	* Fabian 'x3n' Landau
24	* Co-authors:
25	* ...
26	*
27	*/
28
29	/**
30	@file
31	@brief Definition of the Identifier, 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
360	void updateConfigValues(bool updateChildren = true) const;
361
362	private:
363	static void initialiseIdentifier();
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 = 0;
379
380	/**
381	@brief Returns the only instance of this class.
382	@return The unique Identifier
383	*/
384	template <class T>
385	ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
386	{
387	// check if the static field has already been filled
388	if (ClassIdentifier<T>::classIdentifier_s == 0)
389	ClassIdentifier<T>::initialiseIdentifier();
390
391	return ClassIdentifier<T>::classIdentifier_s;
392	}
393
394	/**
395	@brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
396	@param name The name of this Identifier
397	@return The Identifier
398	*/
399	template <class T>
400	ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
401	{
402	ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
403	identifier->setName(name);
404	return identifier;
405	}
406
407	/**
408	@brief Assigns the static field for the identifier singleton.
409	*/
410	template <class T>
411	void ClassIdentifier<T>::initialiseIdentifier()
412	{
413	// Get the name of the class
414	std::string name = typeid(T).name();
415
416	// create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
417	ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
418
419	// Get the entry from the map
420	ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
421
422	if (ClassIdentifier<T>::classIdentifier_s == proposal)
423	{
424	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
425	}
426	else
427	{
428	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
429	}
430	}
431
432	/**
433	@brief Adds an object of the given type to the ObjectList.
434	@param object The object to add
435	*/
436	template <class T>
437	void ClassIdentifier<T>::addObject(T* object)
438	{
439	COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
440	object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
441	if (this->bHasConstructionCallback_)
442	{
443	// Call all registered callbacks that a new object of type T has been created.
444	// Do NOT deliver a T* pointer here because it's way too risky (object not yet fully created).
445	for (unsigned int i = 0; i < this->constructionCallbacks_.size(); ++i)
446	(*constructionCallbacks_[i])();
447	}
448	}
449
450	/**
451	@brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
452	*/
453	template <class T>
454	void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
455	{
456	if (!this->hasConfigValues())
457	return;
458
459	for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
460	it->setConfigValues();
461
462	if (updateChildren)
463	for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
464	(*it)->updateConfigValues(false);
465	}
466
467
468	// ###############################
469	// ### SubclassIdentifier ###
470	// ###############################
471	//! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
472	/**
473	You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
474	If you assign something else, the program aborts.
475	Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
476	*/
477	template <class T>
478	class SubclassIdentifier
479	{
480	public:
481	/**
482	@brief Constructor: Automaticaly assigns the Identifier of the given class.
483	*/
484	SubclassIdentifier()
485	{
486	this->identifier_ = ClassIdentifier<T>::getIdentifier();
487	}
488
489	/**
490	@brief Copyconstructor: Assigns the given Identifier.
491	@param identifier The Identifier
492	*/
493	SubclassIdentifier(Identifier* identifier)
494	{
495	this->operator=(identifier);
496	}
497
498	/**
499	@brief Overloading of the = operator: assigns the identifier and checks its type.
500	@param identifier The Identifier to assign
501	@return The SubclassIdentifier itself
502	*/
503	SubclassIdentifier<T>& operator=(Identifier* identifier)
504	{
505	if (!identifier \|\| !identifier->isA(ClassIdentifier<T>::getIdentifier()))
506	{
507	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
508	if (identifier)
509	{
510	COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
511	COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
512	}
513	else
514	{
515	COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
516	}
517	}
518	else
519	{
520	this->identifier_ = identifier;
521	}
522	return *this;
523	}
524
525	/**
526	@brief Overloading of the * operator: returns the assigned identifier.
527	*/
528	inline Identifier* operator*() const
529	{
530	return this->identifier_;
531	}
532
533	/**
534	@brief Overloading of the -> operator: returns the assigned identifier.
535	*/
536	inline Identifier* operator->() const
537	{
538	return this->identifier_;
539	}
540
541	/**
542	@brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
543	*/
544	inline operator Identifier*() const
545	{
546	return this->identifier_;
547	}
548
549	/**
550	@brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
551	@return The new object
552	*/
553	T* fabricate(BaseObject* creator) const
554	{
555	BaseObject* newObject = this->identifier_->fabricate(creator);
556
557	// Check if the creation was successful
558	if (newObject)
559	{
560	return dynamic_cast<T*>(newObject);
561	}
562	else
563	{
564	// Something went terribly wrong
565	if (this->identifier_)
566	{
567	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
568	COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
569	COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
570	COUT(1) << "Aborting..." << std::endl;
571	}
572	else
573	{
574	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
575	COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
576	COUT(1) << "Aborting..." << std::endl;
577	}
578
579	assert(false);
580	return 0;
581	}
582	}
583
584	/** @brief Returns the assigned identifier. @return The identifier */
585	inline Identifier* getIdentifier() const
586	{ return this->identifier_; }
587
588	// /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
589	// inline bool isA(const Identifier* identifier) const
590	// { return this->identifier_->isA(identifier); }
591	//
592	// /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
593	// inline bool isExactlyA(const Identifier* identifier) const
594	// { return this->identifier_->isExactlyA(identifier); }
595	//
596	// /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
597	// inline bool isChildOf(const Identifier* identifier) const
598	// { return this->identifier_->isChildOf(identifier); }
599	//
600	// /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
601	// inline bool isDirectChildOf(const Identifier* identifier) const
602	// { return this->identifier_->isDirectChildOf(identifier); }
603	//
604	// /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
605	// inline bool isParentOf(const Identifier* identifier) const
606	// { return this->identifier_->isParentOf(identifier); }
607	//
608	// /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
609	// inline bool isDirectParentOf(const Identifier* identifier) const
610	// { return this->identifier_->isDirectParentOf(identifier); }
611
612	private:
613	Identifier* identifier_; //!< The assigned identifier
614	};
615	}
616
617	#endif /* _Identifier_H__ */

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

Download in other formats: