[boost] Re : typeof or similar

Subject: [boost] Re : typeof or similar
From: Pierre Morcello (pmorcell-cppfrance_at_[hidden])
Date: 2010-02-23 16:17:31

Hello,


Steffen Roeber wrote :
>>>My preferred way would be something like a factory: 
>>>> [...]
>>>>>Base *derived = Factory::createDerived<sameAsBase> (base);

I am not convinced you are on the good mailing list ?

Anyway, I think I can give you that. I wrote it for you ^^.

First the .h, then an example of use.
////////////////////
////////////////////.H
////////////////////
#include <map>
#include <boost/shared_ptr.hpp>
#include <memory>

#define nullptr NULL;
typedef int SomeClassId;

// Wichtig : you will need to specialise extractId for each of your template types.
// make sure to send a different id for each class.
template <class T> 
struct ExtractId
{
	static SomeClassId extractTypeId()
	{
		return -1;
	}
};

// I retake your example
class Base
{
public:
	virtual ~Base(){}
	virtual SomeClassId getTypeId(){throw;}
};

template <class T>
class BaseT : public Base
{
	virtual ~BaseT(){}
	virtual SomeClassId getTypeId(){return ExtractId<T>::extractTypeId();}
};

// this was unclear for me if you wanted that Derived derives from Base or not.
// I consider that what you wrote ("Base *derived = base->createDerived(); //base is a Base *")
// implies that Derived inherits from Base after all.
template <class T>
class Derived : public Base
{
	virtual ~Derived(){}
	virtual SomeClassId getTypeId(){return ExtractId<T>::extractTypeId();}
};

// a base factory class, needed for polymorphism.
class OneTypeFactory 
{
public:
	virtual ~OneTypeFactory(){}
	virtual Base* createDerived(){throw;}
	virtual SomeClassId getTypeId(){throw;}
};

template <class T>
class InheritedFactory : public OneTypeFactory 
{
public:
	virtual ~InheritedFactory(){}
	virtual Base* createDerived(){ return new Derived<T>();}
	virtual SomeClassId getTypeId(){ return ExtractId<T>::extractTypeId();}
};

class AllFactories
{
public:
	// you can make it some singleton if you want... (e.g static std::auto_ptr<AllFactories> sData;)
	AllFactories():mAllFactories(){}

	// to register the factories => insert them in the mAllFactories.
	void registerFactory(boost::shared_ptr<OneTypeFactory> pFactory)
	{
		mAllFactories.insert(std::make_pair(pFactory->getTypeId(), pFactory));
	}

	// create a derived from b, using the same template type.
	Base* createDerived(Base* pBase)
	{
		Base* lResult = nullptr;
		if(pBase)
		{
			lResult = createDerived(pBase->getTypeId());
		}
		return lResult;
	}

private:

	Base* createDerived(SomeClassId pId)
	{
		Base* lResult = nullptr;
		// if found in mAllFactories, ask the corresponding factory to create
		// the derived...
		TFactories::iterator lFound = mAllFactories.find(pId);
		if(lFound != mAllFactories.end())
		{
			lResult = (lFound->second)->createDerived();
		}
		return lResult;
	}

	typedef std::map<SomeClassId, boost::shared_ptr<OneTypeFactory> > TFactories;
	TFactories mAllFactories;
};

// and then, at the beginning of the program, you can register factories for your types.
// and later you can call :  AllFactories::getSingleton()->createDerived(base); // base is a Base*

////////////////////
////////////////////example of use in .cpp
////////////////////
#include "factoryforfun.h"

// I write a little macro to help the copy/paste job.
// of course, use typedef or anything (boost.preprocessor sequence) to 
// avoid ',' in the macro... 
// value, corresponding type.
#define MACRO_WRITEEXTRACTID(X,Y)	\
	template <>						\
	struct ExtractId<Y>				\
	{								\
		static SomeClassId extractTypeId()	\
		{							\
			return X;				\
		}							\
	};

MACRO_WRITEEXTRACTID(1, int)
MACRO_WRITEEXTRACTID(2, double)
MACRO_WRITEEXTRACTID(3, char)
// its also possible to only register the type with a template 
// at the beginning of the program, and make a counter increase,
// etc...

int main(void)
{
	// program begins
	AllFactories lAllFactories;
	lAllFactories.registerFactory(boost::shared_ptr<OneTypeFactory>(new InheritedFactory<int>())); 
	lAllFactories.registerFactory(boost::shared_ptr<OneTypeFactory>(new InheritedFactory<double>())); 
	lAllFactories.registerFactory(boost::shared_ptr<OneTypeFactory>(new InheritedFactory<char>())); 

	// later...

	// I create my pointers
	std::auto_ptr<Base> lBaseT_Char		(new BaseT<char>()	);
	std::auto_ptr<Base> lBaseT_Double	(new BaseT<double>());
	std::auto_ptr<Base> lBaseT_Int		(new BaseT<int>()	);

	// I create the derived
	std::auto_ptr<Base> lShouldBeDerived_Char;	
	std::auto_ptr<Base> lShouldBeDerived_Double; 
	std::auto_ptr<Base> lShouldBeDerived_Int;

	if(true)
	{
//pseudo - dynamic branching creation.
		lShouldBeDerived_Char = std::auto_ptr<Base>(lAllFactories.createDerived(lBaseT_Char.get()));
		lShouldBeDerived_Double = std::auto_ptr<Base>(lAllFactories.createDerived(lBaseT_Double.get()));
		lShouldBeDerived_Int = std::auto_ptr<Base>(lAllFactories.createDerived(lBaseT_Int.get()));
	}

	// works like a charm : they are all of the good type.

////////////////////
////////////////////end.
////////////////////

Hope you like it ?

Best regards,

Pierre Morcello