RTTI vs Шаблонная магия?

Есть структура классов:

class IObject {
public:
	virtual bool Method() = 0;
	template<class T> T * As() { return (T*)this; }	// да-да, не dynamic_cast.
}

class Object1 : public IObject {
	public: virtual bool Method() { /* some logic */ }
}

class Object2 : public IObject {
	public: virtual bool Method() { /* some logic */ }
}

И есть класс

class NamedObject : public IObject {
public:
	NamedObject(const std::string& nm, IObject * o) : name(nm), obj(o) {}

	virtual bool Method() { return obj->Method(); }
	std::string& Name() { return name; }
	IObject * Object() { return obj; }
	
private:
	IObject * obj;
	std::string name;
}

И есть некоторая обертка на RTTI, которая призвана сделать так, что NamedObject может восприниматься, как лежащий под ним обьект:

template<typename T> 
inline bool isA(IObject * obj)
{
	return dynamic_cast<T*>(obj) != null ||
		(isA<NamedObject>(obj) && isA<T>(obj->As<NamedObject>()->Object()));
}

template<> 
inline bool isA<NamedObject>(IObject * obj)
{
	return dynamic_cast< NamedObject* >(obj) != null;
}

И есть некое чувство, что эту схему можно реализовать без RTTI, на шаблонах и множественном наследовании.

Код, в некотором смысле, библиотечный, созданием всяческих обьектов данной иерархии занимается фабрика, так что жуткая шаблонная магия приемлема.


Если кто желает поломать голову и имеет большой C++ скилл, приглашаю обсудить возможные варианты.