cache.hpp

#ifndef ENTT_RESOURCE_CACHE_HPP
#define ENTT_RESOURCE_CACHE_HPP
 
 
#include <memory>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include "../config/config.h"
#include "../core/fwd.hpp"
#include "handle.hpp"
#include "loader.hpp"
#include "fwd.hpp"
 
 
namespace entt {
 
 
template<typename Resource>
struct resource_cache {
    using size_type = std::size_t;
    using resource_type = Resource;
 
    resource_cache() = default;
 
    resource_cache(resource_cache &&) = default;
 
    resource_cache & operator=(resource_cache &&) = default;
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return resources.size();
    }
 
    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
        return resources.empty();
    }
 
    void clear() ENTT_NOEXCEPT {
        resources.clear();
    }
 
    template<typename Loader, typename... Args>
    resource_handle<Resource> load(const id_type id, Args &&... args) {
        static_assert(std::is_base_of_v<resource_loader<Loader, Resource>, Loader>, "Invalid loader type");
        resource_handle<Resource> resource{};
 
        if(auto it = resources.find(id); it == resources.cend()) {
            if(auto instance = Loader{}.get(std::forward<Args>(args)...); instance) {
                resources[id] = instance;
                resource = std::move(instance);
            }
        } else {
            resource = it->second;
        }
 
        return resource;
    }
 
    template<typename Loader, typename... Args>
    resource_handle<Resource> reload(const id_type id, Args &&... args) {
        return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
    }
 
    template<typename Loader, typename... Args>
    [[nodiscard]] resource_handle<Resource> temp(Args &&... args) const {
        return { Loader{}.get(std::forward<Args>(args)...) };
    }
 
    [[nodiscard]] resource_handle<Resource> handle(const id_type id) const {
        auto it = resources.find(id);
        return { it == resources.end() ? nullptr : it->second };
    }
 
    [[nodiscard]] bool contains(const id_type id) const {
        return (resources.find(id) != resources.cend());
    }
 
    void discard(const id_type id) {
        if(auto it = resources.find(id); it != resources.end()) {
            resources.erase(it);
        }
    }
 
    template <typename Func>
    void each(Func func) const {
        auto begin = resources.begin();
        auto end = resources.end();
 
        while(begin != end) {
            auto curr = begin++;
 
            if constexpr(std::is_invocable_v<Func, id_type>) {
                func(curr->first);
            } else if constexpr(std::is_invocable_v<Func, resource_handle<Resource>>) {
                func(resource_handle{ curr->second });
            } else {
                func(curr->first, resource_handle{ curr->second });
            }
        }
    }
 
private:
    std::unordered_map<id_type, std::shared_ptr<Resource>> resources;
};
 
 
}
 
 
#endif