typefactory.h

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Dim Himro
 
#ifndef TYPEFACTORY_H
#define TYPEFACTORY_H
 
#include <memory>
#include <type_traits>
#include <unordered_map>
#include <utility>// std::move
 
template<class ClassId, class BaseClass, class... Args>
class TypeFactory {
public:
    using BasePtr = std::shared_ptr<BaseClass>;
    using CreatorFn = BasePtr (*)(Args...);
 
    TypeFactory() = default;
 
    template<class Derived>
    void registerType(const ClassId &id) {
        static_assert(std::is_base_of_v<BaseClass, Derived>,
                      "Derived must inherit from BaseClass");
        static_assert(std::is_constructible_v<Derived, Args...>,
                      "Derived must be constructible from Args...");
 
        classes.insert_or_assign(id, &instantiate<Derived>);
    }
 
    [[nodiscard]] CreatorFn creator(const ClassId &id) const {
        return classes.at(id);
    }
 
    [[nodiscard]] BasePtr create(const ClassId &id, Args... args) const {
        return creator(id)(std::move(args)...);
    }
 
    [[nodiscard]] bool contains(const ClassId &id) const {
        return classes.find(id) != classes.end();
    }
 
protected:
    // Protected by design: derived factories may extend/inspect the registry.
    std::unordered_map<ClassId, CreatorFn> classes;
 
private:
    template<class Derived>
    static BasePtr instantiate(Args... args) {
        return std::make_shared<Derived>(std::move(args)...);
    }
};
#endif// TYPEFACTORY_H