---

Factory.h

#ifndef Factory_H
#define Factory_H

#include <map>
#include <string>

using namespace std;

/*
  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_;
};


#endif

---