Factory.h

#ifndef Factory_H
#define Factory_H

#include <map>
#include <string>

using std::string;
using std::map;

/*
  The "factory" pattern is a technique for creating new
  instances of objects which defines an abstract interface,
  (represented by the "Make" module). The subclasses of
  factory decide which class to instantiate.
  

  Each subclass of factory "registers" itself at compile time;
  therefore, the addition of a new factory requires no change
  the parent class. 

  \author Gilberto Camara
*/
template <class T, class Arg>
class Factory
{
public:

        typedef map<string, Factory<T,Arg>* > FactoryMap; 

        static FactoryMap& instance ()
        { 
                static FactoryMap Fmap_;
                return Fmap_;
                
        }
        
        Factory (const string& name):Fname_(name)
        {
                Factory<T,Arg>::instance()[name] = this;
        };


        virtual ~Factory() 
        {
                // Remove the object from the factory dictionary
                // Fmap_.erase ( Fname_ );
        };


        static T* make  ( string name, const Arg& arg ) 
        {
                // try to find the name on the factory dictionary
                typename FactoryMap::iterator i = Factory<T,Arg>::instance().find ( name );

                // Not found ?  return the Default Object   
                //if ( i == Factory<T,Arg>::instance().end() )
                //      return T::DefaultObject( arg );

                // Create an object, based on the input parameters
                return (*i).second->build ( arg );
                return 0;
        };

        static T* make  ( Arg arg ) 
        {
                string name = arg.decName();

                // try to find the name on the factory dictionary
                typename FactoryMap::iterator i = Factory<T,Arg>::instance().find ( name );

                // Not found ?  return the Default Object   
                if ( i == Factory<T,Arg>::instance().end() )
                        return T::DefaultObject( arg );

                // Create an object, based on the input parameters
                return (*i).second->build ( arg );
                return 0;
        };


protected:

    virtual T* build ( const Arg& arg ) = 0;

private:
        string  Fname_;
};

// Initialisation of static variable
//template <class T, class Arg>
//Factory<T,Arg>::FactoryMap Factory<T,Arg>::Fmap_;


/*
// Constructor
template <class T, class Arg>
Factory<T,Arg>::Factory<T,Arg>(const string& name):
        Fname_(name)
{
        Factory<T,Arg>::instance()[name] = this;

};

// Destructor
template <class T, class Arg>
Factory<T,Arg>::~Factory<T,Arg> ()
{
        // Remove the object from the factory dictionary
        // Fmap_.erase ( Fname_ );
};

// Virtual Constructor
/*
template <class T, class Arg> 
T*
Factory<T,Arg>::make ( string name, const Arg& arg )
{
        // try to find the name on the factory dictionary
        typename FactoryMap::iterator i = Factory<T,Arg>::instance().find ( name );

        // Not found ?  return the Default Object   
        if ( i == Factory<T,Arg>::instance().end() )
                return T::DefaultObject( arg );

        // Create an object, based on the input parameters
        return (*i).second->build ( arg );
        return 0;

};


template <class T, class Arg> 
T*
Factory<T,Arg>::make ( Arg arg )
{
        string name = arg.decName();

        // try to find the name on the factory dictionary
        typename FactoryMap::iterator i = Factory<T,Arg>::instance().find ( name );

        // Not found ?  return the Default Object   
        if ( i == Factory<T,Arg>::instance().end() )
                return T::DefaultObject( arg );

        // Create an object, based on the input parameters
        return (*i).second->build ( arg );
        return 0;

};
*/

#endif

---