objectFactory.hpp

Go to the documentation of this file.

#ifndef JULIAN_OBJECTFACTORY_HPP
#define JULIAN_OBJECTFACTORY_HPP

#include <map>
#include <string>
#include <typeinfo>
#include <utils/smartPointer.hpp>

 
namespace julian {

  template<class T>
  class ObjectFactory {
  public:
    typedef SmartPointer<T> (*CreateT)();

    static ObjectFactory& instance();
    SmartPointer<T> getObject(std::string name);
    void registerObject(std::string, CreateT );

    ~ObjectFactory(){};
  private:
    std::map<std::string, CreateT > creators; 
    ObjectFactory(){}

    ObjectFactory(const ObjectFactory&){}

    ObjectFactory& operator = (const ObjectFactory&){ return *this;}
  };

  template<class T>
  void ObjectFactory<T>::registerObject(std::string name, CreateT f) {
    creators.insert(std::pair<std::string,CreateT>(name,f) );
  }

  template<class T>
  SmartPointer<T> ObjectFactory<T>::getObject(std::string name) {
    auto i = creators.find(name);
    if ( i == creators.end() ) {
      std::cout << name << " is an unknown name" << std::endl;
      return (creators.begin()->second)();
    }  
    return (i->second)();
  }

  template<class T>
  ObjectFactory<T>& ObjectFactory<T>::instance() {
    static ObjectFactory theFactory;
    return theFactory;
  }

  template <class Base,class Derived>
  class ObjectFactoryHelper {
  public:
    ObjectFactoryHelper(std::string);
    static SmartPointer<Base> create();
  };

  template <class Base,class Derived>
  SmartPointer<Base> ObjectFactoryHelper<Base,Derived>::create() {
    Derived a;
    return a;
  }

  template <class Base,class Derived>
  ObjectFactoryHelper<Base,Derived>::ObjectFactoryHelper(std::string name) {
    ObjectFactory<Base>& factory = ObjectFactory<Base>::instance();
    factory.registerObject(name, ObjectFactoryHelper<Base,Derived>::create);
  }
}
#endif