From 4aabe23a4527ee057a40a24e7da89a64addc027d Mon Sep 17 00:00:00 2001 From: sparknack Date: Thu, 31 Jul 2025 20:09:36 +0800 Subject: [PATCH] enhance: update flat_hash_map.hpp to a modified version (#43506) issue: #41435 Signed-off-by: Shawn Wang --- .../flat_hash_map/flat_hash_map.hpp | 2742 +++++++++++------ 1 file changed, 1812 insertions(+), 930 deletions(-) diff --git a/internal/core/thirdparty/flat_hash_map/flat_hash_map.hpp b/internal/core/thirdparty/flat_hash_map/flat_hash_map.hpp index a8723ee8f0..09dd9c03df 100644 --- a/internal/core/thirdparty/flat_hash_map/flat_hash_map.hpp +++ b/internal/core/thirdparty/flat_hash_map/flat_hash_map.hpp @@ -1,17 +1,34 @@ +// Taken from +// https://github.com/pytorch/pytorch/blob/ad507789d12e3f757a43f35cd66e7aea6124140d/c10/util/flat_hash_map.h +// - remove c10 relate macro +// - remove compiler warning handling +// Taken from +// https://github.com/skarupke/flat_hash_map/blob/2c4687431f978f02a3780e24b8b701d22aa32d9c/flat_hash_map.hpp +// with fixes applied: +// - https://github.com/skarupke/flat_hash_map/pull/25 +// - https://github.com/skarupke/flat_hash_map/pull/26 +// - replace size_t with uint64_t to fix it for 32bit +// - add "GCC diagnostic" pragma to ignore -Wshadow +// - make sherwood_v3_table::convertible_to_iterator public because GCC5 seems +// to have issues with it otherwise +// - fix compiler warnings in operator templated_iterator +// - make use of 'if constexpr' and eliminate AssignIfTrue template + // Copyright Malte Skarupke 2017. // Distributed under the Boost Software License, Version 1.0. // (See http://www.boost.org/LICENSE_1_0.txt) #pragma once -#include -#include -#include -#include #include +#include +#include +#include +#include #include -#include +#include #include +#include #ifdef _MSC_VER #define SKA_NOINLINE(...) __declspec(noinline) __VA_ARGS__ @@ -19,205 +36,175 @@ #define SKA_NOINLINE(...) __VA_ARGS__ __attribute__((noinline)) #endif -namespace ska -{ +namespace ska { struct prime_number_hash_policy; struct power_of_two_hash_policy; struct fibonacci_hash_policy; -namespace detailv3 -{ -template -struct functor_storage : Functor -{ +namespace detailv3 { +template +struct functor_storage : Functor { functor_storage() = default; - functor_storage(const Functor & functor) - : Functor(functor) - { + functor_storage(const Functor& functor) : Functor(functor) { } - template - Result operator()(Args &&... args) - { - return static_cast(*this)(std::forward(args)...); + template + Result + operator()(Args&&... args) { + return static_cast(*this)(std::forward(args)...); } - template - Result operator()(Args &&... args) const - { - return static_cast(*this)(std::forward(args)...); + template + Result + operator()(Args&&... args) const { + return static_cast(*this)(std::forward(args)...); } }; -template -struct functor_storage -{ +template +struct functor_storage { typedef Result (*function_ptr)(Args...); function_ptr function; - functor_storage(function_ptr function) - : function(function) - { + functor_storage(function_ptr function) : function(function) { } - Result operator()(Args... args) const - { + Result + operator()(Args... args) const { return function(std::forward(args)...); } - operator function_ptr &() - { + operator function_ptr&() { return function; } - operator const function_ptr &() - { + operator const function_ptr&() { return function; } }; -template -struct KeyOrValueHasher : functor_storage -{ - typedef functor_storage hasher_storage; +template +struct KeyOrValueHasher : functor_storage { + typedef functor_storage hasher_storage; KeyOrValueHasher() = default; - KeyOrValueHasher(const hasher & hash) - : hasher_storage(hash) - { + KeyOrValueHasher(const hasher& hash) : hasher_storage(hash) { } - size_t operator()(const key_type & key) - { - return static_cast(*this)(key); + uint64_t + operator()(const key_type& key) { + return static_cast(*this)(key); } - size_t operator()(const key_type & key) const - { - return static_cast(*this)(key); + uint64_t + operator()(const key_type& key) const { + return static_cast(*this)(key); } - size_t operator()(const value_type & value) - { - return static_cast(*this)(value.first); + uint64_t + operator()(const value_type& value) { + return static_cast(*this)(value.first); } - size_t operator()(const value_type & value) const - { - return static_cast(*this)(value.first); + uint64_t + operator()(const value_type& value) const { + return static_cast(*this)(value.first); } - template - size_t operator()(const std::pair & value) - { - return static_cast(*this)(value.first); + template + uint64_t + operator()(const std::pair& value) { + return static_cast(*this)(value.first); } - template - size_t operator()(const std::pair & value) const - { - return static_cast(*this)(value.first); + template + uint64_t + operator()(const std::pair& value) const { + return static_cast(*this)(value.first); } }; -template -struct KeyOrValueEquality : functor_storage -{ +template +struct KeyOrValueEquality : functor_storage { typedef functor_storage equality_storage; KeyOrValueEquality() = default; - KeyOrValueEquality(const key_equal & equality) - : equality_storage(equality) - { + KeyOrValueEquality(const key_equal& equality) : equality_storage(equality) { } - bool operator()(const key_type & lhs, const key_type & rhs) - { - return static_cast(*this)(lhs, rhs); + bool + operator()(const key_type& lhs, const key_type& rhs) { + return static_cast(*this)(lhs, rhs); } - bool operator()(const key_type & lhs, const value_type & rhs) - { - return static_cast(*this)(lhs, rhs.first); + bool + operator()(const key_type& lhs, const value_type& rhs) { + return static_cast(*this)(lhs, rhs.first); } - bool operator()(const value_type & lhs, const key_type & rhs) - { - return static_cast(*this)(lhs.first, rhs); + bool + operator()(const value_type& lhs, const key_type& rhs) { + return static_cast(*this)(lhs.first, rhs); } - bool operator()(const value_type & lhs, const value_type & rhs) - { - return static_cast(*this)(lhs.first, rhs.first); + bool + operator()(const value_type& lhs, const value_type& rhs) { + return static_cast(*this)(lhs.first, rhs.first); } - template - bool operator()(const key_type & lhs, const std::pair & rhs) - { - return static_cast(*this)(lhs, rhs.first); + template + bool + operator()(const key_type& lhs, const std::pair& rhs) { + return static_cast(*this)(lhs, rhs.first); } - template - bool operator()(const std::pair & lhs, const key_type & rhs) - { - return static_cast(*this)(lhs.first, rhs); + template + bool + operator()(const std::pair& lhs, const key_type& rhs) { + return static_cast(*this)(lhs.first, rhs); } - template - bool operator()(const value_type & lhs, const std::pair & rhs) - { - return static_cast(*this)(lhs.first, rhs.first); + template + bool + operator()(const value_type& lhs, const std::pair& rhs) { + return static_cast(*this)(lhs.first, rhs.first); } - template - bool operator()(const std::pair & lhs, const value_type & rhs) - { - return static_cast(*this)(lhs.first, rhs.first); + template + bool + operator()(const std::pair& lhs, const value_type& rhs) { + return static_cast(*this)(lhs.first, rhs.first); } - template - bool operator()(const std::pair & lhs, const std::pair & rhs) - { - return static_cast(*this)(lhs.first, rhs.first); + template + bool + operator()(const std::pair& lhs, const std::pair& rhs) { + return static_cast(*this)(lhs.first, rhs.first); } }; static constexpr int8_t min_lookups = 4; -template -struct sherwood_v3_entry -{ - sherwood_v3_entry() - { - } +template +struct sherwood_v3_entry { + sherwood_v3_entry() = default; sherwood_v3_entry(int8_t distance_from_desired) - : distance_from_desired(distance_from_desired) - { - } - ~sherwood_v3_entry() - { - } - static sherwood_v3_entry * empty_default_table() - { - static sherwood_v3_entry result[min_lookups] = { {}, {}, {}, {special_end_value} }; - return result; + : distance_from_desired(distance_from_desired) { } + ~sherwood_v3_entry() = default; - bool has_value() const - { + bool + has_value() const { return distance_from_desired >= 0; } - bool is_empty() const - { + bool + is_empty() const { return distance_from_desired < 0; } - bool is_at_desired_position() const - { + bool + is_at_desired_position() const { return distance_from_desired <= 0; } - template - void emplace(int8_t distance, Args &&... args) - { + template + void + emplace(int8_t distance, Args&&... args) { new (std::addressof(value)) T(std::forward(args)...); distance_from_desired = distance; } - void destroy_value() - { + void + destroy_value() { value.~T(); distance_from_desired = -1; } int8_t distance_from_desired = -1; static constexpr int8_t special_end_value = 0; - union { T value; }; + union { + T value; + }; }; -inline int8_t log2(size_t value) -{ - static constexpr int8_t table[64] = - { - 63, 0, 58, 1, 59, 47, 53, 2, - 60, 39, 48, 27, 54, 33, 42, 3, - 61, 51, 37, 40, 49, 18, 28, 20, - 55, 30, 34, 11, 43, 14, 22, 4, - 62, 57, 46, 52, 38, 26, 32, 41, - 50, 36, 17, 19, 29, 10, 13, 21, - 56, 45, 25, 31, 35, 16, 9, 12, - 44, 24, 15, 8, 23, 7, 6, 5 - }; +inline int8_t +log2(uint64_t value) { + // NOLINTNEXTLINE(*c-arrays*) + static constexpr int8_t table[64] = { + 63, 0, 58, 1, 59, 47, 53, 2, 60, 39, 48, 27, 54, 33, 42, 3, + 61, 51, 37, 40, 49, 18, 28, 20, 55, 30, 34, 11, 43, 14, 22, 4, + 62, 57, 46, 52, 38, 26, 32, 41, 50, 36, 17, 19, 29, 10, 13, 21, + 56, 45, 25, 31, 35, 16, 9, 12, 44, 24, 15, 8, 23, 7, 6, 5}; value |= value >> 1; value |= value >> 2; value |= value >> 4; @@ -227,31 +214,8 @@ inline int8_t log2(size_t value) return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58]; } -template -struct AssignIfTrue -{ - void operator()(T & lhs, const T & rhs) - { - lhs = rhs; - } - void operator()(T & lhs, T && rhs) - { - lhs = std::move(rhs); - } -}; -template -struct AssignIfTrue -{ - void operator()(T &, const T &) - { - } - void operator()(T &, T &&) - { - } -}; - -inline size_t next_power_of_two(size_t i) -{ +inline uint64_t +next_power_of_two(uint64_t i) { --i; i |= i >> 1; i |= i >> 2; @@ -263,369 +227,413 @@ inline size_t next_power_of_two(size_t i) return i; } -template using void_t = void; +// Implementation taken from http://en.cppreference.com/w/cpp/types/void_t +// (it takes CWG1558 into account and also works for older compilers) +template +struct make_void { + typedef void type; +}; +template +using void_t = typename make_void::type; -template -struct HashPolicySelector -{ +template +struct HashPolicySelector { typedef fibonacci_hash_policy type; }; -template -struct HashPolicySelector> -{ +template +struct HashPolicySelector> { typedef typename T::hash_policy type; }; -template -class sherwood_v3_table : private EntryAlloc, private Hasher, private Equal -{ +template +class sherwood_v3_table : private EntryAlloc, + private DetailHasher, + private Equal { using Entry = detailv3::sherwood_v3_entry; using AllocatorTraits = std::allocator_traits; using EntryPointer = typename AllocatorTraits::pointer; + + public: struct convertible_to_iterator; -public: - using value_type = T; - using size_type = size_t; + using size_type = uint64_t; using difference_type = std::ptrdiff_t; using hasher = ArgumentHash; using key_equal = ArgumentEqual; using allocator_type = EntryAlloc; - using reference = value_type &; - using const_reference = const value_type &; - using pointer = value_type *; - using const_pointer = const value_type *; + using reference = value_type&; + using const_reference = const value_type&; + using pointer = value_type*; + using const_pointer = const value_type*; - sherwood_v3_table() - { - } - explicit sherwood_v3_table(size_type bucket_count, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc()) - : EntryAlloc(alloc), Hasher(hash), Equal(equal) - { + sherwood_v3_table() = default; + explicit sherwood_v3_table(size_type bucket_count, + const ArgumentHash& hash = ArgumentHash(), + const ArgumentEqual& equal = ArgumentEqual(), + const ArgumentAlloc& alloc = ArgumentAlloc()) + : EntryAlloc(alloc), DetailHasher(hash), Equal(equal) { rehash(bucket_count); } - sherwood_v3_table(size_type bucket_count, const ArgumentAlloc & alloc) - : sherwood_v3_table(bucket_count, ArgumentHash(), ArgumentEqual(), alloc) - { + sherwood_v3_table(size_type bucket_count, const ArgumentAlloc& alloc) + : sherwood_v3_table( + bucket_count, ArgumentHash(), ArgumentEqual(), alloc) { } - sherwood_v3_table(size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc) - : sherwood_v3_table(bucket_count, hash, ArgumentEqual(), alloc) - { + sherwood_v3_table(size_type bucket_count, + const ArgumentHash& hash, + const ArgumentAlloc& alloc) + : sherwood_v3_table(bucket_count, hash, ArgumentEqual(), alloc) { } - explicit sherwood_v3_table(const ArgumentAlloc & alloc) - : EntryAlloc(alloc) - { + explicit sherwood_v3_table(const ArgumentAlloc& alloc) : EntryAlloc(alloc) { } - template - sherwood_v3_table(It first, It last, size_type bucket_count = 0, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc()) - : sherwood_v3_table(bucket_count, hash, equal, alloc) - { + template + sherwood_v3_table(It first, + It last, + size_type bucket_count = 0, + const ArgumentHash& hash = ArgumentHash(), + const ArgumentEqual& equal = ArgumentEqual(), + const ArgumentAlloc& alloc = ArgumentAlloc()) + : sherwood_v3_table(bucket_count, hash, equal, alloc) { insert(first, last); } - template - sherwood_v3_table(It first, It last, size_type bucket_count, const ArgumentAlloc & alloc) - : sherwood_v3_table(first, last, bucket_count, ArgumentHash(), ArgumentEqual(), alloc) - { + template + sherwood_v3_table(It first, + It last, + size_type bucket_count, + const ArgumentAlloc& alloc) + : sherwood_v3_table(first, + last, + bucket_count, + ArgumentHash(), + ArgumentEqual(), + alloc) { } - template - sherwood_v3_table(It first, It last, size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc) - : sherwood_v3_table(first, last, bucket_count, hash, ArgumentEqual(), alloc) - { + template + sherwood_v3_table(It first, + It last, + size_type bucket_count, + const ArgumentHash& hash, + const ArgumentAlloc& alloc) + : sherwood_v3_table( + first, last, bucket_count, hash, ArgumentEqual(), alloc) { } - sherwood_v3_table(std::initializer_list il, size_type bucket_count = 0, const ArgumentHash & hash = ArgumentHash(), const ArgumentEqual & equal = ArgumentEqual(), const ArgumentAlloc & alloc = ArgumentAlloc()) - : sherwood_v3_table(bucket_count, hash, equal, alloc) - { + sherwood_v3_table(std::initializer_list il, + size_type bucket_count = 0, + const ArgumentHash& hash = ArgumentHash(), + const ArgumentEqual& equal = ArgumentEqual(), + const ArgumentAlloc& alloc = ArgumentAlloc()) + : sherwood_v3_table(bucket_count, hash, equal, alloc) { if (bucket_count == 0) rehash(il.size()); insert(il.begin(), il.end()); } - sherwood_v3_table(std::initializer_list il, size_type bucket_count, const ArgumentAlloc & alloc) - : sherwood_v3_table(il, bucket_count, ArgumentHash(), ArgumentEqual(), alloc) - { + sherwood_v3_table(std::initializer_list il, + size_type bucket_count, + const ArgumentAlloc& alloc) + : sherwood_v3_table( + il, bucket_count, ArgumentHash(), ArgumentEqual(), alloc) { } - sherwood_v3_table(std::initializer_list il, size_type bucket_count, const ArgumentHash & hash, const ArgumentAlloc & alloc) - : sherwood_v3_table(il, bucket_count, hash, ArgumentEqual(), alloc) - { + sherwood_v3_table(std::initializer_list il, + size_type bucket_count, + const ArgumentHash& hash, + const ArgumentAlloc& alloc) + : sherwood_v3_table(il, bucket_count, hash, ArgumentEqual(), alloc) { } - sherwood_v3_table(const sherwood_v3_table & other) - : sherwood_v3_table(other, AllocatorTraits::select_on_container_copy_construction(other.get_allocator())) - { + sherwood_v3_table(const sherwood_v3_table& other) + : sherwood_v3_table( + other, + AllocatorTraits::select_on_container_copy_construction( + other.get_allocator())) { } - sherwood_v3_table(const sherwood_v3_table & other, const ArgumentAlloc & alloc) - : EntryAlloc(alloc), Hasher(other), Equal(other), _max_load_factor(other._max_load_factor) - { + sherwood_v3_table(const sherwood_v3_table& other, + const ArgumentAlloc& alloc) + : EntryAlloc(alloc), + DetailHasher(other), + Equal(other), + _max_load_factor(other._max_load_factor) { rehash_for_other_container(other); - try - { + try { insert(other.begin(), other.end()); - } - catch(...) - { + } catch (...) { clear(); deallocate_data(entries, num_slots_minus_one, max_lookups); throw; } } - sherwood_v3_table(sherwood_v3_table && other) noexcept - : EntryAlloc(std::move(other)), Hasher(std::move(other)), Equal(std::move(other)) - { + sherwood_v3_table(sherwood_v3_table&& other) noexcept + : EntryAlloc(std::move(other)), + DetailHasher(std::move(other)), + Equal(std::move(other)) { swap_pointers(other); } - sherwood_v3_table(sherwood_v3_table && other, const ArgumentAlloc & alloc) noexcept - : EntryAlloc(alloc), Hasher(std::move(other)), Equal(std::move(other)) - { + sherwood_v3_table(sherwood_v3_table&& other, + const ArgumentAlloc& alloc) noexcept + : EntryAlloc(alloc), + DetailHasher(std::move(other)), + Equal(std::move(other)) { swap_pointers(other); } - sherwood_v3_table & operator=(const sherwood_v3_table & other) - { + sherwood_v3_table& + operator=(const sherwood_v3_table& other) { if (this == std::addressof(other)) return *this; clear(); - if (AllocatorTraits::propagate_on_container_copy_assignment::value) - { - if (static_cast(*this) != static_cast(other)) - { + if constexpr (AllocatorTraits::propagate_on_container_copy_assignment:: + value) { + if (static_cast(*this) != + static_cast(other)) { reset_to_empty_state(); } - AssignIfTrue()(*this, other); + static_cast(*this) = other; } _max_load_factor = other._max_load_factor; - static_cast(*this) = other; - static_cast(*this) = other; + static_cast(*this) = other; + static_cast(*this) = other; rehash_for_other_container(other); insert(other.begin(), other.end()); return *this; } - sherwood_v3_table & operator=(sherwood_v3_table && other) noexcept - { + sherwood_v3_table& + operator=(sherwood_v3_table&& other) noexcept { if (this == std::addressof(other)) return *this; - else if (AllocatorTraits::propagate_on_container_move_assignment::value) - { + else if constexpr (AllocatorTraits:: + propagate_on_container_move_assignment::value) { clear(); reset_to_empty_state(); - AssignIfTrue()(*this, std::move(other)); + static_cast(*this) = std::move(other); swap_pointers(other); - } - else if (static_cast(*this) == static_cast(other)) - { + } else if (static_cast(*this) == + static_cast(other)) { swap_pointers(other); - } - else - { + } else { clear(); _max_load_factor = other._max_load_factor; rehash_for_other_container(other); - for (T & elem : other) - emplace(std::move(elem)); + for (T& elem : other) emplace(std::move(elem)); other.clear(); } - static_cast(*this) = std::move(other); - static_cast(*this) = std::move(other); + static_cast(*this) = std::move(other); + static_cast(*this) = std::move(other); return *this; } - ~sherwood_v3_table() - { + ~sherwood_v3_table() { clear(); deallocate_data(entries, num_slots_minus_one, max_lookups); } - const allocator_type & get_allocator() const - { - return static_cast(*this); + const allocator_type& + get_allocator() const { + return static_cast(*this); } - const ArgumentEqual & key_eq() const - { - return static_cast(*this); + const ArgumentEqual& + key_eq() const { + return static_cast(*this); } - const ArgumentHash & hash_function() const - { - return static_cast(*this); + const ArgumentHash& + hash_function() const { + return static_cast(*this); } - template - struct templated_iterator - { + template + struct templated_iterator { templated_iterator() = default; - templated_iterator(EntryPointer current) - : current(current) - { + templated_iterator(EntryPointer current) : current(current) { } EntryPointer current = EntryPointer(); using iterator_category = std::forward_iterator_tag; using value_type = ValueType; using difference_type = ptrdiff_t; - using pointer = ValueType *; - using reference = ValueType &; + using pointer = ValueType*; + using reference = ValueType&; - friend bool operator==(const templated_iterator & lhs, const templated_iterator & rhs) - { + friend bool + operator==(const templated_iterator& lhs, + const templated_iterator& rhs) { return lhs.current == rhs.current; } - friend bool operator!=(const templated_iterator & lhs, const templated_iterator & rhs) - { + friend bool + operator!=(const templated_iterator& lhs, + const templated_iterator& rhs) { return !(lhs == rhs); } - templated_iterator & operator++() - { - do - { + templated_iterator& + operator++() { + do { ++current; - } - while(current->is_empty()); + } while (current->is_empty()); return *this; } - templated_iterator operator++(int) - { + templated_iterator + operator++(int) { templated_iterator copy(*this); ++*this; return copy; } - ValueType & operator*() const - { + ValueType& + operator*() const { return current->value; } - ValueType * operator->() const - { + ValueType* + operator->() const { return std::addressof(current->value); } - operator templated_iterator() const - { - return { current }; + // the template automatically disables the operator when value_type is + // already const, because that would cause a lot of compiler warnings + // otherwise. + template && + !std::is_same_v>> + operator templated_iterator() const { + return {current}; } }; using iterator = templated_iterator; using const_iterator = templated_iterator; - iterator begin() - { - for (EntryPointer it = entries;; ++it) - { + iterator + begin() { + for (EntryPointer it = entries;; ++it) { if (it->has_value()) - return { it }; + return {it}; } } - const_iterator begin() const - { - for (EntryPointer it = entries;; ++it) - { + const_iterator + begin() const { + for (EntryPointer it = entries;; ++it) { if (it->has_value()) - return { it }; + return {it}; } } - const_iterator cbegin() const - { + const_iterator + cbegin() const { return begin(); } - iterator end() - { - return { entries + static_cast(num_slots_minus_one + max_lookups) }; + iterator + end() { + return {entries + + static_cast(num_slots_minus_one + max_lookups)}; } - const_iterator end() const - { - return { entries + static_cast(num_slots_minus_one + max_lookups) }; + const_iterator + end() const { + return {entries + + static_cast(num_slots_minus_one + max_lookups)}; } - const_iterator cend() const - { + const_iterator + cend() const { return end(); } - iterator find(const FindKey & key) - { - size_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one); + iterator + find(const FindKey& key) { + uint64_t index = + hash_policy.index_for_hash(hash_object(key), num_slots_minus_one); EntryPointer it = entries + ptrdiff_t(index); - for (int8_t distance = 0; it->distance_from_desired >= distance; ++distance, ++it) - { + for (int8_t distance = 0; it->distance_from_desired >= distance; + ++distance, ++it) { if (compares_equal(key, it->value)) - return { it }; + return {it}; } return end(); } - const_iterator find(const FindKey & key) const - { - return const_cast(this)->find(key); + const_iterator + find(const FindKey& key) const { + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) + return const_cast(this)->find(key); } - size_t count(const FindKey & key) const - { + uint64_t + count(const FindKey& key) const { return find(key) == end() ? 0 : 1; } - std::pair equal_range(const FindKey & key) - { + std::pair + equal_range(const FindKey& key) { iterator found = find(key); if (found == end()) - return { found, found }; + return {found, found}; else - return { found, std::next(found) }; + return {found, std::next(found)}; } - std::pair equal_range(const FindKey & key) const - { + std::pair + equal_range(const FindKey& key) const { const_iterator found = find(key); if (found == end()) - return { found, found }; + return {found, found}; else - return { found, std::next(found) }; + return {found, std::next(found)}; } - template - std::pair emplace(Key && key, Args &&... args) - { - size_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one); + template + std::pair + emplace(Key&& key, Args&&... args) { + uint64_t index = + hash_policy.index_for_hash(hash_object(key), num_slots_minus_one); EntryPointer current_entry = entries + ptrdiff_t(index); int8_t distance_from_desired = 0; - for (; current_entry->distance_from_desired >= distance_from_desired; ++current_entry, ++distance_from_desired) - { + for (; current_entry->distance_from_desired >= distance_from_desired; + ++current_entry, ++distance_from_desired) { if (compares_equal(key, current_entry->value)) - return { { current_entry }, false }; + return {{current_entry}, false}; } - return emplace_new_key(distance_from_desired, current_entry, std::forward(key), std::forward(args)...); + return emplace_new_key(distance_from_desired, + current_entry, + std::forward(key), + std::forward(args)...); } - std::pair insert(const value_type & value) - { + std::pair + insert(const value_type& value) { return emplace(value); } - std::pair insert(value_type && value) - { + std::pair + insert(value_type&& value) { return emplace(std::move(value)); } - template - iterator emplace_hint(const_iterator, Args &&... args) - { + template + iterator + emplace_hint(const_iterator, Args&&... args) { return emplace(std::forward(args)...).first; } - iterator insert(const_iterator, const value_type & value) - { + iterator + insert(const_iterator, const value_type& value) { return emplace(value).first; } - iterator insert(const_iterator, value_type && value) - { + iterator + insert(const_iterator, value_type&& value) { return emplace(std::move(value)).first; } - template - void insert(It begin, It end) - { - for (; begin != end; ++begin) - { + template + void + insert(It begin, It end) { + for (; begin != end; ++begin) { emplace(*begin); } } - void insert(std::initializer_list il) - { + void + insert(std::initializer_list il) { insert(il.begin(), il.end()); } - void rehash(size_t num_buckets) - { - num_buckets = std::max(num_buckets, static_cast(std::ceil(num_elements / static_cast(_max_load_factor)))); - if (num_buckets == 0) - { + void + rehash(uint64_t num_buckets) { + num_buckets = std::max( + num_buckets, + static_cast(std::ceil( + num_elements / static_cast(_max_load_factor)))); + if (num_buckets == 0) { reset_to_empty_state(); return; } @@ -633,8 +641,11 @@ public: if (num_buckets == bucket_count()) return; int8_t new_max_lookups = compute_max_lookups(num_buckets); - EntryPointer new_buckets(AllocatorTraits::allocate(*this, num_buckets + new_max_lookups)); - EntryPointer special_end_item = new_buckets + static_cast(num_buckets + new_max_lookups - 1); + EntryPointer new_buckets( + AllocatorTraits::allocate(*this, num_buckets + new_max_lookups)); + EntryPointer special_end_item = + new_buckets + + static_cast(num_buckets + new_max_lookups - 1); for (EntryPointer it = new_buckets; it != special_end_item; ++it) it->distance_from_desired = -1; special_end_item->distance_from_desired = Entry::special_end_value; @@ -645,10 +656,12 @@ public: int8_t old_max_lookups = max_lookups; max_lookups = new_max_lookups; num_elements = 0; - for (EntryPointer it = new_buckets, end = it + static_cast(num_buckets + old_max_lookups); it != end; ++it) - { - if (it->has_value()) - { + for (EntryPointer it = new_buckets, + end = it + static_cast(num_buckets + + old_max_lookups); + it != end; + ++it) { + if (it->has_value()) { emplace(std::move(it->value)); it->destroy_value(); } @@ -656,9 +669,9 @@ public: deallocate_data(new_buckets, num_buckets, old_max_lookups); } - void reserve(size_t num_elements) - { - size_t required_buckets = num_buckets_for_reserve(num_elements); + void + reserve(uint64_t num_elements_) { + uint64_t required_buckets = num_buckets_for_reserve(num_elements_); if (required_buckets > bucket_count()) rehash(required_buckets); } @@ -667,150 +680,176 @@ public: // the reason for doing this is that it's not free to find the // iterator pointing at the next element. if you care about the // next iterator, turn the return value into an iterator - convertible_to_iterator erase(const_iterator to_erase) - { + convertible_to_iterator + erase(const_iterator to_erase) { EntryPointer current = to_erase.current; current->destroy_value(); --num_elements; - for (EntryPointer next = current + ptrdiff_t(1); !next->is_at_desired_position(); ++current, ++next) - { - current->emplace(next->distance_from_desired - 1, std::move(next->value)); + for (EntryPointer next = current + ptrdiff_t(1); + !next->is_at_desired_position(); + ++current, ++next) { + current->emplace(next->distance_from_desired - 1, + std::move(next->value)); next->destroy_value(); } - return { to_erase.current }; + return {to_erase.current}; } - iterator erase(const_iterator begin_it, const_iterator end_it) - { + iterator + erase(const_iterator begin_it, const_iterator end_it) { if (begin_it == end_it) - return { begin_it.current }; - for (EntryPointer it = begin_it.current, end = end_it.current; it != end; ++it) - { - if (it->has_value()) - { + return {begin_it.current}; + for (EntryPointer it = begin_it.current, end = end_it.current; + it != end; + ++it) { + if (it->has_value()) { it->destroy_value(); --num_elements; } } if (end_it == this->end()) return this->end(); - ptrdiff_t num_to_move = std::min(static_cast(end_it.current->distance_from_desired), end_it.current - begin_it.current); + ptrdiff_t num_to_move = std::min( + static_cast(end_it.current->distance_from_desired), + end_it.current - begin_it.current); EntryPointer to_return = end_it.current - num_to_move; - for (EntryPointer it = end_it.current; !it->is_at_desired_position();) - { + for (EntryPointer it = end_it.current; !it->is_at_desired_position();) { EntryPointer target = it - num_to_move; - target->emplace(it->distance_from_desired - num_to_move, std::move(it->value)); + target->emplace(it->distance_from_desired - num_to_move, + std::move(it->value)); it->destroy_value(); ++it; - num_to_move = std::min(static_cast(it->distance_from_desired), num_to_move); + num_to_move = std::min( + static_cast(it->distance_from_desired), num_to_move); } - return { to_return }; + return {to_return}; } - size_t erase(const FindKey & key) - { + uint64_t + erase(const FindKey& key) { auto found = find(key); if (found == end()) return 0; - else - { + else { erase(found); return 1; } } - void clear() - { - for (EntryPointer it = entries, end = it + static_cast(num_slots_minus_one + max_lookups); it != end; ++it) - { + void + clear() { + for (EntryPointer it = entries, + end = it + static_cast( + num_slots_minus_one + max_lookups); + it != end; + ++it) { if (it->has_value()) it->destroy_value(); } num_elements = 0; } - void shrink_to_fit() - { + void + shrink_to_fit() { rehash_for_other_container(*this); } - void swap(sherwood_v3_table & other) - { + void + swap(sherwood_v3_table& other) noexcept { using std::swap; swap_pointers(other); - swap(static_cast(*this), static_cast(other)); - swap(static_cast(*this), static_cast(other)); + swap(static_cast(*this), + static_cast(other)); + swap(static_cast(*this), + static_cast(other)); if (AllocatorTraits::propagate_on_container_swap::value) - swap(static_cast(*this), static_cast(other)); + swap(static_cast(*this), + static_cast(other)); } - size_t size() const - { + uint64_t + size() const { return num_elements; } - size_t max_size() const - { + uint64_t + max_size() const { return (AllocatorTraits::max_size(*this)) / sizeof(Entry); } - size_t bucket_count() const - { + uint64_t + bucket_count() const { return num_slots_minus_one ? num_slots_minus_one + 1 : 0; } - size_type max_bucket_count() const - { + size_type + max_bucket_count() const { return (AllocatorTraits::max_size(*this) - min_lookups) / sizeof(Entry); } - size_t bucket(const FindKey & key) const - { - return hash_policy.index_for_hash(hash_object(key), num_slots_minus_one); + uint64_t + bucket(const FindKey& key) const { + return hash_policy.index_for_hash(hash_object(key), + num_slots_minus_one); } - float load_factor() const - { - size_t buckets = bucket_count(); + float + load_factor() const { + uint64_t buckets = bucket_count(); if (buckets) return static_cast(num_elements) / bucket_count(); else return 0; } - void max_load_factor(float value) - { + void + max_load_factor(float value) { _max_load_factor = value; } - float max_load_factor() const - { + float + max_load_factor() const { return _max_load_factor; } - bool empty() const - { + bool + empty() const { return num_elements == 0; } -private: - EntryPointer entries = Entry::empty_default_table(); - size_t num_slots_minus_one = 0; + private: + EntryPointer entries = empty_default_table(); + uint64_t num_slots_minus_one = 0; typename HashPolicySelector::type hash_policy; int8_t max_lookups = detailv3::min_lookups - 1; float _max_load_factor = 0.5f; - size_t num_elements = 0; + uint64_t num_elements = 0; - static int8_t compute_max_lookups(size_t num_buckets) - { + EntryPointer + empty_default_table() { + EntryPointer result = + AllocatorTraits::allocate(*this, detailv3::min_lookups); + EntryPointer special_end_item = + result + static_cast(detailv3::min_lookups - 1); + for (EntryPointer it = result; it != special_end_item; ++it) + it->distance_from_desired = -1; + special_end_item->distance_from_desired = Entry::special_end_value; + return result; + } + + static int8_t + compute_max_lookups(uint64_t num_buckets) { int8_t desired = detailv3::log2(num_buckets); return std::max(detailv3::min_lookups, desired); } - size_t num_buckets_for_reserve(size_t num_elements) const - { - return static_cast(std::ceil(num_elements / std::min(0.5, static_cast(_max_load_factor)))); + uint64_t + num_buckets_for_reserve(uint64_t num_elements_) const { + return static_cast( + std::ceil(static_cast(num_elements_) / + std::min(0.5, static_cast(_max_load_factor)))); } - void rehash_for_other_container(const sherwood_v3_table & other) - { - rehash(std::min(num_buckets_for_reserve(other.size()), other.bucket_count())); + void + rehash_for_other_container(const sherwood_v3_table& other) { + rehash(std::min(num_buckets_for_reserve(other.size()), + other.bucket_count())); } - void swap_pointers(sherwood_v3_table & other) - { + void + swap_pointers(sherwood_v3_table& other) { using std::swap; swap(hash_policy, other.hash_policy); swap(entries, other.entries); @@ -820,44 +859,45 @@ private: swap(_max_load_factor, other._max_load_factor); } - template - SKA_NOINLINE(std::pair) emplace_new_key(int8_t distance_from_desired, EntryPointer current_entry, Key && key, Args &&... args) - { + template + SKA_NOINLINE(std::pair) + emplace_new_key(int8_t distance_from_desired, + EntryPointer current_entry, + Key&& key, + Args&&... args) { using std::swap; - if (num_slots_minus_one == 0 || distance_from_desired == max_lookups || num_elements + 1 > (num_slots_minus_one + 1) * static_cast(_max_load_factor)) - { + if (num_slots_minus_one == 0 || distance_from_desired == max_lookups || + num_elements + 1 > (num_slots_minus_one + 1) * + static_cast(_max_load_factor)) { grow(); return emplace(std::forward(key), std::forward(args)...); - } - else if (current_entry->is_empty()) - { - current_entry->emplace(distance_from_desired, std::forward(key), std::forward(args)...); + } else if (current_entry->is_empty()) { + current_entry->emplace(distance_from_desired, + std::forward(key), + std::forward(args)...); ++num_elements; - return { { current_entry }, true }; + return {{current_entry}, true}; } - value_type to_insert(std::forward(key), std::forward(args)...); + value_type to_insert(std::forward(key), + std::forward(args)...); swap(distance_from_desired, current_entry->distance_from_desired); swap(to_insert, current_entry->value); - iterator result = { current_entry }; - for (++distance_from_desired, ++current_entry;; ++current_entry) - { - if (current_entry->is_empty()) - { - current_entry->emplace(distance_from_desired, std::move(to_insert)); + iterator result = {current_entry}; + for (++distance_from_desired, ++current_entry;; ++current_entry) { + if (current_entry->is_empty()) { + current_entry->emplace(distance_from_desired, + std::move(to_insert)); ++num_elements; - return { result, true }; - } - else if (current_entry->distance_from_desired < distance_from_desired) - { - swap(distance_from_desired, current_entry->distance_from_desired); + return {result, true}; + } else if (current_entry->distance_from_desired < + distance_from_desired) { + swap(distance_from_desired, + current_entry->distance_from_desired); swap(to_insert, current_entry->value); ++distance_from_desired; - } - else - { + } else { ++distance_from_desired; - if (distance_from_desired == max_lookups) - { + if (distance_from_desired == max_lookups) { swap(to_insert, result.current->value); grow(); return emplace(std::move(to_insert)); @@ -866,450 +906,1300 @@ private: } } - void grow() - { - rehash(std::max(size_t(4), 2 * bucket_count())); + void + grow() { + rehash(std::max(uint64_t(4), 2 * bucket_count())); } - void deallocate_data(EntryPointer begin, size_t num_slots_minus_one, int8_t max_lookups) - { - if (begin != Entry::empty_default_table()) - { - AllocatorTraits::deallocate(*this, begin, num_slots_minus_one + max_lookups + 1); - } + void + deallocate_data(EntryPointer begin, + uint64_t num_slots_minus_one_, + int8_t max_lookups_) { + AllocatorTraits::deallocate( + *this, begin, num_slots_minus_one_ + max_lookups_ + 1); } - void reset_to_empty_state() - { + void + reset_to_empty_state() { deallocate_data(entries, num_slots_minus_one, max_lookups); - entries = Entry::empty_default_table(); + entries = empty_default_table(); num_slots_minus_one = 0; hash_policy.reset(); max_lookups = detailv3::min_lookups - 1; } - template - size_t hash_object(const U & key) - { - return static_cast(*this)(key); + template + uint64_t + hash_object(const U& key) { + return static_cast(*this)(key); } - template - size_t hash_object(const U & key) const - { - return static_cast(*this)(key); + template + uint64_t + hash_object(const U& key) const { + return static_cast(*this)(key); } - template - bool compares_equal(const L & lhs, const R & rhs) - { - return static_cast(*this)(lhs, rhs); + template + bool + compares_equal(const L& lhs, const R& rhs) { + return static_cast(*this)(lhs, rhs); } - struct convertible_to_iterator - { + public: + struct convertible_to_iterator { EntryPointer it; - operator iterator() - { + operator iterator() { if (it->has_value()) - return { it }; + return {it}; else return ++iterator{it}; } - operator const_iterator() - { + operator const_iterator() { if (it->has_value()) - return { it }; + return {it}; else return ++const_iterator{it}; } }; - }; -} +} // namespace detailv3 -struct prime_number_hash_policy -{ - static size_t mod0(size_t) { return 0llu; } - static size_t mod2(size_t hash) { return hash % 2llu; } - static size_t mod3(size_t hash) { return hash % 3llu; } - static size_t mod5(size_t hash) { return hash % 5llu; } - static size_t mod7(size_t hash) { return hash % 7llu; } - static size_t mod11(size_t hash) { return hash % 11llu; } - static size_t mod13(size_t hash) { return hash % 13llu; } - static size_t mod17(size_t hash) { return hash % 17llu; } - static size_t mod23(size_t hash) { return hash % 23llu; } - static size_t mod29(size_t hash) { return hash % 29llu; } - static size_t mod37(size_t hash) { return hash % 37llu; } - static size_t mod47(size_t hash) { return hash % 47llu; } - static size_t mod59(size_t hash) { return hash % 59llu; } - static size_t mod73(size_t hash) { return hash % 73llu; } - static size_t mod97(size_t hash) { return hash % 97llu; } - static size_t mod127(size_t hash) { return hash % 127llu; } - static size_t mod151(size_t hash) { return hash % 151llu; } - static size_t mod197(size_t hash) { return hash % 197llu; } - static size_t mod251(size_t hash) { return hash % 251llu; } - static size_t mod313(size_t hash) { return hash % 313llu; } - static size_t mod397(size_t hash) { return hash % 397llu; } - static size_t mod499(size_t hash) { return hash % 499llu; } - static size_t mod631(size_t hash) { return hash % 631llu; } - static size_t mod797(size_t hash) { return hash % 797llu; } - static size_t mod1009(size_t hash) { return hash % 1009llu; } - static size_t mod1259(size_t hash) { return hash % 1259llu; } - static size_t mod1597(size_t hash) { return hash % 1597llu; } - static size_t mod2011(size_t hash) { return hash % 2011llu; } - static size_t mod2539(size_t hash) { return hash % 2539llu; } - static size_t mod3203(size_t hash) { return hash % 3203llu; } - static size_t mod4027(size_t hash) { return hash % 4027llu; } - static size_t mod5087(size_t hash) { return hash % 5087llu; } - static size_t mod6421(size_t hash) { return hash % 6421llu; } - static size_t mod8089(size_t hash) { return hash % 8089llu; } - static size_t mod10193(size_t hash) { return hash % 10193llu; } - static size_t mod12853(size_t hash) { return hash % 12853llu; } - static size_t mod16193(size_t hash) { return hash % 16193llu; } - static size_t mod20399(size_t hash) { return hash % 20399llu; } - static size_t mod25717(size_t hash) { return hash % 25717llu; } - static size_t mod32401(size_t hash) { return hash % 32401llu; } - static size_t mod40823(size_t hash) { return hash % 40823llu; } - static size_t mod51437(size_t hash) { return hash % 51437llu; } - static size_t mod64811(size_t hash) { return hash % 64811llu; } - static size_t mod81649(size_t hash) { return hash % 81649llu; } - static size_t mod102877(size_t hash) { return hash % 102877llu; } - static size_t mod129607(size_t hash) { return hash % 129607llu; } - static size_t mod163307(size_t hash) { return hash % 163307llu; } - static size_t mod205759(size_t hash) { return hash % 205759llu; } - static size_t mod259229(size_t hash) { return hash % 259229llu; } - static size_t mod326617(size_t hash) { return hash % 326617llu; } - static size_t mod411527(size_t hash) { return hash % 411527llu; } - static size_t mod518509(size_t hash) { return hash % 518509llu; } - static size_t mod653267(size_t hash) { return hash % 653267llu; } - static size_t mod823117(size_t hash) { return hash % 823117llu; } - static size_t mod1037059(size_t hash) { return hash % 1037059llu; } - static size_t mod1306601(size_t hash) { return hash % 1306601llu; } - static size_t mod1646237(size_t hash) { return hash % 1646237llu; } - static size_t mod2074129(size_t hash) { return hash % 2074129llu; } - static size_t mod2613229(size_t hash) { return hash % 2613229llu; } - static size_t mod3292489(size_t hash) { return hash % 3292489llu; } - static size_t mod4148279(size_t hash) { return hash % 4148279llu; } - static size_t mod5226491(size_t hash) { return hash % 5226491llu; } - static size_t mod6584983(size_t hash) { return hash % 6584983llu; } - static size_t mod8296553(size_t hash) { return hash % 8296553llu; } - static size_t mod10453007(size_t hash) { return hash % 10453007llu; } - static size_t mod13169977(size_t hash) { return hash % 13169977llu; } - static size_t mod16593127(size_t hash) { return hash % 16593127llu; } - static size_t mod20906033(size_t hash) { return hash % 20906033llu; } - static size_t mod26339969(size_t hash) { return hash % 26339969llu; } - static size_t mod33186281(size_t hash) { return hash % 33186281llu; } - static size_t mod41812097(size_t hash) { return hash % 41812097llu; } - static size_t mod52679969(size_t hash) { return hash % 52679969llu; } - static size_t mod66372617(size_t hash) { return hash % 66372617llu; } - static size_t mod83624237(size_t hash) { return hash % 83624237llu; } - static size_t mod105359939(size_t hash) { return hash % 105359939llu; } - static size_t mod132745199(size_t hash) { return hash % 132745199llu; } - static size_t mod167248483(size_t hash) { return hash % 167248483llu; } - static size_t mod210719881(size_t hash) { return hash % 210719881llu; } - static size_t mod265490441(size_t hash) { return hash % 265490441llu; } - static size_t mod334496971(size_t hash) { return hash % 334496971llu; } - static size_t mod421439783(size_t hash) { return hash % 421439783llu; } - static size_t mod530980861(size_t hash) { return hash % 530980861llu; } - static size_t mod668993977(size_t hash) { return hash % 668993977llu; } - static size_t mod842879579(size_t hash) { return hash % 842879579llu; } - static size_t mod1061961721(size_t hash) { return hash % 1061961721llu; } - static size_t mod1337987929(size_t hash) { return hash % 1337987929llu; } - static size_t mod1685759167(size_t hash) { return hash % 1685759167llu; } - static size_t mod2123923447(size_t hash) { return hash % 2123923447llu; } - static size_t mod2675975881(size_t hash) { return hash % 2675975881llu; } - static size_t mod3371518343(size_t hash) { return hash % 3371518343llu; } - static size_t mod4247846927(size_t hash) { return hash % 4247846927llu; } - static size_t mod5351951779(size_t hash) { return hash % 5351951779llu; } - static size_t mod6743036717(size_t hash) { return hash % 6743036717llu; } - static size_t mod8495693897(size_t hash) { return hash % 8495693897llu; } - static size_t mod10703903591(size_t hash) { return hash % 10703903591llu; } - static size_t mod13486073473(size_t hash) { return hash % 13486073473llu; } - static size_t mod16991387857(size_t hash) { return hash % 16991387857llu; } - static size_t mod21407807219(size_t hash) { return hash % 21407807219llu; } - static size_t mod26972146961(size_t hash) { return hash % 26972146961llu; } - static size_t mod33982775741(size_t hash) { return hash % 33982775741llu; } - static size_t mod42815614441(size_t hash) { return hash % 42815614441llu; } - static size_t mod53944293929(size_t hash) { return hash % 53944293929llu; } - static size_t mod67965551447(size_t hash) { return hash % 67965551447llu; } - static size_t mod85631228929(size_t hash) { return hash % 85631228929llu; } - static size_t mod107888587883(size_t hash) { return hash % 107888587883llu; } - static size_t mod135931102921(size_t hash) { return hash % 135931102921llu; } - static size_t mod171262457903(size_t hash) { return hash % 171262457903llu; } - static size_t mod215777175787(size_t hash) { return hash % 215777175787llu; } - static size_t mod271862205833(size_t hash) { return hash % 271862205833llu; } - static size_t mod342524915839(size_t hash) { return hash % 342524915839llu; } - static size_t mod431554351609(size_t hash) { return hash % 431554351609llu; } - static size_t mod543724411781(size_t hash) { return hash % 543724411781llu; } - static size_t mod685049831731(size_t hash) { return hash % 685049831731llu; } - static size_t mod863108703229(size_t hash) { return hash % 863108703229llu; } - static size_t mod1087448823553(size_t hash) { return hash % 1087448823553llu; } - static size_t mod1370099663459(size_t hash) { return hash % 1370099663459llu; } - static size_t mod1726217406467(size_t hash) { return hash % 1726217406467llu; } - static size_t mod2174897647073(size_t hash) { return hash % 2174897647073llu; } - static size_t mod2740199326961(size_t hash) { return hash % 2740199326961llu; } - static size_t mod3452434812973(size_t hash) { return hash % 3452434812973llu; } - static size_t mod4349795294267(size_t hash) { return hash % 4349795294267llu; } - static size_t mod5480398654009(size_t hash) { return hash % 5480398654009llu; } - static size_t mod6904869625999(size_t hash) { return hash % 6904869625999llu; } - static size_t mod8699590588571(size_t hash) { return hash % 8699590588571llu; } - static size_t mod10960797308051(size_t hash) { return hash % 10960797308051llu; } - static size_t mod13809739252051(size_t hash) { return hash % 13809739252051llu; } - static size_t mod17399181177241(size_t hash) { return hash % 17399181177241llu; } - static size_t mod21921594616111(size_t hash) { return hash % 21921594616111llu; } - static size_t mod27619478504183(size_t hash) { return hash % 27619478504183llu; } - static size_t mod34798362354533(size_t hash) { return hash % 34798362354533llu; } - static size_t mod43843189232363(size_t hash) { return hash % 43843189232363llu; } - static size_t mod55238957008387(size_t hash) { return hash % 55238957008387llu; } - static size_t mod69596724709081(size_t hash) { return hash % 69596724709081llu; } - static size_t mod87686378464759(size_t hash) { return hash % 87686378464759llu; } - static size_t mod110477914016779(size_t hash) { return hash % 110477914016779llu; } - static size_t mod139193449418173(size_t hash) { return hash % 139193449418173llu; } - static size_t mod175372756929481(size_t hash) { return hash % 175372756929481llu; } - static size_t mod220955828033581(size_t hash) { return hash % 220955828033581llu; } - static size_t mod278386898836457(size_t hash) { return hash % 278386898836457llu; } - static size_t mod350745513859007(size_t hash) { return hash % 350745513859007llu; } - static size_t mod441911656067171(size_t hash) { return hash % 441911656067171llu; } - static size_t mod556773797672909(size_t hash) { return hash % 556773797672909llu; } - static size_t mod701491027718027(size_t hash) { return hash % 701491027718027llu; } - static size_t mod883823312134381(size_t hash) { return hash % 883823312134381llu; } - static size_t mod1113547595345903(size_t hash) { return hash % 1113547595345903llu; } - static size_t mod1402982055436147(size_t hash) { return hash % 1402982055436147llu; } - static size_t mod1767646624268779(size_t hash) { return hash % 1767646624268779llu; } - static size_t mod2227095190691797(size_t hash) { return hash % 2227095190691797llu; } - static size_t mod2805964110872297(size_t hash) { return hash % 2805964110872297llu; } - static size_t mod3535293248537579(size_t hash) { return hash % 3535293248537579llu; } - static size_t mod4454190381383713(size_t hash) { return hash % 4454190381383713llu; } - static size_t mod5611928221744609(size_t hash) { return hash % 5611928221744609llu; } - static size_t mod7070586497075177(size_t hash) { return hash % 7070586497075177llu; } - static size_t mod8908380762767489(size_t hash) { return hash % 8908380762767489llu; } - static size_t mod11223856443489329(size_t hash) { return hash % 11223856443489329llu; } - static size_t mod14141172994150357(size_t hash) { return hash % 14141172994150357llu; } - static size_t mod17816761525534927(size_t hash) { return hash % 17816761525534927llu; } - static size_t mod22447712886978529(size_t hash) { return hash % 22447712886978529llu; } - static size_t mod28282345988300791(size_t hash) { return hash % 28282345988300791llu; } - static size_t mod35633523051069991(size_t hash) { return hash % 35633523051069991llu; } - static size_t mod44895425773957261(size_t hash) { return hash % 44895425773957261llu; } - static size_t mod56564691976601587(size_t hash) { return hash % 56564691976601587llu; } - static size_t mod71267046102139967(size_t hash) { return hash % 71267046102139967llu; } - static size_t mod89790851547914507(size_t hash) { return hash % 89790851547914507llu; } - static size_t mod113129383953203213(size_t hash) { return hash % 113129383953203213llu; } - static size_t mod142534092204280003(size_t hash) { return hash % 142534092204280003llu; } - static size_t mod179581703095829107(size_t hash) { return hash % 179581703095829107llu; } - static size_t mod226258767906406483(size_t hash) { return hash % 226258767906406483llu; } - static size_t mod285068184408560057(size_t hash) { return hash % 285068184408560057llu; } - static size_t mod359163406191658253(size_t hash) { return hash % 359163406191658253llu; } - static size_t mod452517535812813007(size_t hash) { return hash % 452517535812813007llu; } - static size_t mod570136368817120201(size_t hash) { return hash % 570136368817120201llu; } - static size_t mod718326812383316683(size_t hash) { return hash % 718326812383316683llu; } - static size_t mod905035071625626043(size_t hash) { return hash % 905035071625626043llu; } - static size_t mod1140272737634240411(size_t hash) { return hash % 1140272737634240411llu; } - static size_t mod1436653624766633509(size_t hash) { return hash % 1436653624766633509llu; } - static size_t mod1810070143251252131(size_t hash) { return hash % 1810070143251252131llu; } - static size_t mod2280545475268481167(size_t hash) { return hash % 2280545475268481167llu; } - static size_t mod2873307249533267101(size_t hash) { return hash % 2873307249533267101llu; } - static size_t mod3620140286502504283(size_t hash) { return hash % 3620140286502504283llu; } - static size_t mod4561090950536962147(size_t hash) { return hash % 4561090950536962147llu; } - static size_t mod5746614499066534157(size_t hash) { return hash % 5746614499066534157llu; } - static size_t mod7240280573005008577(size_t hash) { return hash % 7240280573005008577llu; } - static size_t mod9122181901073924329(size_t hash) { return hash % 9122181901073924329llu; } - static size_t mod11493228998133068689(size_t hash) { return hash % 11493228998133068689llu; } - static size_t mod14480561146010017169(size_t hash) { return hash % 14480561146010017169llu; } - static size_t mod18446744073709551557(size_t hash) { return hash % 18446744073709551557llu; } +struct prime_number_hash_policy { + static uint64_t + mod0(uint64_t) { + return 0llu; + } + static uint64_t + mod2(uint64_t hash) { + return hash % 2llu; + } + static uint64_t + mod3(uint64_t hash) { + return hash % 3llu; + } + static uint64_t + mod5(uint64_t hash) { + return hash % 5llu; + } + static uint64_t + mod7(uint64_t hash) { + return hash % 7llu; + } + static uint64_t + mod11(uint64_t hash) { + return hash % 11llu; + } + static uint64_t + mod13(uint64_t hash) { + return hash % 13llu; + } + static uint64_t + mod17(uint64_t hash) { + return hash % 17llu; + } + static uint64_t + mod23(uint64_t hash) { + return hash % 23llu; + } + static uint64_t + mod29(uint64_t hash) { + return hash % 29llu; + } + static uint64_t + mod37(uint64_t hash) { + return hash % 37llu; + } + static uint64_t + mod47(uint64_t hash) { + return hash % 47llu; + } + static uint64_t + mod59(uint64_t hash) { + return hash % 59llu; + } + static uint64_t + mod73(uint64_t hash) { + return hash % 73llu; + } + static uint64_t + mod97(uint64_t hash) { + return hash % 97llu; + } + static uint64_t + mod127(uint64_t hash) { + return hash % 127llu; + } + static uint64_t + mod151(uint64_t hash) { + return hash % 151llu; + } + static uint64_t + mod197(uint64_t hash) { + return hash % 197llu; + } + static uint64_t + mod251(uint64_t hash) { + return hash % 251llu; + } + static uint64_t + mod313(uint64_t hash) { + return hash % 313llu; + } + static uint64_t + mod397(uint64_t hash) { + return hash % 397llu; + } + static uint64_t + mod499(uint64_t hash) { + return hash % 499llu; + } + static uint64_t + mod631(uint64_t hash) { + return hash % 631llu; + } + static uint64_t + mod797(uint64_t hash) { + return hash % 797llu; + } + static uint64_t + mod1009(uint64_t hash) { + return hash % 1009llu; + } + static uint64_t + mod1259(uint64_t hash) { + return hash % 1259llu; + } + static uint64_t + mod1597(uint64_t hash) { + return hash % 1597llu; + } + static uint64_t + mod2011(uint64_t hash) { + return hash % 2011llu; + } + static uint64_t + mod2539(uint64_t hash) { + return hash % 2539llu; + } + static uint64_t + mod3203(uint64_t hash) { + return hash % 3203llu; + } + static uint64_t + mod4027(uint64_t hash) { + return hash % 4027llu; + } + static uint64_t + mod5087(uint64_t hash) { + return hash % 5087llu; + } + static uint64_t + mod6421(uint64_t hash) { + return hash % 6421llu; + } + static uint64_t + mod8089(uint64_t hash) { + return hash % 8089llu; + } + static uint64_t + mod10193(uint64_t hash) { + return hash % 10193llu; + } + static uint64_t + mod12853(uint64_t hash) { + return hash % 12853llu; + } + static uint64_t + mod16193(uint64_t hash) { + return hash % 16193llu; + } + static uint64_t + mod20399(uint64_t hash) { + return hash % 20399llu; + } + static uint64_t + mod25717(uint64_t hash) { + return hash % 25717llu; + } + static uint64_t + mod32401(uint64_t hash) { + return hash % 32401llu; + } + static uint64_t + mod40823(uint64_t hash) { + return hash % 40823llu; + } + static uint64_t + mod51437(uint64_t hash) { + return hash % 51437llu; + } + static uint64_t + mod64811(uint64_t hash) { + return hash % 64811llu; + } + static uint64_t + mod81649(uint64_t hash) { + return hash % 81649llu; + } + static uint64_t + mod102877(uint64_t hash) { + return hash % 102877llu; + } + static uint64_t + mod129607(uint64_t hash) { + return hash % 129607llu; + } + static uint64_t + mod163307(uint64_t hash) { + return hash % 163307llu; + } + static uint64_t + mod205759(uint64_t hash) { + return hash % 205759llu; + } + static uint64_t + mod259229(uint64_t hash) { + return hash % 259229llu; + } + static uint64_t + mod326617(uint64_t hash) { + return hash % 326617llu; + } + static uint64_t + mod411527(uint64_t hash) { + return hash % 411527llu; + } + static uint64_t + mod518509(uint64_t hash) { + return hash % 518509llu; + } + static uint64_t + mod653267(uint64_t hash) { + return hash % 653267llu; + } + static uint64_t + mod823117(uint64_t hash) { + return hash % 823117llu; + } + static uint64_t + mod1037059(uint64_t hash) { + return hash % 1037059llu; + } + static uint64_t + mod1306601(uint64_t hash) { + return hash % 1306601llu; + } + static uint64_t + mod1646237(uint64_t hash) { + return hash % 1646237llu; + } + static uint64_t + mod2074129(uint64_t hash) { + return hash % 2074129llu; + } + static uint64_t + mod2613229(uint64_t hash) { + return hash % 2613229llu; + } + static uint64_t + mod3292489(uint64_t hash) { + return hash % 3292489llu; + } + static uint64_t + mod4148279(uint64_t hash) { + return hash % 4148279llu; + } + static uint64_t + mod5226491(uint64_t hash) { + return hash % 5226491llu; + } + static uint64_t + mod6584983(uint64_t hash) { + return hash % 6584983llu; + } + static uint64_t + mod8296553(uint64_t hash) { + return hash % 8296553llu; + } + static uint64_t + mod10453007(uint64_t hash) { + return hash % 10453007llu; + } + static uint64_t + mod13169977(uint64_t hash) { + return hash % 13169977llu; + } + static uint64_t + mod16593127(uint64_t hash) { + return hash % 16593127llu; + } + static uint64_t + mod20906033(uint64_t hash) { + return hash % 20906033llu; + } + static uint64_t + mod26339969(uint64_t hash) { + return hash % 26339969llu; + } + static uint64_t + mod33186281(uint64_t hash) { + return hash % 33186281llu; + } + static uint64_t + mod41812097(uint64_t hash) { + return hash % 41812097llu; + } + static uint64_t + mod52679969(uint64_t hash) { + return hash % 52679969llu; + } + static uint64_t + mod66372617(uint64_t hash) { + return hash % 66372617llu; + } + static uint64_t + mod83624237(uint64_t hash) { + return hash % 83624237llu; + } + static uint64_t + mod105359939(uint64_t hash) { + return hash % 105359939llu; + } + static uint64_t + mod132745199(uint64_t hash) { + return hash % 132745199llu; + } + static uint64_t + mod167248483(uint64_t hash) { + return hash % 167248483llu; + } + static uint64_t + mod210719881(uint64_t hash) { + return hash % 210719881llu; + } + static uint64_t + mod265490441(uint64_t hash) { + return hash % 265490441llu; + } + static uint64_t + mod334496971(uint64_t hash) { + return hash % 334496971llu; + } + static uint64_t + mod421439783(uint64_t hash) { + return hash % 421439783llu; + } + static uint64_t + mod530980861(uint64_t hash) { + return hash % 530980861llu; + } + static uint64_t + mod668993977(uint64_t hash) { + return hash % 668993977llu; + } + static uint64_t + mod842879579(uint64_t hash) { + return hash % 842879579llu; + } + static uint64_t + mod1061961721(uint64_t hash) { + return hash % 1061961721llu; + } + static uint64_t + mod1337987929(uint64_t hash) { + return hash % 1337987929llu; + } + static uint64_t + mod1685759167(uint64_t hash) { + return hash % 1685759167llu; + } + static uint64_t + mod2123923447(uint64_t hash) { + return hash % 2123923447llu; + } + static uint64_t + mod2675975881(uint64_t hash) { + return hash % 2675975881llu; + } + static uint64_t + mod3371518343(uint64_t hash) { + return hash % 3371518343llu; + } + static uint64_t + mod4247846927(uint64_t hash) { + return hash % 4247846927llu; + } + static uint64_t + mod5351951779(uint64_t hash) { + return hash % 5351951779llu; + } + static uint64_t + mod6743036717(uint64_t hash) { + return hash % 6743036717llu; + } + static uint64_t + mod8495693897(uint64_t hash) { + return hash % 8495693897llu; + } + static uint64_t + mod10703903591(uint64_t hash) { + return hash % 10703903591llu; + } + static uint64_t + mod13486073473(uint64_t hash) { + return hash % 13486073473llu; + } + static uint64_t + mod16991387857(uint64_t hash) { + return hash % 16991387857llu; + } + static uint64_t + mod21407807219(uint64_t hash) { + return hash % 21407807219llu; + } + static uint64_t + mod26972146961(uint64_t hash) { + return hash % 26972146961llu; + } + static uint64_t + mod33982775741(uint64_t hash) { + return hash % 33982775741llu; + } + static uint64_t + mod42815614441(uint64_t hash) { + return hash % 42815614441llu; + } + static uint64_t + mod53944293929(uint64_t hash) { + return hash % 53944293929llu; + } + static uint64_t + mod67965551447(uint64_t hash) { + return hash % 67965551447llu; + } + static uint64_t + mod85631228929(uint64_t hash) { + return hash % 85631228929llu; + } + static uint64_t + mod107888587883(uint64_t hash) { + return hash % 107888587883llu; + } + static uint64_t + mod135931102921(uint64_t hash) { + return hash % 135931102921llu; + } + static uint64_t + mod171262457903(uint64_t hash) { + return hash % 171262457903llu; + } + static uint64_t + mod215777175787(uint64_t hash) { + return hash % 215777175787llu; + } + static uint64_t + mod271862205833(uint64_t hash) { + return hash % 271862205833llu; + } + static uint64_t + mod342524915839(uint64_t hash) { + return hash % 342524915839llu; + } + static uint64_t + mod431554351609(uint64_t hash) { + return hash % 431554351609llu; + } + static uint64_t + mod543724411781(uint64_t hash) { + return hash % 543724411781llu; + } + static uint64_t + mod685049831731(uint64_t hash) { + return hash % 685049831731llu; + } + static uint64_t + mod863108703229(uint64_t hash) { + return hash % 863108703229llu; + } + static uint64_t + mod1087448823553(uint64_t hash) { + return hash % 1087448823553llu; + } + static uint64_t + mod1370099663459(uint64_t hash) { + return hash % 1370099663459llu; + } + static uint64_t + mod1726217406467(uint64_t hash) { + return hash % 1726217406467llu; + } + static uint64_t + mod2174897647073(uint64_t hash) { + return hash % 2174897647073llu; + } + static uint64_t + mod2740199326961(uint64_t hash) { + return hash % 2740199326961llu; + } + static uint64_t + mod3452434812973(uint64_t hash) { + return hash % 3452434812973llu; + } + static uint64_t + mod4349795294267(uint64_t hash) { + return hash % 4349795294267llu; + } + static uint64_t + mod5480398654009(uint64_t hash) { + return hash % 5480398654009llu; + } + static uint64_t + mod6904869625999(uint64_t hash) { + return hash % 6904869625999llu; + } + static uint64_t + mod8699590588571(uint64_t hash) { + return hash % 8699590588571llu; + } + static uint64_t + mod10960797308051(uint64_t hash) { + return hash % 10960797308051llu; + } + static uint64_t + mod13809739252051(uint64_t hash) { + return hash % 13809739252051llu; + } + static uint64_t + mod17399181177241(uint64_t hash) { + return hash % 17399181177241llu; + } + static uint64_t + mod21921594616111(uint64_t hash) { + return hash % 21921594616111llu; + } + static uint64_t + mod27619478504183(uint64_t hash) { + return hash % 27619478504183llu; + } + static uint64_t + mod34798362354533(uint64_t hash) { + return hash % 34798362354533llu; + } + static uint64_t + mod43843189232363(uint64_t hash) { + return hash % 43843189232363llu; + } + static uint64_t + mod55238957008387(uint64_t hash) { + return hash % 55238957008387llu; + } + static uint64_t + mod69596724709081(uint64_t hash) { + return hash % 69596724709081llu; + } + static uint64_t + mod87686378464759(uint64_t hash) { + return hash % 87686378464759llu; + } + static uint64_t + mod110477914016779(uint64_t hash) { + return hash % 110477914016779llu; + } + static uint64_t + mod139193449418173(uint64_t hash) { + return hash % 139193449418173llu; + } + static uint64_t + mod175372756929481(uint64_t hash) { + return hash % 175372756929481llu; + } + static uint64_t + mod220955828033581(uint64_t hash) { + return hash % 220955828033581llu; + } + static uint64_t + mod278386898836457(uint64_t hash) { + return hash % 278386898836457llu; + } + static uint64_t + mod350745513859007(uint64_t hash) { + return hash % 350745513859007llu; + } + static uint64_t + mod441911656067171(uint64_t hash) { + return hash % 441911656067171llu; + } + static uint64_t + mod556773797672909(uint64_t hash) { + return hash % 556773797672909llu; + } + static uint64_t + mod701491027718027(uint64_t hash) { + return hash % 701491027718027llu; + } + static uint64_t + mod883823312134381(uint64_t hash) { + return hash % 883823312134381llu; + } + static uint64_t + mod1113547595345903(uint64_t hash) { + return hash % 1113547595345903llu; + } + static uint64_t + mod1402982055436147(uint64_t hash) { + return hash % 1402982055436147llu; + } + static uint64_t + mod1767646624268779(uint64_t hash) { + return hash % 1767646624268779llu; + } + static uint64_t + mod2227095190691797(uint64_t hash) { + return hash % 2227095190691797llu; + } + static uint64_t + mod2805964110872297(uint64_t hash) { + return hash % 2805964110872297llu; + } + static uint64_t + mod3535293248537579(uint64_t hash) { + return hash % 3535293248537579llu; + } + static uint64_t + mod4454190381383713(uint64_t hash) { + return hash % 4454190381383713llu; + } + static uint64_t + mod5611928221744609(uint64_t hash) { + return hash % 5611928221744609llu; + } + static uint64_t + mod7070586497075177(uint64_t hash) { + return hash % 7070586497075177llu; + } + static uint64_t + mod8908380762767489(uint64_t hash) { + return hash % 8908380762767489llu; + } + static uint64_t + mod11223856443489329(uint64_t hash) { + return hash % 11223856443489329llu; + } + static uint64_t + mod14141172994150357(uint64_t hash) { + return hash % 14141172994150357llu; + } + static uint64_t + mod17816761525534927(uint64_t hash) { + return hash % 17816761525534927llu; + } + static uint64_t + mod22447712886978529(uint64_t hash) { + return hash % 22447712886978529llu; + } + static uint64_t + mod28282345988300791(uint64_t hash) { + return hash % 28282345988300791llu; + } + static uint64_t + mod35633523051069991(uint64_t hash) { + return hash % 35633523051069991llu; + } + static uint64_t + mod44895425773957261(uint64_t hash) { + return hash % 44895425773957261llu; + } + static uint64_t + mod56564691976601587(uint64_t hash) { + return hash % 56564691976601587llu; + } + static uint64_t + mod71267046102139967(uint64_t hash) { + return hash % 71267046102139967llu; + } + static uint64_t + mod89790851547914507(uint64_t hash) { + return hash % 89790851547914507llu; + } + static uint64_t + mod113129383953203213(uint64_t hash) { + return hash % 113129383953203213llu; + } + static uint64_t + mod142534092204280003(uint64_t hash) { + return hash % 142534092204280003llu; + } + static uint64_t + mod179581703095829107(uint64_t hash) { + return hash % 179581703095829107llu; + } + static uint64_t + mod226258767906406483(uint64_t hash) { + return hash % 226258767906406483llu; + } + static uint64_t + mod285068184408560057(uint64_t hash) { + return hash % 285068184408560057llu; + } + static uint64_t + mod359163406191658253(uint64_t hash) { + return hash % 359163406191658253llu; + } + static uint64_t + mod452517535812813007(uint64_t hash) { + return hash % 452517535812813007llu; + } + static uint64_t + mod570136368817120201(uint64_t hash) { + return hash % 570136368817120201llu; + } + static uint64_t + mod718326812383316683(uint64_t hash) { + return hash % 718326812383316683llu; + } + static uint64_t + mod905035071625626043(uint64_t hash) { + return hash % 905035071625626043llu; + } + static uint64_t + mod1140272737634240411(uint64_t hash) { + return hash % 1140272737634240411llu; + } + static uint64_t + mod1436653624766633509(uint64_t hash) { + return hash % 1436653624766633509llu; + } + static uint64_t + mod1810070143251252131(uint64_t hash) { + return hash % 1810070143251252131llu; + } + static uint64_t + mod2280545475268481167(uint64_t hash) { + return hash % 2280545475268481167llu; + } + static uint64_t + mod2873307249533267101(uint64_t hash) { + return hash % 2873307249533267101llu; + } + static uint64_t + mod3620140286502504283(uint64_t hash) { + return hash % 3620140286502504283llu; + } + static uint64_t + mod4561090950536962147(uint64_t hash) { + return hash % 4561090950536962147llu; + } + static uint64_t + mod5746614499066534157(uint64_t hash) { + return hash % 5746614499066534157llu; + } + static uint64_t + mod7240280573005008577(uint64_t hash) { + return hash % 7240280573005008577llu; + } + static uint64_t + mod9122181901073924329(uint64_t hash) { + return hash % 9122181901073924329llu; + } + static uint64_t + mod11493228998133068689(uint64_t hash) { + return hash % 11493228998133068689llu; + } + static uint64_t + mod14480561146010017169(uint64_t hash) { + return hash % 14480561146010017169llu; + } + static uint64_t + mod18446744073709551557(uint64_t hash) { + return hash % 18446744073709551557llu; + } - using mod_function = size_t (*)(size_t); + using mod_function = uint64_t (*)(uint64_t); - mod_function next_size_over(size_t & size) const - { + mod_function + next_size_over(uint64_t& size) const { // prime numbers generated by the following method: // 1. start with a prime p = 2 // 2. go to wolfram alpha and get p = NextPrime(2 * p) // 3. repeat 2. until you overflow 64 bits - // you now have large gaps which you would hit if somebody called reserve() with an unlucky number. - // 4. to fill the gaps for every prime p go to wolfram alpha and get ClosestPrime(p * 2^(1/3)) and ClosestPrime(p * 2^(2/3)) and put those in the gaps + // you now have large gaps which you would hit if somebody called reserve() + // with an unlucky number. + // 4. to fill the gaps for every prime p go to wolfram alpha and get + // ClosestPrime(p * 2^(1/3)) and ClosestPrime(p * 2^(2/3)) and put those in + // the gaps // 5. get PrevPrime(2^64) and put it at the end - static constexpr const size_t prime_list[] = - { - 2llu, 3llu, 5llu, 7llu, 11llu, 13llu, 17llu, 23llu, 29llu, 37llu, 47llu, - 59llu, 73llu, 97llu, 127llu, 151llu, 197llu, 251llu, 313llu, 397llu, - 499llu, 631llu, 797llu, 1009llu, 1259llu, 1597llu, 2011llu, 2539llu, - 3203llu, 4027llu, 5087llu, 6421llu, 8089llu, 10193llu, 12853llu, 16193llu, - 20399llu, 25717llu, 32401llu, 40823llu, 51437llu, 64811llu, 81649llu, - 102877llu, 129607llu, 163307llu, 205759llu, 259229llu, 326617llu, - 411527llu, 518509llu, 653267llu, 823117llu, 1037059llu, 1306601llu, - 1646237llu, 2074129llu, 2613229llu, 3292489llu, 4148279llu, 5226491llu, - 6584983llu, 8296553llu, 10453007llu, 13169977llu, 16593127llu, 20906033llu, - 26339969llu, 33186281llu, 41812097llu, 52679969llu, 66372617llu, - 83624237llu, 105359939llu, 132745199llu, 167248483llu, 210719881llu, - 265490441llu, 334496971llu, 421439783llu, 530980861llu, 668993977llu, - 842879579llu, 1061961721llu, 1337987929llu, 1685759167llu, 2123923447llu, - 2675975881llu, 3371518343llu, 4247846927llu, 5351951779llu, 6743036717llu, - 8495693897llu, 10703903591llu, 13486073473llu, 16991387857llu, - 21407807219llu, 26972146961llu, 33982775741llu, 42815614441llu, - 53944293929llu, 67965551447llu, 85631228929llu, 107888587883llu, - 135931102921llu, 171262457903llu, 215777175787llu, 271862205833llu, - 342524915839llu, 431554351609llu, 543724411781llu, 685049831731llu, - 863108703229llu, 1087448823553llu, 1370099663459llu, 1726217406467llu, - 2174897647073llu, 2740199326961llu, 3452434812973llu, 4349795294267llu, - 5480398654009llu, 6904869625999llu, 8699590588571llu, 10960797308051llu, - 13809739252051llu, 17399181177241llu, 21921594616111llu, 27619478504183llu, - 34798362354533llu, 43843189232363llu, 55238957008387llu, 69596724709081llu, - 87686378464759llu, 110477914016779llu, 139193449418173llu, - 175372756929481llu, 220955828033581llu, 278386898836457llu, - 350745513859007llu, 441911656067171llu, 556773797672909llu, - 701491027718027llu, 883823312134381llu, 1113547595345903llu, - 1402982055436147llu, 1767646624268779llu, 2227095190691797llu, - 2805964110872297llu, 3535293248537579llu, 4454190381383713llu, - 5611928221744609llu, 7070586497075177llu, 8908380762767489llu, - 11223856443489329llu, 14141172994150357llu, 17816761525534927llu, - 22447712886978529llu, 28282345988300791llu, 35633523051069991llu, - 44895425773957261llu, 56564691976601587llu, 71267046102139967llu, - 89790851547914507llu, 113129383953203213llu, 142534092204280003llu, - 179581703095829107llu, 226258767906406483llu, 285068184408560057llu, - 359163406191658253llu, 452517535812813007llu, 570136368817120201llu, - 718326812383316683llu, 905035071625626043llu, 1140272737634240411llu, - 1436653624766633509llu, 1810070143251252131llu, 2280545475268481167llu, - 2873307249533267101llu, 3620140286502504283llu, 4561090950536962147llu, - 5746614499066534157llu, 7240280573005008577llu, 9122181901073924329llu, - 11493228998133068689llu, 14480561146010017169llu, 18446744073709551557llu - }; - static constexpr size_t (* const mod_functions[])(size_t) = - { - &mod0, &mod2, &mod3, &mod5, &mod7, &mod11, &mod13, &mod17, &mod23, &mod29, &mod37, - &mod47, &mod59, &mod73, &mod97, &mod127, &mod151, &mod197, &mod251, &mod313, &mod397, - &mod499, &mod631, &mod797, &mod1009, &mod1259, &mod1597, &mod2011, &mod2539, &mod3203, - &mod4027, &mod5087, &mod6421, &mod8089, &mod10193, &mod12853, &mod16193, &mod20399, - &mod25717, &mod32401, &mod40823, &mod51437, &mod64811, &mod81649, &mod102877, - &mod129607, &mod163307, &mod205759, &mod259229, &mod326617, &mod411527, &mod518509, - &mod653267, &mod823117, &mod1037059, &mod1306601, &mod1646237, &mod2074129, - &mod2613229, &mod3292489, &mod4148279, &mod5226491, &mod6584983, &mod8296553, - &mod10453007, &mod13169977, &mod16593127, &mod20906033, &mod26339969, &mod33186281, - &mod41812097, &mod52679969, &mod66372617, &mod83624237, &mod105359939, &mod132745199, - &mod167248483, &mod210719881, &mod265490441, &mod334496971, &mod421439783, - &mod530980861, &mod668993977, &mod842879579, &mod1061961721, &mod1337987929, - &mod1685759167, &mod2123923447, &mod2675975881, &mod3371518343, &mod4247846927, - &mod5351951779, &mod6743036717, &mod8495693897, &mod10703903591, &mod13486073473, - &mod16991387857, &mod21407807219, &mod26972146961, &mod33982775741, &mod42815614441, - &mod53944293929, &mod67965551447, &mod85631228929, &mod107888587883, &mod135931102921, - &mod171262457903, &mod215777175787, &mod271862205833, &mod342524915839, - &mod431554351609, &mod543724411781, &mod685049831731, &mod863108703229, - &mod1087448823553, &mod1370099663459, &mod1726217406467, &mod2174897647073, - &mod2740199326961, &mod3452434812973, &mod4349795294267, &mod5480398654009, - &mod6904869625999, &mod8699590588571, &mod10960797308051, &mod13809739252051, - &mod17399181177241, &mod21921594616111, &mod27619478504183, &mod34798362354533, - &mod43843189232363, &mod55238957008387, &mod69596724709081, &mod87686378464759, - &mod110477914016779, &mod139193449418173, &mod175372756929481, &mod220955828033581, - &mod278386898836457, &mod350745513859007, &mod441911656067171, &mod556773797672909, - &mod701491027718027, &mod883823312134381, &mod1113547595345903, &mod1402982055436147, - &mod1767646624268779, &mod2227095190691797, &mod2805964110872297, &mod3535293248537579, - &mod4454190381383713, &mod5611928221744609, &mod7070586497075177, &mod8908380762767489, - &mod11223856443489329, &mod14141172994150357, &mod17816761525534927, - &mod22447712886978529, &mod28282345988300791, &mod35633523051069991, - &mod44895425773957261, &mod56564691976601587, &mod71267046102139967, - &mod89790851547914507, &mod113129383953203213, &mod142534092204280003, - &mod179581703095829107, &mod226258767906406483, &mod285068184408560057, - &mod359163406191658253, &mod452517535812813007, &mod570136368817120201, - &mod718326812383316683, &mod905035071625626043, &mod1140272737634240411, - &mod1436653624766633509, &mod1810070143251252131, &mod2280545475268481167, - &mod2873307249533267101, &mod3620140286502504283, &mod4561090950536962147, - &mod5746614499066534157, &mod7240280573005008577, &mod9122181901073924329, - &mod11493228998133068689, &mod14480561146010017169, &mod18446744073709551557 - }; - const size_t * found = std::lower_bound(std::begin(prime_list), std::end(prime_list) - 1, size); + // NOLINTNEXTLINE(*c-arrays*) + static constexpr const uint64_t prime_list[] = { + 2llu, + 3llu, + 5llu, + 7llu, + 11llu, + 13llu, + 17llu, + 23llu, + 29llu, + 37llu, + 47llu, + 59llu, + 73llu, + 97llu, + 127llu, + 151llu, + 197llu, + 251llu, + 313llu, + 397llu, + 499llu, + 631llu, + 797llu, + 1009llu, + 1259llu, + 1597llu, + 2011llu, + 2539llu, + 3203llu, + 4027llu, + 5087llu, + 6421llu, + 8089llu, + 10193llu, + 12853llu, + 16193llu, + 20399llu, + 25717llu, + 32401llu, + 40823llu, + 51437llu, + 64811llu, + 81649llu, + 102877llu, + 129607llu, + 163307llu, + 205759llu, + 259229llu, + 326617llu, + 411527llu, + 518509llu, + 653267llu, + 823117llu, + 1037059llu, + 1306601llu, + 1646237llu, + 2074129llu, + 2613229llu, + 3292489llu, + 4148279llu, + 5226491llu, + 6584983llu, + 8296553llu, + 10453007llu, + 13169977llu, + 16593127llu, + 20906033llu, + 26339969llu, + 33186281llu, + 41812097llu, + 52679969llu, + 66372617llu, + 83624237llu, + 105359939llu, + 132745199llu, + 167248483llu, + 210719881llu, + 265490441llu, + 334496971llu, + 421439783llu, + 530980861llu, + 668993977llu, + 842879579llu, + 1061961721llu, + 1337987929llu, + 1685759167llu, + 2123923447llu, + 2675975881llu, + 3371518343llu, + 4247846927llu, + 5351951779llu, + 6743036717llu, + 8495693897llu, + 10703903591llu, + 13486073473llu, + 16991387857llu, + 21407807219llu, + 26972146961llu, + 33982775741llu, + 42815614441llu, + 53944293929llu, + 67965551447llu, + 85631228929llu, + 107888587883llu, + 135931102921llu, + 171262457903llu, + 215777175787llu, + 271862205833llu, + 342524915839llu, + 431554351609llu, + 543724411781llu, + 685049831731llu, + 863108703229llu, + 1087448823553llu, + 1370099663459llu, + 1726217406467llu, + 2174897647073llu, + 2740199326961llu, + 3452434812973llu, + 4349795294267llu, + 5480398654009llu, + 6904869625999llu, + 8699590588571llu, + 10960797308051llu, + 13809739252051llu, + 17399181177241llu, + 21921594616111llu, + 27619478504183llu, + 34798362354533llu, + 43843189232363llu, + 55238957008387llu, + 69596724709081llu, + 87686378464759llu, + 110477914016779llu, + 139193449418173llu, + 175372756929481llu, + 220955828033581llu, + 278386898836457llu, + 350745513859007llu, + 441911656067171llu, + 556773797672909llu, + 701491027718027llu, + 883823312134381llu, + 1113547595345903llu, + 1402982055436147llu, + 1767646624268779llu, + 2227095190691797llu, + 2805964110872297llu, + 3535293248537579llu, + 4454190381383713llu, + 5611928221744609llu, + 7070586497075177llu, + 8908380762767489llu, + 11223856443489329llu, + 14141172994150357llu, + 17816761525534927llu, + 22447712886978529llu, + 28282345988300791llu, + 35633523051069991llu, + 44895425773957261llu, + 56564691976601587llu, + 71267046102139967llu, + 89790851547914507llu, + 113129383953203213llu, + 142534092204280003llu, + 179581703095829107llu, + 226258767906406483llu, + 285068184408560057llu, + 359163406191658253llu, + 452517535812813007llu, + 570136368817120201llu, + 718326812383316683llu, + 905035071625626043llu, + 1140272737634240411llu, + 1436653624766633509llu, + 1810070143251252131llu, + 2280545475268481167llu, + 2873307249533267101llu, + 3620140286502504283llu, + 4561090950536962147llu, + 5746614499066534157llu, + 7240280573005008577llu, + 9122181901073924329llu, + 11493228998133068689llu, + 14480561146010017169llu, + 18446744073709551557llu}; + // NOLINTNEXTLINE(*c-arrays*) + static constexpr uint64_t (*const mod_functions[])(uint64_t) = { + &mod0, + &mod2, + &mod3, + &mod5, + &mod7, + &mod11, + &mod13, + &mod17, + &mod23, + &mod29, + &mod37, + &mod47, + &mod59, + &mod73, + &mod97, + &mod127, + &mod151, + &mod197, + &mod251, + &mod313, + &mod397, + &mod499, + &mod631, + &mod797, + &mod1009, + &mod1259, + &mod1597, + &mod2011, + &mod2539, + &mod3203, + &mod4027, + &mod5087, + &mod6421, + &mod8089, + &mod10193, + &mod12853, + &mod16193, + &mod20399, + &mod25717, + &mod32401, + &mod40823, + &mod51437, + &mod64811, + &mod81649, + &mod102877, + &mod129607, + &mod163307, + &mod205759, + &mod259229, + &mod326617, + &mod411527, + &mod518509, + &mod653267, + &mod823117, + &mod1037059, + &mod1306601, + &mod1646237, + &mod2074129, + &mod2613229, + &mod3292489, + &mod4148279, + &mod5226491, + &mod6584983, + &mod8296553, + &mod10453007, + &mod13169977, + &mod16593127, + &mod20906033, + &mod26339969, + &mod33186281, + &mod41812097, + &mod52679969, + &mod66372617, + &mod83624237, + &mod105359939, + &mod132745199, + &mod167248483, + &mod210719881, + &mod265490441, + &mod334496971, + &mod421439783, + &mod530980861, + &mod668993977, + &mod842879579, + &mod1061961721, + &mod1337987929, + &mod1685759167, + &mod2123923447, + &mod2675975881, + &mod3371518343, + &mod4247846927, + &mod5351951779, + &mod6743036717, + &mod8495693897, + &mod10703903591, + &mod13486073473, + &mod16991387857, + &mod21407807219, + &mod26972146961, + &mod33982775741, + &mod42815614441, + &mod53944293929, + &mod67965551447, + &mod85631228929, + &mod107888587883, + &mod135931102921, + &mod171262457903, + &mod215777175787, + &mod271862205833, + &mod342524915839, + &mod431554351609, + &mod543724411781, + &mod685049831731, + &mod863108703229, + &mod1087448823553, + &mod1370099663459, + &mod1726217406467, + &mod2174897647073, + &mod2740199326961, + &mod3452434812973, + &mod4349795294267, + &mod5480398654009, + &mod6904869625999, + &mod8699590588571, + &mod10960797308051, + &mod13809739252051, + &mod17399181177241, + &mod21921594616111, + &mod27619478504183, + &mod34798362354533, + &mod43843189232363, + &mod55238957008387, + &mod69596724709081, + &mod87686378464759, + &mod110477914016779, + &mod139193449418173, + &mod175372756929481, + &mod220955828033581, + &mod278386898836457, + &mod350745513859007, + &mod441911656067171, + &mod556773797672909, + &mod701491027718027, + &mod883823312134381, + &mod1113547595345903, + &mod1402982055436147, + &mod1767646624268779, + &mod2227095190691797, + &mod2805964110872297, + &mod3535293248537579, + &mod4454190381383713, + &mod5611928221744609, + &mod7070586497075177, + &mod8908380762767489, + &mod11223856443489329, + &mod14141172994150357, + &mod17816761525534927, + &mod22447712886978529, + &mod28282345988300791, + &mod35633523051069991, + &mod44895425773957261, + &mod56564691976601587, + &mod71267046102139967, + &mod89790851547914507, + &mod113129383953203213, + &mod142534092204280003, + &mod179581703095829107, + &mod226258767906406483, + &mod285068184408560057, + &mod359163406191658253, + &mod452517535812813007, + &mod570136368817120201, + &mod718326812383316683, + &mod905035071625626043, + &mod1140272737634240411, + &mod1436653624766633509, + &mod1810070143251252131, + &mod2280545475268481167, + &mod2873307249533267101, + &mod3620140286502504283, + &mod4561090950536962147, + &mod5746614499066534157, + &mod7240280573005008577, + &mod9122181901073924329, + &mod11493228998133068689, + &mod14480561146010017169, + &mod18446744073709551557}; + const uint64_t* found = std::lower_bound( + std::begin(prime_list), std::end(prime_list) - 1, size); size = *found; return mod_functions[1 + found - prime_list]; } - void commit(mod_function new_mod_function) - { + void + commit(mod_function new_mod_function) { current_mod_function = new_mod_function; } - void reset() - { + void + reset() { current_mod_function = &mod0; } - size_t index_for_hash(size_t hash, size_t /*num_slots_minus_one*/) const - { + uint64_t + index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/) const { return current_mod_function(hash); } - size_t keep_in_range(size_t index, size_t num_slots_minus_one) const - { - return index > num_slots_minus_one ? current_mod_function(index) : index; + uint64_t + keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const { + return index > num_slots_minus_one ? current_mod_function(index) + : index; } -private: + private: mod_function current_mod_function = &mod0; }; -struct power_of_two_hash_policy -{ - size_t index_for_hash(size_t hash, size_t num_slots_minus_one) const - { +struct power_of_two_hash_policy { + uint64_t + index_for_hash(uint64_t hash, uint64_t num_slots_minus_one) const { return hash & num_slots_minus_one; } - size_t keep_in_range(size_t index, size_t num_slots_minus_one) const - { + uint64_t + keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const { return index_for_hash(index, num_slots_minus_one); } - int8_t next_size_over(size_t & size) const - { + int8_t + next_size_over(uint64_t& size) const { size = detailv3::next_power_of_two(size); return 0; } - void commit(int8_t) - { + void + commit(int8_t) { } - void reset() - { + void + reset() { } - }; -struct fibonacci_hash_policy -{ - size_t index_for_hash(size_t hash, size_t /*num_slots_minus_one*/) const - { +struct fibonacci_hash_policy { + uint64_t + index_for_hash(uint64_t hash, uint64_t /*num_slots_minus_one*/) const { return (11400714819323198485ull * hash) >> shift; } - size_t keep_in_range(size_t index, size_t num_slots_minus_one) const - { + uint64_t + keep_in_range(uint64_t index, uint64_t num_slots_minus_one) const { return index & num_slots_minus_one; } - int8_t next_size_over(size_t & size) const - { - size = std::max(size_t(2), detailv3::next_power_of_two(size)); - return 64 - detailv3::log2(size); + int8_t + next_size_over(uint64_t& size) const { + size = std::max(uint64_t(2), detailv3::next_power_of_two(size)); + return static_cast(64 - detailv3::log2(size)); } - void commit(int8_t shift) - { - this->shift = shift; + void + commit(int8_t shift_) { + shift = shift_; } - void reset() - { + void + reset() { shift = 63; } -private: + private: int8_t shift = 63; }; -template, typename E = std::equal_to, typename A = std::allocator > > +template , + typename E = std::equal_to, + typename A = std::allocator>> class flat_hash_map - : public detailv3::sherwood_v3_table - < - std::pair, - K, - H, - detailv3::KeyOrValueHasher, H>, - E, - detailv3::KeyOrValueEquality, E>, - A, - typename std::allocator_traits::template rebind_alloc>> - > -{ - using Table = detailv3::sherwood_v3_table - < + : public detailv3::sherwood_v3_table< + std::pair, + K, + H, + detailv3::KeyOrValueHasher, H>, + E, + detailv3::KeyOrValueEquality, E>, + A, + typename std::allocator_traits::template rebind_alloc< + detailv3::sherwood_v3_entry>>> { + using Table = detailv3::sherwood_v3_table< std::pair, K, H, @@ -1317,180 +2207,172 @@ class flat_hash_map E, detailv3::KeyOrValueEquality, E>, A, - typename std::allocator_traits::template rebind_alloc>> - >; -public: + typename std::allocator_traits::template rebind_alloc< + detailv3::sherwood_v3_entry>>>; + public: using key_type = K; using mapped_type = V; using Table::Table; - flat_hash_map() - { - } + flat_hash_map() = default; - inline V & operator[](const K & key) - { + inline V& + operator[](const K& key) { return emplace(key, convertible_to_value()).first->second; } - inline V & operator[](K && key) - { + inline V& + operator[](K&& key) { return emplace(std::move(key), convertible_to_value()).first->second; } - V & at(const K & key) - { + V& + at(const K& key) { auto found = this->find(key); if (found == this->end()) - throw std::out_of_range("Argument passed to at() was not in the map."); + throw std::out_of_range( + "Argument passed to at() was not in the map."); return found->second; } - const V & at(const K & key) const - { + const V& + at(const K& key) const { auto found = this->find(key); if (found == this->end()) - throw std::out_of_range("Argument passed to at() was not in the map."); + throw std::out_of_range( + "Argument passed to at() was not in the map."); return found->second; } using Table::emplace; - std::pair emplace() - { + std::pair + emplace() { return emplace(key_type(), convertible_to_value()); } - template - std::pair insert_or_assign(const key_type & key, M && m) - { + template + std::pair + insert_or_assign(const key_type& key, M&& m) { auto emplace_result = emplace(key, std::forward(m)); if (!emplace_result.second) emplace_result.first->second = std::forward(m); return emplace_result; } - template - std::pair insert_or_assign(key_type && key, M && m) - { + template + std::pair + insert_or_assign(key_type&& key, M&& m) { auto emplace_result = emplace(std::move(key), std::forward(m)); if (!emplace_result.second) emplace_result.first->second = std::forward(m); return emplace_result; } - template - typename Table::iterator insert_or_assign(typename Table::const_iterator, const key_type & key, M && m) - { + template + typename Table::iterator + insert_or_assign(typename Table::const_iterator, + const key_type& key, + M&& m) { return insert_or_assign(key, std::forward(m)).first; } - template - typename Table::iterator insert_or_assign(typename Table::const_iterator, key_type && key, M && m) - { + template + typename Table::iterator + insert_or_assign(typename Table::const_iterator, key_type&& key, M&& m) { return insert_or_assign(std::move(key), std::forward(m)).first; } - friend bool operator==(const flat_hash_map & lhs, const flat_hash_map & rhs) - { + friend bool + operator==(const flat_hash_map& lhs, const flat_hash_map& rhs) { if (lhs.size() != rhs.size()) return false; - for (const typename Table::value_type & value : lhs) - { + for (const typename Table::value_type& value : lhs) { auto found = rhs.find(value.first); - if (found == rhs.end()) - return false; - else if (value.second != found->second) + if (found == rhs.end() || value.second != found->second) return false; } return true; } - friend bool operator!=(const flat_hash_map & lhs, const flat_hash_map & rhs) - { + friend bool + operator!=(const flat_hash_map& lhs, const flat_hash_map& rhs) { return !(lhs == rhs); } -private: - struct convertible_to_value - { - operator V() const - { + private: + struct convertible_to_value { + operator V() const { return V(); } }; }; -template, typename E = std::equal_to, typename A = std::allocator > +template , + typename E = std::equal_to, + typename A = std::allocator> class flat_hash_set - : public detailv3::sherwood_v3_table - < - T, - T, - H, - detailv3::functor_storage, - E, - detailv3::functor_storage, - A, - typename std::allocator_traits::template rebind_alloc> - > -{ - using Table = detailv3::sherwood_v3_table - < + : public detailv3::sherwood_v3_table< + T, + T, + H, + detailv3::functor_storage, + E, + detailv3::functor_storage, + A, + typename std::allocator_traits::template rebind_alloc< + detailv3::sherwood_v3_entry>> { + using Table = detailv3::sherwood_v3_table< T, T, H, - detailv3::functor_storage, + detailv3::functor_storage, E, detailv3::functor_storage, A, - typename std::allocator_traits::template rebind_alloc> - >; -public: + typename std::allocator_traits::template rebind_alloc< + detailv3::sherwood_v3_entry>>; + public: using key_type = T; using Table::Table; - flat_hash_set() - { - } + flat_hash_set() = default; - template - std::pair emplace(Args &&... args) - { + template + std::pair + emplace(Args&&... args) { return Table::emplace(T(std::forward(args)...)); } - std::pair emplace(const key_type & arg) - { + std::pair + emplace(const key_type& arg) { return Table::emplace(arg); } - std::pair emplace(key_type & arg) - { + std::pair + emplace(key_type& arg) { return Table::emplace(arg); } - std::pair emplace(const key_type && arg) - { + std::pair + emplace(const key_type&& arg) { return Table::emplace(std::move(arg)); } - std::pair emplace(key_type && arg) - { + std::pair + emplace(key_type&& arg) { return Table::emplace(std::move(arg)); } - friend bool operator==(const flat_hash_set & lhs, const flat_hash_set & rhs) - { + friend bool + operator==(const flat_hash_set& lhs, const flat_hash_set& rhs) { if (lhs.size() != rhs.size()) return false; - for (const T & value : lhs) - { + for (const T& value : lhs) { if (rhs.find(value) == rhs.end()) return false; } return true; } - friend bool operator!=(const flat_hash_set & lhs, const flat_hash_set & rhs) - { + friend bool + operator!=(const flat_hash_set& lhs, const flat_hash_set& rhs) { return !(lhs == rhs); } }; - -template -struct power_of_two_std_hash : std::hash -{ +template +struct power_of_two_std_hash : std::hash { typedef ska::power_of_two_hash_policy hash_policy; }; -} // end namespace ska +} // end namespace ska