OBT::PrototypeFactory< TIdentifier, TCreator > Class Template Reference

#include <OBTPrototypeFactory.h>

Collaboration diagram for OBT::PrototypeFactory< TIdentifier, TCreator >:

List of all members.

Public Member Functions

virtual ~PrototypeFactory ()

destructor

const TCreator & create (const TIdentifier &classId) const

template<class TDerivedCreator>

bool registerCreator (const TIdentifier &classId)

register a creator to classId

Private Member Functions

PrototypeFactory ()

constructor

PrototypeFactory (const PrototypeFactory &)

copy constructor

PrototypeFactory & operator= (const PrototypeFactory &)

assignment operator

Private Attributes

std::map
< TIdentifier,
TCreator * > _creators

map of the creators

Friends

class Singleton< PrototypeFactory< TIdentifier, TCreator > >

Detailed Description

template<class TIdentifier, class TCreator>
class OBT::PrototypeFactory< TIdentifier, TCreator >

Template factory prototype class.

Author:: Micha�l Rouill�, bunraku <michael.rouille@irisa.fr>

Helper class to provide you access to a template factory implementation. TIdentifier : type of the identifier used to register and retrieve a Creator. TCreator : creation functor ancestor, defines the ancestor class of the family of classes to be created by the factory and its constructor signature.

Example, in order to instantiate the B and C classes, descendants of a class A you must define A creators :

  // ancestor class creator
        class ACreator
  {
  public:

          // the operator() argument must match A constructor arguments
          virtual A* operator() (       std::string name, unsigned int identifier ) const
          {
                  return NULL ;
          }
  } ;

  // descendants will parametrize this class to register to the prototype factory
  template <class T>
  class ACreatorT : public ACreator
  {
  public:
        
          // this typedef is mandatory
          typedef T object_to_create ;

          // creates and returns a new instance of type T
          A* operator() (       std::string name, unsigned int identifier ) const
          {
                  return new T( name, identifier ) ;
          }
  } ;

The factory is a singleton to avoid different factories for the same classes family

  typedef OBT::Singleton< OBT::PrototypeFactory< unsigned int, ACreator > > AFactory ;
*

B and C, the descendants of A, will then parametrize ACreatorT when they register to the PrototypeFactory :

  AFactory::getInstance().registerCreator< ACreatorT< B > >( B::s_id ) ;
  AFactory::getInstance().registerCreator< ACreatorT< C > >( C::s_id ) ;
*

To create a new instance of class B you will use the create method :

  A* myB = AFactory::getInstance().create( B::s_id )( aName, anIdentifier ) ;

Definition at line 69 of file OBTPrototypeFactory.h.