[Boost-users] Boost ROCKS !!!!!

1 Nov 2006

      For the past few months I have been making more and more use of Boost, in fact I would say becoming more and more reliant on Boost, every so often introducing myslef to a new library. But discovering the MPL, well that was awsome. The first time I applied it was to implement a factory. I would NEVR have though of doing it this way WITHOUT the MPL. Any comments on my use ( or indeed abuse !) of Boost would be more than apprieciated.

#ifndef FACTORY_HEADER_GUARD
#define FACTORY_HEADER_GUARD 
#include<string>
#include<map>
#include"Singleton.h"
#include
#include
#include
#include

//Constructors of different Hierachies take a different humber fo parameters , so we set up
//some helper macros, for constructirs taking up to 10 parameters. More can be defined if required
#define PARAM_0 
#define PARAM_1 typename boost::mpl::at_c::type P1
#define PARAM_2 PARAM_1 , typename boost::mpl::at_c::type P2
#define PARAM_3 PARAM_2 , typename boost::mpl::at_c::type P3
#define PARAM_4 PARAM_3 , typename boost::mpl::at_c::type P4
#define PARAM_5 PARAM_4 , typename boost::mpl::at_c::type P5
#define PARAM_6 PARAM_5 , typename boost::mpl::at_c::type P6
#define PARAM_7 PARAM_6 , typename boost::mpl::at_c::type P7
#define PARAM_8 PARAM_7 , typename boost::mpl::at_c::type P8
#define PARAM_9 PARAM_8 , typename boost::mpl::at_c::type P9
#define PARAM_10 PARAM_9 , typename boost::mpl::at_c::type P10

#define Q0
#define Q1 P1
#define Q2 Q1, P2
#define Q3 Q2, P3
#define Q4 Q3, P4
#define Q5 Q4, P5
#define Q6 Q5, P6
#define Q7 Q6, P7
#define Q8 Q7, P8
#define Q9 Q8, P9
#define Q10 Q9, P10

// One Registration object per class in a hireachy, this is the template blue print for the base classes of
// the registration objects

template
<
class BaseClass,
typename Key = std::string,
unsigned long = boost::mpl::size<typename BaseClass::Constructor_TypeList>::value
...
struct RegistraBase {};

// This is the template blue print for the concrete classes of
// the registration objects
template
<
class BaseClass,
class Derived,
typename Key = std::string,
unsigned long n = boost::mpl::size<typename BaseClass::Constructor_TypeList>::value
...
struct Registra :public RegistraBase{};

// This is the factory template blue print of the Factory class
template
<
class BaseClass,
typename Key = std::string ,
unsigned long n = boost::mpl::size<typename BaseClass::Constructor_TypeList>::value
...
class Factory {};

// This is the Factory 'concrete' class for Hireachies where the constrcutors tales no parameters
template
< 
class BaseClass,
typename Key
...
...
\
class Factory { \
class Factory { 
public: 
bool Register(const Key & theKey,RegistraBase *theRegistra){ 
return theInnerMap.insert(InnerMap::value_type(theKey,theRegistra)).second; 
} 
boost::shared_ptr<BaseClass> RetrieveObject(const Key &id )const { 
InnerMapIterator theIterator (theInnerMap.find(id)); 
if(theIterator==theInnerMap.end())return boost::shared_ptr<BaseClass>(static_cast(0)); 
return theIterator->second->RetrieveObject(Q0); 
}
private: 
typedef typename std::map *> InnerMap; 
typedef typename std::map *>::const_iterator InnerMapIterator; 
std::map *> theInnerMap; 
};
// This is ta Macro definition Factory 'concrete' class for Hireachies where the constrcutors take
// a non xero number of parameters
#define FACTORY(NnN) \
template \
< \
class BaseClass, \
typename Key \
public: \
bool Register(const Key & theKey,RegistraBase *theRegistra){ \
return theInnerMap.insert(InnerMap::value_type(theKey,theRegistra)).second; \
} \
\
boost::shared_ptr<BaseClass> RetrieveObject(const Key &id,PARAM_##NnN )const { \
InnerMapIterator theIterator (theInnerMap.find(id)); \
if(theIterator==theInnerMap.end())return boost::shared_ptr<BaseClass>(static_cast(0)); \
return theIterator->second->RetrieveObject(Q##NnN ); \
} \
private: \
typedef typename std::map *> InnerMap; \
typedef typename std::map *>::const_iterator InnerMapIterator; \
std::map *> theInnerMap; \
};

FACTORY(1)
FACTORY(2)
FACTORY(3)
FACTORY(4)
FACTORY(5)
FACTORY(6)
FACTORY(7)
FACTORY(8)
FACTORY(9)
FACTORY(10)
// The macro defintions of the Registration Objects
#define REGISTRA(NnN) \
template struct RegistraBase { \
virtual boost::shared_ptr<BaseClass> RetrieveObject(PARAM_##NnN)const=0; \
}; \
template \
struct Registra:public RegistraBase { \
Registra(const Key & theKey){Singleton >::instance().Register(theKey,this);} \
boost::shared_ptr<BaseClass> RetrieveObject(PARAM_##NnN)const{return boost::shared_ptr<BaseClass>(new Derived(Q##NnN));} \
virtual ~Registra(){} \
};
REGISTRA(0)
REGISTRA(1)
REGISTRA(2)
REGISTRA(3)
REGISTRA(4)
REGISTRA(5)
REGISTRA(6)
REGISTRA(7)
REGISTRA(8)
REGISTRA(9)
REGISTRA(10)

#endif 

----------------------------- end of Factory.h 

#include<vector>
#include<iostream>
#include"Factory.h"
using namespace std;
struct MyClassVoid {
typedef boost::mpl::list<> Constructor_TypeList;
MyClassVoid(){}
virtual void f()const=0;
virtual ~MyClassVoid(){};
};
struct MyClassVoidDerived :public MyClassVoid {
MyClassVoidDerived(){}
virtual void f()const{cout << " I am in MyClassVoidDerived \n";}
virtual ~MyClassVoidDerived(){};
};
namespace {
Registra theRegistraVoid(std::string("MyClassVoidDerived"));
}
struct MyClassDouble {
typedef boost::mpl::list<double> Constructor_TypeList;
MyClassDouble(double){}
virtual void f(){cout << " I am in MyClassDouble \n";}
virtual ~MyClassDouble(){};
};
struct MyClassDoubleDerived :public MyClassDouble {
MyClassDoubleDerived(double x):MyClassDouble(x){}
virtual void f(){cout << " I am in MyClassDoubleDerived \n";}
virtual ~MyClassDoubleDerived(){};
};
namespace {
Registra theRegistra(std::string("MyClassDouble"));
Registra theRegistraD(std::string("MyClassDoubleDerived"));
}
struct MyClassMultiple {
typedef boost::mpl::list Constructor_TypeList;
MyClassMultiple(std::string,std::vector<double>,double,MyClassDoubleDerived){}
virtual void f(){cout << " I am in MyClassMultiple \n";}
virtual ~MyClassMultiple(){};
};
namespace {
Registra theRegistraM(std::string("MyClassMultiple"));

}

int main() {

boost::shared_ptr<MyClassVoid> thePtrVoid(Singleton::instance().RetrieveObject("MyClassVoidDerived"));
thePtrVoid->f();

boost::shared_ptr<MyClassDouble> thePtrDoubleDerived(Singleton::instance().RetrieveObject("MyClassDoubleDerived",1.0));
thePtrDoubleDerived->f();
boost::shared_ptr<MyClassDouble> thePtrDouble(Singleton::instance().RetrieveObject("MyClassDouble",1.0));
thePtrDouble->f();
boost::shared_ptr<MyClassMultiple> 
thePtrM(Singleton::instance().RetrieveObject("MyClassMultiple",std::string("String"),std::vector<double>(2),1.0,MyClassDoubleDerived(1.0)));
thePtrM->f();

}

Send instant messages to your online friends http://uk.messenger.yahoo.com

[Boost-users] Boost ROCKS !!!!!

Nindi Singh