cache.hpp

#ifndef ENTT_RESOURCE_CACHE_HPP
#define ENTT_RESOURCE_CACHE_HPP
 
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "../container/dense_hash_map.hpp"
#include "../core/fwd.hpp"
#include "../core/utility.hpp"
#include "fwd.hpp"
#include "handle.hpp"
#include "loader.hpp"
 
namespace entt {
 
template<typename Resource>
class resource_cache {
    static_assert(std::is_same_v<Resource, std::remove_const_t<std::remove_reference_t<Resource>>>, "Invalid resource type");
 
public:
    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_type> load(const id_type id, Args &&...args) {
        if(auto it = resources.find(id); it == resources.cend()) {
            if(auto handle = temp<Loader>(std::forward<Args>(args)...); handle) {
                return (resources[id] = std::move(handle));
            }
        } else {
            return it->second;
        }
 
        return {};
    }
 
    template<typename Loader, typename... Args>
    resource_handle<resource_type> 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_type> temp(Args &&...args) const {
        return Loader{}.get(std::forward<Args>(args)...);
    }
 
    [[nodiscard]] resource_handle<const resource_type> handle(const id_type id) const {
        if(auto it = resources.find(id); it != resources.cend()) {
            return it->second;
        }
 
        return {};
    }
 
    [[nodiscard]] resource_handle<resource_type> handle(const id_type id) {
        if(auto it = resources.find(id); it != resources.end()) {
            return it->second;
        }
 
        return {};
    }
 
    [[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<const resource_type>>) {
                func(resource_handle<const resource_type>{curr->second});
            } else {
                func(curr->first, resource_handle<const resource_type>{curr->second});
            }
        }
    }
 
    template<typename Func>
    void each(Func func) {
        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_type>>) {
                func(curr->second);
            } else {
                func(curr->first, curr->second);
            }
        }
    }
 
private:
    dense_hash_map<id_type, resource_handle<resource_type>, identity> resources;
};
 
} // namespace entt
 
#endif