ObjectFactory.h

Go to the documentation of this file.

#ifndef _utl_ObjectFactory_h_
#define _utl_ObjectFactory_h_

#include <map>


namespace utl {

  template<typename IdentifierType, class ObjectPtrType>
  class FactoryErrorIgnore {

  public:
    static ObjectPtrType Unregistered(const IdentifierType&)
    { return nullptr; }

    template<typename ArgumentType>
    static ObjectPtrType Unregistered(const IdentifierType& /*id*/,
                                      const ArgumentType& /*arg*/)
    { return nullptr; }

    template<typename Argument1Type, typename Argument2Type>
    static ObjectPtrType Unregistered(const IdentifierType& /*id*/,
                                      const Argument1Type& /*arg1*/,
                                      const Argument2Type& /*arg2*/)
    { return nullptr; }

  };


  template<class ObjPtrType,
           typename IdentType,
           typename CreatType = ObjPtrType (*)(),
           class FactoryErrorPolicy = FactoryErrorIgnore<IdentType, ObjPtrType>>
  class ObjectFactory : public FactoryErrorPolicy {

  private:
    typedef std::map<IdentType, CreatType> RegistryType;

  public:
    typedef ObjPtrType ObjectPtrType;
    typedef IdentType IdentifierType;
    typedef CreatType CreatorType;
    typedef typename RegistryType::const_iterator Iterator;

  public:
    ObjectFactory();
    ~ObjectFactory();

    static
    bool
    Register(const IdentifierType& id,
             const CreatorType& creator)
    {
      if (!fgRegistry)
        fgRegistry = new RegistryType;
      return fgRegistry->insert(std::make_pair(id, creator)).second;
    }

    static unsigned int GetNumberOfCreators()
    { return fgRegistry ? fgRegistry->size() : 0; }

    static
    ObjectPtrType
    Create(const IdentifierType& id)
    {
      if (!fgRegistry)
        return ObjectFactory::Unregistered(id);

      const auto it = fgRegistry->find(id);
      if (it != fgRegistry->end())
        return (it->second)();
      else
        return ObjectFactory::Unregistered(id);
    }

    template<typename ArgumentType>
    static
    ObjectPtrType
    Create(const IdentifierType& id, const ArgumentType& arg)
    {
      if (!fgRegistry)
        return ObjectFactory::Unregistered(id, arg);

      const auto it = fgRegistry->find(id);
      if (it != fgRegistry->end())
        return (it->second)(arg);
      else
        return ObjectFactory::Unregistered(id, arg);
    }

    template<typename Argument1Type, typename Argument2Type>
    static
    ObjectPtrType
    Create(const IdentifierType& id,
           const Argument1Type& arg1,
           const Argument2Type& arg2)
    {
      if (!fgRegistry)
        return ObjectFactory::Unregistered(id, arg1, arg2);

      const auto it = fgRegistry->find(id);
      if (it != fgRegistry->end())
        return (it->second)(arg1, arg2);
      else
        return ObjectFactory::Unregistered(id, arg1, arg2);
    }

    static
    Iterator
    Begin()
    { 
      if (!fgRegistry)
        fgRegistry = new RegistryType;
      return fgRegistry->begin();
    }

    static
    Iterator
    End()
    {
      if (!fgRegistry)
        fgRegistry = new RegistryType;
      return fgRegistry->end();
    }

  private:
    ObjectFactory(const ObjectFactory& objectFactory);
    ObjectFactory& operator=(const ObjectFactory& objectFactory);

    static RegistryType* fgRegistry;

  };


  // the definition of the registry, which cannot be done in the class defn.
  template<class ObjectPtrType,
           typename IdentifierType,
           typename CreatorType,
           class FactoryErrorPolicy>
  typename ObjectFactory<ObjectPtrType, IdentifierType,
                         CreatorType, FactoryErrorPolicy>::RegistryType*
  ObjectFactory<ObjectPtrType, IdentifierType,
                CreatorType, FactoryErrorPolicy>::fgRegistry = nullptr;

}


#endif