cache.hpp

#ifndef ENTT_RESOURCE_RESOURCE_CACHE_HPP
#define ENTT_RESOURCE_RESOURCE_CACHE_HPP
 
#include <cstddef>
#include <functional>
#include <iterator>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "../container/dense_map.hpp"
#include "../core/compressed_pair.hpp"
#include "../core/fwd.hpp"
#include "../core/iterator.hpp"
#include "../core/utility.hpp"
#include "fwd.hpp"
#include "loader.hpp"
#include "resource.hpp"
 
namespace entt {
 
namespace internal {
 
template<typename Type, typename It>
class resource_cache_iterator final {
    template<typename, typename>
    friend class resource_cache_iterator;
 
public:
    using value_type = std::pair<id_type, resource<Type>>;
    using pointer = input_iterator_pointer<value_type>;
    using reference = value_type;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::input_iterator_tag;
 
    resource_cache_iterator() ENTT_NOEXCEPT = default;
 
    resource_cache_iterator(const It iter) ENTT_NOEXCEPT
        : it{iter} {}
 
    template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
    resource_cache_iterator(const resource_cache_iterator<std::remove_const_t<Type>, Other> &other) ENTT_NOEXCEPT
        : it{other.it} {}
 
    resource_cache_iterator &operator++() ENTT_NOEXCEPT {
        return ++it, *this;
    }
 
    resource_cache_iterator operator++(int) ENTT_NOEXCEPT {
        resource_cache_iterator orig = *this;
        return ++(*this), orig;
    }
 
    resource_cache_iterator &operator--() ENTT_NOEXCEPT {
        return --it, *this;
    }
 
    resource_cache_iterator operator--(int) ENTT_NOEXCEPT {
        resource_cache_iterator orig = *this;
        return operator--(), orig;
    }
 
    resource_cache_iterator &operator+=(const difference_type value) ENTT_NOEXCEPT {
        it += value;
        return *this;
    }
 
    resource_cache_iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
        resource_cache_iterator copy = *this;
        return (copy += value);
    }
 
    resource_cache_iterator &operator-=(const difference_type value) ENTT_NOEXCEPT {
        return (*this += -value);
    }
 
    resource_cache_iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
        return (*this + -value);
    }
 
    [[nodiscard]] reference operator[](const difference_type value) const ENTT_NOEXCEPT {
        return {it[value].first, resource<Type>{it[value].second}};
    }
 
    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
        return (*this)[0];
    }
 
    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
        return operator*();
    }
 
    template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
    friend std::ptrdiff_t operator-(const resource_cache_iterator<TLhs, ILhs> &, const resource_cache_iterator<TRhs, IRhs> &) ENTT_NOEXCEPT;
 
    template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
    friend bool operator==(const resource_cache_iterator<TLhs, ILhs> &, const resource_cache_iterator<TRhs, IRhs> &) ENTT_NOEXCEPT;
 
    template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
    friend bool operator<(const resource_cache_iterator<TLhs, ILhs> &, const resource_cache_iterator<TRhs, IRhs> &) ENTT_NOEXCEPT;
 
private:
    It it;
};
 
template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
[[nodiscard]] std::ptrdiff_t operator-(const resource_cache_iterator<TLhs, ILhs> &lhs, const resource_cache_iterator<TRhs, IRhs> &rhs) ENTT_NOEXCEPT {
    return lhs.it - rhs.it;
}
 
template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
[[nodiscard]] bool operator==(const resource_cache_iterator<TLhs, ILhs> &lhs, const resource_cache_iterator<TRhs, IRhs> &rhs) ENTT_NOEXCEPT {
    return lhs.it == rhs.it;
}
 
template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
[[nodiscard]] bool operator!=(const resource_cache_iterator<TLhs, ILhs> &lhs, const resource_cache_iterator<TRhs, IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
[[nodiscard]] bool operator<(const resource_cache_iterator<TLhs, ILhs> &lhs, const resource_cache_iterator<TRhs, IRhs> &rhs) ENTT_NOEXCEPT {
    return lhs.it < rhs.it;
}
 
template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
[[nodiscard]] bool operator>(const resource_cache_iterator<TLhs, ILhs> &lhs, const resource_cache_iterator<TRhs, IRhs> &rhs) ENTT_NOEXCEPT {
    return rhs < lhs;
}
 
template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
[[nodiscard]] bool operator<=(const resource_cache_iterator<TLhs, ILhs> &lhs, const resource_cache_iterator<TRhs, IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs > rhs);
}
 
template<typename TLhs, typename ILhs, typename TRhs, typename IRhs>
[[nodiscard]] bool operator>=(const resource_cache_iterator<TLhs, ILhs> &lhs, const resource_cache_iterator<TRhs, IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs < rhs);
}
 
} // namespace internal
 
template<typename Type, typename Loader, typename Allocator>
class resource_cache {
    using alloc_traits = typename std::allocator_traits<Allocator>;
    static_assert(std::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
    using container_allocator = typename alloc_traits::template rebind_alloc<std::pair<const id_type, typename Loader::result_type>>;
    using container_type = dense_map<id_type, typename Loader::result_type, identity, std::equal_to<id_type>, container_allocator>;
 
public:
    using value_type = Type;
    using size_type = std::size_t;
    using loader_type = Loader;
    using allocator_type = Allocator;
    using iterator = internal::resource_cache_iterator<Type, typename container_type::iterator>;
    using const_iterator = internal::resource_cache_iterator<const Type, typename container_type::const_iterator>;
 
    resource_cache()
        : resource_cache{loader_type{}} {}
 
    explicit resource_cache(const allocator_type &allocator)
        : resource_cache{loader_type{}, allocator} {}
 
    explicit resource_cache(const loader_type &callable, const allocator_type &allocator = allocator_type{})
        : pool{container_type{allocator}, callable} {}
 
    resource_cache(const resource_cache &) = default;
 
    resource_cache(const resource_cache &other, const allocator_type &allocator)
        : pool{std::piecewise_construct, std::forward_as_tuple(other.pool.first(), allocator), std::forward_as_tuple(other.pool.second())} {}
 
    resource_cache(resource_cache &&) = default;
 
    resource_cache(resource_cache &&other, const allocator_type &allocator)
        : pool{std::piecewise_construct, std::forward_as_tuple(std::move(other.pool.first()), allocator), std::forward_as_tuple(std::move(other.pool.second()))} {}
 
    resource_cache &operator=(const resource_cache &) = default;
 
    resource_cache &operator=(resource_cache &&) = default;
 
    [[nodiscard]] constexpr allocator_type get_allocator() const ENTT_NOEXCEPT {
        return pool.first().get_allocator();
    }
 
    [[nodiscard]] const_iterator cbegin() const ENTT_NOEXCEPT {
        return pool.first().begin();
    }
 
    [[nodiscard]] const_iterator begin() const ENTT_NOEXCEPT {
        return cbegin();
    }
 
    [[nodiscard]] iterator begin() ENTT_NOEXCEPT {
        return pool.first().begin();
    }
 
    [[nodiscard]] const_iterator cend() const ENTT_NOEXCEPT {
        return pool.first().end();
    }
 
    [[nodiscard]] const_iterator end() const ENTT_NOEXCEPT {
        return cend();
    }
 
    [[nodiscard]] iterator end() ENTT_NOEXCEPT {
        return pool.first().end();
    }
 
    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
        return pool.first().empty();
    }
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return pool.first().size();
    }
 
    void clear() ENTT_NOEXCEPT {
        pool.first().clear();
    }
 
    template<typename... Args>
    std::pair<iterator, bool> load(const id_type id, Args &&...args) {
        if(auto it = pool.first().find(id); it != pool.first().end()) {
            return {it, false};
        }
 
        return pool.first().emplace(id, pool.second()(std::forward<Args>(args)...));
    }
 
    template<typename... Args>
    std::pair<iterator, bool> force_load(const id_type id, Args &&...args) {
        return {pool.first().insert_or_assign(id, pool.second()(std::forward<Args>(args)...)).first, true};
    }
 
    [[nodiscard]] resource<const value_type> operator[](const id_type id) const {
        if(auto it = pool.first().find(id); it != pool.first().cend()) {
            return resource<const value_type>{it->second};
        }
 
        return {};
    }
 
    [[nodiscard]] resource<value_type> operator[](const id_type id) {
        if(auto it = pool.first().find(id); it != pool.first().end()) {
            return resource<value_type>{it->second};
        }
 
        return {};
    }
 
    [[nodiscard]] bool contains(const id_type id) const {
        return pool.first().contains(id);
    }
 
    iterator erase(const_iterator pos) {
        const auto it = pool.first().begin();
        return pool.first().erase(it + (pos - const_iterator{it}));
    }
 
    iterator erase(const_iterator first, const_iterator last) {
        const auto it = pool.first().begin();
        return pool.first().erase(it + (first - const_iterator{it}), it + (last - const_iterator{it}));
    }
 
    size_type erase(const id_type id) {
        return pool.first().erase(id);
    }
 
    [[nodiscard]] loader_type loader() const {
        return pool.second();
    }
 
private:
    compressed_pair<container_type, loader_type> pool;
};
 
} // namespace entt
 
#endif