316 KiB
316 KiB
<html lang="en">
<head>
</head>
</html>
| LCOV - code coverage report | ||||||||||||||||||||||
 | ||||||||||||||||||||||
|
||||||||||||||||||||||
|
Line data Source code 1 : // hashtable.h header -*- C++ -*- 2 : 3 : // Copyright (C) 2007-2023 Free Software Foundation, Inc. 4 : // 5 : // This file is part of the GNU ISO C++ Library. This library is free 6 : // software; you can redistribute it and/or modify it under the 7 : // terms of the GNU General Public License as published by the 8 : // Free Software Foundation; either version 3, or (at your option) 9 : // any later version. 10 : 11 : // This library is distributed in the hope that it will be useful, 12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 : // GNU General Public License for more details. 15 : 16 : // Under Section 7 of GPL version 3, you are granted additional 17 : // permissions described in the GCC Runtime Library Exception, version 18 : // 3.1, as published by the Free Software Foundation. 19 : 20 : // You should have received a copy of the GNU General Public License and 21 : // a copy of the GCC Runtime Library Exception along with this program; 22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 : // <http://www.gnu.org/licenses/>. 24 : 25 : /** @file bits/hashtable.h 26 : * This is an internal header file, included by other library headers. 27 : * Do not attempt to use it directly. @headername{unordered_map, unordered_set} 28 : */ 29 : 30 : #ifndef _HASHTABLE_H 31 : #define _HASHTABLE_H 1 32 : 33 : #pragma GCC system_header 34 : 35 : #include <bits/hashtable_policy.h> 36 : #include <bits/enable_special_members.h> 37 : #include <bits/stl_function.h> // __has_is_transparent_t 38 : #if __cplusplus > 201402L 39 : # include <bits/node_handle.h> 40 : #endif 41 : 42 : namespace std _GLIBCXX_VISIBILITY(default) 43 : { 44 : _GLIBCXX_BEGIN_NAMESPACE_VERSION 45 : /// @cond undocumented 46 : 47 : template<typename _Tp, typename _Hash> 48 : using __cache_default 49 : = __not_<__and_<// Do not cache for fast hasher. 50 : __is_fast_hash<_Hash>, 51 : // Mandatory to have erase not throwing. 52 : __is_nothrow_invocable<const _Hash&, const _Tp&>>>; 53 : 54 : // Helper to conditionally delete the default constructor. 55 : // The _Hash_node_base type is used to distinguish this specialization 56 : // from any other potentially-overlapping subobjects of the hashtable. 57 : template<typename _Equal, typename _Hash, typename _Allocator> 58 : using _Hashtable_enable_default_ctor 59 : = _Enable_default_constructor<__and_<is_default_constructible<_Equal>, 60 : is_default_constructible<_Hash>, 61 : is_default_constructible<_Allocator>>{}, 62 : __detail::_Hash_node_base>; 63 : 64 : /** 65 : * Primary class template _Hashtable. 66 : * 67 : * @ingroup hashtable-detail 68 : * 69 : * @tparam _Value CopyConstructible type. 70 : * 71 : * @tparam _Key CopyConstructible type. 72 : * 73 : * @tparam _Alloc An allocator type 74 : * ([lib.allocator.requirements]) whose _Alloc::value_type is 75 : * _Value. As a conforming extension, we allow for 76 : * _Alloc::value_type != _Value. 77 : * 78 : * @tparam _ExtractKey Function object that takes an object of type 79 : * _Value and returns a value of type _Key. 80 : * 81 : * @tparam _Equal Function object that takes two objects of type k 82 : * and returns a bool-like value that is true if the two objects 83 : * are considered equal. 84 : * 85 : * @tparam _Hash The hash function. A unary function object with 86 : * argument type _Key and result type size_t. Return values should 87 : * be distributed over the entire range [0, numeric_limits<size_t>:::max()]. 88 : * 89 : * @tparam _RangeHash The range-hashing function (in the terminology of 90 : * Tavori and Dreizin). A binary function object whose argument 91 : * types and result type are all size_t. Given arguments r and N, 92 : * the return value is in the range [0, N). 93 : * 94 : * @tparam _Unused Not used. 95 : * 96 : * @tparam _RehashPolicy Policy class with three members, all of 97 : * which govern the bucket count. _M_next_bkt(n) returns a bucket 98 : * count no smaller than n. _M_bkt_for_elements(n) returns a 99 : * bucket count appropriate for an element count of n. 100 : * _M_need_rehash(n_bkt, n_elt, n_ins) determines whether, if the 101 : * current bucket count is n_bkt and the current element count is 102 : * n_elt, we need to increase the bucket count for n_ins insertions. 103 : * If so, returns make_pair(true, n), where n is the new bucket count. If 104 : * not, returns make_pair(false, <anything>) 105 : * 106 : * @tparam _Traits Compile-time class with three boolean 107 : * std::integral_constant members: __cache_hash_code, __constant_iterators, 108 : * __unique_keys. 109 : * 110 : * Each _Hashtable data structure has: 111 : * 112 : * - _Bucket[] _M_buckets 113 : * - _Hash_node_base _M_before_begin 114 : * - size_type _M_bucket_count 115 : * - size_type _M_element_count 116 : * 117 : * with _Bucket being _Hash_node_base* and _Hash_node containing: 118 : * 119 : * - _Hash_node* _M_next 120 : * - Tp _M_value 121 : * - size_t _M_hash_code if cache_hash_code is true 122 : * 123 : * In terms of Standard containers the hashtable is like the aggregation of: 124 : * 125 : * - std::forward_list<_Node> containing the elements 126 : * - std::vector<std::forward_list<_Node>::iterator> representing the buckets 127 : * 128 : * The non-empty buckets contain the node before the first node in the 129 : * bucket. This design makes it possible to implement something like a 130 : * std::forward_list::insert_after on container insertion and 131 : * std::forward_list::erase_after on container erase 132 : * calls. _M_before_begin is equivalent to 133 : * std::forward_list::before_begin. Empty buckets contain 134 : * nullptr. Note that one of the non-empty buckets contains 135 : * &_M_before_begin which is not a dereferenceable node so the 136 : * node pointer in a bucket shall never be dereferenced, only its 137 : * next node can be. 138 : * 139 : * Walking through a bucket's nodes requires a check on the hash code to 140 : * see if each node is still in the bucket. Such a design assumes a 141 : * quite efficient hash functor and is one of the reasons it is 142 : * highly advisable to set __cache_hash_code to true. 143 : * 144 : * The container iterators are simply built from nodes. This way 145 : * incrementing the iterator is perfectly efficient independent of 146 : * how many empty buckets there are in the container. 147 : * 148 : * On insert we compute the element's hash code and use it to find the 149 : * bucket index. If the element must be inserted in an empty bucket 150 : * we add it at the beginning of the singly linked list and make the 151 : * bucket point to _M_before_begin. The bucket that used to point to 152 : * _M_before_begin, if any, is updated to point to its new before 153 : * begin node. 154 : * 155 : * On erase, the simple iterator design requires using the hash 156 : * functor to get the index of the bucket to update. For this 157 : * reason, when __cache_hash_code is set to false the hash functor must 158 : * not throw and this is enforced by a static assertion. 159 : * 160 : * Functionality is implemented by decomposition into base classes, 161 : * where the derived _Hashtable class is used in _Map_base, 162 : * _Insert, _Rehash_base, and _Equality base classes to access the 163 : * "this" pointer. _Hashtable_base is used in the base classes as a 164 : * non-recursive, fully-completed-type so that detailed nested type 165 : * information, such as iterator type and node type, can be 166 : * used. This is similar to the "Curiously Recurring Template 167 : * Pattern" (CRTP) technique, but uses a reconstructed, not 168 : * explicitly passed, template pattern. 169 : * 170 : * Base class templates are: 171 : * - __detail::_Hashtable_base 172 : * - __detail::_Map_base 173 : * - __detail::_Insert 174 : * - __detail::_Rehash_base 175 : * - __detail::_Equality 176 : */ 177 : template<typename _Key, typename _Value, typename _Alloc, 178 : typename _ExtractKey, typename _Equal, 179 : typename _Hash, typename _RangeHash, typename _Unused, 180 : typename _RehashPolicy, typename _Traits> 181 : class _Hashtable 182 : : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, 183 : _Hash, _RangeHash, _Unused, _Traits>, 184 : public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, 185 : _Hash, _RangeHash, _Unused, 186 : _RehashPolicy, _Traits>, 187 : public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, 188 : _Hash, _RangeHash, _Unused, 189 : _RehashPolicy, _Traits>, 190 : public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, 191 : _Hash, _RangeHash, _Unused, 192 : _RehashPolicy, _Traits>, 193 : public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, 194 : _Hash, _RangeHash, _Unused, 195 : _RehashPolicy, _Traits>, 196 : private __detail::_Hashtable_alloc< 197 : __alloc_rebind<_Alloc, 198 : __detail::_Hash_node<_Value, 199 : _Traits::__hash_cached::value>>>, 200 : private _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc> 201 : { 202 : static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value, 203 : "unordered container must have a non-const, non-volatile value_type"); 204 : #if __cplusplus > 201703L || defined __STRICT_ANSI__ 205 : static_assert(is_same<typename _Alloc::value_type, _Value>{}, 206 : "unordered container must have the same value_type as its allocator"); 207 : #endif 208 : 209 : using __traits_type = _Traits; 210 : using __hash_cached = typename __traits_type::__hash_cached; 211 : using __constant_iterators = typename __traits_type::__constant_iterators; 212 : using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>; 213 : using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>; 214 : 215 : using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>; 216 : 217 : using __node_value_type = 218 : __detail::_Hash_node_value<_Value, __hash_cached::value>; 219 : using __node_ptr = typename __hashtable_alloc::__node_ptr; 220 : using __value_alloc_traits = 221 : typename __hashtable_alloc::__value_alloc_traits; 222 : using __node_alloc_traits = 223 : typename __hashtable_alloc::__node_alloc_traits; 224 : using __node_base = typename __hashtable_alloc::__node_base; 225 : using __node_base_ptr = typename __hashtable_alloc::__node_base_ptr; 226 : using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr; 227 : 228 : using __insert_base = __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, 229 : _Equal, _Hash, 230 : _RangeHash, _Unused, 231 : _RehashPolicy, _Traits>; 232 : using __enable_default_ctor 233 : = _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>; 234 : 235 : public: 236 : typedef _Key key_type; 237 : typedef _Value value_type; 238 : typedef _Alloc allocator_type; 239 : typedef _Equal key_equal; 240 : 241 : // mapped_type, if present, comes from _Map_base. 242 : // hasher, if present, comes from _Hash_code_base/_Hashtable_base. 243 : typedef typename __value_alloc_traits::pointer pointer; 244 : typedef typename __value_alloc_traits::const_pointer const_pointer; 245 : typedef value_type& reference; 246 : typedef const value_type& const_reference; 247 : 248 : using iterator = typename __insert_base::iterator; 249 : 250 : using const_iterator = typename __insert_base::const_iterator; 251 : 252 : using local_iterator = __detail::_Local_iterator<key_type, _Value, 253 : _ExtractKey, _Hash, _RangeHash, _Unused, 254 : __constant_iterators::value, 255 : __hash_cached::value>; 256 : 257 : using const_local_iterator = __detail::_Local_const_iterator< 258 : key_type, _Value, 259 : _ExtractKey, _Hash, _RangeHash, _Unused, 260 : __constant_iterators::value, __hash_cached::value>; 261 : 262 : private: 263 : using __rehash_type = _RehashPolicy; 264 : using __rehash_state = typename __rehash_type::_State; 265 : 266 : using __unique_keys = typename __traits_type::__unique_keys; 267 : 268 : using __hashtable_base = __detail:: 269 : _Hashtable_base<_Key, _Value, _ExtractKey, 270 : _Equal, _Hash, _RangeHash, _Unused, _Traits>; 271 : 272 : using __hash_code_base = typename __hashtable_base::__hash_code_base; 273 : using __hash_code = typename __hashtable_base::__hash_code; 274 : using __ireturn_type = typename __insert_base::__ireturn_type; 275 : 276 : using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, 277 : _Equal, _Hash, _RangeHash, _Unused, 278 : _RehashPolicy, _Traits>; 279 : 280 : using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc, 281 : _ExtractKey, _Equal, 282 : _Hash, _RangeHash, _Unused, 283 : _RehashPolicy, _Traits>; 284 : 285 : using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, 286 : _Equal, _Hash, _RangeHash, _Unused, 287 : _RehashPolicy, _Traits>; 288 : 289 : using __reuse_or_alloc_node_gen_t = 290 : __detail::_ReuseOrAllocNode<__node_alloc_type>; 291 : using __alloc_node_gen_t = 292 : __detail::_AllocNode<__node_alloc_type>; 293 : using __node_builder_t = 294 : __detail::_NodeBuilder<_ExtractKey>; 295 : 296 : // Simple RAII type for managing a node containing an element 297 : struct _Scoped_node 298 : { 299 : // Take ownership of a node with a constructed element. 300 61162 : _Scoped_node(__node_ptr __n, __hashtable_alloc* __h) 301 61162 : : _M_h(__h), _M_node(__n) { } 302 : 303 : // Allocate a node and construct an element within it. 304 : template<typename... _Args> 305 198996 : _Scoped_node(__hashtable_alloc* __h, _Args&&... __args) 306 198996 : : _M_h(__h), 307 198996 : _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...)) 308 198996 : { } 309 : 310 : // Destroy element and deallocate node. 311 260158 : ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); }; 312 : 313 : _Scoped_node(const _Scoped_node&) = delete; 314 : _Scoped_node& operator=(const _Scoped_node&) = delete; 315 : 316 : __hashtable_alloc* _M_h; 317 : __node_ptr _M_node; 318 : }; 319 : 320 : template<typename _Ht> 321 : static constexpr 322 : __conditional_t<std::is_lvalue_reference<_Ht>::value, 323 : const value_type&, value_type&&> 324 : __fwd_value_for(value_type& __val) noexcept 325 : { return std::move(__val); } 326 : 327 : // Compile-time diagnostics. 328 : 329 : // _Hash_code_base has everything protected, so use this derived type to 330 : // access it. 331 : struct __hash_code_base_access : __hash_code_base 332 : { using __hash_code_base::_M_bucket_index; }; 333 : 334 : // To get bucket index we need _RangeHash not to throw. 335 : static_assert(is_nothrow_default_constructible<_RangeHash>::value, 336 : "Functor used to map hash code to bucket index" 337 : " must be nothrow default constructible"); 338 : static_assert(noexcept( 339 : std::declval<const _RangeHash&>()((std::size_t)0, (std::size_t)0)), 340 : "Functor used to map hash code to bucket index must be" 341 : " noexcept"); 342 : 343 : // To compute bucket index we also need _ExtratKey not to throw. 344 : static_assert(is_nothrow_default_constructible<_ExtractKey>::value, 345 : "_ExtractKey must be nothrow default constructible"); 346 : static_assert(noexcept( 347 : std::declval<const _ExtractKey&>()(std::declval<_Value>())), 348 : "_ExtractKey functor must be noexcept invocable"); 349 : 350 : template<typename _Keya, typename _Valuea, typename _Alloca, 351 : typename _ExtractKeya, typename _Equala, 352 : typename _Hasha, typename _RangeHasha, typename _Unuseda, 353 : typename _RehashPolicya, typename _Traitsa, 354 : bool _Unique_keysa> 355 : friend struct __detail::_Map_base; 356 : 357 : template<typename _Keya, typename _Valuea, typename _Alloca, 358 : typename _ExtractKeya, typename _Equala, 359 : typename _Hasha, typename _RangeHasha, typename _Unuseda, 360 : typename _RehashPolicya, typename _Traitsa> 361 : friend struct __detail::_Insert_base; 362 : 363 : template<typename _Keya, typename _Valuea, typename _Alloca, 364 : typename _ExtractKeya, typename _Equala, 365 : typename _Hasha, typename _RangeHasha, typename _Unuseda, 366 : typename _RehashPolicya, typename _Traitsa, 367 : bool _Constant_iteratorsa> 368 : friend struct __detail::_Insert; 369 : 370 : template<typename _Keya, typename _Valuea, typename _Alloca, 371 : typename _ExtractKeya, typename _Equala, 372 : typename _Hasha, typename _RangeHasha, typename _Unuseda, 373 : typename _RehashPolicya, typename _Traitsa, 374 : bool _Unique_keysa> 375 : friend struct __detail::_Equality; 376 : 377 : public: 378 : using size_type = typename __hashtable_base::size_type; 379 : using difference_type = typename __hashtable_base::difference_type; 380 : 381 : #if __cplusplus > 201402L 382 : using node_type = _Node_handle<_Key, _Value, __node_alloc_type>; 383 : using insert_return_type = _Node_insert_return<iterator, node_type>; 384 : #endif 385 : 386 : private: 387 : __buckets_ptr _M_buckets = &_M_single_bucket; 388 : size_type _M_bucket_count = 1; 389 : __node_base _M_before_begin; 390 : size_type _M_element_count = 0; 391 : _RehashPolicy _M_rehash_policy; 392 : 393 : // A single bucket used when only need for 1 bucket. Especially 394 : // interesting in move semantic to leave hashtable with only 1 bucket 395 : // which is not allocated so that we can have those operations noexcept 396 : // qualified. 397 : // Note that we can't leave hashtable with 0 bucket without adding 398 : // numerous checks in the code to avoid 0 modulus. 399 : __node_base_ptr _M_single_bucket = nullptr; 400 : 401 : void 402 : _M_update_bbegin() 403 : { 404 : if (_M_begin()) 405 : _M_buckets[_M_bucket_index(*_M_begin())] = &_M_before_begin; 406 : } 407 : 408 : void 409 : _M_update_bbegin(__node_ptr __n) 410 : { 411 : _M_before_begin._M_nxt = __n; 412 : _M_update_bbegin(); 413 : } 414 : 415 : bool 416 240284 : _M_uses_single_bucket(__buckets_ptr __bkts) const 417 240284 : { return __builtin_expect(__bkts == &_M_single_bucket, false); } 418 : 419 : bool 420 : _M_uses_single_bucket() const 421 : { return _M_uses_single_bucket(_M_buckets); } 422 : 423 : static constexpr size_t 424 194614 : __small_size_threshold() noexcept 425 : { 426 : return 427 194614 : __detail::_Hashtable_hash_traits<_Hash>::__small_size_threshold(); 428 : } 429 : 430 : __hashtable_alloc& 431 : _M_base_alloc() { return *this; } 432 : 433 : __buckets_ptr 434 116628 : _M_allocate_buckets(size_type __bkt_count) 435 : { 436 116628 : if (__builtin_expect(__bkt_count == 1, false)) 437 : { 438 0 : _M_single_bucket = nullptr; 439 0 : return &_M_single_bucket; 440 : } 441 : 442 116628 : return __hashtable_alloc::_M_allocate_buckets(__bkt_count); 443 : } 444 : 445 : void 446 240284 : _M_deallocate_buckets(__buckets_ptr __bkts, size_type __bkt_count) 447 : { 448 240284 : if (_M_uses_single_bucket(__bkts)) 449 123658 : return; 450 : 451 116626 : __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count); 452 : } 453 : 454 : void 455 240284 : _M_deallocate_buckets() 456 240284 : { _M_deallocate_buckets(_M_buckets, _M_bucket_count); } 457 : 458 : // Gets bucket begin, deals with the fact that non-empty buckets contain 459 : // their before begin node. 460 : __node_ptr 461 : _M_bucket_begin(size_type __bkt) const; 462 : 463 : __node_ptr 464 393732 : _M_begin() const 465 393732 : { return static_cast<__node_ptr>(_M_before_begin._M_nxt); } 466 : 467 : // Assign *this using another _Hashtable instance. Whether elements 468 : // are copied or moved depends on the _Ht reference. 469 : template<typename _Ht> 470 : void 471 : _M_assign_elements(_Ht&&); 472 : 473 : template<typename _Ht, typename _NodeGenerator> 474 : void 475 : _M_assign(_Ht&&, const _NodeGenerator&); 476 : 477 : void 478 : _M_move_assign(_Hashtable&&, true_type); 479 : 480 : void 481 : _M_move_assign(_Hashtable&&, false_type); 482 : 483 : void 484 : _M_reset() noexcept; 485 : 486 : _Hashtable(const _Hash& __h, const _Equal& __eq, 487 : const allocator_type& __a) 488 : : __hashtable_base(__h, __eq), 489 : __hashtable_alloc(__node_alloc_type(__a)), 490 : __enable_default_ctor(_Enable_default_constructor_tag{}) 491 : { } 492 : 493 : template<bool _No_realloc = true> 494 : static constexpr bool 495 : _S_nothrow_move() 496 : { 497 : #if __cplusplus <= 201402L 498 : return __and_<__bool_constant<_No_realloc>, 499 : is_nothrow_copy_constructible<_Hash>, 500 : is_nothrow_copy_constructible<_Equal>>::value; 501 : #else 502 : if constexpr (_No_realloc) 503 : if constexpr (is_nothrow_copy_constructible<_Hash>()) 504 : return is_nothrow_copy_constructible<_Equal>(); 505 : return false; 506 : #endif 507 : } 508 : 509 : _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, 510 : true_type /* alloc always equal */) 511 : noexcept(_S_nothrow_move()); 512 : 513 : _Hashtable(_Hashtable&&, __node_alloc_type&&, 514 : false_type /* alloc always equal */); 515 : 516 : template<typename _InputIterator> 517 : _Hashtable(_InputIterator __first, _InputIterator __last, 518 : size_type __bkt_count_hint, 519 : const _Hash&, const _Equal&, const allocator_type&, 520 : true_type __uks); 521 : 522 : template<typename _InputIterator> 523 : _Hashtable(_InputIterator __first, _InputIterator __last, 524 : size_type __bkt_count_hint, 525 : const _Hash&, const _Equal&, const allocator_type&, 526 : false_type __uks); 527 : 528 : public: 529 : // Constructor, destructor, assignment, swap 530 123656 : _Hashtable() = default; 531 : 532 : _Hashtable(const _Hashtable&); 533 : 534 : _Hashtable(const _Hashtable&, const allocator_type&); 535 : 536 : explicit 537 : _Hashtable(size_type __bkt_count_hint, 538 : const _Hash& __hf = _Hash(), 539 : const key_equal& __eql = key_equal(), 540 : const allocator_type& __a = allocator_type()); 541 : 542 : // Use delegating constructors. 543 : _Hashtable(_Hashtable&& __ht) 544 : noexcept(_S_nothrow_move()) 545 : : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()), 546 : true_type{}) 547 : { } 548 : 549 : _Hashtable(_Hashtable&& __ht, const allocator_type& __a) 550 : noexcept(_S_nothrow_move<__node_alloc_traits::_S_always_equal()>()) 551 : : _Hashtable(std::move(__ht), __node_alloc_type(__a), 552 : typename __node_alloc_traits::is_always_equal{}) 553 : { } 554 : 555 : explicit 556 : _Hashtable(const allocator_type& __a) 557 : : __hashtable_alloc(__node_alloc_type(__a)), 558 : __enable_default_ctor(_Enable_default_constructor_tag{}) 559 : { } 560 : 561 : template<typename _InputIterator> 562 : _Hashtable(_InputIterator __f, _InputIterator __l, 563 : size_type __bkt_count_hint = 0, 564 : const _Hash& __hf = _Hash(), 565 : const key_equal& __eql = key_equal(), 566 : const allocator_type& __a = allocator_type()) 567 : : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a, 568 : __unique_keys{}) 569 : { } 570 : 571 : _Hashtable(initializer_list<value_type> __l, 572 : size_type __bkt_count_hint = 0, 573 : const _Hash& __hf = _Hash(), 574 : const key_equal& __eql = key_equal(), 575 : const allocator_type& __a = allocator_type()) 576 : : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint, 577 : __hf, __eql, __a, __unique_keys{}) 578 : { } 579 : 580 : _Hashtable& 581 : operator=(const _Hashtable& __ht); 582 : 583 : _Hashtable& 584 : operator=(_Hashtable&& __ht) 585 : noexcept(__node_alloc_traits::_S_nothrow_move() 586 : && is_nothrow_move_assignable<_Hash>::value 587 : && is_nothrow_move_assignable<_Equal>::value) 588 : { 589 : constexpr bool __move_storage = 590 : __node_alloc_traits::_S_propagate_on_move_assign() 591 : || __node_alloc_traits::_S_always_equal(); 592 : _M_move_assign(std::move(__ht), __bool_constant<__move_storage>()); 593 : return *this; 594 : } 595 : 596 : _Hashtable& 597 : operator=(initializer_list<value_type> __l) 598 : { 599 : __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); 600 : _M_before_begin._M_nxt = nullptr; 601 : clear(); 602 : 603 : // We consider that all elements of __l are going to be inserted. 604 : auto __l_bkt_count = _M_rehash_policy._M_bkt_for_elements(__l.size()); 605 : 606 : // Do not shrink to keep potential user reservation. 607 : if (_M_bucket_count < __l_bkt_count) 608 : rehash(__l_bkt_count); 609 : 610 : this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys{}); 611 : return *this; 612 : } 613 : 614 : ~_Hashtable() noexcept; 615 : 616 : void 617 : swap(_Hashtable&) 618 : noexcept(__and_<__is_nothrow_swappable<_Hash>, 619 : __is_nothrow_swappable<_Equal>>::value); 620 : 621 : // Basic container operations 622 : iterator 623 153448 : begin() noexcept 624 153448 : { return iterator(_M_begin()); } 625 : 626 : const_iterator 627 : begin() const noexcept 628 : { return const_iterator(_M_begin()); } 629 : 630 : iterator 631 284938 : end() noexcept 632 284938 : { return iterator(nullptr); } 633 : 634 : const_iterator 635 : end() const noexcept 636 : { return const_iterator(nullptr); } 637 : 638 : const_iterator 639 : cbegin() const noexcept 640 : { return const_iterator(_M_begin()); } 641 : 642 : const_iterator 643 : cend() const noexcept 644 : { return const_iterator(nullptr); } 645 : 646 : size_type 647 194614 : size() const noexcept 648 194614 : { return _M_element_count; } 649 : 650 : _GLIBCXX_NODISCARD bool 651 : empty() const noexcept 652 : { return size() == 0; } 653 : 654 : allocator_type 655 : get_allocator() const noexcept 656 : { return allocator_type(this->_M_node_allocator()); } 657 : 658 : size_type 659 : max_size() const noexcept 660 : { return __node_alloc_traits::max_size(this->_M_node_allocator()); } 661 : 662 : // Observers 663 : key_equal 664 : key_eq() const 665 : { return this->_M_eq(); } 666 : 667 : // hash_function, if present, comes from _Hash_code_base. 668 : 669 : // Bucket operations 670 : size_type 671 : bucket_count() const noexcept 672 : { return _M_bucket_count; } 673 : 674 : size_type 675 : max_bucket_count() const noexcept 676 : { return max_size(); } 677 : 678 : size_type 679 : bucket_size(size_type __bkt) const 680 : { return std::distance(begin(__bkt), end(__bkt)); } 681 : 682 : size_type 683 : bucket(const key_type& __k) const 684 : { return _M_bucket_index(this->_M_hash_code(__k)); } 685 : 686 : local_iterator 687 : begin(size_type __bkt) 688 : { 689 : return local_iterator(*this, _M_bucket_begin(__bkt), 690 : __bkt, _M_bucket_count); 691 : } 692 : 693 : local_iterator 694 : end(size_type __bkt) 695 : { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); } 696 : 697 : const_local_iterator 698 : begin(size_type __bkt) const 699 : { 700 : return const_local_iterator(*this, _M_bucket_begin(__bkt), 701 : __bkt, _M_bucket_count); 702 : } 703 : 704 : const_local_iterator 705 : end(size_type __bkt) const 706 : { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } 707 : 708 : // DR 691. 709 : const_local_iterator 710 : cbegin(size_type __bkt) const 711 : { 712 : return const_local_iterator(*this, _M_bucket_begin(__bkt), 713 : __bkt, _M_bucket_count); 714 : } 715 : 716 : const_local_iterator 717 : cend(size_type __bkt) const 718 : { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } 719 : 720 : float 721 : load_factor() const noexcept 722 : { 723 : return static_cast<float>(size()) / static_cast<float>(bucket_count()); 724 : } 725 : 726 : // max_load_factor, if present, comes from _Rehash_base. 727 : 728 : // Generalization of max_load_factor. Extension, not found in 729 : // TR1. Only useful if _RehashPolicy is something other than 730 : // the default. 731 : const _RehashPolicy& 732 : __rehash_policy() const 733 : { return _M_rehash_policy; } 734 : 735 : void 736 : __rehash_policy(const _RehashPolicy& __pol) 737 : { _M_rehash_policy = __pol; } 738 : 739 : // Lookup. 740 : iterator 741 : find(const key_type& __k); 742 : 743 : const_iterator 744 : find(const key_type& __k) const; 745 : 746 : size_type 747 : count(const key_type& __k) const; 748 : 749 : std::pair<iterator, iterator> 750 : equal_range(const key_type& __k); 751 : 752 : std::pair<const_iterator, const_iterator> 753 : equal_range(const key_type& __k) const; 754 : 755 : #if __cplusplus >= 202002L 756 : #define __cpp_lib_generic_unordered_lookup 201811L 757 : 758 : template<typename _Kt, 759 : typename = __has_is_transparent_t<_Hash, _Kt>, 760 : typename = __has_is_transparent_t<_Equal, _Kt>> 761 : iterator 762 : _M_find_tr(const _Kt& __k); 763 : 764 : template<typename _Kt, 765 : typename = __has_is_transparent_t<_Hash, _Kt>, 766 : typename = __has_is_transparent_t<_Equal, _Kt>> 767 : const_iterator 768 : _M_find_tr(const _Kt& __k) const; 769 : 770 : template<typename _Kt, 771 : typename = __has_is_transparent_t<_Hash, _Kt>, 772 : typename = __has_is_transparent_t<_Equal, _Kt>> 773 : size_type 774 : _M_count_tr(const _Kt& __k) const; 775 : 776 : template<typename _Kt, 777 : typename = __has_is_transparent_t<_Hash, _Kt>, 778 : typename = __has_is_transparent_t<_Equal, _Kt>> 779 : pair<iterator, iterator> 780 : _M_equal_range_tr(const _Kt& __k); 781 : 782 : template<typename _Kt, 783 : typename = __has_is_transparent_t<_Hash, _Kt>, 784 : typename = __has_is_transparent_t<_Equal, _Kt>> 785 : pair<const_iterator, const_iterator> 786 : _M_equal_range_tr(const _Kt& __k) const; 787 : #endif // C++20 788 : 789 : private: 790 : // Bucket index computation helpers. 791 : size_type 792 184146 : _M_bucket_index(const __node_value_type& __n) const noexcept 793 184146 : { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); } 794 : 795 : size_type 796 6106460 : _M_bucket_index(__hash_code __c) const 797 6106460 : { return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); } 798 : 799 : __node_base_ptr 800 : _M_find_before_node(const key_type&); 801 : 802 : // Find and insert helper functions and types 803 : // Find the node before the one matching the criteria. 804 : __node_base_ptr 805 : _M_find_before_node(size_type, const key_type&, __hash_code) const; 806 : 807 : template<typename _Kt> 808 : __node_base_ptr 809 : _M_find_before_node_tr(size_type, const _Kt&, __hash_code) const; 810 : 811 : __node_ptr 812 5928642 : _M_find_node(size_type __bkt, const key_type& __key, 813 : __hash_code __c) const 814 : { 815 5928642 : __node_base_ptr __before_n = _M_find_before_node(__bkt, __key, __c); 816 5928642 : if (__before_n) 817 5724128 : return static_cast<__node_ptr>(__before_n->_M_nxt); 818 204514 : return nullptr; 819 : } 820 : 821 : template<typename _Kt> 822 : __node_ptr 823 2832 : _M_find_node_tr(size_type __bkt, const _Kt& __key, 824 : __hash_code __c) const 825 : { 826 2832 : auto __before_n = _M_find_before_node_tr(__bkt, __key, __c); 827 2832 : if (__before_n) 828 2 : return static_cast<__node_ptr>(__before_n->_M_nxt); 829 2830 : return nullptr; 830 : } 831 : 832 : // Insert a node at the beginning of a bucket. 833 : void 834 : _M_insert_bucket_begin(size_type, __node_ptr); 835 : 836 : // Remove the bucket first node 837 : void 838 : _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n, 839 : size_type __next_bkt); 840 : 841 : // Get the node before __n in the bucket __bkt 842 : __node_base_ptr 843 : _M_get_previous_node(size_type __bkt, __node_ptr __n); 844 : 845 : pair<const_iterator, __hash_code> 846 : _M_compute_hash_code(const_iterator __hint, const key_type& __k) const; 847 : 848 : // Insert node __n with hash code __code, in bucket __bkt if no 849 : // rehash (assumes no element with same key already present). 850 : // Takes ownership of __n if insertion succeeds, throws otherwise. 851 : iterator 852 : _M_insert_unique_node(size_type __bkt, __hash_code, 853 : __node_ptr __n, size_type __n_elt = 1); 854 : 855 : // Insert node __n with key __k and hash code __code. 856 : // Takes ownership of __n if insertion succeeds, throws otherwise. 857 : iterator 858 : _M_insert_multi_node(__node_ptr __hint, 859 : __hash_code __code, __node_ptr __n); 860 : 861 : template<typename... _Args> 862 : std::pair<iterator, bool> 863 : _M_emplace(true_type __uks, _Args&&... __args); 864 : 865 : template<typename... _Args> 866 : iterator 867 : _M_emplace(false_type __uks, _Args&&... __args) 868 : { return _M_emplace(cend(), __uks, std::forward<_Args>(__args)...); } 869 : 870 : // Emplace with hint, useless when keys are unique. 871 : template<typename... _Args> 872 : iterator 873 : _M_emplace(const_iterator, true_type __uks, _Args&&... __args) 874 : { return _M_emplace(__uks, std::forward<_Args>(__args)...).first; } 875 : 876 : template<typename... _Args> 877 : iterator 878 : _M_emplace(const_iterator, false_type __uks, _Args&&... __args); 879 : 880 : template<typename _Kt, typename _Arg, typename _NodeGenerator> 881 : std::pair<iterator, bool> 882 : _M_insert_unique(_Kt&&, _Arg&&, const _NodeGenerator&); 883 : 884 : template<typename _Kt> 885 : static __conditional_t< 886 : __and_<__is_nothrow_invocable<_Hash&, const key_type&>, 887 : __not_<__is_nothrow_invocable<_Hash&, _Kt>>>::value, 888 : key_type, _Kt&&> 889 : _S_forward_key(_Kt&& __k) 890 : { return std::forward<_Kt>(__k); } 891 : 892 : static const key_type& 893 61166 : _S_forward_key(const key_type& __k) 894 61166 : { return __k; } 895 : 896 : static key_type&& 897 : _S_forward_key(key_type&& __k) 898 : { return std::move(__k); } 899 : 900 : template<typename _Arg, typename _NodeGenerator> 901 : std::pair<iterator, bool> 902 61166 : _M_insert_unique_aux(_Arg&& __arg, const _NodeGenerator& __node_gen) 903 : { 904 122332 : return _M_insert_unique( 905 122332 : _S_forward_key(_ExtractKey{}(std::forward<_Arg>(__arg))), 906 122332 : std::forward<_Arg>(__arg), __node_gen); 907 : } 908 : 909 : template<typename _Arg, typename _NodeGenerator> 910 : std::pair<iterator, bool> 911 61166 : _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, 912 : true_type /* __uks */) 913 : { 914 : using __to_value 915 : = __detail::_ConvertToValueType<_ExtractKey, value_type>; 916 122332 : return _M_insert_unique_aux( 917 122332 : __to_value{}(std::forward<_Arg>(__arg)), __node_gen); 918 : } 919 : 920 : template<typename _Arg, typename _NodeGenerator> 921 : iterator 922 : _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, 923 : false_type __uks) 924 : { 925 : using __to_value 926 : = __detail::_ConvertToValueType<_ExtractKey, value_type>; 927 : return _M_insert(cend(), 928 : __to_value{}(std::forward<_Arg>(__arg)), __node_gen, __uks); 929 : } 930 : 931 : // Insert with hint, not used when keys are unique. 932 : template<typename _Arg, typename _NodeGenerator> 933 : iterator 934 : _M_insert(const_iterator, _Arg&& __arg, 935 : const _NodeGenerator& __node_gen, true_type __uks) 936 : { 937 : return 938 : _M_insert(std::forward<_Arg>(__arg), __node_gen, __uks).first; 939 : } 940 : 941 : // Insert with hint when keys are not unique. 942 : template<typename _Arg, typename _NodeGenerator> 943 : iterator 944 : _M_insert(const_iterator, _Arg&&, 945 : const _NodeGenerator&, false_type __uks); 946 : 947 : size_type 948 : _M_erase(true_type __uks, const key_type&); 949 : 950 : size_type 951 : _M_erase(false_type __uks, const key_type&); 952 : 953 : iterator 954 : _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n); 955 : 956 : public: 957 : // Emplace 958 : template<typename... _Args> 959 : __ireturn_type 960 30 : emplace(_Args&&... __args) 961 30 : { return _M_emplace(__unique_keys{}, std::forward<_Args>(__args)...); } 962 : 963 : template<typename... _Args> 964 : iterator 965 : emplace_hint(const_iterator __hint, _Args&&... __args) 966 : { 967 : return _M_emplace(__hint, __unique_keys{}, 968 : std::forward<_Args>(__args)...); 969 : } 970 : 971 : // Insert member functions via inheritance. 972 : 973 : // Erase 974 : iterator 975 : erase(const_iterator); 976 : 977 : // LWG 2059. 978 : iterator 979 : erase(iterator __it) 980 : { return erase(const_iterator(__it)); } 981 : 982 : size_type 983 30520 : erase(const key_type& __k) 984 30520 : { return _M_erase(__unique_keys{}, __k); } 985 : 986 : iterator 987 : erase(const_iterator, const_iterator); 988 : 989 : void 990 : clear() noexcept; 991 : 992 : // Set number of buckets keeping it appropriate for container's number 993 : // of elements. 994 : void rehash(size_type __bkt_count); 995 : 996 : // DR 1189. 997 : // reserve, if present, comes from _Rehash_base. 998 : 999 : #if __cplusplus > 201402L 1000 : /// Re-insert an extracted node into a container with unique keys. 1001 : insert_return_type 1002 : _M_reinsert_node(node_type&& __nh) 1003 : { 1004 : insert_return_type __ret; 1005 : if (__nh.empty()) 1006 : __ret.position = end(); 1007 : else 1008 : { 1009 : __glibcxx_assert(get_allocator() == __nh.get_allocator()); 1010 : 1011 : const key_type& __k = __nh._M_key(); 1012 : __hash_code __code = this->_M_hash_code(__k); 1013 : size_type __bkt = _M_bucket_index(__code); 1014 : if (__node_ptr __n = _M_find_node(__bkt, __k, __code)) 1015 : { 1016 : __ret.node = std::move(__nh); 1017 : __ret.position = iterator(__n); 1018 : __ret.inserted = false; 1019 : } 1020 : else 1021 : { 1022 : __ret.position 1023 : = _M_insert_unique_node(__bkt, __code, __nh._M_ptr); 1024 : __nh._M_ptr = nullptr; 1025 : __ret.inserted = true; 1026 : } 1027 : } 1028 : return __ret; 1029 : } 1030 : 1031 : /// Re-insert an extracted node into a container with equivalent keys. 1032 : iterator 1033 : _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh) 1034 : { 1035 : if (__nh.empty()) 1036 : return end(); 1037 : 1038 : __glibcxx_assert(get_allocator() == __nh.get_allocator()); 1039 : 1040 : const key_type& __k = __nh._M_key(); 1041 : auto __code = this->_M_hash_code(__k); 1042 : auto __ret 1043 : = _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr); 1044 : __nh._M_ptr = nullptr; 1045 : return __ret; 1046 : } 1047 : 1048 : private: 1049 : node_type 1050 : _M_extract_node(size_t __bkt, __node_base_ptr __prev_n) 1051 : { 1052 : __node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt); 1053 : if (__prev_n == _M_buckets[__bkt]) 1054 : _M_remove_bucket_begin(__bkt, __n->_M_next(), 1055 : __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); 1056 : else if (__n->_M_nxt) 1057 : { 1058 : size_type __next_bkt = _M_bucket_index(*__n->_M_next()); 1059 : if (__next_bkt != __bkt) 1060 : _M_buckets[__next_bkt] = __prev_n; 1061 : } 1062 : 1063 : __prev_n->_M_nxt = __n->_M_nxt; 1064 : __n->_M_nxt = nullptr; 1065 : --_M_element_count; 1066 : return { __n, this->_M_node_allocator() }; 1067 : } 1068 : 1069 : // Only use the possibly cached node's hash code if its hash function 1070 : // _H2 matches _Hash and is stateless. Otherwise recompute it using _Hash. 1071 : template<typename _H2> 1072 : __hash_code 1073 : _M_src_hash_code(const _H2&, const key_type& __k, 1074 : const __node_value_type& __src_n) const 1075 : { 1076 : if constexpr (std::is_same_v<_H2, _Hash>) 1077 : if constexpr (std::is_empty_v<_Hash>) 1078 : return this->_M_hash_code(__src_n); 1079 : 1080 : return this->_M_hash_code(__k); 1081 : } 1082 : 1083 : public: 1084 : // Extract a node. 1085 : node_type 1086 : extract(const_iterator __pos) 1087 : { 1088 : size_t __bkt = _M_bucket_index(*__pos._M_cur); 1089 : return _M_extract_node(__bkt, 1090 : _M_get_previous_node(__bkt, __pos._M_cur)); 1091 : } 1092 : 1093 : /// Extract a node. 1094 : node_type 1095 : extract(const _Key& __k) 1096 : { 1097 : node_type __nh; 1098 : __hash_code __code = this->_M_hash_code(__k); 1099 : std::size_t __bkt = _M_bucket_index(__code); 1100 : if (__node_base_ptr __prev_node = _M_find_before_node(__bkt, __k, __code)) 1101 : __nh = _M_extract_node(__bkt, __prev_node); 1102 : return __nh; 1103 : } 1104 : 1105 : /// Merge from a compatible container into one with unique keys. 1106 : template<typename _Compatible_Hashtable> 1107 : void 1108 : _M_merge_unique(_Compatible_Hashtable& __src) 1109 : { 1110 : static_assert(is_same_v<typename _Compatible_Hashtable::node_type, 1111 : node_type>, "Node types are compatible"); 1112 : __glibcxx_assert(get_allocator() == __src.get_allocator()); 1113 : 1114 : auto __n_elt = __src.size(); 1115 : for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) 1116 : { 1117 : auto __pos = __i++; 1118 : const key_type& __k = _ExtractKey{}(*__pos); 1119 : __hash_code __code 1120 : = _M_src_hash_code(__src.hash_function(), __k, *__pos._M_cur); 1121 : size_type __bkt = _M_bucket_index(__code); 1122 : if (_M_find_node(__bkt, __k, __code) == nullptr) 1123 : { 1124 : auto __nh = __src.extract(__pos); 1125 : _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt); 1126 : __nh._M_ptr = nullptr; 1127 : __n_elt = 1; 1128 : } 1129 : else if (__n_elt != 1) 1130 : --__n_elt; 1131 : } 1132 : } 1133 : 1134 : /// Merge from a compatible container into one with equivalent keys. 1135 : template<typename _Compatible_Hashtable> 1136 : void 1137 : _M_merge_multi(_Compatible_Hashtable& __src) 1138 : { 1139 : static_assert(is_same_v<typename _Compatible_Hashtable::node_type, 1140 : node_type>, "Node types are compatible"); 1141 : __glibcxx_assert(get_allocator() == __src.get_allocator()); 1142 : 1143 : __node_ptr __hint = nullptr; 1144 : this->reserve(size() + __src.size()); 1145 : for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) 1146 : { 1147 : auto __pos = __i++; 1148 : const key_type& __k = _ExtractKey{}(*__pos); 1149 : __hash_code __code 1150 : = _M_src_hash_code(__src.hash_function(), __k, *__pos._M_cur); 1151 : auto __nh = __src.extract(__pos); 1152 : __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur; 1153 : __nh._M_ptr = nullptr; 1154 : } 1155 : } 1156 : #endif // C++17 1157 : 1158 : private: 1159 : // Helper rehash method used when keys are unique. 1160 : void _M_rehash_aux(size_type __bkt_count, true_type __uks); 1161 : 1162 : // Helper rehash method used when keys can be non-unique. 1163 : void _M_rehash_aux(size_type __bkt_count, false_type __uks); 1164 : 1165 : // Unconditionally change size of bucket array to n, restore 1166 : // hash policy state to __state on exception. 1167 : void _M_rehash(size_type __bkt_count, const __rehash_state& __state); 1168 : }; 1169 : 1170 : // Definitions of class template _Hashtable's out-of-line member functions. 1171 : template<typename _Key, typename _Value, typename _Alloc, 1172 : typename _ExtractKey, typename _Equal, 1173 : typename _Hash, typename _RangeHash, typename _Unused, 1174 : typename _RehashPolicy, typename _Traits> 1175 : auto 1176 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1177 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1178 : _M_bucket_begin(size_type __bkt) const 1179 : -> __node_ptr 1180 : { 1181 : __node_base_ptr __n = _M_buckets[__bkt]; 1182 : return __n ? static_cast<__node_ptr>(__n->_M_nxt) : nullptr; 1183 : } 1184 : 1185 : template<typename _Key, typename _Value, typename _Alloc, 1186 : typename _ExtractKey, typename _Equal, 1187 : typename _Hash, typename _RangeHash, typename _Unused, 1188 : typename _RehashPolicy, typename _Traits> 1189 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1190 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1191 : _Hashtable(size_type __bkt_count_hint, 1192 : const _Hash& __h, const _Equal& __eq, const allocator_type& __a) 1193 : : _Hashtable(__h, __eq, __a) 1194 : { 1195 : auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint); 1196 : if (__bkt_count > _M_bucket_count) 1197 : { 1198 : _M_buckets = _M_allocate_buckets(__bkt_count); 1199 : _M_bucket_count = __bkt_count; 1200 : } 1201 : } 1202 : 1203 : template<typename _Key, typename _Value, typename _Alloc, 1204 : typename _ExtractKey, typename _Equal, 1205 : typename _Hash, typename _RangeHash, typename _Unused, 1206 : typename _RehashPolicy, typename _Traits> 1207 : template<typename _InputIterator> 1208 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1209 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1210 : _Hashtable(_InputIterator __f, _InputIterator __l, 1211 : size_type __bkt_count_hint, 1212 : const _Hash& __h, const _Equal& __eq, 1213 : const allocator_type& __a, true_type /* __uks */) 1214 : : _Hashtable(__bkt_count_hint, __h, __eq, __a) 1215 : { this->insert(__f, __l); } 1216 : 1217 : template<typename _Key, typename _Value, typename _Alloc, 1218 : typename _ExtractKey, typename _Equal, 1219 : typename _Hash, typename _RangeHash, typename _Unused, 1220 : typename _RehashPolicy, typename _Traits> 1221 : template<typename _InputIterator> 1222 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1223 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1224 : _Hashtable(_InputIterator __f, _InputIterator __l, 1225 : size_type __bkt_count_hint, 1226 : const _Hash& __h, const _Equal& __eq, 1227 : const allocator_type& __a, false_type __uks) 1228 : : _Hashtable(__h, __eq, __a) 1229 : { 1230 : auto __nb_elems = __detail::__distance_fw(__f, __l); 1231 : auto __bkt_count = 1232 : _M_rehash_policy._M_next_bkt( 1233 : std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems), 1234 : __bkt_count_hint)); 1235 : 1236 : if (__bkt_count > _M_bucket_count) 1237 : { 1238 : _M_buckets = _M_allocate_buckets(__bkt_count); 1239 : _M_bucket_count = __bkt_count; 1240 : } 1241 : 1242 : __alloc_node_gen_t __node_gen(*this); 1243 : for (; __f != __l; ++__f) 1244 : _M_insert(*__f, __node_gen, __uks); 1245 : } 1246 : 1247 : template<typename _Key, typename _Value, typename _Alloc, 1248 : typename _ExtractKey, typename _Equal, 1249 : typename _Hash, typename _RangeHash, typename _Unused, 1250 : typename _RehashPolicy, typename _Traits> 1251 : auto 1252 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1253 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1254 : operator=(const _Hashtable& __ht) 1255 : -> _Hashtable& 1256 : { 1257 : if (&__ht == this) 1258 : return *this; 1259 : 1260 : if (__node_alloc_traits::_S_propagate_on_copy_assign()) 1261 : { 1262 : auto& __this_alloc = this->_M_node_allocator(); 1263 : auto& __that_alloc = __ht._M_node_allocator(); 1264 : if (!__node_alloc_traits::_S_always_equal() 1265 : && __this_alloc != __that_alloc) 1266 : { 1267 : // Replacement allocator cannot free existing storage. 1268 : this->_M_deallocate_nodes(_M_begin()); 1269 : _M_before_begin._M_nxt = nullptr; 1270 : _M_deallocate_buckets(); 1271 : _M_buckets = nullptr; 1272 : std::__alloc_on_copy(__this_alloc, __that_alloc); 1273 : __hashtable_base::operator=(__ht); 1274 : _M_bucket_count = __ht._M_bucket_count; 1275 : _M_element_count = __ht._M_element_count; 1276 : _M_rehash_policy = __ht._M_rehash_policy; 1277 : __alloc_node_gen_t __alloc_node_gen(*this); 1278 : __try 1279 : { 1280 : _M_assign(__ht, __alloc_node_gen); 1281 : } 1282 : __catch(...) 1283 : { 1284 : // _M_assign took care of deallocating all memory. Now we 1285 : // must make sure this instance remains in a usable state. 1286 : _M_reset(); 1287 : __throw_exception_again; 1288 : } 1289 : return *this; 1290 : } 1291 : std::__alloc_on_copy(__this_alloc, __that_alloc); 1292 : } 1293 : 1294 : // Reuse allocated buckets and nodes. 1295 : _M_assign_elements(__ht); 1296 : return *this; 1297 : } 1298 : 1299 : template<typename _Key, typename _Value, typename _Alloc, 1300 : typename _ExtractKey, typename _Equal, 1301 : typename _Hash, typename _RangeHash, typename _Unused, 1302 : typename _RehashPolicy, typename _Traits> 1303 : template<typename _Ht> 1304 : void 1305 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1306 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1307 : _M_assign_elements(_Ht&& __ht) 1308 : { 1309 : __buckets_ptr __former_buckets = nullptr; 1310 : std::size_t __former_bucket_count = _M_bucket_count; 1311 : const __rehash_state& __former_state = _M_rehash_policy._M_state(); 1312 : 1313 : if (_M_bucket_count != __ht._M_bucket_count) 1314 : { 1315 : __former_buckets = _M_buckets; 1316 : _M_buckets = _M_allocate_buckets(__ht._M_bucket_count); 1317 : _M_bucket_count = __ht._M_bucket_count; 1318 : } 1319 : else 1320 : __builtin_memset(_M_buckets, 0, 1321 : _M_bucket_count * sizeof(__node_base_ptr)); 1322 : 1323 : __try 1324 : { 1325 : __hashtable_base::operator=(std::forward<_Ht>(__ht)); 1326 : _M_element_count = __ht._M_element_count; 1327 : _M_rehash_policy = __ht._M_rehash_policy; 1328 : __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); 1329 : _M_before_begin._M_nxt = nullptr; 1330 : _M_assign(std::forward<_Ht>(__ht), __roan); 1331 : if (__former_buckets) 1332 : _M_deallocate_buckets(__former_buckets, __former_bucket_count); 1333 : } 1334 : __catch(...) 1335 : { 1336 : if (__former_buckets) 1337 : { 1338 : // Restore previous buckets. 1339 : _M_deallocate_buckets(); 1340 : _M_rehash_policy._M_reset(__former_state); 1341 : _M_buckets = __former_buckets; 1342 : _M_bucket_count = __former_bucket_count; 1343 : } 1344 : __builtin_memset(_M_buckets, 0, 1345 : _M_bucket_count * sizeof(__node_base_ptr)); 1346 : __throw_exception_again; 1347 : } 1348 : } 1349 : 1350 : template<typename _Key, typename _Value, typename _Alloc, 1351 : typename _ExtractKey, typename _Equal, 1352 : typename _Hash, typename _RangeHash, typename _Unused, 1353 : typename _RehashPolicy, typename _Traits> 1354 : template<typename _Ht, typename _NodeGenerator> 1355 : void 1356 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1357 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1358 : _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen) 1359 : { 1360 : __buckets_ptr __buckets = nullptr; 1361 : if (!_M_buckets) 1362 : _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count); 1363 : 1364 : __try 1365 : { 1366 : if (!__ht._M_before_begin._M_nxt) 1367 : return; 1368 : 1369 : // First deal with the special first node pointed to by 1370 : // _M_before_begin. 1371 : __node_ptr __ht_n = __ht._M_begin(); 1372 : __node_ptr __this_n 1373 : = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); 1374 : this->_M_copy_code(*__this_n, *__ht_n); 1375 : _M_update_bbegin(__this_n); 1376 : 1377 : // Then deal with other nodes. 1378 : __node_ptr __prev_n = __this_n; 1379 : for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) 1380 : { 1381 : __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); 1382 : __prev_n->_M_nxt = __this_n; 1383 : this->_M_copy_code(*__this_n, *__ht_n); 1384 : size_type __bkt = _M_bucket_index(*__this_n); 1385 : if (!_M_buckets[__bkt]) 1386 : _M_buckets[__bkt] = __prev_n; 1387 : __prev_n = __this_n; 1388 : } 1389 : } 1390 : __catch(...) 1391 : { 1392 : clear(); 1393 : if (__buckets) 1394 : _M_deallocate_buckets(); 1395 : __throw_exception_again; 1396 : } 1397 : } 1398 : 1399 : template<typename _Key, typename _Value, typename _Alloc, 1400 : typename _ExtractKey, typename _Equal, 1401 : typename _Hash, typename _RangeHash, typename _Unused, 1402 : typename _RehashPolicy, typename _Traits> 1403 : void 1404 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1405 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1406 : _M_reset() noexcept 1407 : { 1408 : _M_rehash_policy._M_reset(); 1409 : _M_bucket_count = 1; 1410 : _M_single_bucket = nullptr; 1411 : _M_buckets = &_M_single_bucket; 1412 : _M_before_begin._M_nxt = nullptr; 1413 : _M_element_count = 0; 1414 : } 1415 : 1416 : template<typename _Key, typename _Value, typename _Alloc, 1417 : typename _ExtractKey, typename _Equal, 1418 : typename _Hash, typename _RangeHash, typename _Unused, 1419 : typename _RehashPolicy, typename _Traits> 1420 : void 1421 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1422 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1423 : _M_move_assign(_Hashtable&& __ht, true_type) 1424 : { 1425 : if (__builtin_expect(std::__addressof(__ht) == this, false)) 1426 : return; 1427 : 1428 : this->_M_deallocate_nodes(_M_begin()); 1429 : _M_deallocate_buckets(); 1430 : __hashtable_base::operator=(std::move(__ht)); 1431 : _M_rehash_policy = __ht._M_rehash_policy; 1432 : if (!__ht._M_uses_single_bucket()) 1433 : _M_buckets = __ht._M_buckets; 1434 : else 1435 : { 1436 : _M_buckets = &_M_single_bucket; 1437 : _M_single_bucket = __ht._M_single_bucket; 1438 : } 1439 : 1440 : _M_bucket_count = __ht._M_bucket_count; 1441 : _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; 1442 : _M_element_count = __ht._M_element_count; 1443 : std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator()); 1444 : 1445 : // Fix bucket containing the _M_before_begin pointer that can't be moved. 1446 : _M_update_bbegin(); 1447 : __ht._M_reset(); 1448 : } 1449 : 1450 : template<typename _Key, typename _Value, typename _Alloc, 1451 : typename _ExtractKey, typename _Equal, 1452 : typename _Hash, typename _RangeHash, typename _Unused, 1453 : typename _RehashPolicy, typename _Traits> 1454 : void 1455 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1456 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1457 : _M_move_assign(_Hashtable&& __ht, false_type) 1458 : { 1459 : if (__ht._M_node_allocator() == this->_M_node_allocator()) 1460 : _M_move_assign(std::move(__ht), true_type{}); 1461 : else 1462 : { 1463 : // Can't move memory, move elements then. 1464 : _M_assign_elements(std::move(__ht)); 1465 : __ht.clear(); 1466 : } 1467 : } 1468 : 1469 : template<typename _Key, typename _Value, typename _Alloc, 1470 : typename _ExtractKey, typename _Equal, 1471 : typename _Hash, typename _RangeHash, typename _Unused, 1472 : typename _RehashPolicy, typename _Traits> 1473 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1474 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1475 : _Hashtable(const _Hashtable& __ht) 1476 : : __hashtable_base(__ht), 1477 : __map_base(__ht), 1478 : __rehash_base(__ht), 1479 : __hashtable_alloc( 1480 : __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())), 1481 : __enable_default_ctor(__ht), 1482 : _M_buckets(nullptr), 1483 : _M_bucket_count(__ht._M_bucket_count), 1484 : _M_element_count(__ht._M_element_count), 1485 : _M_rehash_policy(__ht._M_rehash_policy) 1486 : { 1487 : __alloc_node_gen_t __alloc_node_gen(*this); 1488 : _M_assign(__ht, __alloc_node_gen); 1489 : } 1490 : 1491 : template<typename _Key, typename _Value, typename _Alloc, 1492 : typename _ExtractKey, typename _Equal, 1493 : typename _Hash, typename _RangeHash, typename _Unused, 1494 : typename _RehashPolicy, typename _Traits> 1495 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1496 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1497 : _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, 1498 : true_type /* alloc always equal */) 1499 : noexcept(_S_nothrow_move()) 1500 : : __hashtable_base(__ht), 1501 : __map_base(__ht), 1502 : __rehash_base(__ht), 1503 : __hashtable_alloc(std::move(__a)), 1504 : __enable_default_ctor(__ht), 1505 : _M_buckets(__ht._M_buckets), 1506 : _M_bucket_count(__ht._M_bucket_count), 1507 : _M_before_begin(__ht._M_before_begin._M_nxt), 1508 : _M_element_count(__ht._M_element_count), 1509 : _M_rehash_policy(__ht._M_rehash_policy) 1510 : { 1511 : // Update buckets if __ht is using its single bucket. 1512 : if (__ht._M_uses_single_bucket()) 1513 : { 1514 : _M_buckets = &_M_single_bucket; 1515 : _M_single_bucket = __ht._M_single_bucket; 1516 : } 1517 : 1518 : // Fix bucket containing the _M_before_begin pointer that can't be moved. 1519 : _M_update_bbegin(); 1520 : 1521 : __ht._M_reset(); 1522 : } 1523 : 1524 : template<typename _Key, typename _Value, typename _Alloc, 1525 : typename _ExtractKey, typename _Equal, 1526 : typename _Hash, typename _RangeHash, typename _Unused, 1527 : typename _RehashPolicy, typename _Traits> 1528 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1529 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1530 : _Hashtable(const _Hashtable& __ht, const allocator_type& __a) 1531 : : __hashtable_base(__ht), 1532 : __map_base(__ht), 1533 : __rehash_base(__ht), 1534 : __hashtable_alloc(__node_alloc_type(__a)), 1535 : __enable_default_ctor(__ht), 1536 : _M_buckets(), 1537 : _M_bucket_count(__ht._M_bucket_count), 1538 : _M_element_count(__ht._M_element_count), 1539 : _M_rehash_policy(__ht._M_rehash_policy) 1540 : { 1541 : __alloc_node_gen_t __alloc_node_gen(*this); 1542 : _M_assign(__ht, __alloc_node_gen); 1543 : } 1544 : 1545 : template<typename _Key, typename _Value, typename _Alloc, 1546 : typename _ExtractKey, typename _Equal, 1547 : typename _Hash, typename _RangeHash, typename _Unused, 1548 : typename _RehashPolicy, typename _Traits> 1549 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1550 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1551 : _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, 1552 : false_type /* alloc always equal */) 1553 : : __hashtable_base(__ht), 1554 : __map_base(__ht), 1555 : __rehash_base(__ht), 1556 : __hashtable_alloc(std::move(__a)), 1557 : __enable_default_ctor(__ht), 1558 : _M_buckets(nullptr), 1559 : _M_bucket_count(__ht._M_bucket_count), 1560 : _M_element_count(__ht._M_element_count), 1561 : _M_rehash_policy(__ht._M_rehash_policy) 1562 : { 1563 : if (__ht._M_node_allocator() == this->_M_node_allocator()) 1564 : { 1565 : if (__ht._M_uses_single_bucket()) 1566 : { 1567 : _M_buckets = &_M_single_bucket; 1568 : _M_single_bucket = __ht._M_single_bucket; 1569 : } 1570 : else 1571 : _M_buckets = __ht._M_buckets; 1572 : 1573 : // Fix bucket containing the _M_before_begin pointer that can't be 1574 : // moved. 1575 : _M_update_bbegin(__ht._M_begin()); 1576 : 1577 : __ht._M_reset(); 1578 : } 1579 : else 1580 : { 1581 : __alloc_node_gen_t __alloc_gen(*this); 1582 : 1583 : using _Fwd_Ht = __conditional_t< 1584 : __move_if_noexcept_cond<value_type>::value, 1585 : const _Hashtable&, _Hashtable&&>; 1586 : _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen); 1587 : __ht.clear(); 1588 : } 1589 : } 1590 : 1591 : template<typename _Key, typename _Value, typename _Alloc, 1592 : typename _ExtractKey, typename _Equal, 1593 : typename _Hash, typename _RangeHash, typename _Unused, 1594 : typename _RehashPolicy, typename _Traits> 1595 123656 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1596 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1597 : ~_Hashtable() noexcept 1598 : { 1599 : // Getting a bucket index from a node shall not throw because it is used 1600 : // in methods (erase, swap...) that shall not throw. Need a complete 1601 : // type to check this, so do it in the destructor not at class scope. 1602 : static_assert(noexcept(declval<const __hash_code_base_access&>() 1603 : ._M_bucket_index(declval<const __node_value_type&>(), 1604 : (std::size_t)0)), 1605 : "Cache the hash code or qualify your functors involved" 1606 : " in hash code and bucket index computation with noexcept"); 1607 : 1608 123656 : clear(); 1609 123656 : _M_deallocate_buckets(); 1610 123656 : } 1611 : 1612 : template<typename _Key, typename _Value, typename _Alloc, 1613 : typename _ExtractKey, typename _Equal, 1614 : typename _Hash, typename _RangeHash, typename _Unused, 1615 : typename _RehashPolicy, typename _Traits> 1616 : void 1617 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1618 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1619 : swap(_Hashtable& __x) 1620 : noexcept(__and_<__is_nothrow_swappable<_Hash>, 1621 : __is_nothrow_swappable<_Equal>>::value) 1622 : { 1623 : // The only base class with member variables is hash_code_base. 1624 : // We define _Hash_code_base::_M_swap because different 1625 : // specializations have different members. 1626 : this->_M_swap(__x); 1627 : 1628 : std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator()); 1629 : std::swap(_M_rehash_policy, __x._M_rehash_policy); 1630 : 1631 : // Deal properly with potentially moved instances. 1632 : if (this->_M_uses_single_bucket()) 1633 : { 1634 : if (!__x._M_uses_single_bucket()) 1635 : { 1636 : _M_buckets = __x._M_buckets; 1637 : __x._M_buckets = &__x._M_single_bucket; 1638 : } 1639 : } 1640 : else if (__x._M_uses_single_bucket()) 1641 : { 1642 : __x._M_buckets = _M_buckets; 1643 : _M_buckets = &_M_single_bucket; 1644 : } 1645 : else 1646 : std::swap(_M_buckets, __x._M_buckets); 1647 : 1648 : std::swap(_M_bucket_count, __x._M_bucket_count); 1649 : std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt); 1650 : std::swap(_M_element_count, __x._M_element_count); 1651 : std::swap(_M_single_bucket, __x._M_single_bucket); 1652 : 1653 : // Fix buckets containing the _M_before_begin pointers that can't be 1654 : // swapped. 1655 : _M_update_bbegin(); 1656 : __x._M_update_bbegin(); 1657 : } 1658 : 1659 : template<typename _Key, typename _Value, typename _Alloc, 1660 : typename _ExtractKey, typename _Equal, 1661 : typename _Hash, typename _RangeHash, typename _Unused, 1662 : typename _RehashPolicy, typename _Traits> 1663 : auto 1664 41704 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1665 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1666 : find(const key_type& __k) 1667 : -> iterator 1668 : { 1669 41704 : if (size() <= __small_size_threshold()) 1670 : { 1671 69624 : for (auto __it = begin(); __it != end(); ++__it) 1672 33476 : if (this->_M_key_equals(__k, *__it._M_cur)) 1673 8 : return __it; 1674 36148 : return end(); 1675 : } 1676 : 1677 5548 : __hash_code __code = this->_M_hash_code(__k); 1678 5548 : std::size_t __bkt = _M_bucket_index(__code); 1679 5548 : return iterator(_M_find_node(__bkt, __k, __code)); 1680 : } 1681 : 1682 : template<typename _Key, typename _Value, typename _Alloc, 1683 : typename _ExtractKey, typename _Equal, 1684 : typename _Hash, typename _RangeHash, typename _Unused, 1685 : typename _RehashPolicy, typename _Traits> 1686 : auto 1687 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1688 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1689 : find(const key_type& __k) const 1690 : -> const_iterator 1691 : { 1692 : if (size() <= __small_size_threshold()) 1693 : { 1694 : for (auto __it = begin(); __it != end(); ++__it) 1695 : if (this->_M_key_equals(__k, *__it._M_cur)) 1696 : return __it; 1697 : return end(); 1698 : } 1699 : 1700 : __hash_code __code = this->_M_hash_code(__k); 1701 : std::size_t __bkt = _M_bucket_index(__code); 1702 : return const_iterator(_M_find_node(__bkt, __k, __code)); 1703 : } 1704 : 1705 : #if __cplusplus > 201703L 1706 : template<typename _Key, typename _Value, typename _Alloc, 1707 : typename _ExtractKey, typename _Equal, 1708 : typename _Hash, typename _RangeHash, typename _Unused, 1709 : typename _RehashPolicy, typename _Traits> 1710 : template<typename _Kt, typename, typename> 1711 : auto 1712 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1713 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1714 : _M_find_tr(const _Kt& __k) 1715 : -> iterator 1716 : { 1717 : __hash_code __code = this->_M_hash_code_tr(__k); 1718 : std::size_t __bkt = _M_bucket_index(__code); 1719 : return iterator(_M_find_node_tr(__bkt, __k, __code)); 1720 : } 1721 : 1722 : template<typename _Key, typename _Value, typename _Alloc, 1723 : typename _ExtractKey, typename _Equal, 1724 : typename _Hash, typename _RangeHash, typename _Unused, 1725 : typename _RehashPolicy, typename _Traits> 1726 : template<typename _Kt, typename, typename> 1727 : auto 1728 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1729 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1730 : _M_find_tr(const _Kt& __k) const 1731 : -> const_iterator 1732 : { 1733 : __hash_code __code = this->_M_hash_code_tr(__k); 1734 : std::size_t __bkt = _M_bucket_index(__code); 1735 : return const_iterator(_M_find_node_tr(__bkt, __k, __code)); 1736 : } 1737 : #endif 1738 : 1739 : template<typename _Key, typename _Value, typename _Alloc, 1740 : typename _ExtractKey, typename _Equal, 1741 : typename _Hash, typename _RangeHash, typename _Unused, 1742 : typename _RehashPolicy, typename _Traits> 1743 : auto 1744 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1745 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1746 : count(const key_type& __k) const 1747 : -> size_type 1748 : { 1749 : auto __it = find(__k); 1750 : if (!__it._M_cur) 1751 : return 0; 1752 : 1753 : if (__unique_keys::value) 1754 : return 1; 1755 : 1756 : // All equivalent values are next to each other, if we find a 1757 : // non-equivalent value after an equivalent one it means that we won't 1758 : // find any new equivalent value. 1759 : size_type __result = 1; 1760 : for (auto __ref = __it++; 1761 : __it._M_cur && this->_M_node_equals(*__ref._M_cur, *__it._M_cur); 1762 : ++__it) 1763 : ++__result; 1764 : 1765 : return __result; 1766 : } 1767 : 1768 : #if __cplusplus > 201703L 1769 : template<typename _Key, typename _Value, typename _Alloc, 1770 : typename _ExtractKey, typename _Equal, 1771 : typename _Hash, typename _RangeHash, typename _Unused, 1772 : typename _RehashPolicy, typename _Traits> 1773 : template<typename _Kt, typename, typename> 1774 : auto 1775 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1776 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1777 : _M_count_tr(const _Kt& __k) const 1778 : -> size_type 1779 : { 1780 : __hash_code __code = this->_M_hash_code_tr(__k); 1781 : std::size_t __bkt = _M_bucket_index(__code); 1782 : auto __n = _M_find_node_tr(__bkt, __k, __code); 1783 : if (!__n) 1784 : return 0; 1785 : 1786 : // All equivalent values are next to each other, if we find a 1787 : // non-equivalent value after an equivalent one it means that we won't 1788 : // find any new equivalent value. 1789 : iterator __it(__n); 1790 : size_type __result = 1; 1791 : for (++__it; 1792 : __it._M_cur && this->_M_equals_tr(__k, __code, *__it._M_cur); 1793 : ++__it) 1794 : ++__result; 1795 : 1796 : return __result; 1797 : } 1798 : #endif 1799 : 1800 : template<typename _Key, typename _Value, typename _Alloc, 1801 : typename _ExtractKey, typename _Equal, 1802 : typename _Hash, typename _RangeHash, typename _Unused, 1803 : typename _RehashPolicy, typename _Traits> 1804 : auto 1805 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1806 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1807 : equal_range(const key_type& __k) 1808 : -> pair<iterator, iterator> 1809 : { 1810 : auto __ite = find(__k); 1811 : if (!__ite._M_cur) 1812 : return { __ite, __ite }; 1813 : 1814 : auto __beg = __ite++; 1815 : if (__unique_keys::value) 1816 : return { __beg, __ite }; 1817 : 1818 : // All equivalent values are next to each other, if we find a 1819 : // non-equivalent value after an equivalent one it means that we won't 1820 : // find any new equivalent value. 1821 : while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) 1822 : ++__ite; 1823 : 1824 : return { __beg, __ite }; 1825 : } 1826 : 1827 : template<typename _Key, typename _Value, typename _Alloc, 1828 : typename _ExtractKey, typename _Equal, 1829 : typename _Hash, typename _RangeHash, typename _Unused, 1830 : typename _RehashPolicy, typename _Traits> 1831 : auto 1832 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1833 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1834 : equal_range(const key_type& __k) const 1835 : -> pair<const_iterator, const_iterator> 1836 : { 1837 : auto __ite = find(__k); 1838 : if (!__ite._M_cur) 1839 : return { __ite, __ite }; 1840 : 1841 : auto __beg = __ite++; 1842 : if (__unique_keys::value) 1843 : return { __beg, __ite }; 1844 : 1845 : // All equivalent values are next to each other, if we find a 1846 : // non-equivalent value after an equivalent one it means that we won't 1847 : // find any new equivalent value. 1848 : while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) 1849 : ++__ite; 1850 : 1851 : return { __beg, __ite }; 1852 : } 1853 : 1854 : #if __cplusplus > 201703L 1855 : template<typename _Key, typename _Value, typename _Alloc, 1856 : typename _ExtractKey, typename _Equal, 1857 : typename _Hash, typename _RangeHash, typename _Unused, 1858 : typename _RehashPolicy, typename _Traits> 1859 : template<typename _Kt, typename, typename> 1860 : auto 1861 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1862 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1863 : _M_equal_range_tr(const _Kt& __k) 1864 : -> pair<iterator, iterator> 1865 : { 1866 : __hash_code __code = this->_M_hash_code_tr(__k); 1867 : std::size_t __bkt = _M_bucket_index(__code); 1868 : auto __n = _M_find_node_tr(__bkt, __k, __code); 1869 : iterator __ite(__n); 1870 : if (!__n) 1871 : return { __ite, __ite }; 1872 : 1873 : // All equivalent values are next to each other, if we find a 1874 : // non-equivalent value after an equivalent one it means that we won't 1875 : // find any new equivalent value. 1876 : auto __beg = __ite++; 1877 : while (__ite._M_cur && this->_M_equals_tr(__k, __code, *__ite._M_cur)) 1878 : ++__ite; 1879 : 1880 : return { __beg, __ite }; 1881 : } 1882 : 1883 : template<typename _Key, typename _Value, typename _Alloc, 1884 : typename _ExtractKey, typename _Equal, 1885 : typename _Hash, typename _RangeHash, typename _Unused, 1886 : typename _RehashPolicy, typename _Traits> 1887 : template<typename _Kt, typename, typename> 1888 : auto 1889 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1890 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1891 : _M_equal_range_tr(const _Kt& __k) const 1892 : -> pair<const_iterator, const_iterator> 1893 : { 1894 : __hash_code __code = this->_M_hash_code_tr(__k); 1895 : std::size_t __bkt = _M_bucket_index(__code); 1896 : auto __n = _M_find_node_tr(__bkt, __k, __code); 1897 : const_iterator __ite(__n); 1898 : if (!__n) 1899 : return { __ite, __ite }; 1900 : 1901 : // All equivalent values are next to each other, if we find a 1902 : // non-equivalent value after an equivalent one it means that we won't 1903 : // find any new equivalent value. 1904 : auto __beg = __ite++; 1905 : while (__ite._M_cur && this->_M_equals_tr(__k, __code, *__ite._M_cur)) 1906 : ++__ite; 1907 : 1908 : return { __beg, __ite }; 1909 : } 1910 : #endif 1911 : 1912 : // Find the node before the one whose key compares equal to k. 1913 : // Return nullptr if no node is found. 1914 : template<typename _Key, typename _Value, typename _Alloc, 1915 : typename _ExtractKey, typename _Equal, 1916 : typename _Hash, typename _RangeHash, typename _Unused, 1917 : typename _RehashPolicy, typename _Traits> 1918 : auto 1919 30520 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1920 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1921 : _M_find_before_node(const key_type& __k) 1922 : -> __node_base_ptr 1923 : { 1924 30520 : __node_base_ptr __prev_p = &_M_before_begin; 1925 30520 : if (!__prev_p->_M_nxt) 1926 0 : return nullptr; 1927 : 1928 30520 : for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt); 1929 30568 : __p != nullptr; 1930 48 : __p = __p->_M_next()) 1931 : { 1932 30568 : if (this->_M_key_equals(__k, *__p)) 1933 30520 : return __prev_p; 1934 : 1935 48 : __prev_p = __p; 1936 : } 1937 : 1938 0 : return nullptr; 1939 : } 1940 : 1941 : // Find the node before the one whose key compares equal to k in the bucket 1942 : // bkt. Return nullptr if no node is found. 1943 : template<typename _Key, typename _Value, typename _Alloc, 1944 : typename _ExtractKey, typename _Equal, 1945 : typename _Hash, typename _RangeHash, typename _Unused, 1946 : typename _RehashPolicy, typename _Traits> 1947 : auto 1948 5928688 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1949 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1950 : _M_find_before_node(size_type __bkt, const key_type& __k, 1951 : __hash_code __code) const 1952 : -> __node_base_ptr 1953 : { 1954 5928688 : __node_base_ptr __prev_p = _M_buckets[__bkt]; 1955 5928688 : if (!__prev_p) 1956 201034 : return nullptr; 1957 : 1958 5727654 : for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; 1959 1966 : __p = __p->_M_next()) 1960 : { 1961 5729620 : if (this->_M_equals(__k, __code, *__p)) 1962 5724128 : return __prev_p; 1963 : 1964 5492 : if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt) 1965 3526 : break; 1966 1966 : __prev_p = __p; 1967 : } 1968 : 1969 3526 : return nullptr; 1970 : } 1971 : 1972 : template<typename _Key, typename _Value, typename _Alloc, 1973 : typename _ExtractKey, typename _Equal, 1974 : typename _Hash, typename _RangeHash, typename _Unused, 1975 : typename _RehashPolicy, typename _Traits> 1976 : template<typename _Kt> 1977 : auto 1978 2832 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 1979 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 1980 : _M_find_before_node_tr(size_type __bkt, const _Kt& __k, 1981 : __hash_code __code) const 1982 : -> __node_base_ptr 1983 : { 1984 2832 : __node_base_ptr __prev_p = _M_buckets[__bkt]; 1985 2832 : if (!__prev_p) 1986 1376 : return nullptr; 1987 : 1988 1456 : for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; 1989 564 : __p = __p->_M_next()) 1990 : { 1991 2020 : if (this->_M_equals_tr(__k, __code, *__p)) 1992 2 : return __prev_p; 1993 : 1994 2018 : if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt) 1995 1454 : break; 1996 564 : __prev_p = __p; 1997 : } 1998 : 1999 1454 : return nullptr; 2000 : } 2001 : 2002 : template<typename _Key, typename _Value, typename _Alloc, 2003 : typename _ExtractKey, typename _Equal, 2004 : typename _Hash, typename _RangeHash, typename _Unused, 2005 : typename _RehashPolicy, typename _Traits> 2006 : void 2007 260158 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2008 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2009 : _M_insert_bucket_begin(size_type __bkt, __node_ptr __node) 2010 : { 2011 260158 : if (_M_buckets[__bkt]) 2012 : { 2013 : // Bucket is not empty, we just need to insert the new node 2014 : // after the bucket before begin. 2015 3210 : __node->_M_nxt = _M_buckets[__bkt]->_M_nxt; 2016 3210 : _M_buckets[__bkt]->_M_nxt = __node; 2017 : } 2018 : else 2019 : { 2020 : // The bucket is empty, the new node is inserted at the 2021 : // beginning of the singly-linked list and the bucket will 2022 : // contain _M_before_begin pointer. 2023 256948 : __node->_M_nxt = _M_before_begin._M_nxt; 2024 256948 : _M_before_begin._M_nxt = __node; 2025 : 2026 256948 : if (__node->_M_nxt) 2027 : // We must update former begin bucket that is pointing to 2028 : // _M_before_begin. 2029 140732 : _M_buckets[_M_bucket_index(*__node->_M_next())] = __node; 2030 : 2031 256948 : _M_buckets[__bkt] = &_M_before_begin; 2032 : } 2033 260158 : } 2034 : 2035 : template<typename _Key, typename _Value, typename _Alloc, 2036 : typename _ExtractKey, typename _Equal, 2037 : typename _Hash, typename _RangeHash, typename _Unused, 2038 : typename _RehashPolicy, typename _Traits> 2039 : void 2040 30520 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2041 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2042 : _M_remove_bucket_begin(size_type __bkt, __node_ptr __next, 2043 : size_type __next_bkt) 2044 : { 2045 30520 : if (!__next || __next_bkt != __bkt) 2046 : { 2047 : // Bucket is now empty 2048 : // First update next bucket if any 2049 30108 : if (__next) 2050 5166 : _M_buckets[__next_bkt] = _M_buckets[__bkt]; 2051 : 2052 : // Second update before begin node if necessary 2053 30108 : if (&_M_before_begin == _M_buckets[__bkt]) 2054 30108 : _M_before_begin._M_nxt = __next; 2055 30108 : _M_buckets[__bkt] = nullptr; 2056 : } 2057 30520 : } 2058 : 2059 : template<typename _Key, typename _Value, typename _Alloc, 2060 : typename _ExtractKey, typename _Equal, 2061 : typename _Hash, typename _RangeHash, typename _Unused, 2062 : typename _RehashPolicy, typename _Traits> 2063 : auto 2064 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2065 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2066 : _M_get_previous_node(size_type __bkt, __node_ptr __n) 2067 : -> __node_base_ptr 2068 : { 2069 : __node_base_ptr __prev_n = _M_buckets[__bkt]; 2070 : while (__prev_n->_M_nxt != __n) 2071 : __prev_n = __prev_n->_M_nxt; 2072 : return __prev_n; 2073 : } 2074 : 2075 : template<typename _Key, typename _Value, typename _Alloc, 2076 : typename _ExtractKey, typename _Equal, 2077 : typename _Hash, typename _RangeHash, typename _Unused, 2078 : typename _RehashPolicy, typename _Traits> 2079 : template<typename... _Args> 2080 : auto 2081 30 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2082 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2083 : _M_emplace(true_type /* __uks */, _Args&&... __args) 2084 : -> pair<iterator, bool> 2085 : { 2086 : // First build the node to get access to the hash code 2087 30 : _Scoped_node __node { this, std::forward<_Args>(__args)... }; 2088 60 : const key_type& __k = _ExtractKey{}(__node._M_node->_M_v()); 2089 30 : if (size() <= __small_size_threshold()) 2090 : { 2091 62 : for (auto __it = begin(); __it != end(); ++__it) 2092 32 : if (this->_M_key_equals(__k, *__it._M_cur)) 2093 : // There is already an equivalent node, no insertion 2094 0 : return { __it, false }; 2095 : } 2096 : 2097 30 : __hash_code __code = this->_M_hash_code(__k); 2098 30 : size_type __bkt = _M_bucket_index(__code); 2099 30 : if (size() > __small_size_threshold()) 2100 0 : if (__node_ptr __p = _M_find_node(__bkt, __k, __code)) 2101 : // There is already an equivalent node, no insertion 2102 0 : return { iterator(__p), false }; 2103 : 2104 : // Insert the node 2105 30 : auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node); 2106 30 : __node._M_node = nullptr; 2107 30 : return { __pos, true }; 2108 30 : } 2109 : 2110 : template<typename _Key, typename _Value, typename _Alloc, 2111 : typename _ExtractKey, typename _Equal, 2112 : typename _Hash, typename _RangeHash, typename _Unused, 2113 : typename _RehashPolicy, typename _Traits> 2114 : template<typename... _Args> 2115 : auto 2116 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2117 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2118 : _M_emplace(const_iterator __hint, false_type /* __uks */, 2119 : _Args&&... __args) 2120 : -> iterator 2121 : { 2122 : // First build the node to get its hash code. 2123 : _Scoped_node __node { this, std::forward<_Args>(__args)... }; 2124 : const key_type& __k = _ExtractKey{}(__node._M_node->_M_v()); 2125 : 2126 : auto __res = this->_M_compute_hash_code(__hint, __k); 2127 : auto __pos 2128 : = _M_insert_multi_node(__res.first._M_cur, __res.second, 2129 : __node._M_node); 2130 : __node._M_node = nullptr; 2131 : return __pos; 2132 : } 2133 : 2134 : template<typename _Key, typename _Value, typename _Alloc, 2135 : typename _ExtractKey, typename _Equal, 2136 : typename _Hash, typename _RangeHash, typename _Unused, 2137 : typename _RehashPolicy, typename _Traits> 2138 : auto 2139 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2140 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2141 : _M_compute_hash_code(const_iterator __hint, const key_type& __k) const 2142 : -> pair<const_iterator, __hash_code> 2143 : { 2144 : if (size() <= __small_size_threshold()) 2145 : { 2146 : if (__hint != cend()) 2147 : { 2148 : for (auto __it = __hint; __it != cend(); ++__it) 2149 : if (this->_M_key_equals(__k, *__it._M_cur)) 2150 : return { __it, this->_M_hash_code(*__it._M_cur) }; 2151 : } 2152 : 2153 : for (auto __it = cbegin(); __it != __hint; ++__it) 2154 : if (this->_M_key_equals(__k, *__it._M_cur)) 2155 : return { __it, this->_M_hash_code(*__it._M_cur) }; 2156 : } 2157 : 2158 : return { __hint, this->_M_hash_code(__k) }; 2159 : } 2160 : 2161 : template<typename _Key, typename _Value, typename _Alloc, 2162 : typename _ExtractKey, typename _Equal, 2163 : typename _Hash, typename _RangeHash, typename _Unused, 2164 : typename _RehashPolicy, typename _Traits> 2165 : auto 2166 260158 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2167 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2168 : _M_insert_unique_node(size_type __bkt, __hash_code __code, 2169 : __node_ptr __node, size_type __n_elt) 2170 : -> iterator 2171 : { 2172 260158 : const __rehash_state& __saved_state = _M_rehash_policy._M_state(); 2173 : std::pair<bool, std::size_t> __do_rehash 2174 260158 : = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 2175 : __n_elt); 2176 : 2177 260158 : if (__do_rehash.first) 2178 : { 2179 116624 : _M_rehash(__do_rehash.second, __saved_state); 2180 116624 : __bkt = _M_bucket_index(__code); 2181 : } 2182 : 2183 260158 : this->_M_store_code(*__node, __code); 2184 : 2185 : // Always insert at the beginning of the bucket. 2186 260158 : _M_insert_bucket_begin(__bkt, __node); 2187 260158 : ++_M_element_count; 2188 260158 : return iterator(__node); 2189 : } 2190 : 2191 : template<typename _Key, typename _Value, typename _Alloc, 2192 : typename _ExtractKey, typename _Equal, 2193 : typename _Hash, typename _RangeHash, typename _Unused, 2194 : typename _RehashPolicy, typename _Traits> 2195 : auto 2196 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2197 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2198 : _M_insert_multi_node(__node_ptr __hint, 2199 : __hash_code __code, __node_ptr __node) 2200 : -> iterator 2201 : { 2202 : const __rehash_state& __saved_state = _M_rehash_policy._M_state(); 2203 : std::pair<bool, std::size_t> __do_rehash 2204 : = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); 2205 : 2206 : if (__do_rehash.first) 2207 : _M_rehash(__do_rehash.second, __saved_state); 2208 : 2209 : this->_M_store_code(*__node, __code); 2210 : const key_type& __k = _ExtractKey{}(__node->_M_v()); 2211 : size_type __bkt = _M_bucket_index(__code); 2212 : 2213 : // Find the node before an equivalent one or use hint if it exists and 2214 : // if it is equivalent. 2215 : __node_base_ptr __prev 2216 : = __builtin_expect(__hint != nullptr, false) 2217 : && this->_M_equals(__k, __code, *__hint) 2218 : ? __hint 2219 : : _M_find_before_node(__bkt, __k, __code); 2220 : 2221 : if (__prev) 2222 : { 2223 : // Insert after the node before the equivalent one. 2224 : __node->_M_nxt = __prev->_M_nxt; 2225 : __prev->_M_nxt = __node; 2226 : if (__builtin_expect(__prev == __hint, false)) 2227 : // hint might be the last bucket node, in this case we need to 2228 : // update next bucket. 2229 : if (__node->_M_nxt 2230 : && !this->_M_equals(__k, __code, *__node->_M_next())) 2231 : { 2232 : size_type __next_bkt = _M_bucket_index(*__node->_M_next()); 2233 : if (__next_bkt != __bkt) 2234 : _M_buckets[__next_bkt] = __node; 2235 : } 2236 : } 2237 : else 2238 : // The inserted node has no equivalent in the hashtable. We must 2239 : // insert the new node at the beginning of the bucket to preserve 2240 : // equivalent elements' relative positions. 2241 : _M_insert_bucket_begin(__bkt, __node); 2242 : ++_M_element_count; 2243 : return iterator(__node); 2244 : } 2245 : 2246 : // Insert v if no element with its key is already present. 2247 : template<typename _Key, typename _Value, typename _Alloc, 2248 : typename _ExtractKey, typename _Equal, 2249 : typename _Hash, typename _RangeHash, typename _Unused, 2250 : typename _RehashPolicy, typename _Traits> 2251 : template<typename _Kt, typename _Arg, typename _NodeGenerator> 2252 : auto 2253 61166 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2254 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2255 : _M_insert_unique(_Kt&& __k, _Arg&& __v, 2256 : const _NodeGenerator& __node_gen) 2257 : -> pair<iterator, bool> 2258 : { 2259 61166 : if (size() <= __small_size_threshold()) 2260 78472 : for (auto __it = begin(); __it != end(); ++__it) 2261 20140 : if (this->_M_key_equals_tr(__k, *__it._M_cur)) 2262 2 : return { __it, false }; 2263 : 2264 61164 : __hash_code __code = this->_M_hash_code_tr(__k); 2265 61164 : size_type __bkt = _M_bucket_index(__code); 2266 : 2267 61164 : if (size() > __small_size_threshold()) 2268 2832 : if (__node_ptr __node = _M_find_node_tr(__bkt, __k, __code)) 2269 2 : return { iterator(__node), false }; 2270 : 2271 61162 : _Scoped_node __node { 2272 : __node_builder_t::_S_build(std::forward<_Kt>(__k), 2273 : std::forward<_Arg>(__v), 2274 : __node_gen), 2275 : this 2276 : }; 2277 : auto __pos 2278 61162 : = _M_insert_unique_node(__bkt, __code, __node._M_node); 2279 61162 : __node._M_node = nullptr; 2280 61162 : return { __pos, true }; 2281 61162 : } 2282 : 2283 : // Insert v unconditionally. 2284 : template<typename _Key, typename _Value, typename _Alloc, 2285 : typename _ExtractKey, typename _Equal, 2286 : typename _Hash, typename _RangeHash, typename _Unused, 2287 : typename _RehashPolicy, typename _Traits> 2288 : template<typename _Arg, typename _NodeGenerator> 2289 : auto 2290 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2291 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2292 : _M_insert(const_iterator __hint, _Arg&& __v, 2293 : const _NodeGenerator& __node_gen, 2294 : false_type /* __uks */) 2295 : -> iterator 2296 : { 2297 : // First allocate new node so that we don't do anything if it throws. 2298 : _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this }; 2299 : 2300 : // Second compute the hash code so that we don't rehash if it throws. 2301 : auto __res = this->_M_compute_hash_code( 2302 : __hint, _ExtractKey{}(__node._M_node->_M_v())); 2303 : 2304 : auto __pos 2305 : = _M_insert_multi_node(__res.first._M_cur, __res.second, 2306 : __node._M_node); 2307 : __node._M_node = nullptr; 2308 : return __pos; 2309 : } 2310 : 2311 : template<typename _Key, typename _Value, typename _Alloc, 2312 : typename _ExtractKey, typename _Equal, 2313 : typename _Hash, typename _RangeHash, typename _Unused, 2314 : typename _RehashPolicy, typename _Traits> 2315 : auto 2316 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2317 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2318 : erase(const_iterator __it) 2319 : -> iterator 2320 : { 2321 : __node_ptr __n = __it._M_cur; 2322 : std::size_t __bkt = _M_bucket_index(*__n); 2323 : 2324 : // Look for previous node to unlink it from the erased one, this 2325 : // is why we need buckets to contain the before begin to make 2326 : // this search fast. 2327 : __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); 2328 : return _M_erase(__bkt, __prev_n, __n); 2329 : } 2330 : 2331 : template<typename _Key, typename _Value, typename _Alloc, 2332 : typename _ExtractKey, typename _Equal, 2333 : typename _Hash, typename _RangeHash, typename _Unused, 2334 : typename _RehashPolicy, typename _Traits> 2335 : auto 2336 30520 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2337 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2338 : _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n) 2339 : -> iterator 2340 : { 2341 30520 : if (__prev_n == _M_buckets[__bkt]) 2342 30520 : _M_remove_bucket_begin(__bkt, __n->_M_next(), 2343 30520 : __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); 2344 0 : else if (__n->_M_nxt) 2345 : { 2346 0 : size_type __next_bkt = _M_bucket_index(*__n->_M_next()); 2347 0 : if (__next_bkt != __bkt) 2348 0 : _M_buckets[__next_bkt] = __prev_n; 2349 : } 2350 : 2351 30520 : __prev_n->_M_nxt = __n->_M_nxt; 2352 30520 : iterator __result(__n->_M_next()); 2353 30520 : this->_M_deallocate_node(__n); 2354 30520 : --_M_element_count; 2355 : 2356 30520 : return __result; 2357 : } 2358 : 2359 : template<typename _Key, typename _Value, typename _Alloc, 2360 : typename _ExtractKey, typename _Equal, 2361 : typename _Hash, typename _RangeHash, typename _Unused, 2362 : typename _RehashPolicy, typename _Traits> 2363 : auto 2364 30520 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2365 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2366 : _M_erase(true_type /* __uks */, const key_type& __k) 2367 : -> size_type 2368 : { 2369 : __node_base_ptr __prev_n; 2370 : __node_ptr __n; 2371 : std::size_t __bkt; 2372 30520 : if (size() <= __small_size_threshold()) 2373 : { 2374 30520 : __prev_n = _M_find_before_node(__k); 2375 30520 : if (!__prev_n) 2376 0 : return 0; 2377 : 2378 : // We found a matching node, erase it. 2379 30520 : __n = static_cast<__node_ptr>(__prev_n->_M_nxt); 2380 30520 : __bkt = _M_bucket_index(*__n); 2381 : } 2382 : else 2383 : { 2384 0 : __hash_code __code = this->_M_hash_code(__k); 2385 0 : __bkt = _M_bucket_index(__code); 2386 : 2387 : // Look for the node before the first matching node. 2388 0 : __prev_n = _M_find_before_node(__bkt, __k, __code); 2389 0 : if (!__prev_n) 2390 0 : return 0; 2391 : 2392 : // We found a matching node, erase it. 2393 0 : __n = static_cast<__node_ptr>(__prev_n->_M_nxt); 2394 : } 2395 : 2396 30520 : _M_erase(__bkt, __prev_n, __n); 2397 30520 : return 1; 2398 : } 2399 : 2400 : template<typename _Key, typename _Value, typename _Alloc, 2401 : typename _ExtractKey, typename _Equal, 2402 : typename _Hash, typename _RangeHash, typename _Unused, 2403 : typename _RehashPolicy, typename _Traits> 2404 : auto 2405 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2406 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2407 : _M_erase(false_type /* __uks */, const key_type& __k) 2408 : -> size_type 2409 : { 2410 : std::size_t __bkt; 2411 : __node_base_ptr __prev_n; 2412 : __node_ptr __n; 2413 : if (size() <= __small_size_threshold()) 2414 : { 2415 : __prev_n = _M_find_before_node(__k); 2416 : if (!__prev_n) 2417 : return 0; 2418 : 2419 : // We found a matching node, erase it. 2420 : __n = static_cast<__node_ptr>(__prev_n->_M_nxt); 2421 : __bkt = _M_bucket_index(*__n); 2422 : } 2423 : else 2424 : { 2425 : __hash_code __code = this->_M_hash_code(__k); 2426 : __bkt = _M_bucket_index(__code); 2427 : 2428 : // Look for the node before the first matching node. 2429 : __prev_n = _M_find_before_node(__bkt, __k, __code); 2430 : if (!__prev_n) 2431 : return 0; 2432 : 2433 : __n = static_cast<__node_ptr>(__prev_n->_M_nxt); 2434 : } 2435 : 2436 : // _GLIBCXX_RESOLVE_LIB_DEFECTS 2437 : // 526. Is it undefined if a function in the standard changes 2438 : // in parameters? 2439 : // We use one loop to find all matching nodes and another to deallocate 2440 : // them so that the key stays valid during the first loop. It might be 2441 : // invalidated indirectly when destroying nodes. 2442 : __node_ptr __n_last = __n->_M_next(); 2443 : while (__n_last && this->_M_node_equals(*__n, *__n_last)) 2444 : __n_last = __n_last->_M_next(); 2445 : 2446 : std::size_t __n_last_bkt = __n_last ? _M_bucket_index(*__n_last) : __bkt; 2447 : 2448 : // Deallocate nodes. 2449 : size_type __result = 0; 2450 : do 2451 : { 2452 : __node_ptr __p = __n->_M_next(); 2453 : this->_M_deallocate_node(__n); 2454 : __n = __p; 2455 : ++__result; 2456 : } 2457 : while (__n != __n_last); 2458 : 2459 : _M_element_count -= __result; 2460 : if (__prev_n == _M_buckets[__bkt]) 2461 : _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); 2462 : else if (__n_last_bkt != __bkt) 2463 : _M_buckets[__n_last_bkt] = __prev_n; 2464 : __prev_n->_M_nxt = __n_last; 2465 : return __result; 2466 : } 2467 : 2468 : template<typename _Key, typename _Value, typename _Alloc, 2469 : typename _ExtractKey, typename _Equal, 2470 : typename _Hash, typename _RangeHash, typename _Unused, 2471 : typename _RehashPolicy, typename _Traits> 2472 : auto 2473 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2474 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2475 : erase(const_iterator __first, const_iterator __last) 2476 : -> iterator 2477 : { 2478 : __node_ptr __n = __first._M_cur; 2479 : __node_ptr __last_n = __last._M_cur; 2480 : if (__n == __last_n) 2481 : return iterator(__n); 2482 : 2483 : std::size_t __bkt = _M_bucket_index(*__n); 2484 : 2485 : __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); 2486 : bool __is_bucket_begin = __n == _M_bucket_begin(__bkt); 2487 : std::size_t __n_bkt = __bkt; 2488 : for (;;) 2489 : { 2490 : do 2491 : { 2492 : __node_ptr __tmp = __n; 2493 : __n = __n->_M_next(); 2494 : this->_M_deallocate_node(__tmp); 2495 : --_M_element_count; 2496 : if (!__n) 2497 : break; 2498 : __n_bkt = _M_bucket_index(*__n); 2499 : } 2500 : while (__n != __last_n && __n_bkt == __bkt); 2501 : if (__is_bucket_begin) 2502 : _M_remove_bucket_begin(__bkt, __n, __n_bkt); 2503 : if (__n == __last_n) 2504 : break; 2505 : __is_bucket_begin = true; 2506 : __bkt = __n_bkt; 2507 : } 2508 : 2509 : if (__n && (__n_bkt != __bkt || __is_bucket_begin)) 2510 : _M_buckets[__n_bkt] = __prev_n; 2511 : __prev_n->_M_nxt = __n; 2512 : return iterator(__n); 2513 : } 2514 : 2515 : template<typename _Key, typename _Value, typename _Alloc, 2516 : typename _ExtractKey, typename _Equal, 2517 : typename _Hash, typename _RangeHash, typename _Unused, 2518 : typename _RehashPolicy, typename _Traits> 2519 : void 2520 123656 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2521 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2522 : clear() noexcept 2523 : { 2524 123656 : this->_M_deallocate_nodes(_M_begin()); 2525 123656 : __builtin_memset(_M_buckets, 0, 2526 123656 : _M_bucket_count * sizeof(__node_base_ptr)); 2527 123656 : _M_element_count = 0; 2528 123656 : _M_before_begin._M_nxt = nullptr; 2529 123656 : } 2530 : 2531 : template<typename _Key, typename _Value, typename _Alloc, 2532 : typename _ExtractKey, typename _Equal, 2533 : typename _Hash, typename _RangeHash, typename _Unused, 2534 : typename _RehashPolicy, typename _Traits> 2535 : void 2536 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2537 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2538 : rehash(size_type __bkt_count) 2539 : { 2540 : const __rehash_state& __saved_state = _M_rehash_policy._M_state(); 2541 : __bkt_count 2542 : = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), 2543 : __bkt_count); 2544 : __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count); 2545 : 2546 : if (__bkt_count != _M_bucket_count) 2547 : _M_rehash(__bkt_count, __saved_state); 2548 : else 2549 : // No rehash, restore previous state to keep it consistent with 2550 : // container state. 2551 : _M_rehash_policy._M_reset(__saved_state); 2552 : } 2553 : 2554 : template<typename _Key, typename _Value, typename _Alloc, 2555 : typename _ExtractKey, typename _Equal, 2556 : typename _Hash, typename _RangeHash, typename _Unused, 2557 : typename _RehashPolicy, typename _Traits> 2558 : void 2559 116628 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2560 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2561 : _M_rehash(size_type __bkt_count, const __rehash_state& __state) 2562 : { 2563 : __try 2564 : { 2565 116628 : _M_rehash_aux(__bkt_count, __unique_keys{}); 2566 : } 2567 0 : __catch(...) 2568 : { 2569 : // A failure here means that buckets allocation failed. We only 2570 : // have to restore hash policy previous state. 2571 0 : _M_rehash_policy._M_reset(__state); 2572 0 : __throw_exception_again; 2573 : } 2574 116628 : } 2575 : 2576 : // Rehash when there is no equivalent elements. 2577 : template<typename _Key, typename _Value, typename _Alloc, 2578 : typename _ExtractKey, typename _Equal, 2579 : typename _Hash, typename _RangeHash, typename _Unused, 2580 : typename _RehashPolicy, typename _Traits> 2581 : void 2582 116628 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2583 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2584 : _M_rehash_aux(size_type __bkt_count, true_type /* __uks */) 2585 : { 2586 116628 : __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); 2587 116628 : __node_ptr __p = _M_begin(); 2588 116628 : _M_before_begin._M_nxt = nullptr; 2589 116628 : std::size_t __bbegin_bkt = 0; 2590 125964 : while (__p) 2591 : { 2592 9336 : __node_ptr __next = __p->_M_next(); 2593 : std::size_t __bkt 2594 9336 : = __hash_code_base::_M_bucket_index(*__p, __bkt_count); 2595 9336 : if (!__new_buckets[__bkt]) 2596 : { 2597 8344 : __p->_M_nxt = _M_before_begin._M_nxt; 2598 8344 : _M_before_begin._M_nxt = __p; 2599 8344 : __new_buckets[__bkt] = &_M_before_begin; 2600 8344 : if (__p->_M_nxt) 2601 7932 : __new_buckets[__bbegin_bkt] = __p; 2602 8344 : __bbegin_bkt = __bkt; 2603 : } 2604 : else 2605 : { 2606 992 : __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; 2607 992 : __new_buckets[__bkt]->_M_nxt = __p; 2608 : } 2609 : 2610 9336 : __p = __next; 2611 : } 2612 : 2613 116628 : _M_deallocate_buckets(); 2614 116628 : _M_bucket_count = __bkt_count; 2615 116628 : _M_buckets = __new_buckets; 2616 116628 : } 2617 : 2618 : // Rehash when there can be equivalent elements, preserve their relative 2619 : // order. 2620 : template<typename _Key, typename _Value, typename _Alloc, 2621 : typename _ExtractKey, typename _Equal, 2622 : typename _Hash, typename _RangeHash, typename _Unused, 2623 : typename _RehashPolicy, typename _Traits> 2624 : void 2625 : _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, 2626 : _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: 2627 : _M_rehash_aux(size_type __bkt_count, false_type /* __uks */) 2628 : { 2629 : __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); 2630 : __node_ptr __p = _M_begin(); 2631 : _M_before_begin._M_nxt = nullptr; 2632 : std::size_t __bbegin_bkt = 0; 2633 : std::size_t __prev_bkt = 0; 2634 : __node_ptr __prev_p = nullptr; 2635 : bool __check_bucket = false; 2636 : 2637 : while (__p) 2638 : { 2639 : __node_ptr __next = __p->_M_next(); 2640 : std::size_t __bkt 2641 : = __hash_code_base::_M_bucket_index(*__p, __bkt_count); 2642 : 2643 : if (__prev_p && __prev_bkt == __bkt) 2644 : { 2645 : // Previous insert was already in this bucket, we insert after 2646 : // the previously inserted one to preserve equivalent elements 2647 : // relative order. 2648 : __p->_M_nxt = __prev_p->_M_nxt; 2649 : __prev_p->_M_nxt = __p; 2650 : 2651 : // Inserting after a node in a bucket require to check that we 2652 : // haven't change the bucket last node, in this case next 2653 : // bucket containing its before begin node must be updated. We 2654 : // schedule a check as soon as we move out of the sequence of 2655 : // equivalent nodes to limit the number of checks. 2656 : __check_bucket = true; 2657 : } 2658 : else 2659 : { 2660 : if (__check_bucket) 2661 : { 2662 : // Check if we shall update the next bucket because of 2663 : // insertions into __prev_bkt bucket. 2664 : if (__prev_p->_M_nxt) 2665 : { 2666 : std::size_t __next_bkt 2667 : = __hash_code_base::_M_bucket_index( 2668 : *__prev_p->_M_next(), __bkt_count); 2669 : if (__next_bkt != __prev_bkt) 2670 : __new_buckets[__next_bkt] = __prev_p; 2671 : } 2672 : __check_bucket = false; 2673 : } 2674 : 2675 : if (!__new_buckets[__bkt]) 2676 : { 2677 : __p->_M_nxt = _M_before_begin._M_nxt; 2678 : _M_before_begin._M_nxt = __p; 2679 : __new_buckets[__bkt] = &_M_before_begin; 2680 : if (__p->_M_nxt) 2681 : __new_buckets[__bbegin_bkt] = __p; 2682 : __bbegin_bkt = __bkt; 2683 : } 2684 : else 2685 : { 2686 : __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; 2687 : __new_buckets[__bkt]->_M_nxt = __p; 2688 : } 2689 : } 2690 : __prev_p = __p; 2691 : __prev_bkt = __bkt; 2692 : __p = __next; 2693 : } 2694 : 2695 : if (__check_bucket && __prev_p->_M_nxt) 2696 : { 2697 : std::size_t __next_bkt 2698 : = __hash_code_base::_M_bucket_index(*__prev_p->_M_next(), 2699 : __bkt_count); 2700 : if (__next_bkt != __prev_bkt) 2701 : __new_buckets[__next_bkt] = __prev_p; 2702 : } 2703 : 2704 : _M_deallocate_buckets(); 2705 : _M_bucket_count = __bkt_count; 2706 : _M_buckets = __new_buckets; 2707 : } 2708 : 2709 : #if __cplusplus > 201402L 2710 : template<typename, typename, typename> class _Hash_merge_helper { }; 2711 : #endif // C++17 2712 : 2713 : #if __cpp_deduction_guides >= 201606 2714 : // Used to constrain deduction guides 2715 : template<typename _Hash> 2716 : using _RequireNotAllocatorOrIntegral 2717 : = __enable_if_t<!__or_<is_integral<_Hash>, __is_allocator<_Hash>>::value>; 2718 : #endif 2719 : 2720 : /// @endcond 2721 : _GLIBCXX_END_NAMESPACE_VERSION 2722 : } // namespace std 2723 : 2724 : #endif // _HASHTABLE_H |
|
| Generated by: LCOV version 2.0-1 |
</html>