resource_manager.h

#pragma once
 
#include <memory>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "l_assert.h"
#include "logger.h"
 
#include "core/memory/slot_allocator.h"
#include "core/memory/sparse_set.h"
#include "core/memory/types.h"
#include "core/memory/type_registry.h"
#include "resource/asset_ref.h"
#include "resource/asset_type.h"
#include "resource/resource.h"
#include "resource/resource_handle.h"
 
namespace Vkm::Engine {
 
struct FontAsset;

template<typename T>
inline constexpr bool IS_ENGINE_ASSET = ASSET_TYPE<T> != AssetType::Count || std::is_same_v<T, FontAsset>;

class ResourceManager {
    public:
        ResourceManager();
        ~ResourceManager() = default;
 
        ResourceManager(const ResourceManager& other) = delete;
        ResourceManager& operator=(const ResourceManager& other) = delete;
 
        ResourceManager(ResourceManager && other) = delete;
        ResourceManager& operator=(ResourceManager && other) = delete;
 
    public:
        template<typename ResourceType>
        auto add(ResourceType && resource) {
            using T = std::remove_cv_t<std::remove_reference_t<ResourceType>>;
            static_assert(
                std::is_base_of_v<Resource, T>,
                "ResourceManager stores only types deriving from Resource."
            );
            auto& slot = getSlot<T>();
 
            if (resource.m_name.empty()) ensureUniqueName(slot, resource.m_name);
 
            if (const auto taken = slot.nameIndex.find(resource.m_name); taken != slot.nameIndex.end()) {
                return replaceAt<T>(slot, taken->second, std::forward<ResourceType>(resource));
            }
 
            StorageIndex key = slot.allocator.allocate();
            std::string indexName = resource.m_name;  // non-empty now
            // Stamped on the stored asset, not the argument: insertion may copy,
            // and a copy is a duplicate that carries no identity of its own.
            Resource& stored = storageOf<T>(slot).add(key.index, std::forward<ResourceType>(resource));
            stored.m_uid     = mintUid();
            stored.m_version = 1;
            slot.nameIndex.emplace(std::move(indexName), key.index);
 
            return Handle<T>{key};
        }

        template<typename ResourceType>
        auto add(ResourceType && resource, std::string name) {
            resource.m_name = std::move(name);
            return add(std::forward<ResourceType>(resource));
        }

        template<typename ResourceType>
        auto addPrivate(ResourceType && resource, std::string name) {
            resource.m_hidden = true;
            resource.m_name   = std::move(name);
            return add(std::forward<ResourceType>(resource));
        }

        template<typename HandleType>
        void remove(const HandleType& handle) {
            using T = typename HandleType::resource_t;
            auto& slot = getSlot<T>();
            VKM_ASSERT(slot.allocator.has(handle.key), "ResourceManager::remove invalid handle");
            if (!slot.allocator.has(handle.key)) return;
 
            const T& res = storageOfConst<T>(slot).get(handle.key.index);
            dropNameIndex(slot, res.m_name, handle.key.index);
            storageOf<T>(slot).remove(handle.key.index);
            slot.allocator.free(handle.key);
        }

        template<typename HandleType>
        bool isAlive(const HandleType& handle) const {
            using T = typename HandleType::resource_t;
            const TypedSlot* slot = trySlot<T>();
            return slot && slot->allocator.has(handle.key);
        }

        template<typename HandleType>
        const auto& get(const HandleType& handle) const {
            using T = typename HandleType::resource_t;
            const auto& slot = getSlotConst<T>();
            VKM_ASSERT(slot.allocator.has(handle.key), "ResourceManager::get invalid handle");
            return storageOfConst<T>(slot).get(handle.key.index);
        }

        template<typename HandleType>
        const auto* tryGet(const HandleType& handle) const {
            using T = typename HandleType::resource_t;
            const TypedSlot* slot = trySlot<T>();
            if (!slot || !slot->allocator.has(handle.key)) return static_cast<const T*>(nullptr);
            return &storageOfConst<T>(*slot).get(handle.key.index);
        }

        template<typename HandleType>
        auto* tryEdit(const HandleType& handle) {
            using T = typename HandleType::resource_t;
            TypedSlot* slot = m_slots.find<T>();
            if (!slot || !slot->allocator.has(handle.key)) return static_cast<T*>(nullptr);
            return &storageOf<T>(*slot).get(handle.key.index);
        }

        template<typename HandleType>
        auto& edit(const HandleType& handle) {
            using T = typename HandleType::resource_t;
            auto& slot = getSlot<T>();
            VKM_ASSERT(slot.allocator.has(handle.key), "ResourceManager::edit invalid handle");
            return storageOf<T>(slot).get(handle.key.index);
        }

        template<typename HandleType>
        void rename(const HandleType& handle, std::string newName) {
            using T = typename HandleType::resource_t;
            auto& slot = getSlot<T>();
            VKM_ASSERT(slot.allocator.has(handle.key), "ResourceManager::rename invalid handle");
            auto& res = storageOf<T>(slot).get(handle.key.index);
            // Before the uniqueness check, so renaming to the current name is not a self-collision.
            dropNameIndex(slot, res.m_name, handle.key.index);
            ensureUniqueName(slot, newName);
            res.m_name = std::move(newName);
            slot.nameIndex[res.m_name] = handle.key.index;
        }

        template<typename HandleType>
        void swapValue(const HandleType& handle, typename HandleType::resource_t& value) {
            using T = typename HandleType::resource_t;
            static_assert(
                std::is_base_of_v<Resource, T>,
                "Resource type must inherit from Resource to use swapValue()."
            );
            auto& slot = getSlot<T>();
            VKM_ASSERT(slot.allocator.has(handle.key), "ResourceManager::swapValue invalid handle");
            T& target = storageOf<T>(slot).get(handle.key.index);
            if (&target == &value) return;
 
            using std::swap;
            swap(target, value);
            swap(target.m_version, value.m_version);
            swap(target.m_uid,     value.m_uid);
            swap(target.m_hidden,  value.m_hidden);
            swap(target.m_name,    value.m_name);
            ++target.m_version;
        }

        template<typename HandleType>
        void commit(const HandleType& handle) {
            using T = typename HandleType::resource_t;
            static_assert(
                std::is_base_of_v<Resource, T>,
                "Resource type must inherit from Resource to use commit()."
            );
            auto& slot = getSlot<T>();
            VKM_ASSERT(slot.allocator.has(handle.key), "ResourceManager::commit invalid handle");
            ++storageOf<T>(slot).get(handle.key.index).m_version;
        }

        template<typename T>
        Handle<T> findByName(const std::string& name) const {
            const TypedSlot* slot = trySlot<T>();
            if (!slot) return {};
 
            auto it = slot->nameIndex.find(name);
            if (it == slot->nameIndex.end()) return {};
            return Handle<T>{slot->allocator.handleAt(it->second)};
        }

        template<typename T>
        Handle<T> find(const AssetRef<T>& ref) const {
            return ref.name.empty() ? Handle<T>{} : findByName<T>(ref.name);
        }

        template<typename T, typename Fn>
        void forEachOfType(Fn&& fn) const {
            const TypedSlot* slot = trySlot<T>();
            if (!slot) return;
            storageOfConst<T>(*slot).forEach([&](uint32_t index, const T& res) {
                fn(Handle<T>{slot->allocator.handleAt(index)}, res);
            });
        }

        template<typename T>
        size_t countOfType() const {
            const TypedSlot* slot = trySlot<T>();
            return slot ? storageOfConst<T>(*slot).size() : 0;
        }

        void clear();

        void swap(ResourceManager& other) noexcept;

        uint64_t epoch() const { return m_epoch; }
 
    private:
        struct TypedSlot {
            SlotAllocator                   allocator;
            std::unique_ptr<ISparseSet>     storage;
            std::unordered_map<std::string, uint32_t> nameIndex;
        };
 
    private:
        void makeEngineSlots();
 
        template<typename T>
        TypedSlot& getSlot() {
            static_assert(
                IS_ENGINE_ASSET<T>,
                "ResourceManager stores the engine's asset types only: a slot for a type a "
                "gameplay module declares would carry the module's code past its unload."
            );
            return m_slots.ensure<T>([] {
                auto slot = std::make_unique<TypedSlot>();
                slot->storage = std::make_unique<SparseSet<T>>();
                return slot;
            });
        }

        template<typename T>
        const TypedSlot* trySlot() const {
            return m_slots.find<T>();
        }
 
        template<typename T>
        const TypedSlot& getSlotConst() const {
            const TypedSlot* slot = trySlot<T>();
            VKM_ASSERT(slot, "ResourceManager: type not registered");
            return *slot;
        }
 
        template<typename T>
        static SparseSet<T>& storageOf(TypedSlot& slot) {
            return static_cast<SparseSet<T>&>(*slot.storage);
        }
 
        template<typename T>
        static const SparseSet<T>& storageOfConst(const TypedSlot& slot) {
            return static_cast<const SparseSet<T>&>(*slot.storage);
        }

        static void dropNameIndex(TypedSlot& slot, const std::string& name, uint32_t index) {
            auto it = slot.nameIndex.find(name);
            if (it != slot.nameIndex.end() && it->second == index) {
                slot.nameIndex.erase(it);
            }
        }

        template <typename T, typename ResourceType>
        Handle<T> replaceAt(TypedSlot& slot, uint32_t index, ResourceType && resource) {
            T& target = storageOf<T>(slot).get(index);
 
            // First: re-declaring an asset with its own contents hands in target itself, and
            // constructing from it would move the name away.
            const uint64_t version = target.m_version;
            std::string    name    = std::move(target.m_name);
 
            // Constructed: Resource has no copy assignment.
            T incoming(std::forward<ResourceType>(resource));
            using std::swap;
            swap(target, incoming);
 
            target.m_name    = std::move(name);
            target.m_uid     = mintUid();
            target.m_version = version + 1;
            return Handle<T>{slot.allocator.handleAt(index)};
        }

        static void ensureUniqueName(const TypedSlot& slot, std::string& name) {
            if (name.empty()) name = "asset";
            if (slot.nameIndex.find(name) == slot.nameIndex.end()) return;
            const std::string base = name;
            for (int n = 2; ; ++n) {
                std::string candidate = base + " (" + std::to_string(n) + ")";
                if (slot.nameIndex.find(candidate) == slot.nameIndex.end()) {
                    name = std::move(candidate);
                    return;
                }
            }
        }

        static uint64_t mintUid();
 
    private:
        TypeRegistry<TypedSlot> m_slots;

        uint64_t m_epoch = 1;
};
 
} // namespace Vkm::Engine