type_registry.h

#pragma once
 
#include <cstddef>
#include <memory>
#include <utility>
#include <vector>
 
#include "core/memory/types.h"
 
namespace Vkm::Engine {

template <typename Base>
class TypeRegistry {
    public:
        TypeRegistry()  = default;
        ~TypeRegistry() = default;
 
        TypeRegistry(const TypeRegistry& other) = delete;
        TypeRegistry& operator=(const TypeRegistry& other) = delete;
 
        // Exchanged through swap(), never moved.
        TypeRegistry(TypeRegistry && other) = delete;
        TypeRegistry& operator=(TypeRegistry && other) = delete;
 
    public:
        template <typename T, typename Make>
        Base& ensure(Make&& make) {
            std::unique_ptr<Base>& held = slot<T>();
            if (!held) held = make();
            return *held;
        }

        template <typename T>
        Base* find() {
            const TypeId id = typeId<T>();
            return id < m_slots.size() ? m_slots[id].get() : nullptr;
        }

        template <typename T>
        const Base* find() const {
            const TypeId id = typeId<T>();
            return id < m_slots.size() ? m_slots[id].get() : nullptr;
        }

        template <typename T>
        std::unique_ptr<Base>& slot() {
            const TypeId id = typeId<T>();
            if (id >= m_slots.size()) m_slots.resize(id + 1);
            return m_slots[id];
        }

        void clear() { m_slots.clear(); }

        template <typename Pred>
        void removeIf(Pred&& pred) {
            for (auto& held : m_slots) {
                if (held && pred(static_cast<const Base&>(*held))) held.reset();
            }
        }

        void swap(TypeRegistry& other) noexcept { m_slots.swap(other.m_slots); }

        std::size_t count() const {
            std::size_t n = 0;
            for (const auto& held : m_slots) {
                if (held) ++n;
            }
            return n;
        }

        template <typename Fn>
        void forEach(Fn&& fn) {
            for (auto& held : m_slots) {
                if (held) fn(*held);
            }
        }

        template <typename Fn>
        void forEach(Fn&& fn) const {
            for (const auto& held : m_slots) {
                if (held) fn(*held);
            }
        }
 
    private:
        std::vector<std::unique_ptr<Base>> m_slots;
};
 
} // namespace Vkm::Engine