EnTT: src/entt/container/dense_map.hpp Source File

EnTT 3.15.0

Loading...
Searching...
No Matches
dense_map.hpp
1#ifndef ENTT_CONTAINER_DENSE_MAP_HPP
2#define ENTT_CONTAINER_DENSE_MAP_HPP
3
4#include <cmath>
5#include <cstddef>
6#include <functional>
7#include <iterator>
8#include <limits>
9#include <memory>
10#include <tuple>
11#include <type_traits>
12#include <utility>
13#include <vector>
14#include "../config/config.h"
15#include "../core/bit.hpp"
16#include "../core/compressed_pair.hpp"
17#include "../core/iterator.hpp"
18#include "../core/memory.hpp"
19#include "../core/type_traits.hpp"
20#include "fwd.hpp"
21
22 namespace entt {
23
25namespace internal {
26
27template<typename Key, typename Type>
28struct dense_map_node final {
29 using value_type = std::pair<Key, Type>;
30
31 template<typename... Args>
32 dense_map_node(const std::size_t pos, Args &&...args)
33 : next{pos},
34 element{std::forward<Args>(args)...} {}
35
36 template<typename Allocator, typename... Args>
37 dense_map_node(std::allocator_arg_t, const Allocator &allocator, const std::size_t pos, Args &&...args)
38 : next{pos},
39 element{entt::make_obj_using_allocator<value_type>(allocator, std::forward<Args>(args)...)} {}
40
41 template<typename Allocator>
42 dense_map_node(std::allocator_arg_t, const Allocator &allocator, const dense_map_node &other)
43 : next{other.next},
44 element{entt::make_obj_using_allocator<value_type>(allocator, other.element)} {}
45
46 template<typename Allocator>
47 dense_map_node(std::allocator_arg_t, const Allocator &allocator, dense_map_node &&other)
48 : next{other.next},
49 element{entt::make_obj_using_allocator<value_type>(allocator, std::move(other.element))} {}
50
51 std::size_t next;
52 value_type element;
53};
54
55template<typename It>
56class dense_map_iterator final {
57 template<typename>
58 friend class dense_map_iterator;
59
60 using first_type = decltype(std::as_const(std::declval<It>()->element.first));
61 using second_type = decltype((std::declval<It>()->element.second));
62
63public:
64 using value_type = std::pair<first_type, second_type>;
65 using pointer = input_iterator_pointer<value_type>;
66 using reference = value_type;
67 using difference_type = std::ptrdiff_t;
68 using iterator_category = std::input_iterator_tag;
69 using iterator_concept = std::random_access_iterator_tag;
70
71 constexpr dense_map_iterator() noexcept
72 : it{} {}
73
74 constexpr dense_map_iterator(const It iter) noexcept
75 : it{iter} {}
76
77 template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
78 constexpr dense_map_iterator(const dense_map_iterator<Other> &other) noexcept
79 : it{other.it} {}
80
81 constexpr dense_map_iterator &operator++() noexcept {
82 return ++it, *this;
83 }
84
85 constexpr dense_map_iterator operator++(int) noexcept {
86 const dense_map_iterator orig = *this;
87 return ++(*this), orig;
88 }
89
90 constexpr dense_map_iterator &operator--() noexcept {
91 return --it, *this;
92 }
93
94 constexpr dense_map_iterator operator--(int) noexcept {
95 const dense_map_iterator orig = *this;
96 return operator--(), orig;
97 }
98
99 constexpr dense_map_iterator &operator+=(const difference_type value) noexcept {
100 it += value;
101 return *this;
102 }
103
104 constexpr dense_map_iterator operator+(const difference_type value) const noexcept {
105 dense_map_iterator copy = *this;
106 return (copy += value);
107 }
108
109 constexpr dense_map_iterator &operator-=(const difference_type value) noexcept {
110 return (*this += -value);
111 }
112
113 constexpr dense_map_iterator operator-(const difference_type value) const noexcept {
114 return (*this + -value);
115 }
116
117 [[nodiscard]] constexpr reference operator[](const difference_type value) const noexcept {
118 return {it[value].element.first, it[value].element.second};
119 }
120
121 [[nodiscard]] constexpr pointer operator->() const noexcept {
122 return operator*();
123 }
124
125 [[nodiscard]] constexpr reference operator*() const noexcept {
126 return operator[](0);
127 }
128
129 template<typename Lhs, typename Rhs>
130 friend constexpr std::ptrdiff_t operator-(const dense_map_iterator<Lhs> &, const dense_map_iterator<Rhs> &) noexcept;
131
132 template<typename Lhs, typename Rhs>
133 friend constexpr bool operator==(const dense_map_iterator<Lhs> &, const dense_map_iterator<Rhs> &) noexcept;
134
135 template<typename Lhs, typename Rhs>
136 friend constexpr bool operator<(const dense_map_iterator<Lhs> &, const dense_map_iterator<Rhs> &) noexcept;
137
138private:
139 It it;
140};
141
142template<typename Lhs, typename Rhs>
143[[nodiscard]] constexpr std::ptrdiff_t operator-(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
144 return lhs.it - rhs.it;
145}
146
147template<typename Lhs, typename Rhs>
148[[nodiscard]] constexpr bool operator==(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
149 return lhs.it == rhs.it;
150}
151
152template<typename Lhs, typename Rhs>
153[[nodiscard]] constexpr bool operator!=(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
154 return !(lhs == rhs);
155}
156
157template<typename Lhs, typename Rhs>
158[[nodiscard]] constexpr bool operator<(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
159 return lhs.it < rhs.it;
160}
161
162template<typename Lhs, typename Rhs>
163[[nodiscard]] constexpr bool operator>(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
164 return rhs < lhs;
165}
166
167template<typename Lhs, typename Rhs>
168[[nodiscard]] constexpr bool operator<=(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
169 return !(lhs > rhs);
170}
171
172template<typename Lhs, typename Rhs>
173[[nodiscard]] constexpr bool operator>=(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
174 return !(lhs < rhs);
175}
176
177template<typename It>
178class dense_map_local_iterator final {
179 template<typename>
180 friend class dense_map_local_iterator;
181
182 using first_type = decltype(std::as_const(std::declval<It>()->element.first));
183 using second_type = decltype((std::declval<It>()->element.second));
184
185public:
186 using value_type = std::pair<first_type, second_type>;
187 using pointer = input_iterator_pointer<value_type>;
188 using reference = value_type;
189 using difference_type = std::ptrdiff_t;
190 using iterator_category = std::input_iterator_tag;
191 using iterator_concept = std::forward_iterator_tag;
192
193 constexpr dense_map_local_iterator() noexcept
194 : it{},
195 offset{} {}
196
197 constexpr dense_map_local_iterator(It iter, const std::size_t pos) noexcept
198 : it{iter},
199 offset{pos} {}
200
201 template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
202 constexpr dense_map_local_iterator(const dense_map_local_iterator<Other> &other) noexcept
203 : it{other.it},
204 offset{other.offset} {}
205
206 constexpr dense_map_local_iterator &operator++() noexcept {
207 return (offset = it[static_cast<typename It::difference_type>(offset)].next), *this;
208 }
209
210 constexpr dense_map_local_iterator operator++(int) noexcept {
211 const dense_map_local_iterator orig = *this;
212 return ++(*this), orig;
213 }
214
215 [[nodiscard]] constexpr pointer operator->() const noexcept {
216 return operator*();
217 }
218
219 [[nodiscard]] constexpr reference operator*() const noexcept {
220 const auto idx = static_cast<typename It::difference_type>(offset);
221 return {it[idx].element.first, it[idx].element.second};
222 }
223
224 [[nodiscard]] constexpr std::size_t index() const noexcept {
225 return offset;
226 }
227
228private:
229 It it;
230 std::size_t offset;
231};
232
233template<typename Lhs, typename Rhs>
234[[nodiscard]] constexpr bool operator==(const dense_map_local_iterator<Lhs> &lhs, const dense_map_local_iterator<Rhs> &rhs) noexcept {
235 return lhs.index() == rhs.index();
236}
237
238template<typename Lhs, typename Rhs>
239[[nodiscard]] constexpr bool operator!=(const dense_map_local_iterator<Lhs> &lhs, const dense_map_local_iterator<Rhs> &rhs) noexcept {
240 return !(lhs == rhs);
241}
242
243} // namespace internal
245
259template<typename Key, typename Type, typename Hash, typename KeyEqual, typename Allocator>
260 class dense_map {
261 static constexpr float default_threshold = 0.875f;
262 static constexpr std::size_t minimum_capacity = 8u;
263
264 using node_type = internal::dense_map_node<Key, Type>;
265 using alloc_traits = std::allocator_traits<Allocator>;
266 static_assert(std::is_same_v<typename alloc_traits::value_type, std::pair<const Key, Type>>, "Invalid value type");
267 using sparse_container_type = std::vector<std::size_t, typename alloc_traits::template rebind_alloc<std::size_t>>;
268 using packed_container_type = std::vector<node_type, typename alloc_traits::template rebind_alloc<node_type>>;
269
270 template<typename Other>
271 [[nodiscard]] std::size_t key_to_bucket(const Other &key) const noexcept {
272 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
273 return fast_mod(static_cast<size_type>(sparse.second()(key)), bucket_count());
274 }
275
276 template<typename Other>
277 [[nodiscard]] auto constrained_find(const Other &key, std::size_t bucket) {
278 for(auto it = begin(bucket), last = end(bucket); it != last; ++it) {
279 if(packed.second()(it->first, key)) {
280 return begin() + static_cast<difference_type>(it.index());
281 }
282 }
283
284 return end();
285 }
286
287 template<typename Other>
288 [[nodiscard]] auto constrained_find(const Other &key, std::size_t bucket) const {
289 for(auto it = cbegin(bucket), last = cend(bucket); it != last; ++it) {
290 if(packed.second()(it->first, key)) {
291 return cbegin() + static_cast<difference_type>(it.index());
292 }
293 }
294
295 return cend();
296 }
297
298 template<typename Other, typename... Args>
299 [[nodiscard]] auto insert_or_do_nothing(Other &&key, Args &&...args) {
300 const auto index = key_to_bucket(key);
301
302 if(auto it = constrained_find(key, index); it != end()) {
303 return std::make_pair(it, false);
304 }
305
306 packed.first().emplace_back(sparse.first()[index], std::piecewise_construct, std::forward_as_tuple(std::forward<Other>(key)), std::forward_as_tuple(std::forward<Args>(args)...));
307 sparse.first()[index] = packed.first().size() - 1u;
308 rehash_if_required();
309
310 return std::make_pair(--end(), true);
311 }
312
313 template<typename Other, typename Arg>
314 [[nodiscard]] auto insert_or_overwrite(Other &&key, Arg &&value) {
315 const auto index = key_to_bucket(key);
316
317 if(auto it = constrained_find(key, index); it != end()) {
318 it->second = std::forward<Arg>(value);
319 return std::make_pair(it, false);
320 }
321
322 packed.first().emplace_back(sparse.first()[index], std::forward<Other>(key), std::forward<Arg>(value));
323 sparse.first()[index] = packed.first().size() - 1u;
324 rehash_if_required();
325
326 return std::make_pair(--end(), true);
327 }
328
329 void move_and_pop(const std::size_t pos) {
330 if(const auto last = size() - 1u; pos != last) {
331 size_type *curr = &sparse.first()[key_to_bucket(packed.first().back().element.first)];
332 packed.first()[pos] = std::move(packed.first().back());
333 for(; *curr != last; curr = &packed.first()[*curr].next) {}
334 *curr = pos;
335 }
336
337 packed.first().pop_back();
338 }
339
340 void rehash_if_required() {
341 if(const auto bc = bucket_count(); size() > static_cast<size_type>(static_cast<float>(bc) * max_load_factor())) {
342 rehash(bc * 2u);
343 }
344 }
345
346public:
348 using allocator_type = Allocator;
350 using key_type = Key;
352 using mapped_type = Type;
354 using value_type = std::pair<const Key, Type>;
356 using size_type = std::size_t;
358 using difference_type = std::ptrdiff_t;
360 using hasher = Hash;
362 using key_equal = KeyEqual;
364 using iterator = internal::dense_map_iterator<typename packed_container_type::iterator>;
366 using const_iterator = internal::dense_map_iterator<typename packed_container_type::const_iterator>;
368 using local_iterator = internal::dense_map_local_iterator<typename packed_container_type::iterator>;
370 using const_local_iterator = internal::dense_map_local_iterator<typename packed_container_type::const_iterator>;
371
373 dense_map()
374 : dense_map{minimum_capacity} {}
375
380 explicit dense_map(const allocator_type &allocator)
381 : dense_map{minimum_capacity, hasher{}, key_equal{}, allocator} {}
382
389 dense_map(const size_type cnt, const allocator_type &allocator)
390 : dense_map{cnt, hasher{}, key_equal{}, allocator} {}
391
399 dense_map(const size_type cnt, const hasher &hash, const allocator_type &allocator)
400 : dense_map{cnt, hash, key_equal{}, allocator} {}
401
410 explicit dense_map(const size_type cnt, const hasher &hash = hasher{}, const key_equal &equal = key_equal{}, const allocator_type &allocator = allocator_type{})
411 : sparse{allocator, hash},
412 packed{allocator, equal} {
413 rehash(cnt);
414 }
415
417 dense_map(const dense_map &) = default;
418
424 dense_map(const dense_map &other, const allocator_type &allocator)
425 : sparse{std::piecewise_construct, std::forward_as_tuple(other.sparse.first(), allocator), std::forward_as_tuple(other.sparse.second())},
426 packed{std::piecewise_construct, std::forward_as_tuple(other.packed.first(), allocator), std::forward_as_tuple(other.packed.second())},
427 threshold{other.threshold} {}
428
430 dense_map(dense_map &&) noexcept = default;
431
437 dense_map(dense_map &&other, const allocator_type &allocator)
438 : sparse{std::piecewise_construct, std::forward_as_tuple(std::move(other.sparse.first()), allocator), std::forward_as_tuple(std::move(other.sparse.second()))},
439 packed{std::piecewise_construct, std::forward_as_tuple(std::move(other.packed.first()), allocator), std::forward_as_tuple(std::move(other.packed.second()))},
440 threshold{other.threshold} {}
441
443 ~dense_map() = default;
444
449 dense_map &operator=(const dense_map &) = default;
450
455 dense_map &operator=(dense_map &&) noexcept = default;
456
461 void swap(dense_map &other) noexcept {
462 using std::swap;
463 swap(sparse, other.sparse);
464 swap(packed, other.packed);
465 swap(threshold, other.threshold);
466 }
467
472 [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
473 return sparse.first().get_allocator();
474 }
475
483 [[nodiscard]] const_iterator cbegin() const noexcept {
484 return packed.first().begin();
485 }
486
488 [[nodiscard]] const_iterator begin() const noexcept {
489 return cbegin();
490 }
491
493 [[nodiscard]] iterator begin() noexcept {
494 return packed.first().begin();
495 }
496
502 [[nodiscard]] const_iterator cend() const noexcept {
503 return packed.first().end();
504 }
505
507 [[nodiscard]] const_iterator end() const noexcept {
508 return cend();
509 }
510
512 [[nodiscard]] iterator end() noexcept {
513 return packed.first().end();
514 }
515
520 [[nodiscard]] bool empty() const noexcept {
521 return packed.first().empty();
522 }
523
528 [[nodiscard]] size_type size() const noexcept {
529 return packed.first().size();
530 }
531
536 [[nodiscard]] size_type max_size() const noexcept {
537 return packed.first().max_size();
538 }
539
541 void clear() noexcept {
542 sparse.first().clear();
543 packed.first().clear();
544 rehash(0u);
545 }
546
554 std::pair<iterator, bool> insert(const value_type &value) {
555 return insert_or_do_nothing(value.first, value.second);
556 }
557
559 std::pair<iterator, bool> insert(value_type &&value) {
560 return insert_or_do_nothing(std::move(value.first), std::move(value.second));
561 }
562
567 template<typename Arg>
568 std::enable_if_t<std::is_constructible_v<value_type, Arg &&>, std::pair<iterator, bool>>
569 insert(Arg &&value) {
570 return insert_or_do_nothing(std::forward<Arg>(value).first, std::forward<Arg>(value).second);
571 }
572
579 template<typename It>
580 void insert(It first, It last) {
581 for(; first != last; ++first) {
582 insert(*first);
583 }
584 }
585
595 template<typename Arg>
596 std::pair<iterator, bool> insert_or_assign(const key_type &key, Arg &&value) {
597 return insert_or_overwrite(key, std::forward<Arg>(value));
598 }
599
601 template<typename Arg>
602 std::pair<iterator, bool> insert_or_assign(key_type &&key, Arg &&value) {
603 return insert_or_overwrite(std::move(key), std::forward<Arg>(value));
604 }
605
619 template<typename... Args>
620 std::pair<iterator, bool> emplace([[maybe_unused]] Args &&...args) {
621 if constexpr(sizeof...(Args) == 0u) {
622 return insert_or_do_nothing(key_type{});
623 } else if constexpr(sizeof...(Args) == 1u) {
624 return insert_or_do_nothing(std::forward<Args>(args).first..., std::forward<Args>(args).second...);
625 } else if constexpr(sizeof...(Args) == 2u) {
626 return insert_or_do_nothing(std::forward<Args>(args)...);
627 } else {
628 auto &node = packed.first().emplace_back(packed.first().size(), std::forward<Args>(args)...);
629 const auto index = key_to_bucket(node.element.first);
630
631 if(auto it = constrained_find(node.element.first, index); it != end()) {
632 packed.first().pop_back();
633 return std::make_pair(it, false);
634 }
635
636 std::swap(node.next, sparse.first()[index]);
637 rehash_if_required();
638
639 return std::make_pair(--end(), true);
640 }
641 }
642
654 template<typename... Args>
655 std::pair<iterator, bool> try_emplace(const key_type &key, Args &&...args) {
656 return insert_or_do_nothing(key, std::forward<Args>(args)...);
657 }
658
660 template<typename... Args>
661 std::pair<iterator, bool> try_emplace(key_type &&key, Args &&...args) {
662 return insert_or_do_nothing(std::move(key), std::forward<Args>(args)...);
663 }
664
670 iterator erase(const_iterator pos) {
671 const auto diff = pos - cbegin();
672 erase(pos->first);
673 return begin() + diff;
674 }
675
682 iterator erase(const_iterator first, const_iterator last) {
683 const auto dist = first - cbegin();
684
685 for(auto from = last - cbegin(); from != dist; --from) {
686 erase(packed.first()[static_cast<size_type>(from) - 1u].element.first);
687 }
688
689 return (begin() + dist);
690 }
691
697 size_type erase(const key_type &key) {
698 for(size_type *curr = &sparse.first()[key_to_bucket(key)]; *curr != (std::numeric_limits<size_type>::max)(); curr = &packed.first()[*curr].next) {
699 if(packed.second()(packed.first()[*curr].element.first, key)) {
700 const auto index = *curr;
701 *curr = packed.first()[*curr].next;
702 move_and_pop(index);
703 return 1u;
704 }
705 }
706
707 return 0u;
708 }
709
715 [[nodiscard]] mapped_type &at(const key_type &key) {
716 auto it = find(key);
717 ENTT_ASSERT(it != end(), "Invalid key");
718 return it->second;
719 }
720
722 [[nodiscard]] const mapped_type &at(const key_type &key) const {
723 auto it = find(key);
724 ENTT_ASSERT(it != cend(), "Invalid key");
725 return it->second;
726 }
727
733 [[nodiscard]] mapped_type &operator[](const key_type &key) {
734 return insert_or_do_nothing(key).first->second;
735 }
736
742 [[nodiscard]] mapped_type &operator[](key_type &&key) {
743 return insert_or_do_nothing(std::move(key)).first->second;
744 }
745
751 [[nodiscard]] size_type count(const key_type &key) const {
752 return find(key) != end();
753 }
754
761 template<typename Other>
762 [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, size_type>>
763 count(const Other &key) const {
764 return find(key) != end();
765 }
766
773 [[nodiscard]] iterator find(const key_type &key) {
774 return constrained_find(key, key_to_bucket(key));
775 }
776
778 [[nodiscard]] const_iterator find(const key_type &key) const {
779 return constrained_find(key, key_to_bucket(key));
780 }
781
790 template<typename Other>
791 [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, iterator>>
792 find(const Other &key) {
793 return constrained_find(key, key_to_bucket(key));
794 }
795
797 template<typename Other>
798 [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, const_iterator>>
799 find(const Other &key) const {
800 return constrained_find(key, key_to_bucket(key));
801 }
802
809 [[nodiscard]] std::pair<iterator, iterator> equal_range(const key_type &key) {
810 const auto it = find(key);
811 return {it, it + !(it == end())};
812 }
813
815 [[nodiscard]] std::pair<const_iterator, const_iterator> equal_range(const key_type &key) const {
816 const auto it = find(key);
817 return {it, it + !(it == cend())};
818 }
819
828 template<typename Other>
829 [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, std::pair<iterator, iterator>>>
830 equal_range(const Other &key) {
831 const auto it = find(key);
832 return {it, it + !(it == end())};
833 }
834
836 template<typename Other>
837 [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, std::pair<const_iterator, const_iterator>>>
838 equal_range(const Other &key) const {
839 const auto it = find(key);
840 return {it, it + !(it == cend())};
841 }
842
848 [[nodiscard]] bool contains(const key_type &key) const {
849 return (find(key) != cend());
850 }
851
859 template<typename Other>
860 [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, bool>>
861 contains(const Other &key) const {
862 return (find(key) != cend());
863 }
864
870 [[nodiscard]] const_local_iterator cbegin(const size_type index) const {
871 return {packed.first().begin(), sparse.first()[index]};
872 }
873
879 [[nodiscard]] const_local_iterator begin(const size_type index) const {
880 return cbegin(index);
881 }
882
888 [[nodiscard]] local_iterator begin(const size_type index) {
889 return {packed.first().begin(), sparse.first()[index]};
890 }
891
897 [[nodiscard]] const_local_iterator cend([[maybe_unused]] const size_type index) const {
898 return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
899 }
900
906 [[nodiscard]] const_local_iterator end(const size_type index) const {
907 return cend(index);
908 }
909
915 [[nodiscard]] local_iterator end([[maybe_unused]] const size_type index) {
916 return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
917 }
918
923 [[nodiscard]] size_type bucket_count() const {
924 return sparse.first().size();
925 }
926
931 [[nodiscard]] size_type max_bucket_count() const {
932 return sparse.first().max_size();
933 }
934
940 [[nodiscard]] size_type bucket_size(const size_type index) const {
941 return static_cast<size_type>(std::distance(begin(index), end(index)));
942 }
943
949 [[nodiscard]] size_type bucket(const key_type &key) const {
950 return key_to_bucket(key);
951 }
952
957 [[nodiscard]] float load_factor() const {
958 return static_cast<float>(size()) / static_cast<float>(bucket_count());
959 }
960
965 [[nodiscard]] float max_load_factor() const {
966 return threshold;
967 }
968
973 void max_load_factor(const float value) {
974 ENTT_ASSERT(value > 0.f, "Invalid load factor");
975 threshold = value;
976 rehash(0u);
977 }
978
984 void rehash(const size_type cnt) {
985 auto value = cnt > minimum_capacity ? cnt : minimum_capacity;
986 const auto cap = static_cast<size_type>(static_cast<float>(size()) / max_load_factor());
987 value = value > cap ? value : cap;
988
989 if(const auto sz = next_power_of_two(value); sz != bucket_count()) {
990 sparse.first().resize(sz);
991
992 for(auto &&elem: sparse.first()) {
993 elem = (std::numeric_limits<size_type>::max)();
994 }
995
996 for(size_type pos{}, last = size(); pos < last; ++pos) {
997 const auto index = key_to_bucket(packed.first()[pos].element.first);
998 packed.first()[pos].next = std::exchange(sparse.first()[index], pos);
999 }
1000 }
1001 }
1002
1008 void reserve(const size_type cnt) {
1009 packed.first().reserve(cnt);
1010 rehash(static_cast<size_type>(std::ceil(static_cast<float>(cnt) / max_load_factor())));
1011 }
1012
1017 [[nodiscard]] hasher hash_function() const {
1018 return sparse.second();
1019 }
1020
1025 [[nodiscard]] key_equal key_eq() const {
1026 return packed.second();
1027 }
1028
1029private:
1030 compressed_pair<sparse_container_type, hasher> sparse;
1031 compressed_pair<packed_container_type, key_equal> packed;
1032 float threshold{default_threshold};
1033};
1034
1035} // namespace entt
1036
1038namespace std {
1039
1040template<typename Key, typename Value, typename Allocator>
1041struct uses_allocator<entt::internal::dense_map_node<Key, Value>, Allocator>
1042 : std::true_type {};
1043
1044} // namespace std
1046
1047#endif
entt::compressed_pair
A compressed pair.
Definition compressed_pair.hpp:87
entt::dense_map::dense_map
dense_map(const size_type cnt, const hasher &hash=hasher{}, const key_equal &equal=key_equal{}, const allocator_type &allocator=allocator_type{})
Constructs an empty container with a given allocator, hash function, compare function and user suppli...
Definition dense_map.hpp:410
entt::dense_map::dense_map
dense_map(const allocator_type &allocator)
Constructs an empty container with a given allocator.
Definition dense_map.hpp:380
entt::dense_map::clear
void clear() noexcept
Clears the container.
Definition dense_map.hpp:541
entt::dense_map::load_factor
float load_factor() const
Returns the average number of elements per bucket.
Definition dense_map.hpp:957
entt::dense_map::erase
size_type erase(const key_type &key)
Removes the element associated with a given key.
Definition dense_map.hpp:697
entt::dense_map::operator[]
mapped_type & operator[](key_type &&key)
Accesses or inserts a given element.
Definition dense_map.hpp:742
entt::dense_map::contains
std::enable_if_t< is_transparent_v< hasher > &&is_transparent_v< key_equal >, std::conditional_t< false, Other, bool > > contains(const Other &key) const
Checks if the container contains an element with a key that compares equivalent to a given value.
Definition dense_map.hpp:861
entt::dense_map::cbegin
const_iterator cbegin() const noexcept
Returns an iterator to the beginning.
Definition dense_map.hpp:483
entt::dense_map::begin
const_local_iterator begin(const size_type index) const
Returns an iterator to the beginning of a given bucket.
Definition dense_map.hpp:879
entt::dense_map::count
std::enable_if_t< is_transparent_v< hasher > &&is_transparent_v< key_equal >, std::conditional_t< false, Other, size_type > > count(const Other &key) const
Returns the number of elements matching a key (either 1 or 0).
Definition dense_map.hpp:763
entt::dense_map::size
size_type size() const noexcept
Returns the number of elements in a container.
Definition dense_map.hpp:528
entt::dense_map::size_type
std::size_t size_type
Unsigned integer type.
Definition dense_map.hpp:356
entt::dense_map::end
const_local_iterator end(const size_type index) const
Returns an iterator to the end of a given bucket.
Definition dense_map.hpp:906
entt::dense_map::insert
void insert(It first, It last)
Inserts elements into the container, if their keys do not exist.
Definition dense_map.hpp:580
entt::dense_map::equal_range
std::enable_if_t< is_transparent_v< hasher > &&is_transparent_v< key_equal >, std::conditional_t< false, Other, std::pair< iterator, iterator > > > equal_range(const Other &key)
Returns a range containing all elements that compare equivalent to a given key.
Definition dense_map.hpp:830
entt::dense_map::operator=
dense_map & operator=(dense_map &&) noexcept=default
Default move assignment operator.
entt::dense_map::at
const mapped_type & at(const key_type &key) const
Accesses a given element with bounds checking.
Definition dense_map.hpp:722
entt::dense_map::key_equal
KeyEqual key_equal
Type of function to use to compare the keys for equality.
Definition dense_map.hpp:362
entt::dense_map::max_size
size_type max_size() const noexcept
Returns the maximum possible number of elements.
Definition dense_map.hpp:536
entt::dense_map::at
mapped_type & at(const key_type &key)
Accesses a given element with bounds checking.
Definition dense_map.hpp:715
entt::dense_map::reserve
void reserve(const size_type cnt)
Reserves space for at least the specified number of elements and regenerates the hash table.
Definition dense_map.hpp:1008
entt::dense_map::max_bucket_count
size_type max_bucket_count() const
Returns the maximum number of buckets.
Definition dense_map.hpp:931
entt::dense_map::erase
iterator erase(const_iterator first, const_iterator last)
Removes the given elements from a container.
Definition dense_map.hpp:682
entt::dense_map::count
size_type count(const key_type &key) const
Returns the number of elements matching a key (either 1 or 0).
Definition dense_map.hpp:751
entt::dense_map::begin
local_iterator begin(const size_type index)
Returns an iterator to the beginning of a given bucket.
Definition dense_map.hpp:888
entt::dense_map::find
std::enable_if_t< is_transparent_v< hasher > &&is_transparent_v< key_equal >, std::conditional_t< false, Other, const_iterator > > find(const Other &key) const
Finds an element with a given key.
Definition dense_map.hpp:799
entt::dense_map::contains
bool contains(const key_type &key) const
Checks if the container contains an element with a given key.
Definition dense_map.hpp:848
entt::dense_map::cend
const_iterator cend() const noexcept
Returns an iterator to the end.
Definition dense_map.hpp:502
entt::dense_map::dense_map
dense_map(const size_type cnt, const allocator_type &allocator)
Constructs an empty container with a given allocator and user supplied minimal number of buckets.
Definition dense_map.hpp:389
entt::dense_map::try_emplace
std::pair< iterator, bool > try_emplace(const key_type &key, Args &&...args)
Inserts in-place if the key does not exist, does nothing if the key exists.
Definition dense_map.hpp:655
entt::dense_map::max_load_factor
float max_load_factor() const
Returns the maximum average number of elements per bucket.
Definition dense_map.hpp:965
entt::dense_map::find
const_iterator find(const key_type &key) const
Finds an element with a given key.
Definition dense_map.hpp:778
entt::dense_map::const_iterator
internal::dense_map_iterator< typename packed_container_type::const_iterator > const_iterator
Constant input iterator type.
Definition dense_map.hpp:366
entt::dense_map::max_load_factor
void max_load_factor(const float value)
Sets the desired maximum average number of elements per bucket.
Definition dense_map.hpp:973
entt::dense_map::operator=
dense_map & operator=(const dense_map &)=default
Default copy assignment operator.
entt::dense_map::insert
std::pair< iterator, bool > insert(value_type &&value)
Inserts an element into the container, if the key does not exist.
Definition dense_map.hpp:559
entt::dense_map::find
iterator find(const key_type &key)
Finds an element with a given key.
Definition dense_map.hpp:773
entt::dense_map::equal_range
std::pair< iterator, iterator > equal_range(const key_type &key)
Returns a range containing all elements with a given key.
Definition dense_map.hpp:809
entt::dense_map::begin
const_iterator begin() const noexcept
Returns an iterator to the beginning.
Definition dense_map.hpp:488
entt::dense_map::mapped_type
Type mapped_type
Mapped type of the container.
Definition dense_map.hpp:352
entt::dense_map::rehash
void rehash(const size_type cnt)
Reserves at least the specified number of buckets and regenerates the hash table.
Definition dense_map.hpp:984
entt::dense_map::cend
const_local_iterator cend(const size_type index) const
Returns an iterator to the end of a given bucket.
Definition dense_map.hpp:897
entt::dense_map::erase
iterator erase(const_iterator pos)
Removes an element from a given position.
Definition dense_map.hpp:670
entt::dense_map< id_type, std::shared_ptr< base_type >, identity, std::equal_to<>, typename alloc_traits::template rebind_alloc< std::pair< const id_type, std::shared_ptr< base_type > > > >::swap
void swap(dense_map &other) noexcept
Definition dense_map.hpp:461
entt::dense_map::dense_map
dense_map(const dense_map &other, const allocator_type &allocator)
Allocator-extended copy constructor.
Definition dense_map.hpp:424
entt::dense_map::insert
std::enable_if_t< std::is_constructible_v< value_type, Arg && >, std::pair< iterator, bool > > insert(Arg &&value)
Inserts an element into the container, if the key does not exist.
Definition dense_map.hpp:569
entt::dense_map::equal_range
std::enable_if_t< is_transparent_v< hasher > &&is_transparent_v< key_equal >, std::conditional_t< false, Other, std::pair< const_iterator, const_iterator > > > equal_range(const Other &key) const
Returns a range containing all elements with a given key.
Definition dense_map.hpp:838
entt::dense_map::bucket
size_type bucket(const key_type &key) const
Returns the bucket for a given key.
Definition dense_map.hpp:949
entt::dense_map::insert_or_assign
std::pair< iterator, bool > insert_or_assign(key_type &&key, Arg &&value)
Inserts an element into the container or assigns to the current element if the key already exists.
Definition dense_map.hpp:602
entt::dense_map::operator[]
mapped_type & operator[](const key_type &key)
Accesses or inserts a given element.
Definition dense_map.hpp:733
entt::dense_map::get_allocator
constexpr allocator_type get_allocator() const noexcept
Returns the associated allocator.
Definition dense_map.hpp:472
entt::dense_map::cbegin
const_local_iterator cbegin(const size_type index) const
Returns an iterator to the beginning of a given bucket.
Definition dense_map.hpp:870
entt::dense_map::value_type
std::pair< const Key, Type > value_type
Key-value type of the container.
Definition dense_map.hpp:354
entt::dense_map::dense_map
dense_map(const dense_map &)=default
Default copy constructor.
entt::dense_map::insert_or_assign
std::pair< iterator, bool > insert_or_assign(const key_type &key, Arg &&value)
Inserts an element into the container or assigns to the current element if the key already exists.
Definition dense_map.hpp:596
entt::dense_map::emplace
std::pair< iterator, bool > emplace(Args &&...args)
Constructs an element in-place, if the key does not exist.
Definition dense_map.hpp:620
entt::dense_map::try_emplace
std::pair< iterator, bool > try_emplace(key_type &&key, Args &&...args)
Inserts in-place if the key does not exist, does nothing if the key exists.
Definition dense_map.hpp:661
entt::dense_map::end
local_iterator end(const size_type index)
Returns an iterator to the end of a given bucket.
Definition dense_map.hpp:915
entt::dense_map::find
std::enable_if_t< is_transparent_v< hasher > &&is_transparent_v< key_equal >, std::conditional_t< false, Other, iterator > > find(const Other &key)
Finds an element with a key that compares equivalent to a given key.
Definition dense_map.hpp:792
entt::dense_map::key_eq
key_equal key_eq() const
Returns the function used to compare keys for equality.
Definition dense_map.hpp:1025
entt::dense_map::dense_map
dense_map(const size_type cnt, const hasher &hash, const allocator_type &allocator)
Constructs an empty container with a given allocator, hash function and user supplied minimal number ...
Definition dense_map.hpp:399
entt::dense_map::iterator
internal::dense_map_iterator< typename packed_container_type::iterator > iterator
Input iterator type.
Definition dense_map.hpp:364
entt::dense_map::local_iterator
internal::dense_map_local_iterator< typename packed_container_type::iterator > local_iterator
Input iterator type.
Definition dense_map.hpp:368
entt::dense_map::dense_map
dense_map(dense_map &&) noexcept=default
Default move constructor.
entt::dense_map::const_local_iterator
internal::dense_map_local_iterator< typename packed_container_type::const_iterator > const_local_iterator
Constant input iterator type.
Definition dense_map.hpp:370
entt::dense_map::empty
bool empty() const noexcept
Checks whether a container is empty.
Definition dense_map.hpp:520
entt::dense_map::insert
std::pair< iterator, bool > insert(const value_type &value)
Inserts an element into the container, if the key does not exist.
Definition dense_map.hpp:554
entt::dense_map::allocator_type
Allocator allocator_type
Allocator type.
Definition dense_map.hpp:348
entt::dense_map::bucket_size
size_type bucket_size(const size_type index) const
Returns the number of elements in a given bucket.
Definition dense_map.hpp:940
entt::dense_map::hasher
Hash hasher
Type of function to use to hash the keys.
Definition dense_map.hpp:360
entt::dense_map::key_type
Key key_type
Key type of the container.
Definition dense_map.hpp:350
entt::dense_map::bucket_count
size_type bucket_count() const
Returns the number of buckets.
Definition dense_map.hpp:923
entt::dense_map::dense_map
dense_map()
Default constructor.
Definition dense_map.hpp:373
entt::dense_map::~dense_map
~dense_map()=default
Default destructor.
entt::dense_map::equal_range
std::pair< const_iterator, const_iterator > equal_range(const key_type &key) const
Returns a range containing all elements with a given key.
Definition dense_map.hpp:815
entt::dense_map::hash_function
hasher hash_function() const
Returns the function used to hash the keys.
Definition dense_map.hpp:1017
entt::dense_map::end
const_iterator end() const noexcept
Returns an iterator to the end.
Definition dense_map.hpp:507
entt::dense_map::begin
iterator begin() noexcept
Returns an iterator to the beginning.
Definition dense_map.hpp:493
entt::dense_map::end
iterator end() noexcept
Returns an iterator to the end.
Definition dense_map.hpp:512
entt::dense_map::difference_type
std::ptrdiff_t difference_type
Signed integer type.
Definition dense_map.hpp:358
entt
EnTT default namespace.
Definition dense_map.hpp:22
entt::make_obj_using_allocator
constexpr Type make_obj_using_allocator(const Allocator &allocator, Args &&...args)
Uses-allocator construction utility (waiting for C++20).
Definition memory.hpp:219
entt::fast_mod
constexpr std::enable_if_t< std::is_unsigned_v< Type >, Type > fast_mod(const Type value, const std::size_t mod) noexcept
Fast module utility function (powers of two only).
Definition bit.hpp:63
entt::is_transparent_v
constexpr bool is_transparent_v
Helper variable template.
Definition type_traits.hpp:737
entt::operator<=
constexpr bool operator<=(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:257
entt::next_power_of_two
constexpr std::enable_if_t< std::is_unsigned_v< Type >, Type > next_power_of_two(const Type value) noexcept
Computes the smallest power of two greater than or equal to a value (waiting for C++20 and std::bit_c...
Definition bit.hpp:43
entt::operator<
constexpr bool operator<(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:244
entt::operator+
constexpr type_list< Type..., Other... > operator+(type_list< Type... >, type_list< Other... >)
Concatenates multiple type lists.
Definition type_traits.hpp:210
entt::operator!=
constexpr bool operator!=(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:232
entt::operator>=
constexpr bool operator>=(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:283
entt::operator>
constexpr bool operator>(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:270
entt::operator==
constexpr bool operator==(const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
Compares two hashed strings.
Definition hashed_string.hpp:220
entt::input_iterator_pointer
Helper type to use as pointer with input iterators.
Definition iterator.hpp:16