dariomt@gmail.com wrote:
class Base {...};
class Factory {...};
template <typename T> struct Helper {...}; // constructor registers
creation function for template parameter
Now we have a template defining a family of derived classes:
template class DerivedUVW : public
Base {...};
...
And all possible U V and W classes in the combination game:
struct A1 {}; struct A2 {}; // for U
struct B1 {}; struct B2 {}; // for V
struct C1 {}; struct C2 {}; // for W
...
And now the six million dollar question:
Is there a way in which MPL and fusion can automatically do the
registration?
I think so (see attachment)!
Here's an MPL-based solution. It does not require any preprocessor code
and compiles with GCC4.
Just for the fun of it, I reduced the Factory code to a one-liner using
the recently reviewed factory functional, which can be downloaded here:
http://tinyurl.com/35vlvb
Regards,
Tobias
#include <iostream>
#include <sstream>
#include <string>
#include <memory>
#include <map>
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// Class hierarchy:
class base
{
public:
virtual void introduce_yourself() = 0;
virtual ~base() { }
};
template< class U, class V, class W >
class derived : public base
{
public:
static std::string name()
{
// not using typeid(derived).name() since ABI-dependent
static std::string* result;
if (! result)
{
std::ostringstream s;
s << "derived<" << U::name() << "," << V::name()
<< "," << W::name() << ">";
result = new std::string(s.str());
}
return *result;
}
void introduce_yourself()
{
std::cout << "Hi I'm " << name() << "." << std::endl;
}
};
// Arguments for 'derived' (note I could've used some traits class
// for the names):
struct A1
{
static char const* name() { return "A1"; }
};
struct A2
{
static char const* name() { return "A2"; }
};
struct B1
{
static char const* name() { return "B1"; }
};
struct B2
{
static char const* name() { return "B2"; }
};
struct C1
{
static char const* name() { return "C1"; }
};
struct C2
{
static char const* name() { return "C2"; }
};
// Factory pattern reduced to its essence, using the recently reviewed
// function object:
std::map< std::string, boost::function > factories;
// Metaprogramming
namespace mpl = boost::mpl;
using namespace mpl::placeholders;
// Let's call an iterator and a range a "cursor"
template< class Iter, class From, class To > struct cursor;
// We create it from a sequence...
template< class Sequence >
struct make_cursor
{
typedef typename mpl::begin<Sequence>::type from;
typedef typename mpl::end<Sequence>::type to;
typedef cursor type;
};
// ...can dereference it...
template< class Cursor > struct deref;
template< class Iterator, class From, class To >
struct deref< cursor >
: mpl::deref<Iterator>
{ };
// ...move it forward...
template< class Cursor > struct next;
template< class Iterator, class From, class To >
struct next< cursor >
{
typedef cursor< typename mpl::next<Iterator>::type, From, To > type;
};
// ...and have it wrap around once it reaces the end.
template< class Cursor > struct wrap_around;
template< class Iterator, class From, class To >
struct wrap_around< cursor >
{
typedef cursor type;
typedef mpl::false_ wrapped;
};
template< class To, class From >
struct wrap_around< cursor >
{
typedef cursor type;
typedef mpl::true_ wrapped;
};
// State machine intended to be used with mpl::fold that adds moved cursors to
// a sequence until one does not hit the end. Remaining cursors are added as-is.
struct nested_loops_fold_op
{
typedef mpl::pair< mpl::true_, mpl::vector<> > initial_state;
template< class State, class Cursor >
struct apply;
template< class Sequence, class Cursor >
struct apply< mpl::pairmpl::true_,Sequence, Cursor >
{
typedef typename next<Cursor>::type next_cursor;
typedef typename wrap_around::type new_cursor;
typedef typename wrap_around::wrapped wrapped;
typedef typename mpl::push_back::type sequence;
typedef mpl::pair< wrapped, sequence > type;
};
template< class Sequence, class Cursor >
struct apply< mpl::pairmpl::false_,Sequence, Cursor >
{
typedef typename mpl::push_back::type sequence;
typedef mpl::pair< mpl::false_, sequence > type;
};
};
template< class Cursors, class Done >
struct register_factories_impl
{
static inline void call()
{
// deref cursors and specialize 'derived' template
typedef typename mpl::unpack_args< derived<_1,_2,_3> >
// typedef typename xyz
::template apply<
mpl::transform_view< Cursors, deref<_1> >
>::type the_type;
// register factory
factories[the_type::name()] = boost::factory< std::auto_ptr >();
// tail-recurse
typedef typename mpl::fold::type next_state;
register_factories_impl<
typename mpl::second::type,
typename mpl::first::type >::call();
}
};
template< class Cursors >
struct register_factories_impl< Cursors, mpl::true_ >
{
static inline void call()
{ }
};
template< class Sequences >
inline void register_factories()
{
typedef typename mpl::transform >::type cursors;
typedef typename mpl::fold::type next_state;
typedef typename mpl::first::type done;
register_factories_impl::call();
}
int main()
{
register_factories<
mpl::vector<
mpl::vector,
mpl::vector,
mpl::vector
>
>();
factories["derived"]()->introduce_yourself();
factories["derived"]()->introduce_yourself();
// ...
return 0;
}
