dense_map.hpp

#ifndef ENTT_CONTAINER_DENSE_MAP_HPP
#define ENTT_CONTAINER_DENSE_MAP_HPP
 
#include <compare>
#include "../config/config.h"
#include "../core/bit.hpp"
#include "../core/compressed_pair.hpp"
#include "../core/iterator.hpp"
#include "../core/memory.hpp"
#include "../core/type_traits.hpp"
#include "../stl/bit.hpp"
#include "../stl/cmath.hpp"
#include "../stl/concepts.hpp"
#include "../stl/cstddef.hpp"
#include "../stl/functional.hpp"
#include "../stl/iterator.hpp"
#include "../stl/limits.hpp"
#include "../stl/memory.hpp"
#include "../stl/tuple.hpp"
#include "../stl/type_traits.hpp"
#include "../stl/utility.hpp"
#include "../stl/vector.hpp"
#include "fwd.hpp"
 
namespace entt {

namespace internal {
 
static constexpr stl::size_t dense_map_placeholder_position = (stl::numeric_limits<stl::size_t>::max)();
 
template<typename Key, typename Type>
struct dense_map_node final {
    using value_type = stl::pair<Key, Type>;
 
    template<typename... Args>
    dense_map_node(const stl::size_t pos, Args &&...args)
        : next{pos},
          element{stl::forward<Args>(args)...} {}
 
    template<typename... Args>
    dense_map_node(stl::allocator_arg_t, const auto &allocator, const stl::size_t pos, Args &&...args)
        : next{pos},
          element{entt::make_obj_using_allocator<value_type>(allocator, stl::forward<Args>(args)...)} {}
 
    dense_map_node(stl::allocator_arg_t, const auto &allocator, const dense_map_node &other)
        : next{other.next},
          element{entt::make_obj_using_allocator<value_type>(allocator, other.element)} {}
 
    dense_map_node(stl::allocator_arg_t, const auto &allocator, dense_map_node &&other)
        : next{other.next},
          element{entt::make_obj_using_allocator<value_type>(allocator, stl::move(other.element))} {}
 
    stl::size_t next;
    value_type element;
};
 
template<typename It>
class dense_map_iterator final {
    template<typename>
    friend class dense_map_iterator;
 
    static_assert(stl::is_pointer_v<It>, "Not a pointer type");
    using first_type = decltype(stl::as_const(stl::declval<It>()->element.first));
    using second_type = decltype((stl::declval<It>()->element.second));
 
public:
    using value_type = stl::pair<first_type, second_type>;
    using pointer = input_iterator_pointer<value_type>;
    using reference = value_type;
    using difference_type = stl::ptrdiff_t;
    using iterator_category = stl::input_iterator_tag;
    using iterator_concept = stl::random_access_iterator_tag;
 
    constexpr dense_map_iterator() noexcept
        : it{} {}
 
    constexpr dense_map_iterator(const It iter) noexcept
        : it{iter} {}
 
    template<typename Other>
    requires (!stl::same_as<It, Other> && stl::constructible_from<It, Other>)
    constexpr dense_map_iterator(const dense_map_iterator<Other> &other) noexcept
        : it{other.it} {}
 
    constexpr dense_map_iterator &operator++() noexcept {
        return ++it, *this;
    }
 
    constexpr dense_map_iterator operator++(int) noexcept {
        const dense_map_iterator orig = *this;
        return ++(*this), orig;
    }
 
    constexpr dense_map_iterator &operator--() noexcept {
        return --it, *this;
    }
 
    constexpr dense_map_iterator operator--(int) noexcept {
        const dense_map_iterator orig = *this;
        return operator--(), orig;
    }
 
    constexpr dense_map_iterator &operator+=(const difference_type value) noexcept {
        it += value;
        return *this;
    }
 
    constexpr dense_map_iterator operator+(const difference_type value) const noexcept {
        dense_map_iterator copy = *this;
        return (copy += value);
    }
 
    constexpr dense_map_iterator &operator-=(const difference_type value) noexcept {
        return (*this += -value);
    }
 
    constexpr dense_map_iterator operator-(const difference_type value) const noexcept {
        return (*this + -value);
    }
 
    [[nodiscard]] constexpr reference operator[](const difference_type value) const noexcept {
        return {it[value].element.first, it[value].element.second};
    }
 
    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return operator*();
    }
 
    [[nodiscard]] constexpr reference operator*() const noexcept {
        return operator[](0);
    }
 
    template<typename Other>
    [[nodiscard]] constexpr stl::ptrdiff_t operator-(const dense_map_iterator<Other> &other) const noexcept {
        return it - other.it;
    }
 
    template<typename Other>
    [[nodiscard]] constexpr bool operator==(const dense_map_iterator<Other> &other) const noexcept {
        return it == other.it;
    }
 
    template<typename Other>
    [[nodiscard]] constexpr auto operator<=>(const dense_map_iterator<Other> &other) const noexcept {
        return it <=> other.it;
    }
 
private:
    It it;
};
 
template<typename It>
class dense_map_local_iterator final {
    template<typename>
    friend class dense_map_local_iterator;
 
    static_assert(stl::is_pointer_v<It>, "Not a pointer type");
    using first_type = decltype(stl::as_const(stl::declval<It>()->element.first));
    using second_type = decltype((stl::declval<It>()->element.second));
 
public:
    using value_type = stl::pair<first_type, second_type>;
    using pointer = input_iterator_pointer<value_type>;
    using reference = value_type;
    using difference_type = stl::ptrdiff_t;
    using iterator_category = stl::input_iterator_tag;
    using iterator_concept = stl::forward_iterator_tag;
 
    constexpr dense_map_local_iterator() noexcept = default;
 
    constexpr dense_map_local_iterator(It iter, const stl::size_t pos) noexcept
        : it{iter},
          offset{pos} {}
 
    template<typename Other>
    requires (!stl::same_as<It, Other> && stl::constructible_from<It, Other>)
    constexpr dense_map_local_iterator(const dense_map_local_iterator<Other> &other) noexcept
        : it{other.it},
          offset{other.offset} {}
 
    constexpr dense_map_local_iterator &operator++() noexcept {
        return (offset = it[static_cast<difference_type>(offset)].next), *this;
    }
 
    constexpr dense_map_local_iterator operator++(int) noexcept {
        const dense_map_local_iterator orig = *this;
        return ++(*this), orig;
    }
 
    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return operator*();
    }
 
    [[nodiscard]] constexpr reference operator*() const noexcept {
        const auto idx = static_cast<difference_type>(offset);
        return {it[idx].element.first, it[idx].element.second};
    }
 
    template<typename Other>
    [[nodiscard]] constexpr bool operator==(const dense_map_local_iterator<Other> &other) const noexcept {
        return offset == other.offset;
    }
 
    [[nodiscard]] constexpr stl::size_t index() const noexcept {
        return offset;
    }
 
private:
    It it{};
    stl::size_t offset{dense_map_placeholder_position};
};
 
} // namespace internal

template<typename Key, typename Type, typename Hash, typename KeyEqual, typename Allocator>
class dense_map {
    static constexpr float default_threshold = 0.875f;
    static constexpr stl::size_t minimum_capacity = 8u;
    static constexpr stl::size_t placeholder_position = internal::dense_map_placeholder_position;
 
    using node_type = internal::dense_map_node<Key, Type>;
    using alloc_traits = stl::allocator_traits<Allocator>;
    static_assert(stl::is_same_v<typename alloc_traits::value_type, stl::pair<const Key, Type>>, "Invalid value type");
    using sparse_container_type = stl::vector<stl::size_t, typename alloc_traits::template rebind_alloc<stl::size_t>>;
    using packed_container_type = stl::vector<node_type, typename alloc_traits::template rebind_alloc<node_type>>;
 
    [[nodiscard]] stl::size_t key_to_bucket(const auto &key) const noexcept {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
        return fast_mod(static_cast<size_type>(sparse.second()(key)), bucket_count());
    }
 
    [[nodiscard]] auto constrained_find(const auto &key, const stl::size_t bucket) {
        for(auto offset = sparse.first()[bucket]; offset != placeholder_position; offset = packed.first()[offset].next) {
            if(packed.second()(packed.first()[offset].element.first, key)) {
                return begin() + static_cast<iterator::difference_type>(offset);
            }
        }
 
        return end();
    }
 
    [[nodiscard]] auto constrained_find(const auto &key, const stl::size_t bucket) const {
        for(auto offset = sparse.first()[bucket]; offset != placeholder_position; offset = packed.first()[offset].next) {
            if(packed.second()(packed.first()[offset].element.first, key)) {
                return cbegin() + static_cast<const_iterator::difference_type>(offset);
            }
        }
 
        return cend();
    }
 
    template<typename Other, typename... Args>
    [[nodiscard]] auto insert_or_do_nothing(Other &&key, Args &&...args) {
        const auto index = key_to_bucket(key);
 
        if(auto it = constrained_find(key, index); it != end()) {
            return stl::make_pair(it, false);
        }
 
        packed.first().emplace_back(sparse.first()[index], stl::piecewise_construct, stl::forward_as_tuple(stl::forward<Other>(key)), stl::forward_as_tuple(stl::forward<Args>(args)...));
        sparse.first()[index] = packed.first().size() - 1u;
        rehash_if_required();
 
        return stl::make_pair(--end(), true);
    }
 
    template<typename Other, typename Arg>
    [[nodiscard]] auto insert_or_overwrite(Other &&key, Arg &&value) {
        const auto index = key_to_bucket(key);
 
        if(auto it = constrained_find(key, index); it != end()) {
            it->second = stl::forward<Arg>(value);
            return stl::make_pair(it, false);
        }
 
        packed.first().emplace_back(sparse.first()[index], stl::forward<Other>(key), stl::forward<Arg>(value));
        sparse.first()[index] = packed.first().size() - 1u;
        rehash_if_required();
 
        return stl::make_pair(--end(), true);
    }
 
    void move_and_pop(const stl::size_t pos) {
        if(const auto last = size() - 1u; pos != last) {
            size_type *curr = &sparse.first()[key_to_bucket(packed.first().back().element.first)];
            packed.first()[pos] = stl::move(packed.first().back());
            for(; *curr != last; curr = &packed.first()[*curr].next) {}
            *curr = pos;
        }
 
        packed.first().pop_back();
    }
 
    void rehash_if_required() {
        if(const auto bc = bucket_count(); size() > static_cast<size_type>(static_cast<float>(bc) * max_load_factor())) {
            rehash(bc * 2u);
        }
    }
 
public:
    using allocator_type = Allocator;
    using key_type = Key;
    using mapped_type = Type;
    using value_type = stl::pair<const Key, Type>;
    using size_type = stl::size_t;
    using difference_type = stl::ptrdiff_t;
    using hasher = Hash;
    using key_equal = KeyEqual;
    using iterator = internal::dense_map_iterator<typename packed_container_type::pointer>;
    using const_iterator = internal::dense_map_iterator<typename packed_container_type::const_pointer>;
    using local_iterator = internal::dense_map_local_iterator<typename packed_container_type::pointer>;
    using const_local_iterator = internal::dense_map_local_iterator<typename packed_container_type::const_pointer>;

    dense_map()
        : dense_map{minimum_capacity} {}

    explicit dense_map(const allocator_type &allocator)
        : dense_map{minimum_capacity, hasher{}, key_equal{}, allocator} {}

    dense_map(const size_type cnt, const allocator_type &allocator)
        : dense_map{cnt, hasher{}, key_equal{}, allocator} {}

    dense_map(const size_type cnt, const hasher &hash, const allocator_type &allocator)
        : dense_map{cnt, hash, key_equal{}, allocator} {}

    explicit dense_map(const size_type cnt, const hasher &hash = hasher{}, const key_equal &equal = key_equal{}, const allocator_type &allocator = allocator_type{})
        : sparse{allocator, hash},
          packed{allocator, equal} {
        rehash(cnt);
    }

    dense_map(const dense_map &) = default;

    dense_map(const dense_map &other, const allocator_type &allocator)
        : sparse{stl::piecewise_construct, stl::forward_as_tuple(other.sparse.first(), allocator), stl::forward_as_tuple(other.sparse.second())},
          packed{stl::piecewise_construct, stl::forward_as_tuple(other.packed.first(), allocator), stl::forward_as_tuple(other.packed.second())},
          threshold{other.threshold} {}

    dense_map(dense_map &&) noexcept = default;

    dense_map(dense_map &&other, const allocator_type &allocator)
        : sparse{stl::piecewise_construct, stl::forward_as_tuple(stl::move(other.sparse.first()), allocator), stl::forward_as_tuple(stl::move(other.sparse.second()))},
          packed{stl::piecewise_construct, stl::forward_as_tuple(stl::move(other.packed.first()), allocator), stl::forward_as_tuple(stl::move(other.packed.second()))},
          threshold{other.threshold} {}

    ~dense_map() = default;

    dense_map &operator=(const dense_map &) = default;

    dense_map &operator=(dense_map &&) noexcept = default;

    void swap(dense_map &other) noexcept {
        using stl::swap;
        swap(sparse, other.sparse);
        swap(packed, other.packed);
        swap(threshold, other.threshold);
    }

    [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
        return sparse.first().get_allocator();
    }

    [[nodiscard]] const_iterator cbegin() const noexcept {
        return packed.first().data();
    }

    [[nodiscard]] const_iterator begin() const noexcept {
        return cbegin();
    }

    [[nodiscard]] iterator begin() noexcept {
        return packed.first().data();
    }

    [[nodiscard]] const_iterator cend() const noexcept {
        return packed.first().data() + packed.first().size();
    }

    [[nodiscard]] const_iterator end() const noexcept {
        return cend();
    }

    [[nodiscard]] iterator end() noexcept {
        return packed.first().data() + packed.first().size();
    }

    [[nodiscard]] bool empty() const noexcept {
        return packed.first().empty();
    }

    [[nodiscard]] size_type size() const noexcept {
        return packed.first().size();
    }

    [[nodiscard]] size_type max_size() const noexcept {
        return packed.first().max_size();
    }

    void clear() noexcept {
        sparse.first().clear();
        packed.first().clear();
        rehash(0u);
    }

    stl::pair<iterator, bool> insert(const value_type &value) {
        return insert_or_do_nothing(value.first, value.second);
    }

    stl::pair<iterator, bool> insert(value_type &&value) {
        return insert_or_do_nothing(stl::move(value.first), stl::move(value.second));
    }

    template<typename Arg>
    requires stl::constructible_from<value_type, Arg &&>
    stl::pair<iterator, bool> insert(Arg &&value) {
        return insert_or_do_nothing(stl::forward<Arg>(value).first, stl::forward<Arg>(value).second);
    }

    void insert(stl::input_iterator auto first, stl::input_iterator auto last) {
        for(; first != last; ++first) {
            insert(*first);
        }
    }

    template<typename Arg>
    stl::pair<iterator, bool> insert_or_assign(const key_type &key, Arg &&value) {
        return insert_or_overwrite(key, stl::forward<Arg>(value));
    }

    template<typename Arg>
    stl::pair<iterator, bool> insert_or_assign(key_type &&key, Arg &&value) {
        return insert_or_overwrite(stl::move(key), stl::forward<Arg>(value));
    }

    template<typename... Args>
    stl::pair<iterator, bool> emplace([[maybe_unused]] Args &&...args) {
        if constexpr(sizeof...(Args) == 0u) {
            return insert_or_do_nothing(key_type{});
        } else if constexpr(sizeof...(Args) == 1u) {
            return insert_or_do_nothing(stl::forward<Args>(args).first..., stl::forward<Args>(args).second...);
        } else if constexpr(sizeof...(Args) == 2u) {
            return insert_or_do_nothing(stl::forward<Args>(args)...);
        } else {
            auto &node = packed.first().emplace_back(packed.first().size(), stl::forward<Args>(args)...);
            const auto index = key_to_bucket(node.element.first);
 
            if(auto it = constrained_find(node.element.first, index); it != end()) {
                packed.first().pop_back();
                return stl::make_pair(it, false);
            }
 
            stl::swap(node.next, sparse.first()[index]);
            rehash_if_required();
 
            return stl::make_pair(--end(), true);
        }
    }

    template<typename... Args>
    stl::pair<iterator, bool> try_emplace(const key_type &key, Args &&...args) {
        return insert_or_do_nothing(key, stl::forward<Args>(args)...);
    }

    template<typename... Args>
    stl::pair<iterator, bool> try_emplace(key_type &&key, Args &&...args) {
        return insert_or_do_nothing(stl::move(key), stl::forward<Args>(args)...);
    }

    iterator erase(const_iterator pos) {
        const auto diff = pos - cbegin();
        erase(pos->first);
        return begin() + diff;
    }

    iterator erase(const_iterator first, const_iterator last) {
        const auto dist = first - cbegin();
 
        for(auto from = last - cbegin(); from != dist; --from) {
            erase(packed.first()[static_cast<size_type>(from) - 1u].element.first);
        }
 
        return (begin() + dist);
    }

    size_type erase(const key_type &key) {
        for(size_type *curr = &sparse.first()[key_to_bucket(key)]; *curr != placeholder_position; curr = &packed.first()[*curr].next) {
            if(packed.second()(packed.first()[*curr].element.first, key)) {
                const auto index = *curr;
                *curr = packed.first()[*curr].next;
                move_and_pop(index);
                return 1u;
            }
        }
 
        return 0u;
    }

    [[nodiscard]] mapped_type &at(const key_type &key) {
        auto it = find(key);
        ENTT_ASSERT(it != end(), "Invalid key");
        return it->second;
    }

    [[nodiscard]] const mapped_type &at(const key_type &key) const {
        auto it = find(key);
        ENTT_ASSERT(it != cend(), "Invalid key");
        return it->second;
    }

    [[nodiscard]] mapped_type const &at(const auto &key) const
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        auto it = find(key);
        ENTT_ASSERT(it != cend(), "Invalid key");
        return it->second;
    }

    [[nodiscard]] mapped_type &at(const auto &key)
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        auto it = find(key);
        ENTT_ASSERT(it != end(), "Invalid key");
        return it->second;
    }

    [[nodiscard]] mapped_type &operator[](const key_type &key) {
        return insert_or_do_nothing(key).first->second;
    }

    [[nodiscard]] mapped_type &operator[](key_type &&key) {
        return insert_or_do_nothing(stl::move(key)).first->second;
    }

    [[nodiscard]] size_type count(const key_type &key) const {
        return find(key) != end();
    }

    [[nodiscard]] size_type count(const auto &key) const
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        return find(key) != end();
    }

    [[nodiscard]] iterator find(const key_type &key) {
        return constrained_find(key, key_to_bucket(key));
    }

    [[nodiscard]] const_iterator find(const key_type &key) const {
        return constrained_find(key, key_to_bucket(key));
    }

    [[nodiscard]] iterator find(const auto &key)
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        return constrained_find(key, key_to_bucket(key));
    }

    [[nodiscard]] const_iterator find(const auto &key) const
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        return constrained_find(key, key_to_bucket(key));
    }

    [[nodiscard]] stl::pair<iterator, iterator> equal_range(const key_type &key) {
        const auto it = find(key);
        return {it, it + !(it == end())};
    }

    [[nodiscard]] stl::pair<const_iterator, const_iterator> equal_range(const key_type &key) const {
        const auto it = find(key);
        return {it, it + !(it == cend())};
    }

    [[nodiscard]] stl::pair<iterator, iterator> equal_range(const auto &key)
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        const auto it = find(key);
        return {it, it + !(it == end())};
    }

    [[nodiscard]] stl::pair<const_iterator, const_iterator> equal_range(const auto &key) const
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        const auto it = find(key);
        return {it, it + !(it == cend())};
    }

    [[nodiscard]] bool contains(const key_type &key) const {
        return (find(key) != cend());
    }

    [[nodiscard]] bool contains(const auto &key) const
    requires is_transparent_v<hasher> && is_transparent_v<key_equal> {
        return (find(key) != cend());
    }

    [[nodiscard]] const_local_iterator cbegin(const size_type index) const {
        return {packed.first().data(), sparse.first()[index]};
    }

    [[nodiscard]] const_local_iterator begin(const size_type index) const {
        return cbegin(index);
    }

    [[nodiscard]] local_iterator begin(const size_type index) {
        return {packed.first().data(), sparse.first()[index]};
    }

    [[nodiscard]] const_local_iterator cend([[maybe_unused]] const size_type index) const {
        return {};
    }

    [[nodiscard]] const_local_iterator end(const size_type index) const {
        return cend(index);
    }

    [[nodiscard]] local_iterator end([[maybe_unused]] const size_type index) {
        return {};
    }

    [[nodiscard]] size_type bucket_count() const {
        return sparse.first().size();
    }

    [[nodiscard]] size_type max_bucket_count() const {
        return sparse.first().max_size();
    }

    [[nodiscard]] size_type bucket_size(const size_type index) const {
        return static_cast<size_type>(stl::distance(begin(index), end(index)));
    }

    [[nodiscard]] size_type bucket(const key_type &key) const {
        return key_to_bucket(key);
    }

    [[nodiscard]] float load_factor() const {
        return static_cast<float>(size()) / static_cast<float>(bucket_count());
    }

    [[nodiscard]] float max_load_factor() const {
        return threshold;
    }

    void max_load_factor(const float value) {
        ENTT_ASSERT(value > 0.f, "Invalid load factor");
        threshold = value;
        rehash(0u);
    }

    void rehash(const size_type cnt) {
        auto value = cnt > minimum_capacity ? cnt : minimum_capacity;
        const auto cap = static_cast<size_type>(static_cast<float>(size()) / max_load_factor());
        value = value > cap ? value : cap;
 
        if(const auto sz = stl::bit_ceil(value); sz != bucket_count()) {
            sparse.first().resize(sz);
 
            for(auto &&elem: sparse.first()) {
                elem = placeholder_position;
            }
 
            for(size_type pos{}, last = size(); pos < last; ++pos) {
                const auto index = key_to_bucket(packed.first()[pos].element.first);
                packed.first()[pos].next = stl::exchange(sparse.first()[index], pos);
            }
        }
    }

    void reserve(const size_type cnt) {
        packed.first().reserve(cnt);
        rehash(static_cast<size_type>(stl::ceil(static_cast<float>(cnt) / max_load_factor())));
    }

    [[nodiscard]] hasher hash_function() const {
        return sparse.second();
    }

    [[nodiscard]] key_equal key_eq() const {
        return packed.second();
    }
 
private:
    compressed_pair<sparse_container_type, hasher> sparse;
    compressed_pair<packed_container_type, key_equal> packed;
    float threshold{default_threshold};
};
 
} // namespace entt

#include <utility>
 
namespace std {
 
template<typename Key, typename Value, typename Allocator>
struct uses_allocator<entt::internal::dense_map_node<Key, Value>, Allocator>
    : entt::stl::true_type {};
 
} // namespace std
 
#endif