Фабрики и бибилотеки Ruslan Mullakhmetov

Factory.h

template<typename Base, typename… Args>
class NewCreatorBase
{
public:
    virtual Base * operator()(Args… args) = 0;
    virtual ~NewCreatorBase(){}
};


template<typename Base, typename Derived, typename… Args >
class NewCreatorImpl : public NewCreatorBase<Base, Args…>
{
public:
    Derived * operator()(Args… args) override
    {
        return new Derived(args…);
    }
};

template<typename Base, typename… Args>
class NewCreatorHolder
{
    std::unique_ptr<NewCreatorBase<Base, Args…> > _pimpl; // NOT actual _pimpl!!!
public:
    template<typename Derived>
    explicit NewCreatorHolder(boost::mpl::identity<Derived>  )
    {
        _pimpl.reset(new NewCreatorImpl<Base, Derived, Args…> );
    }

    Base * operator()(Args… args)
    {
        return _pimpl->operator()( args… );
    }
};

template<typename Product, typename Identifier, typename Creator = NewCreatorHolder<Product> >
class Factory
{
    typedef Factory<Product, Identifier,Creator> ThisType;

    std::map<Identifier,Creator> _creators;

public:

    typedef Identifier    IdentifierType;
    typedef Product        ProductType;
    typedef Creator        CreatorType;

    int register_type( Identifier id, Creator creator )
    {
        auto r = _creators.insert( std::make_pair(id, std::move(creator) ) );

        if( ! r.second )
        {
            std::ostringstream ost;
            ost << "Factory::register_type: id: " << id << " already registered";
        
            throw std::logic_error( ost.str() );
        }

        return 1;
    }


    static ThisType * instance()
    {
        static ThisType static_instance;
    
        return &static_instance;
    }


    bool find(Identifier id)
    {
        return _creators.count(id) > 0;
    }

    std::vector<Identifier> list_all_registered_id() const
    {
        std::vector<Identifier> ret;
    
        for( auto & x : _creators )
        {
            ret.push_back( x.first );
        }
    
        return ret;
    }

    template<typename… Args>
    std::unique_ptr<Product> create(Identifier id, Args… args)
    {
        auto it = _creators.find( id );
        if( it == _creators.end() )
        {
            std::ostringstream ost;
            ost << "Factory::create: id: " << id << " has not been registered";

            throw std::runtime_error( ost.str() );
        }
    
        return std::unique_ptr<Product>( it->second(args…) );
    }


};

template<typename ConcreteProduct, typename Factory>
class FactoryRegistrar
{
public:
    FactoryRegistrar(const typename Factory::IdentifierType & id )
    {
        // std::cout << "FactoryRegistrar: " << __PRETTY_FUNCTION__ << std::endl;
        typedef typename Factory::CreatorType T;
        boost::mpl::identity<ConcreteProduct> tag;
        T creator ( tag );
        Factory::instance()->register_type(id, std::move(creator) );
    }
    
    int get()
    {
        return 1;
    }
    
};

Base.h

class Base
	{
	public:
		Base();
		virtual std::string identify_me() = 0;
	};

	typedef Factory<Base,std::string> BaseFactory;

Derided.cpp  

static FactoryRegistrar<Derived,BaseFactory> __factory_registrar__;