cache.hpp

#ifndef ENTT_RESOURCE_CACHE_HPP
#define ENTT_RESOURCE_CACHE_HPP


#include <memory>
#include <utility>
#include <type_traits>
#include <unordered_map>
#include "../core/hashed_string.hpp"
#include "handle.hpp"
#include "loader.hpp"


namespace entt {


template<typename Resource>
class ResourceCache {
    using container_type = std::unordered_map<HashedString::hash_type, std::shared_ptr<Resource>>;

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

    ResourceCache() = default;

    ResourceCache(const ResourceCache &) noexcept = delete;
    ResourceCache(ResourceCache &&) noexcept = default;

    ResourceCache & operator=(const ResourceCache &) noexcept = delete;
    ResourceCache & operator=(ResourceCache &&) noexcept = default;

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

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

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

    template<typename Loader, typename... Args>
    bool load(resource_type id, Args&&... args) {
        static_assert(std::is_base_of<ResourceLoader<Loader, Resource>, Loader>::value, "!");

        bool loaded = true;

        if(resources.find(id) == resources.cend()) {
            std::shared_ptr<Resource> resource = Loader{}.get(std::forward<Args>(args)...);
            loaded = (static_cast<bool>(resource) ? (resources[id] = std::move(resource), loaded) : false);
        }

        return loaded;
    }

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

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

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

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

    void discard(resource_type id) noexcept {
        auto it = resources.find(id);

        if(it != resources.end()) {
            resources.erase(it);
        }
    }

private:
    container_type resources;
};


}


#endif // ENTT_RESOURCE_CACHE_HPP