Context Navigation

Identifier.h @ 2499

Last change on this file since 2499 was 2310, checked in by rgrieder, 16 years ago
Fixed build (missing include).
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 <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	protected:
261	Identifier();
262	Identifier(const Identifier& identifier); // don't copy
263	virtual ~Identifier();
264
265	static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
266	virtual void createSuperFunctionCaller() const = 0;
267
268	/** @brief Returns the map that stores all Identifiers. @return The map */
269	static std::map<std::string, Identifier*>& getIdentifierMapIntern();
270	/** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
271	static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
272
273	/** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
274	inline std::set<const Identifier>& getChildrenIntern() const { return (this->children_); }
275	/** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
276	inline std::set<const Identifier>& getDirectChildrenIntern() const { return (this->directChildren_); }
277
278	bool bHasConstructionCallback_; //!< True if at least one Functor is registered to get informed when an object of type T is created.
279	std::vector<Functor*> constructionCallbacks_; //!< All construction callback Functors of this class.
280
281	ObjectListBase* objects_; //!< The list of all objects of this class
282
283	private:
284	/**
285	@brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
286	*/
287	inline static void startCreatingHierarchy()
288	{
289	hierarchyCreatingCounter_s++;
290	COUT(4) << "*** Identifier: Increased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
291	}
292
293	/**
294	@brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
295	*/
296	inline static void stopCreatingHierarchy()
297	{
298	hierarchyCreatingCounter_s--;
299	COUT(4) << "*** Identifier: Decreased Hierarchy-Creating-Counter to " << hierarchyCreatingCounter_s << std::endl;
300	}
301
302	void initialize(std::set<const Identifier> parents);
303
304	static void destroyAllIdentifiers();
305
306	std::set<const Identifier*> parents_; //!< The parents of the class the Identifier belongs to
307	std::set<const Identifier> children_; //!< The children of the class the Identifier belongs to
308
309	std::set<const Identifier*> directParents_; //!< The direct parents of the class the Identifier belongs to
310	std::set<const Identifier> directChildren_; //!< The direct children of the class the Identifier belongs to
311
312	bool bCreatedOneObject_; //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
313	bool bSetName_; //!< True if the name is set
314	bool bLoadable_; //!< False = it's not permitted to load the object through XML
315	std::string name_; //!< The name of the class the Identifier belongs to
316	BaseFactory* factory_; //!< The Factory, able to create new objects of the given class (if available)
317	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)
318	uint32_t classID_; //!< The network ID to identify a class through the network
319
320	bool bHasConfigValues_; //!< True if this class has at least one assigned config value
321	std::map<std::string, ConfigValueContainer*> configValues_; //!< A map to link the string of configurable variables with their ConfigValueContainer
322	std::map<std::string, ConfigValueContainer*> configValues_LC_; //!< A map to link the string of configurable variables with their ConfigValueContainer
323
324	bool bHasConsoleCommands_; //!< True if this class has at least one assigned console command
325	std::map<std::string, ConsoleCommand*> consoleCommands_; //!< All console commands of this class
326	std::map<std::string, ConsoleCommand*> consoleCommands_LC_; //!< All console commands of this class with their names in lowercase
327
328	std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_; //!< All loadable parameters
329	std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_; //!< All attachable objects
330	std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_; //!< All events
331	};
332
333	_CoreExport std::ostream& operator<<(std::ostream& out, const std::set<const Identifier*>& list);
334
335
336	// ###############################
337	// ### ClassIdentifier ###
338	// ###############################
339	//! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
340	/**
341	ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
342	This makes it possible to store informations about a class, sharing them with all
343	objects of that class without defining static variables in every class.
344
345	To be really sure that not more than exactly one object exists (even with libraries),
346	ClassIdentifiers are stored in the Identifier Singleton.
347	*/
348	template <class T>
349	class ClassIdentifier : public Identifier
350	{
351	#define SUPER_INTRUSIVE_DECLARATION_INCLUDE
352	#include "Super.h"
353
354	public:
355	static ClassIdentifier<T> *getIdentifier();
356	static ClassIdentifier<T> *getIdentifier(const std::string& name);
357	void addObject(T* object);
358	static bool isFirstCall();
359
360	void updateConfigValues(bool updateChildren = true) const;
361
362	private:
363	ClassIdentifier(const ClassIdentifier<T>& identifier) {} // don't copy
364	ClassIdentifier()
365	{
366	SuperFunctionInitialization<0, T>::initialize(this);
367	}
368	~ClassIdentifier()
369	{
370	SuperFunctionDestruction<0, T>::destroy(this);
371	}
372
373	static ClassIdentifier<T>* classIdentifier_s;
374	};
375
376	template <class T>
377	ClassIdentifier<T>* ClassIdentifier<T>::classIdentifier_s;
378
379	/**
380	@brief Returns true if the function gets called the first time, false otherwise.
381	@return True if this function got called the first time.
382	*/
383	template <class T>
384	bool ClassIdentifier<T>::isFirstCall()
385	{
386	static bool bFirstCall = true;
387
388	if (bFirstCall)
389	{
390	bFirstCall = false;
391	return true;
392	}
393	else
394	{
395	return false;
396	}
397	}
398
399	/**
400	@brief Returns the only instance of this class.
401	@return The unique Identifier
402	*/
403	template <class T>
404	ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
405	{
406	// check if the static field has already been filled
407	if (ClassIdentifier<T>::isFirstCall())
408	{
409	// Get the name of the class
410	std::string name = typeid(T).name();
411
412	// create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
413	ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
414
415	// Get the entry from the map
416	ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
417
418	if (ClassIdentifier<T>::classIdentifier_s == proposal)
419	{
420	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
421	}
422	else
423	{
424	COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
425	}
426	}
427
428	// Finally return the unique ClassIdentifier
429	return ClassIdentifier<T>::classIdentifier_s;
430	}
431
432	/**
433	@brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
434	@param name The name of this Identifier
435	@return The Identifier
436	*/
437	template <class T>
438	ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
439	{
440	ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
441	identifier->setName(name);
442	return identifier;
443	}
444
445	/**
446	@brief Adds an object of the given type to the ObjectList.
447	@param object The object to add
448	*/
449	template <class T>
450	void ClassIdentifier<T>::addObject(T* object)
451	{
452	COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
453	object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
454	if (this->bHasConstructionCallback_)
455	{
456	// Call all registered callbacks that a new object of type T has been created.
457	// Do NOT deliver a T* pointer here because it's way too risky (object not yet fully created).
458	for (unsigned int i = 0; i < this->constructionCallbacks_.size(); ++i)
459	(*constructionCallbacks_[i])();
460	}
461	}
462
463	/**
464	@brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
465	*/
466	template <class T>
467	void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
468	{
469	if (!this->hasConfigValues())
470	return;
471
472	for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
473	it->setConfigValues();
474
475	if (updateChildren)
476	for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
477	(*it)->updateConfigValues(false);
478	}
479
480
481	// ###############################
482	// ### SubclassIdentifier ###
483	// ###############################
484	//! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
485	/**
486	You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
487	If you assign something else, the program aborts.
488	Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
489	*/
490	template <class T>
491	class SubclassIdentifier
492	{
493	public:
494	/**
495	@brief Constructor: Automaticaly assigns the Identifier of the given class.
496	*/
497	SubclassIdentifier()
498	{
499	this->identifier_ = ClassIdentifier<T>::getIdentifier();
500	}
501
502	/**
503	@brief Copyconstructor: Assigns the given Identifier.
504	@param identifier The Identifier
505	*/
506	SubclassIdentifier(Identifier* identifier)
507	{
508	this->operator=(identifier);
509	}
510
511	/**
512	@brief Overloading of the = operator: assigns the identifier and checks its type.
513	@param identifier The Identifier to assign
514	@return The SubclassIdentifier itself
515	*/
516	SubclassIdentifier<T>& operator=(Identifier* identifier)
517	{
518	if (!identifier \|\| !identifier->isA(ClassIdentifier<T>::getIdentifier()))
519	{
520	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
521	if (identifier)
522	{
523	COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
524	COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
525	}
526	else
527	{
528	COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
529	}
530	}
531	else
532	{
533	this->identifier_ = identifier;
534	}
535	return *this;
536	}
537
538	/**
539	@brief Overloading of the * operator: returns the assigned identifier.
540	*/
541	inline Identifier* operator*() const
542	{
543	return this->identifier_;
544	}
545
546	/**
547	@brief Overloading of the -> operator: returns the assigned identifier.
548	*/
549	inline Identifier* operator->() const
550	{
551	return this->identifier_;
552	}
553
554	/**
555	@brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
556	*/
557	inline operator Identifier*() const
558	{
559	return this->identifier_;
560	}
561
562	/**
563	@brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
564	@return The new object
565	*/
566	T* fabricate(BaseObject* creator) const
567	{
568	BaseObject* newObject = this->identifier_->fabricate(creator);
569
570	// Check if the creation was successful
571	if (newObject)
572	{
573	return dynamic_cast<T*>(newObject);
574	}
575	else
576	{
577	// Something went terribly wrong
578	if (this->identifier_)
579	{
580	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
581	COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
582	COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
583	COUT(1) << "Aborting..." << std::endl;
584	}
585	else
586	{
587	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
588	COUT(1) << "Error: Couldn't fabricate a new Object - Identifier is undefined." << std::endl;
589	COUT(1) << "Aborting..." << std::endl;
590	}
591
592	assert(false);
593	return 0;
594	}
595	}
596
597	/** @brief Returns the assigned identifier. @return The identifier */
598	inline Identifier* getIdentifier() const
599	{ return this->identifier_; }
600
601	// /** @brief Returns true, if the assigned identifier is at least of the given type. @param identifier The identifier to compare with */
602	// inline bool isA(const Identifier* identifier) const
603	// { return this->identifier_->isA(identifier); }
604	//
605	// /** @brief Returns true, if the assigned identifier is exactly of the given type. @param identifier The identifier to compare with */
606	// inline bool isExactlyA(const Identifier* identifier) const
607	// { return this->identifier_->isExactlyA(identifier); }
608	//
609	// /** @brief Returns true, if the assigned identifier is a child of the given identifier. @param identifier The identifier to compare with */
610	// inline bool isChildOf(const Identifier* identifier) const
611	// { return this->identifier_->isChildOf(identifier); }
612	//
613	// /** @brief Returns true, if the assigned identifier is a direct child of the given identifier. @param identifier The identifier to compare with */
614	// inline bool isDirectChildOf(const Identifier* identifier) const
615	// { return this->identifier_->isDirectChildOf(identifier); }
616	//
617	// /** @brief Returns true, if the assigned identifier is a parent of the given identifier. @param identifier The identifier to compare with */
618	// inline bool isParentOf(const Identifier* identifier) const
619	// { return this->identifier_->isParentOf(identifier); }
620	//
621	// /** @brief Returns true, if the assigned identifier is a direct parent of the given identifier. @param identifier The identifier to compare with */
622	// inline bool isDirectParentOf(const Identifier* identifier) const
623	// { return this->identifier_->isDirectParentOf(identifier); }
624
625	private:
626	Identifier* identifier_; //!< The assigned identifier
627	};
628	}
629
630	#endif /* _Identifier_H__ */

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

Context Navigation

source: code/branches/network/src/core/Identifier.h @ 2499

Download in other formats: