ResourceManager.hpp

Go to the documentation of this file.

#pragma once
 
#include "Logger.hpp"
#include "exception/ResourceManagerError.hpp"
#include <concepts>
#include <entt/core/hashed_string.hpp>
#include <entt/resource/cache.hpp>
#include <fmt/format.h>
#include <optional>
#include <type_traits>
 
namespace Object::Resource {
 
template <typename TType>
concept CViewStringable = std::is_constructible_v<std::string_view, const TType &> &&
                          !std::is_same_v<std::decay_t<TType>, entt::hashed_string>;

template <typename ResourceType> class ResourceManager {
  private:
    struct ResourceLoader final {
        using result_type = std::shared_ptr<ResourceType>;
 
        template <typename... Args> result_type operator()(Args &&...args) const
        {
            return std::make_shared<ResourceType>(std::forward<Args>(args)...);
        }
    };
 
  public:
    ResourceManager() = default;
    ~ResourceManager() = default;
 
    ResourceManager(const ResourceManager &) = delete;
    ResourceManager &operator=(const ResourceManager &) = delete;
 
    ResourceManager(ResourceManager &&) noexcept = default;
    ResourceManager &operator=(ResourceManager &&) noexcept = default;

    template <typename... Args> entt::resource<ResourceType> Add(const entt::hashed_string &id, Args &&...args)
    {
        auto ret = cache.load(id, std::forward<Args>(args)...);
 
        if (!ret.second)
        {
            Log::Warning(fmt::format("Resource with id {} already exists. Overwriting.", id.data()));
            ret = cache.force_load(id, std::forward<Args>(args)...);
        }
 
        return ret.first->second;
    }
 
    template <CViewStringable TViewStringable, typename... Args>
    entt::resource<ResourceType> Add(const TViewStringable &id, Args &&...args)
    {
        std::string_view stringViewId{id};
        return Add(entt::hashed_string{stringViewId.data(), stringViewId.size()}, std::forward<Args>(args)...);
    }

    [[nodiscard]] ResourceType &Get(const entt::hashed_string &id)
    {
        auto resource = cache[id];
 
        if (!resource)
            throw ResourceManagerError(fmt::format("Resource with id {} not found.", id.data()));
 
        return *resource;
    }
 
    template <CViewStringable TViewStringable> [[nodiscard]] ResourceType &Get(const TViewStringable &id)
    {
        std::string_view stringViewId{id};
        return Get(entt::hashed_string{stringViewId.data(), stringViewId.size()});
    }

    [[nodiscard]] const ResourceType &Get(const entt::hashed_string &id) const
    {
        const auto &resource = cache[id];
 
        if (!resource)
            throw ResourceManagerError(
                fmt::format("Resource with id {} not found.", std::string_view(id.data(), id.size())));
 
        return *resource;
    }
    template <CViewStringable TViewStringable> [[nodiscard]] const ResourceType &Get(const TViewStringable &id) const
    {
        std::string_view stringViewId{id};
        return Get(entt::hashed_string{stringViewId.data(), stringViewId.size()});
    }

    void Remove(const entt::hashed_string &id) { cache.erase(id); }
 
    template <CViewStringable TViewStringable> void Remove(const TViewStringable &id)
    {
        std::string_view stringViewId{id};
        Remove(entt::hashed_string{stringViewId.data(), stringViewId.size()});
    }

    [[nodiscard]] bool Contains(const entt::hashed_string &id) const { return cache.contains(id); }
 
    template <CViewStringable TViewStringable> [[nodiscard]] bool Contains(const TViewStringable &id) const
    {
        std::string_view stringViewId{id};
        return Contains(entt::hashed_string{stringViewId.data(), stringViewId.size()});
    }

    void SetDefault(ResourceType &&resource) { defaultResource = std::move(resource); }
 
    template <typename... Args> void SetDefault(Args &&...args)
    {
        defaultResource = ResourceType(std::forward<Args>(args)...);
    }

    [[nodiscard]] ResourceType &GetDefault()
    {
        if (!defaultResource.has_value())
            throw ResourceManagerError("No default resource is set.");
 
        return *defaultResource;
    }

    [[nodiscard]] const ResourceType &GetDefault() const
    {
        if (!defaultResource.has_value())
            throw ResourceManagerError("No default resource is set.");
 
        return *defaultResource;
    }

    [[nodiscard]] ResourceType &GetOrDefault(const entt::hashed_string &id)
    {
        auto resource = cache[id];
 
        if (resource)
            return *resource;
 
        if (!defaultResource.has_value())
            throw ResourceManagerError(
                fmt::format("Resource with id {} not found and no default resource is set.", id.data()));
 
        return *defaultResource;
    }
 
    template <CViewStringable TViewStringable> [[nodiscard]] ResourceType &GetOrDefault(const TViewStringable &id)
    {
        std::string_view stringViewId{id};
        return GetOrDefault(entt::hashed_string{stringViewId.data(), stringViewId.size()});
    }

    [[nodiscard]] const ResourceType &GetOrDefault(const entt::hashed_string &id) const
    {
        const auto &resource = cache[id];
 
        if (resource)
            return *resource;
 
        if (!defaultResource.has_value())
            throw ResourceManagerError(
                fmt::format("Resource with id {} not found and no default resource is set.", id.data()));
 
        return *defaultResource;
    }
 
    template <CViewStringable TViewStringable>
    [[nodiscard]] const ResourceType &GetOrDefault(const TViewStringable &id) const
    {
        std::string_view stringViewId{id};
        return GetOrDefault(entt::hashed_string{stringViewId.data(), stringViewId.size()});
    }

    [[nodiscard]] bool HasDefault() const { return defaultResource.has_value(); }
 
  private:
    entt::resource_cache<ResourceType, ResourceLoader> cache{};
    std::optional<ResourceType> defaultResource = std::nullopt;
};
 
} // namespace Object::Resource