//The usual sollution of a rtti system supporting dynamic cast
class BaseClass : public support DYNAMIC_CAST {
EXPOSE_CLASS;
};
RTTI_CLASS BaseClass::RTTI_OBJECT rtti_info("BaseClass");
//Ok that one is not so bad...
//BUT how about when having templates as well? IT GETS UGLY AND UNREADABLE!

template <class T, U, V>
class Derived1: public BaseClass {
EXPOSE_CLASS;
};
template <class T, U, V>
RTTI_CLASS Derived1<T,U,V>::RTTI_OBJECT rtti_info("Derived1", BaseClass::info);

class BaseClass : public custom_rtti {
};

template <class T,U,V>
class Derived1 : public BaseClass {
_SUPER<BaseClass>CLASSES_
}

template <class T,U,V>
class Derived2  : public Derived1 {
_SUPER< Derived1<T,U,V> >CLASSES_
}

//This class will contain ID info about a class//later on... for now, lets keep it emptyclass RttiInfo {};//Each class that wants to support dynamic_cast//needs to derive from this class.class CustomRtti {public:	//This function will return the most "derived"	//objects class info - the ID - actually a list	//of dynamically created RttiInfo* objects.	virtual RttiInfo** GetRttiInfo() = 0;};

//MyBase will now support our RTTI system... //and especially our dynamic castclass MyBase : public CustomRtti {};

class RttiInfo {	unsigned int&	m_ruiID;			//The UNIQUE id for a class	String			m_strClassName;		//The class namepublic:	RttiInfo(unsigned int& uiID, const String& strClassName) 		: m_ruiID(uiID), m_strClassName(strClassName) 	{}	//Get the ID...	inline	unsigned int GetID() { return m_ruiID; };};

//This class will just work as a counterclass Counter {public:	static unsigned int GetNextID() {		static unsigned int the_next_id = 0;		return the_next_id++;	}};//This is the class... for each parameter T a unique int value will//be generated.template <class T>class UniqueClassID {public:	//Get the unique ID!	static unsigned int& GetID() {		static unsigned int the_id = Counter::GetNextID();		return the_id;	}};

//This is the class... for each parameter T a unique int value will//be generated.template <class T>class RttiInfoCreator {public:	//Get the RttiInfo object.	static RttiInfo& GetRttiInfo() {		//OK!, now you remember that an unsigned int was required to create a RttiInfo		//This value is later used to identify classes, so it REALLY needs to be unique		//Yep, you're right lets use our UniqueClassID class!		static RttiInfo the_rtti_info = new RttiInfo(UniqueClassID<T>::GetID(), "NO CLASS NAME");		return the_rtti_info;	}};

//RttiInfoCreator<MyClass>::GetRttiInfo() will ALWAYS return the same//RttiInfo, no matter where/how/when you call it.RttiInfo& MyClassInfo = RttiInfoCreator<MyClass>::GetRttiInfo();//Same object will be retrieved here:RttiInfo& MyClassInfo2 = RttiInfoCreator<MyClass>::GetRttiInfo();//Another RttiInfo:RttiInfo& MyOtherClassInfo = RttiInfoCreator<MyOtherClass>::GetRttiInfo();//etc...

//If our CustomRtti would look like this:class CustomRtti {public:	//This function will return the RttiInfo	//object from the most derived class:	virtual RttiInfo& GetRttiInfo() = 0;};//Lets make a test:class MyBaseClass : public CustomRtti {public:	//This is how it COULD look... but it's not how we	//will do it...	virtual RttiInfo& GetRttiInfo() {		return RttiInfoCreator<MyBaseClass>::GetRttiInfo();	}};//Could be used like this:CustomRtti* pSomeClass = new MyBaseClass();RttiInfo& pClassInfo = pSomeClass->GetRttiInfo();//And now check the id to know what class we got...

//A typelist containing Class1, Class2, Class3typedef TypeList<Class1, TypeList<Class2, TypeList<Class3, NullClass> > > CLASS1_CLASS2_CLASS3_LIST;

//Lets make a test:class MyBaseClass : public CustomRtti {	//Now here we want to define the classes	//we want to derive from! But any of you	//guys that have been working with typelists	//know that some "ugly" macros are needed,	//depending on the number of entrys in the typelist:	// TYPE_LIST_1(Class1);	// TYPE_LIST_2(Class1, Class2);	// TYPE_LIST_3(Class1, Class2, Class3);	//etc...		//So we could do like this:	typedef TYPE_LIST_1(CustomRtti) DERIVED_CLASSES_LIST;	//Now we have defined a typelist with only one entry	//namely the class MyBaseClass is derived from.	//If MyBaseClass would be derived from more than one class	//we would have to use another macro:	typedef TYPE_LIST_2(CustomRtti, SomeOtherBaseClass) DERIVED_CLASSES_LIST_2;	//you get the point right :)public:	//Aha! now we just create a RttiInfo object from the 	//first TYPE in our DERIVED_CLASSES_LIST!	// thats piece a cake!	//... well unfortunately not... you will have to use	//some templated functions.	//Look at the CreateRttiInfoFromTypeList class...	virtual RttiInfo& GetRttiInfo() {		//First read about CreateRttiInfoFromTypeList below...		//Then look at this again.		//Aha! here we use the above defined typelist DERIVED_CLASSES_LIST		//To EXTRACT the first TYPE from it and create a RttiInfo		//object from it :)		return CreateRttiInfoFromTypeList<DERIVED_CLASSES_LIST>::CreateRttiInfo();	}};//This class just encapsulates the CreateRttiInfo function//which is used to "extract" the first TYPE from the TypeList//And then create a RttiInfo from this TYPE!//Here goes the templated definition:template <class TList>class CreateRttiInfoFromTypeList {public:	//This one wont be used anyway...	inline	static RttiInfo& CreateRttiInfo();};//And here we explicitly define the class for a TypeList//So if we use CreateRttiInfoFromTypeLista<SomeClass>//with SomeClass = TypeList<....> this one will be//used://The Head is the first entry in the TypeList//And the Tail is the REST of the TypeList, which//is a TypeList that to. So we could recurse this//If we would want to by calling CreateRttiInfoFromTypeList<Tail> ...template <class Head, class Tail>class CreateRttiInfoFromTypeList<TypeList<Head,Tail> > {public:	//Create the RttiInfo object from the first entry	//in the TypeList -> the Head type.	inline	static RttiInfo& CreateRttiInfo() {		return RttiInfoCreator<Head>::GetRttiInfo();	}};

template <class Class1 = NullClass, class Class2 = NullClass, class Class3 = NullClass> // you could continue here...class TypeListCreationHelper {public:	//The template parameters could look like this:	//<X,	NullClass,	NullClass>	//<X,	X,			NullClass>	//<X,	X,			X>	//We just define our typelist here...	//Just check out DerivedClassesTypeList to know what I mean :)	typedef DerivedClassesTypeList<Class1, Class2, Class3>::the_list	DERIVED_CLASSES_LIST;};//This class will encapulate the ugly TYPE_LIST_X macros we so wanted to avoid!template <class Class1, Class2, Class3>DerivedClassesTypeList {}//For each combination the template parameters could occure in TypeListCreationHelper<Class1, Class2, Class3>//we define a specialization of DerivedClassesTypeList:template <class Class1>DerivedClassesTypeList<Class1, NullClass, NullClass> {public:	typedef TYPE_LIST_1(Class1)		the_list;}template <class Class1, Class2>DerivedClassesTypeList<Class1, Class2, NullClass> {public:	typedef TYPE_LIST_1(Class1, Class2)		the_list;}template <class Class1, Class2, Class3>DerivedClassesTypeList<Class1, Class2, Class3> {public:	typedef TYPE_LIST_1(Class1, Class2, Class3)		the_list;}//etc...

//Lets make a test:class MyBaseClass : public CustomRtti {	typedef TypeListCreationHelper<CustomRtti>::the_list	DERIVED_CLASSES_LIST;	//Oh yeh baby... now there is no need for the ugly TYPE_LIST_X(...) macros	//anymore ! :) Just beautiful :)	// another example:	// typedef TypeListCreationHelper<CustomRtti, SomeOtherBaseClass>::the_list	DERIVED_CLASSES_LIST;public:	//This is how it COULD look... but it's not how we	//will do it...	virtual RttiInfo& GetRttiInfo() {		return CreateRttiInfoFromTypeList<DERIVED_CLASSES_LIST>::CreateRttiInfo();	}};

//We will fake A derived class here:class BaseClass : public CustomRtti {};template <class T>class DerivedClass : public BaseClass {//We don't inherit the class T, but we still//can FAKE it... enabling us some intresting//designe features :)_SUPER<T>CLASSES_};BaseClass* pBase = new DerivedClass<Class1>();if(rtti_system::my_dynamic_cast<Class1>(pBase) != 0) {//we have tested if pBase "supports" a "faked" inherited//class...}

class IFactoryCreator : public CustomRtti {public:	virtual void* Create() = 0;};template <class T>class CFactoryCreator : public IFactoryCreator {	//We fake inheritance from the type T	//Will be used to test if a IFactoryCreator supports a 	//specific interface...	_SUPER<T>CLASSES_public:	virtual void* Create() {		return new T;	}};class IFactory {public:	virtual bool AddCreator(ID id, IFactoryCreator* pCreator) = 0;	virtual IFactoryCreator* GetCreator(ID id) = 0;	template <class T>	T* Create(ID id) {		IFactoryCreator* pCreator = GetCreator(id);		if(rtti_system::my_dynamic_cast<T>(pCreator) != 0) {			//OK... now we can go on and create the object!			//We didnt have to CREATE the object to test if it supports			//the T interface:			return pCreator->Create();		}	}};template <class T>class CFactory {public:	virtual bool AddCreator(ID id, IFactoryCreator* pCreator) {		if(rtti_system::my_dynamic_cast<T>(pCreator) != 0) {			//The Creator is compatible with this Factory!			//So go on and add it....		}	}	virtual IFactoryCreator* GetCreator(ID id) {		//find the IFactoryCreator corresponding to the ID	}};