cache.hpp

#ifndef ENTT_RESOURCE_CACHE_HPP
#define ENTT_RESOURCE_CACHE_HPP


#include <memory>
#include <utility>
#include <type_traits>
#include <unordered_map>
#include "../config/config.h"
#include "handle.hpp"
#include "loader.hpp"
#include "fwd.hpp"


namespace entt {


template<typename Resource>
class resource_cache {
    using container_type = std::unordered_map<ENTT_ID_TYPE, std::shared_ptr<Resource>>;

public:
    using size_type = typename container_type::size_type;
    using resource_type = ENTT_ID_TYPE;

    resource_cache() = default;

    resource_cache(resource_cache &&) = default;

    resource_cache & operator=(resource_cache &&) = default;

    size_type size() const ENTT_NOEXCEPT {
        return resources.size();
    }

    bool empty() const ENTT_NOEXCEPT {
        return resources.empty();
    }

    void clear() ENTT_NOEXCEPT {
        resources.clear();
    }

    template<typename Loader, typename... Args>
    resource_handle<Resource> load(const resource_type id, Args &&... args) {
        static_assert(std::is_base_of_v<resource_loader<Loader, Resource>, Loader>);
        resource_handle<Resource> handle{};

        if(auto it = resources.find(id); it == resources.cend()) {
            if(auto resource = Loader{}.get(std::forward<Args>(args)...); resource) {
                resources[id] = resource;
                handle = std::move(resource);
            }
        } else {
            handle = it->second;
        }

        return handle;
    }

    template<typename Loader, typename... Args>
    resource_handle<Resource> reload(const resource_type id, Args &&... args) {
        return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
    }

    template<typename Loader, typename... Args>
    resource_handle<Resource> temp(Args &&... args) const {
        return { Loader{}.get(std::forward<Args>(args)...) };
    }

    resource_handle<Resource> handle(const resource_type id) const {
        auto it = resources.find(id);
        return { it == resources.end() ? nullptr : it->second };
    }

    bool contains(const resource_type id) const ENTT_NOEXCEPT {
        return (resources.find(id) != resources.cend());
    }

    void discard(const resource_type id) ENTT_NOEXCEPT {
        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, resource_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:
    container_type resources;
};


}


#endif // ENTT_RESOURCE_CACHE_HPP