dense_set.hpp

#ifndef ENTT_CONTAINER_DENSE_SET_HPP
#define ENTT_CONTAINER_DENSE_SET_HPP
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <functional>
#include <iterator>
#include <limits>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
#include "../config/config.h"
#include "../core/compressed_pair.hpp"
#include "../core/memory.hpp"
#include "../core/type_traits.hpp"
#include "fwd.hpp"
 
namespace entt {
 
namespace internal {
 
template<typename It>
class dense_set_iterator final {
    template<typename>
    friend class dense_set_iterator;
 
public:
    using value_type = typename It::value_type::second_type;
    using pointer = const value_type *;
    using reference = const value_type &;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::random_access_iterator_tag;
 
    dense_set_iterator() ENTT_NOEXCEPT
        : it{} {}
 
    dense_set_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>>>
    dense_set_iterator(const dense_set_iterator<Other> &other) ENTT_NOEXCEPT
        : it{other.it} {}
 
    dense_set_iterator &operator++() ENTT_NOEXCEPT {
        return ++it, *this;
    }
 
    dense_set_iterator operator++(int) ENTT_NOEXCEPT {
        dense_set_iterator orig = *this;
        return ++(*this), orig;
    }
 
    dense_set_iterator &operator--() ENTT_NOEXCEPT {
        return --it, *this;
    }
 
    dense_set_iterator operator--(int) ENTT_NOEXCEPT {
        dense_set_iterator orig = *this;
        return operator--(), orig;
    }
 
    dense_set_iterator &operator+=(const difference_type value) ENTT_NOEXCEPT {
        it += value;
        return *this;
    }
 
    dense_set_iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
        dense_set_iterator copy = *this;
        return (copy += value);
    }
 
    dense_set_iterator &operator-=(const difference_type value) ENTT_NOEXCEPT {
        return (*this += -value);
    }
 
    dense_set_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].second;
    }
 
    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
        return std::addressof(it->second);
    }
 
    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
        return *operator->();
    }
 
    template<typename ILhs, typename IRhs>
    friend std::ptrdiff_t operator-(const dense_set_iterator<ILhs> &, const dense_set_iterator<IRhs> &) ENTT_NOEXCEPT;
 
    template<typename ILhs, typename IRhs>
    friend bool operator==(const dense_set_iterator<ILhs> &, const dense_set_iterator<IRhs> &) ENTT_NOEXCEPT;
 
    template<typename ILhs, typename IRhs>
    friend bool operator<(const dense_set_iterator<ILhs> &, const dense_set_iterator<IRhs> &) ENTT_NOEXCEPT;
 
private:
    It it;
};
 
template<typename ILhs, typename IRhs>
[[nodiscard]] std::ptrdiff_t operator-(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return lhs.it - rhs.it;
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator==(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return lhs.it == rhs.it;
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator!=(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator<(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return lhs.it < rhs.it;
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator>(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return rhs < lhs;
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator<=(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs > rhs);
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator>=(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs < rhs);
}
 
template<typename It>
class dense_set_local_iterator final {
    template<typename>
    friend class dense_set_local_iterator;
 
public:
    using value_type = typename It::value_type::second_type;
    using pointer = const value_type *;
    using reference = const value_type &;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
 
    dense_set_local_iterator() ENTT_NOEXCEPT
        : it{},
          offset{} {}
 
    dense_set_local_iterator(It iter, const std::size_t pos) ENTT_NOEXCEPT
        : it{iter},
          offset{pos} {}
 
    template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
    dense_set_local_iterator(const dense_set_local_iterator<Other> &other) ENTT_NOEXCEPT
        : it{other.it},
          offset{other.offset} {}
 
    dense_set_local_iterator &operator++() ENTT_NOEXCEPT {
        return offset = it[offset].first, *this;
    }
 
    dense_set_local_iterator operator++(int) ENTT_NOEXCEPT {
        dense_set_local_iterator orig = *this;
        return ++(*this), orig;
    }
 
    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
        return std::addressof(it[offset].second);
    }
 
    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
        return *operator->();
    }
 
    [[nodiscard]] std::size_t index() const ENTT_NOEXCEPT {
        return offset;
    }
 
private:
    It it;
    std::size_t offset;
};
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator==(const dense_set_local_iterator<ILhs> &lhs, const dense_set_local_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return lhs.index() == rhs.index();
}
 
template<typename ILhs, typename IRhs>
[[nodiscard]] bool operator!=(const dense_set_local_iterator<ILhs> &lhs, const dense_set_local_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
} // namespace internal
 
template<typename Type, typename Hash, typename KeyEqual, typename Allocator>
class dense_set {
    static constexpr float default_threshold = 0.875f;
    static constexpr std::size_t minimum_capacity = 8u;
 
    using node_type = std::pair<std::size_t, Type>;
    using alloc_traits = std::allocator_traits<Allocator>;
    static_assert(std::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
    using sparse_container_type = std::vector<std::size_t, typename alloc_traits::template rebind_alloc<std::size_t>>;
    using packed_container_type = std::vector<node_type, typename alloc_traits::template rebind_alloc<node_type>>;
 
    template<typename Other>
    [[nodiscard]] std::size_t value_to_bucket(const Other &value) const ENTT_NOEXCEPT {
        return fast_mod(sparse.second()(value), bucket_count());
    }
 
    template<typename Other>
    [[nodiscard]] auto constrained_find(const Other &value, std::size_t bucket) {
        for(auto it = begin(bucket), last = end(bucket); it != last; ++it) {
            if(packed.second()(*it, value)) {
                return begin() + static_cast<typename iterator::difference_type>(it.index());
            }
        }
 
        return end();
    }
 
    template<typename Other>
    [[nodiscard]] auto constrained_find(const Other &value, std::size_t bucket) const {
        for(auto it = cbegin(bucket), last = cend(bucket); it != last; ++it) {
            if(packed.second()(*it, value)) {
                return cbegin() + static_cast<typename iterator::difference_type>(it.index());
            }
        }
 
        return cend();
    }
 
    template<typename Other>
    [[nodiscard]] auto insert_or_do_nothing(Other &&value) {
        const auto index = value_to_bucket(value);
 
        if(auto it = constrained_find(value, index); it != end()) {
            return std::make_pair(it, false);
        }
 
        packed.first().emplace_back(sparse.first()[index], std::forward<Other>(value));
        sparse.first()[index] = packed.first().size() - 1u;
        rehash_if_required();
 
        return std::make_pair(--end(), true);
    }
 
    void move_and_pop(const std::size_t pos) {
        if(const auto last = size() - 1u; pos != last) {
            packed.first()[pos] = std::move(packed.first().back());
            size_type *curr = sparse.first().data() + value_to_bucket(packed.first().back().second);
            for(; *curr != last; curr = &packed.first()[*curr].first) {}
            *curr = pos;
        }
 
        packed.first().pop_back();
    }
 
    void rehash_if_required() {
        if(size() > (bucket_count() * max_load_factor())) {
            rehash(bucket_count() * 2u);
        }
    }
 
public:
    using key_type = Type;
    using value_type = Type;
    using size_type = std::size_t;
    using hasher = Hash;
    using key_equal = KeyEqual;
    using allocator_type = Allocator;
    using iterator = internal::dense_set_iterator<typename packed_container_type::iterator>;
    using const_iterator = internal::dense_set_iterator<typename packed_container_type::const_iterator>;
    using local_iterator = internal::dense_set_local_iterator<typename packed_container_type::iterator>;
    using const_local_iterator = internal::dense_set_local_iterator<typename packed_container_type::const_iterator>;
 
    dense_set()
        : dense_set(minimum_capacity) {}
 
    explicit dense_set(const allocator_type &allocator)
        : dense_set{minimum_capacity, hasher{}, key_equal{}, allocator} {}
 
    dense_set(const size_type bucket_count, const allocator_type &allocator)
        : dense_set{bucket_count, hasher{}, key_equal{}, allocator} {}
 
    dense_set(const size_type bucket_count, const hasher &hash, const allocator_type &allocator)
        : dense_set{bucket_count, hash, key_equal{}, allocator} {}
 
    explicit dense_set(const size_type bucket_count, const hasher &hash = hasher{}, const key_equal &equal = key_equal{}, const allocator_type &allocator = allocator_type{})
        : sparse{allocator, hash},
          packed{allocator, equal},
          threshold{default_threshold} {
        rehash(bucket_count);
    }
 
    dense_set(const dense_set &) = default;
 
    dense_set(const dense_set &other, const allocator_type &allocator)
        : sparse{std::piecewise_construct, std::forward_as_tuple(other.sparse.first(), allocator), std::forward_as_tuple(other.sparse.second())},
          packed{std::piecewise_construct, std::forward_as_tuple(other.packed.first(), allocator), std::forward_as_tuple(other.packed.second())},
          threshold{other.threshold} {}
 
    dense_set(dense_set &&) = default;
 
    dense_set(dense_set &&other, const allocator_type &allocator)
        : sparse{std::piecewise_construct, std::forward_as_tuple(std::move(other.sparse.first()), allocator), std::forward_as_tuple(std::move(other.sparse.second()))},
          packed{std::piecewise_construct, std::forward_as_tuple(std::move(other.packed.first()), allocator), std::forward_as_tuple(std::move(other.packed.second()))},
          threshold{other.threshold} {}
 
    dense_set &operator=(const dense_set &) = default;
 
    dense_set &operator=(dense_set &&) = default;
 
    [[nodiscard]] constexpr allocator_type get_allocator() const ENTT_NOEXCEPT {
        return sparse.first().get_allocator();
    }
 
    [[nodiscard]] const_iterator cbegin() const ENTT_NOEXCEPT {
        return packed.first().begin();
    }
 
    [[nodiscard]] const_iterator begin() const ENTT_NOEXCEPT {
        return cbegin();
    }
 
    [[nodiscard]] iterator begin() ENTT_NOEXCEPT {
        return packed.first().begin();
    }
 
    [[nodiscard]] const_iterator cend() const ENTT_NOEXCEPT {
        return packed.first().end();
    }
 
    [[nodiscard]] const_iterator end() const ENTT_NOEXCEPT {
        return cend();
    }
 
    [[nodiscard]] iterator end() ENTT_NOEXCEPT {
        return packed.first().end();
    }
 
    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
        return packed.first().empty();
    }
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return packed.first().size();
    }
 
    void clear() ENTT_NOEXCEPT {
        sparse.first().clear();
        packed.first().clear();
        rehash(0u);
    }
 
    std::pair<iterator, bool> insert(const value_type &value) {
        return insert_or_do_nothing(value);
    }
 
    std::pair<iterator, bool> insert(value_type &&value) {
        return insert_or_do_nothing(std::move(value));
    }
 
    template<typename It>
    void insert(It first, It last) {
        for(; first != last; ++first) {
            insert(*first);
        }
    }
 
    template<typename... Args>
    std::pair<iterator, bool> emplace(Args &&...args) {
        if constexpr(((sizeof...(Args) == 1u) && ... && std::is_same_v<std::remove_cv_t<std::remove_reference_t<Args>>, value_type>)) {
            return insert_or_do_nothing(std::forward<Args>(args)...);
        } else {
            auto &node = packed.first().emplace_back(std::piecewise_construct, std::make_tuple(packed.first().size()), std::forward_as_tuple(std::forward<Args>(args)...));
            const auto index = value_to_bucket(node.second);
 
            if(auto it = constrained_find(node.second, index); it != end()) {
                packed.first().pop_back();
                return std::make_pair(it, false);
            }
 
            std::swap(node.first, sparse.first()[index]);
            rehash_if_required();
 
            return std::make_pair(--end(), true);
        }
    }
 
    iterator erase(const_iterator pos) {
        const auto diff = pos - cbegin();
        erase(*pos);
        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()[from - 1u].second);
        }
 
        return (begin() + dist);
    }
 
    size_type erase(const value_type &value) {
        for(size_type *curr = sparse.first().data() + value_to_bucket(value); *curr != (std::numeric_limits<size_type>::max)(); curr = &packed.first()[*curr].first) {
            if(packed.second()(packed.first()[*curr].second, value)) {
                const auto index = *curr;
                *curr = packed.first()[*curr].first;
                move_and_pop(index);
                return 1u;
            }
        }
 
        return 0u;
    }
 
    void swap(dense_set &other) {
        using std::swap;
        swap(sparse, other.sparse);
        swap(packed, other.packed);
        swap(threshold, other.threshold);
    }
 
    [[nodiscard]] iterator find(const value_type &value) {
        return constrained_find(value, value_to_bucket(value));
    }
 
    [[nodiscard]] const_iterator find(const value_type &value) const {
        return constrained_find(value, value_to_bucket(value));
    }
 
    template<typename Other>
    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, iterator>>
    find(const Other &value) {
        return constrained_find(value, value_to_bucket(value));
    }
 
    template<typename Other>
    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, const_iterator>>
    find(const Other &value) const {
        return constrained_find(value, value_to_bucket(value));
    }
 
    [[nodiscard]] bool contains(const value_type &value) const {
        return (find(value) != cend());
    }
 
    template<typename Other>
    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, bool>>
    contains(const Other &value) const {
        return (find(value) != cend());
    }
 
    [[nodiscard]] const_local_iterator cbegin(const size_type index) const {
        return {packed.first().begin(), 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().begin(), sparse.first()[index]};
    }
 
    [[nodiscard]] const_local_iterator cend([[maybe_unused]] const size_type index) const {
        return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
    }
 
    [[nodiscard]] const_local_iterator end([[maybe_unused]] const size_type index) const {
        return cend(index);
    }
 
    [[nodiscard]] local_iterator end([[maybe_unused]] const size_type index) {
        return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
    }
 
    [[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>(std::distance(begin(index), end(index)));
    }
 
    [[nodiscard]] size_type bucket(const value_type &value) const {
        return value_to_bucket(value);
    }
 
    [[nodiscard]] float load_factor() const {
        return 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 count) {
        auto value = (std::max)(count, minimum_capacity);
        value = (std::max)(value, static_cast<size_type>(size() / max_load_factor()));
 
        if(const auto sz = next_power_of_two(value); sz != bucket_count()) {
            sparse.first().resize(sz);
            std::fill(sparse.first().begin(), sparse.first().end(), (std::numeric_limits<size_type>::max)());
 
            for(size_type pos{}, last = size(); pos < last; ++pos) {
                const auto index = value_to_bucket(packed.first()[pos].second);
                packed.first()[pos].first = std::exchange(sparse.first()[index], pos);
            }
        }
    }
 
    void reserve(const size_type count) {
        packed.first().reserve(count);
        rehash(static_cast<size_type>(std::ceil(count / 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;
};
 
} // namespace entt
 
#endif