Factory.hpp

Go to the documentation of this file.

#pragma once
 
#include <exception>
#include <functional>
 
namespace smgl
{
namespace policy
{
template <class IdentifierType, class ProductType>
class DefaultFactoryError
{
public:
    class unknown_identifier : public std::exception
    {
    public:
        explicit unknown_identifier(const IdentifierType& unknownId);
 
        const char* what() const noexcept override;
 
    private:
        IdentifierType unknownId_;
    };
 
protected:
    static ProductType OnUnknownType(const IdentifierType& id);
 
    static IdentifierType OnUnnamedType(const std::type_info& info);
};
 
}  // namespace policy
 
namespace detail
{
// clang-format off
template <
    class BaseClass,
    typename IdentifierType,
    class AbstractProduct = BaseClass*,
    typename ProductCreator = std::function<AbstractProduct()>,
template <typename, class> class FactoryErrorPolicy = policy::DefaultFactoryError
>
// clang-format on
class Factory : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
{
public:
    using IDType = IdentifierType;
 
    void Reserve(std::size_t count);
 
    void ReserveAdditional(std::size_t count);
 
    bool Register(
        const IDType& id, ProductCreator creator, const std::type_info& info);
 
    bool Deregister(const IDType& id);
 
    bool IsRegistered(const IDType& id);
 
    bool IsRegistered(const std::type_info& info);
 
    AbstractProduct CreateObject(const IDType& id);
 
    IDType GetTypeIdentifier(const std::type_info& info);
 
    std::vector<IDType> GetRegisteredIdentifiers() const;
 
private:
    using NameMap = std::unordered_map<size_t, IdentifierType>;
    using TypeMap = std::unordered_map<IdentifierType, ProductCreator>;
    NameMap typeToIDMap_;
    TypeMap idToCreatorMap_;
};
 
}  // namespace detail
}  // namespace smgl
 
#include "smgl/FactoryImpl.hpp"