1// -*- C++ -*- 2//===-------------------------- unordered_map -----------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_UNORDERED_MAP 12#define _LIBCPP_UNORDERED_MAP 13 14/* 15 16 unordered_map synopsis 17 18#include <initializer_list> 19 20namespace std 21{ 22 23template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 24 class Alloc = allocator<pair<const Key, T>>> 25class unordered_map 26{ 27public: 28 // types 29 typedef Key key_type; 30 typedef T mapped_type; 31 typedef Hash hasher; 32 typedef Pred key_equal; 33 typedef Alloc allocator_type; 34 typedef pair<const key_type, mapped_type> value_type; 35 typedef value_type& reference; 36 typedef const value_type& const_reference; 37 typedef typename allocator_traits<allocator_type>::pointer pointer; 38 typedef typename allocator_traits<allocator_type>::const_pointer const_pointer; 39 typedef typename allocator_traits<allocator_type>::size_type size_type; 40 typedef typename allocator_traits<allocator_type>::difference_type difference_type; 41 42 typedef /unspecified/ iterator; 43 typedef /unspecified/ const_iterator; 44 typedef /unspecified/ local_iterator; 45 typedef /unspecified/ const_local_iterator; 46 47 unordered_map() 48 noexcept( 49 is_nothrow_default_constructible<hasher>::value && 50 is_nothrow_default_constructible<key_equal>::value && 51 is_nothrow_default_constructible<allocator_type>::value); 52 explicit unordered_map(size_type n, const hasher& hf = hasher(), 53 const key_equal& eql = key_equal(), 54 const allocator_type& a = allocator_type()); 55 template <class InputIterator> 56 unordered_map(InputIterator f, InputIterator l, 57 size_type n = 0, const hasher& hf = hasher(), 58 const key_equal& eql = key_equal(), 59 const allocator_type& a = allocator_type()); 60 explicit unordered_map(const allocator_type&); 61 unordered_map(const unordered_map&); 62 unordered_map(const unordered_map&, const Allocator&); 63 unordered_map(unordered_map&&) 64 noexcept( 65 is_nothrow_move_constructible<hasher>::value && 66 is_nothrow_move_constructible<key_equal>::value && 67 is_nothrow_move_constructible<allocator_type>::value); 68 unordered_map(unordered_map&&, const Allocator&); 69 unordered_map(initializer_list<value_type>, size_type n = 0, 70 const hasher& hf = hasher(), const key_equal& eql = key_equal(), 71 const allocator_type& a = allocator_type()); 72 unordered_map(size_type n, const allocator_type& a) 73 : unordered_map(n, hasher(), key_equal(), a) {} // C++14 74 unordered_map(size_type n, const hasher& hf, const allocator_type& a) 75 : unordered_map(n, hf, key_equal(), a) {} // C++14 76 template <class InputIterator> 77 unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a) 78 : unordered_map(f, l, n, hasher(), key_equal(), a) {} // C++14 79 template <class InputIterator> 80 unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf, 81 const allocator_type& a) 82 : unordered_map(f, l, n, hf, key_equal(), a) {} // C++14 83 unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a) 84 : unordered_map(il, n, hasher(), key_equal(), a) {} // C++14 85 unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf, 86 const allocator_type& a) 87 : unordered_map(il, n, hf, key_equal(), a) {} // C++14 88 ~unordered_map(); 89 unordered_map& operator=(const unordered_map&); 90 unordered_map& operator=(unordered_map&&) 91 noexcept( 92 allocator_type::propagate_on_container_move_assignment::value && 93 is_nothrow_move_assignable<allocator_type>::value && 94 is_nothrow_move_assignable<hasher>::value && 95 is_nothrow_move_assignable<key_equal>::value); 96 unordered_map& operator=(initializer_list<value_type>); 97 98 allocator_type get_allocator() const noexcept; 99 100 bool empty() const noexcept; 101 size_type size() const noexcept; 102 size_type max_size() const noexcept; 103 104 iterator begin() noexcept; 105 iterator end() noexcept; 106 const_iterator begin() const noexcept; 107 const_iterator end() const noexcept; 108 const_iterator cbegin() const noexcept; 109 const_iterator cend() const noexcept; 110 111 template <class... Args> 112 pair<iterator, bool> emplace(Args&&... args); 113 template <class... Args> 114 iterator emplace_hint(const_iterator position, Args&&... args); 115 pair<iterator, bool> insert(const value_type& obj); 116 template <class P> 117 pair<iterator, bool> insert(P&& obj); 118 iterator insert(const_iterator hint, const value_type& obj); 119 template <class P> 120 iterator insert(const_iterator hint, P&& obj); 121 template <class InputIterator> 122 void insert(InputIterator first, InputIterator last); 123 void insert(initializer_list<value_type>); 124 125 template <class... Args> 126 pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17 127 template <class... Args> 128 pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17 129 template <class... Args> 130 iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17 131 template <class... Args> 132 iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17 133 template <class M> 134 pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17 135 template <class M> 136 pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17 137 template <class M> 138 iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17 139 template <class M> 140 iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17 141 142 iterator erase(const_iterator position); 143 iterator erase(iterator position); // C++14 144 size_type erase(const key_type& k); 145 iterator erase(const_iterator first, const_iterator last); 146 void clear() noexcept; 147 148 void swap(unordered_map&) 149 noexcept( 150 (!allocator_type::propagate_on_container_swap::value || 151 __is_nothrow_swappable<allocator_type>::value) && 152 __is_nothrow_swappable<hasher>::value && 153 __is_nothrow_swappable<key_equal>::value); 154 155 hasher hash_function() const; 156 key_equal key_eq() const; 157 158 iterator find(const key_type& k); 159 const_iterator find(const key_type& k) const; 160 size_type count(const key_type& k) const; 161 pair<iterator, iterator> equal_range(const key_type& k); 162 pair<const_iterator, const_iterator> equal_range(const key_type& k) const; 163 164 mapped_type& operator[](const key_type& k); 165 mapped_type& operator[](key_type&& k); 166 167 mapped_type& at(const key_type& k); 168 const mapped_type& at(const key_type& k) const; 169 170 size_type bucket_count() const noexcept; 171 size_type max_bucket_count() const noexcept; 172 173 size_type bucket_size(size_type n) const; 174 size_type bucket(const key_type& k) const; 175 176 local_iterator begin(size_type n); 177 local_iterator end(size_type n); 178 const_local_iterator begin(size_type n) const; 179 const_local_iterator end(size_type n) const; 180 const_local_iterator cbegin(size_type n) const; 181 const_local_iterator cend(size_type n) const; 182 183 float load_factor() const noexcept; 184 float max_load_factor() const noexcept; 185 void max_load_factor(float z); 186 void rehash(size_type n); 187 void reserve(size_type n); 188}; 189 190template <class Key, class T, class Hash, class Pred, class Alloc> 191 void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 192 unordered_map<Key, T, Hash, Pred, Alloc>& y) 193 noexcept(noexcept(x.swap(y))); 194 195template <class Key, class T, class Hash, class Pred, class Alloc> 196 bool 197 operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& x, 198 const unordered_map<Key, T, Hash, Pred, Alloc>& y); 199 200template <class Key, class T, class Hash, class Pred, class Alloc> 201 bool 202 operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x, 203 const unordered_map<Key, T, Hash, Pred, Alloc>& y); 204 205template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 206 class Alloc = allocator<pair<const Key, T>>> 207class unordered_multimap 208{ 209public: 210 // types 211 typedef Key key_type; 212 typedef T mapped_type; 213 typedef Hash hasher; 214 typedef Pred key_equal; 215 typedef Alloc allocator_type; 216 typedef pair<const key_type, mapped_type> value_type; 217 typedef value_type& reference; 218 typedef const value_type& const_reference; 219 typedef typename allocator_traits<allocator_type>::pointer pointer; 220 typedef typename allocator_traits<allocator_type>::const_pointer const_pointer; 221 typedef typename allocator_traits<allocator_type>::size_type size_type; 222 typedef typename allocator_traits<allocator_type>::difference_type difference_type; 223 224 typedef /unspecified/ iterator; 225 typedef /unspecified/ const_iterator; 226 typedef /unspecified/ local_iterator; 227 typedef /unspecified/ const_local_iterator; 228 229 unordered_multimap() 230 noexcept( 231 is_nothrow_default_constructible<hasher>::value && 232 is_nothrow_default_constructible<key_equal>::value && 233 is_nothrow_default_constructible<allocator_type>::value); 234 explicit unordered_multimap(size_type n, const hasher& hf = hasher(), 235 const key_equal& eql = key_equal(), 236 const allocator_type& a = allocator_type()); 237 template <class InputIterator> 238 unordered_multimap(InputIterator f, InputIterator l, 239 size_type n = 0, const hasher& hf = hasher(), 240 const key_equal& eql = key_equal(), 241 const allocator_type& a = allocator_type()); 242 explicit unordered_multimap(const allocator_type&); 243 unordered_multimap(const unordered_multimap&); 244 unordered_multimap(const unordered_multimap&, const Allocator&); 245 unordered_multimap(unordered_multimap&&) 246 noexcept( 247 is_nothrow_move_constructible<hasher>::value && 248 is_nothrow_move_constructible<key_equal>::value && 249 is_nothrow_move_constructible<allocator_type>::value); 250 unordered_multimap(unordered_multimap&&, const Allocator&); 251 unordered_multimap(initializer_list<value_type>, size_type n = 0, 252 const hasher& hf = hasher(), const key_equal& eql = key_equal(), 253 const allocator_type& a = allocator_type()); 254 unordered_multimap(size_type n, const allocator_type& a) 255 : unordered_multimap(n, hasher(), key_equal(), a) {} // C++14 256 unordered_multimap(size_type n, const hasher& hf, const allocator_type& a) 257 : unordered_multimap(n, hf, key_equal(), a) {} // C++14 258 template <class InputIterator> 259 unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a) 260 : unordered_multimap(f, l, n, hasher(), key_equal(), a) {} // C++14 261 template <class InputIterator> 262 unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf, 263 const allocator_type& a) 264 : unordered_multimap(f, l, n, hf, key_equal(), a) {} // C++14 265 unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a) 266 : unordered_multimap(il, n, hasher(), key_equal(), a) {} // C++14 267 unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf, 268 const allocator_type& a) 269 : unordered_multimap(il, n, hf, key_equal(), a) {} // C++14 270 ~unordered_multimap(); 271 unordered_multimap& operator=(const unordered_multimap&); 272 unordered_multimap& operator=(unordered_multimap&&) 273 noexcept( 274 allocator_type::propagate_on_container_move_assignment::value && 275 is_nothrow_move_assignable<allocator_type>::value && 276 is_nothrow_move_assignable<hasher>::value && 277 is_nothrow_move_assignable<key_equal>::value); 278 unordered_multimap& operator=(initializer_list<value_type>); 279 280 allocator_type get_allocator() const noexcept; 281 282 bool empty() const noexcept; 283 size_type size() const noexcept; 284 size_type max_size() const noexcept; 285 286 iterator begin() noexcept; 287 iterator end() noexcept; 288 const_iterator begin() const noexcept; 289 const_iterator end() const noexcept; 290 const_iterator cbegin() const noexcept; 291 const_iterator cend() const noexcept; 292 293 template <class... Args> 294 iterator emplace(Args&&... args); 295 template <class... Args> 296 iterator emplace_hint(const_iterator position, Args&&... args); 297 iterator insert(const value_type& obj); 298 template <class P> 299 iterator insert(P&& obj); 300 iterator insert(const_iterator hint, const value_type& obj); 301 template <class P> 302 iterator insert(const_iterator hint, P&& obj); 303 template <class InputIterator> 304 void insert(InputIterator first, InputIterator last); 305 void insert(initializer_list<value_type>); 306 307 iterator erase(const_iterator position); 308 iterator erase(iterator position); // C++14 309 size_type erase(const key_type& k); 310 iterator erase(const_iterator first, const_iterator last); 311 void clear() noexcept; 312 313 void swap(unordered_multimap&) 314 noexcept( 315 (!allocator_type::propagate_on_container_swap::value || 316 __is_nothrow_swappable<allocator_type>::value) && 317 __is_nothrow_swappable<hasher>::value && 318 __is_nothrow_swappable<key_equal>::value); 319 320 hasher hash_function() const; 321 key_equal key_eq() const; 322 323 iterator find(const key_type& k); 324 const_iterator find(const key_type& k) const; 325 size_type count(const key_type& k) const; 326 pair<iterator, iterator> equal_range(const key_type& k); 327 pair<const_iterator, const_iterator> equal_range(const key_type& k) const; 328 329 size_type bucket_count() const noexcept; 330 size_type max_bucket_count() const noexcept; 331 332 size_type bucket_size(size_type n) const; 333 size_type bucket(const key_type& k) const; 334 335 local_iterator begin(size_type n); 336 local_iterator end(size_type n); 337 const_local_iterator begin(size_type n) const; 338 const_local_iterator end(size_type n) const; 339 const_local_iterator cbegin(size_type n) const; 340 const_local_iterator cend(size_type n) const; 341 342 float load_factor() const noexcept; 343 float max_load_factor() const noexcept; 344 void max_load_factor(float z); 345 void rehash(size_type n); 346 void reserve(size_type n); 347}; 348 349template <class Key, class T, class Hash, class Pred, class Alloc> 350 void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 351 unordered_multimap<Key, T, Hash, Pred, Alloc>& y) 352 noexcept(noexcept(x.swap(y))); 353 354template <class Key, class T, class Hash, class Pred, class Alloc> 355 bool 356 operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 357 const unordered_multimap<Key, T, Hash, Pred, Alloc>& y); 358 359template <class Key, class T, class Hash, class Pred, class Alloc> 360 bool 361 operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 362 const unordered_multimap<Key, T, Hash, Pred, Alloc>& y); 363 364} // std 365 366*/ 367 368#include <__config> 369#include <__hash_table> 370#include <functional> 371#include <stdexcept> 372 373#include <__debug> 374 375#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 376#pragma GCC system_header 377#endif 378 379_LIBCPP_BEGIN_NAMESPACE_STD 380 381template <class _Key, class _Cp, class _Hash, 382 bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value 383 > 384class __unordered_map_hasher 385 : private _Hash 386{ 387public: 388 _LIBCPP_INLINE_VISIBILITY 389 __unordered_map_hasher() 390 _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value) 391 : _Hash() {} 392 _LIBCPP_INLINE_VISIBILITY 393 __unordered_map_hasher(const _Hash& __h) 394 _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value) 395 : _Hash(__h) {} 396 _LIBCPP_INLINE_VISIBILITY 397 const _Hash& hash_function() const _NOEXCEPT {return *this;} 398 _LIBCPP_INLINE_VISIBILITY 399 size_t operator()(const _Cp& __x) const 400 {return static_cast<const _Hash&>(*this)(__x.__cc.first);} 401 _LIBCPP_INLINE_VISIBILITY 402 size_t operator()(const _Key& __x) const 403 {return static_cast<const _Hash&>(*this)(__x);} 404 void swap(__unordered_map_hasher&__y) 405 _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) 406 { 407 using _VSTD::swap; 408 swap(static_cast<const _Hash&>(*this), static_cast<const _Hash&>(__y)); 409 } 410}; 411 412template <class _Key, class _Cp, class _Hash> 413class __unordered_map_hasher<_Key, _Cp, _Hash, false> 414{ 415 _Hash __hash_; 416 417public: 418 _LIBCPP_INLINE_VISIBILITY 419 __unordered_map_hasher() 420 _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value) 421 : __hash_() {} 422 _LIBCPP_INLINE_VISIBILITY 423 __unordered_map_hasher(const _Hash& __h) 424 _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value) 425 : __hash_(__h) {} 426 _LIBCPP_INLINE_VISIBILITY 427 const _Hash& hash_function() const _NOEXCEPT {return __hash_;} 428 _LIBCPP_INLINE_VISIBILITY 429 size_t operator()(const _Cp& __x) const 430 {return __hash_(__x.__cc.first);} 431 _LIBCPP_INLINE_VISIBILITY 432 size_t operator()(const _Key& __x) const 433 {return __hash_(__x);} 434 void swap(__unordered_map_hasher&__y) 435 _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) 436 { 437 using _VSTD::swap; 438 swap(__hash_, __y.__hash_); 439 } 440}; 441 442template <class _Key, class _Cp, class _Hash, bool __b> 443inline _LIBCPP_INLINE_VISIBILITY 444void 445swap(__unordered_map_hasher<_Key, _Cp, _Hash, __b>& __x, 446 __unordered_map_hasher<_Key, _Cp, _Hash, __b>& __y) 447 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 448{ 449 __x.swap(__y); 450} 451 452template <class _Key, class _Cp, class _Pred, 453 bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value 454 > 455class __unordered_map_equal 456 : private _Pred 457{ 458public: 459 _LIBCPP_INLINE_VISIBILITY 460 __unordered_map_equal() 461 _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value) 462 : _Pred() {} 463 _LIBCPP_INLINE_VISIBILITY 464 __unordered_map_equal(const _Pred& __p) 465 _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value) 466 : _Pred(__p) {} 467 _LIBCPP_INLINE_VISIBILITY 468 const _Pred& key_eq() const _NOEXCEPT {return *this;} 469 _LIBCPP_INLINE_VISIBILITY 470 bool operator()(const _Cp& __x, const _Cp& __y) const 471 {return static_cast<const _Pred&>(*this)(__x.__cc.first, __y.__cc.first);} 472 _LIBCPP_INLINE_VISIBILITY 473 bool operator()(const _Cp& __x, const _Key& __y) const 474 {return static_cast<const _Pred&>(*this)(__x.__cc.first, __y);} 475 _LIBCPP_INLINE_VISIBILITY 476 bool operator()(const _Key& __x, const _Cp& __y) const 477 {return static_cast<const _Pred&>(*this)(__x, __y.__cc.first);} 478 void swap(__unordered_map_equal&__y) 479 _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) 480 { 481 using _VSTD::swap; 482 swap(static_cast<const _Pred&>(*this), static_cast<const _Pred&>(__y)); 483 } 484}; 485 486template <class _Key, class _Cp, class _Pred> 487class __unordered_map_equal<_Key, _Cp, _Pred, false> 488{ 489 _Pred __pred_; 490 491public: 492 _LIBCPP_INLINE_VISIBILITY 493 __unordered_map_equal() 494 _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value) 495 : __pred_() {} 496 _LIBCPP_INLINE_VISIBILITY 497 __unordered_map_equal(const _Pred& __p) 498 _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value) 499 : __pred_(__p) {} 500 _LIBCPP_INLINE_VISIBILITY 501 const _Pred& key_eq() const _NOEXCEPT {return __pred_;} 502 _LIBCPP_INLINE_VISIBILITY 503 bool operator()(const _Cp& __x, const _Cp& __y) const 504 {return __pred_(__x.__cc.first, __y.__cc.first);} 505 _LIBCPP_INLINE_VISIBILITY 506 bool operator()(const _Cp& __x, const _Key& __y) const 507 {return __pred_(__x.__cc.first, __y);} 508 _LIBCPP_INLINE_VISIBILITY 509 bool operator()(const _Key& __x, const _Cp& __y) const 510 {return __pred_(__x, __y.__cc.first);} 511 void swap(__unordered_map_equal&__y) 512 _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) 513 { 514 using _VSTD::swap; 515 swap(__pred_, __y.__pred_); 516 } 517}; 518 519template <class _Key, class _Cp, class _Pred, bool __b> 520inline _LIBCPP_INLINE_VISIBILITY 521void 522swap(__unordered_map_equal<_Key, _Cp, _Pred, __b>& __x, 523 __unordered_map_equal<_Key, _Cp, _Pred, __b>& __y) 524 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 525{ 526 __x.swap(__y); 527} 528 529template <class _Alloc> 530class __hash_map_node_destructor 531{ 532 typedef _Alloc allocator_type; 533 typedef allocator_traits<allocator_type> __alloc_traits; 534 typedef typename __alloc_traits::value_type::value_type value_type; 535public: 536 typedef typename __alloc_traits::pointer pointer; 537private: 538 typedef typename value_type::value_type::first_type first_type; 539 typedef typename value_type::value_type::second_type second_type; 540 541 allocator_type& __na_; 542 543 __hash_map_node_destructor& operator=(const __hash_map_node_destructor&); 544 545public: 546 bool __first_constructed; 547 bool __second_constructed; 548 549 _LIBCPP_INLINE_VISIBILITY 550 explicit __hash_map_node_destructor(allocator_type& __na) _NOEXCEPT 551 : __na_(__na), 552 __first_constructed(false), 553 __second_constructed(false) 554 {} 555 556#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 557 _LIBCPP_INLINE_VISIBILITY 558 __hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x) 559 _NOEXCEPT 560 : __na_(__x.__na_), 561 __first_constructed(__x.__value_constructed), 562 __second_constructed(__x.__value_constructed) 563 { 564 __x.__value_constructed = false; 565 } 566#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 567 _LIBCPP_INLINE_VISIBILITY 568 __hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x) 569 : __na_(__x.__na_), 570 __first_constructed(__x.__value_constructed), 571 __second_constructed(__x.__value_constructed) 572 { 573 const_cast<bool&>(__x.__value_constructed) = false; 574 } 575#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 576 577 _LIBCPP_INLINE_VISIBILITY 578 void operator()(pointer __p) _NOEXCEPT 579 { 580 if (__second_constructed) 581 __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__cc.second)); 582 if (__first_constructed) 583 __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__cc.first)); 584 if (__p) 585 __alloc_traits::deallocate(__na_, __p, 1); 586 } 587}; 588 589#if __cplusplus >= 201103L 590 591template <class _Key, class _Tp> 592union __hash_value_type 593{ 594 typedef _Key key_type; 595 typedef _Tp mapped_type; 596 typedef pair<const key_type, mapped_type> value_type; 597 typedef pair<key_type, mapped_type> __nc_value_type; 598 599 value_type __cc; 600 __nc_value_type __nc; 601 602 template <class ..._Args> 603 _LIBCPP_INLINE_VISIBILITY 604 __hash_value_type(_Args&& ...__args) 605 : __cc(std::forward<_Args>(__args)...) {} 606 607 _LIBCPP_INLINE_VISIBILITY 608 __hash_value_type(const __hash_value_type& __v) 609 : __cc(__v.__cc) {} 610 611 _LIBCPP_INLINE_VISIBILITY 612 __hash_value_type(__hash_value_type&& __v) 613 : __nc(_VSTD::move(__v.__nc)) {} 614 615 _LIBCPP_INLINE_VISIBILITY 616 __hash_value_type& operator=(const __hash_value_type& __v) 617 {__nc = __v.__cc; return *this;} 618 619 _LIBCPP_INLINE_VISIBILITY 620 __hash_value_type& operator=(__hash_value_type&& __v) 621 {__nc = _VSTD::move(__v.__nc); return *this;} 622 623 _LIBCPP_INLINE_VISIBILITY 624 ~__hash_value_type() {__cc.~value_type();} 625}; 626 627#else 628 629template <class _Key, class _Tp> 630struct __hash_value_type 631{ 632 typedef _Key key_type; 633 typedef _Tp mapped_type; 634 typedef pair<const key_type, mapped_type> value_type; 635 636 value_type __cc; 637 638 _LIBCPP_INLINE_VISIBILITY 639 __hash_value_type() {} 640 641 template <class _A0> 642 _LIBCPP_INLINE_VISIBILITY 643 __hash_value_type(const _A0& __a0) 644 : __cc(__a0) {} 645 646 template <class _A0, class _A1> 647 _LIBCPP_INLINE_VISIBILITY 648 __hash_value_type(const _A0& __a0, const _A1& __a1) 649 : __cc(__a0, __a1) {} 650}; 651 652#endif 653 654template <class _HashIterator> 655class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator 656{ 657 _HashIterator __i_; 658 659 typedef pointer_traits<typename _HashIterator::pointer> __pointer_traits; 660 typedef const typename _HashIterator::value_type::value_type::first_type key_type; 661 typedef typename _HashIterator::value_type::value_type::second_type mapped_type; 662public: 663 typedef forward_iterator_tag iterator_category; 664 typedef pair<key_type, mapped_type> value_type; 665 typedef typename _HashIterator::difference_type difference_type; 666 typedef value_type& reference; 667 typedef typename __pointer_traits::template 668#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 669 rebind<value_type> 670#else 671 rebind<value_type>::other 672#endif 673 pointer; 674 675 _LIBCPP_INLINE_VISIBILITY 676 __hash_map_iterator() _NOEXCEPT {} 677 678 _LIBCPP_INLINE_VISIBILITY 679 __hash_map_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {} 680 681 _LIBCPP_INLINE_VISIBILITY 682 reference operator*() const {return __i_->__cc;} 683 _LIBCPP_INLINE_VISIBILITY 684 pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__cc);} 685 686 _LIBCPP_INLINE_VISIBILITY 687 __hash_map_iterator& operator++() {++__i_; return *this;} 688 _LIBCPP_INLINE_VISIBILITY 689 __hash_map_iterator operator++(int) 690 { 691 __hash_map_iterator __t(*this); 692 ++(*this); 693 return __t; 694 } 695 696 friend _LIBCPP_INLINE_VISIBILITY 697 bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y) 698 {return __x.__i_ == __y.__i_;} 699 friend _LIBCPP_INLINE_VISIBILITY 700 bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) 701 {return __x.__i_ != __y.__i_;} 702 703 template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map; 704 template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap; 705 template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator; 706 template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator; 707 template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator; 708}; 709 710template <class _HashIterator> 711class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator 712{ 713 _HashIterator __i_; 714 715 typedef pointer_traits<typename _HashIterator::pointer> __pointer_traits; 716 typedef const typename _HashIterator::value_type::value_type::first_type key_type; 717 typedef typename _HashIterator::value_type::value_type::second_type mapped_type; 718public: 719 typedef forward_iterator_tag iterator_category; 720 typedef pair<key_type, mapped_type> value_type; 721 typedef typename _HashIterator::difference_type difference_type; 722 typedef const value_type& reference; 723 typedef typename __pointer_traits::template 724#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 725 rebind<const value_type> 726#else 727 rebind<const value_type>::other 728#endif 729 pointer; 730 731 _LIBCPP_INLINE_VISIBILITY 732 __hash_map_const_iterator() _NOEXCEPT {} 733 734 _LIBCPP_INLINE_VISIBILITY 735 __hash_map_const_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {} 736 _LIBCPP_INLINE_VISIBILITY 737 __hash_map_const_iterator( 738 __hash_map_iterator<typename _HashIterator::__non_const_iterator> __i) 739 _NOEXCEPT 740 : __i_(__i.__i_) {} 741 742 _LIBCPP_INLINE_VISIBILITY 743 reference operator*() const {return __i_->__cc;} 744 _LIBCPP_INLINE_VISIBILITY 745 pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__cc);} 746 747 _LIBCPP_INLINE_VISIBILITY 748 __hash_map_const_iterator& operator++() {++__i_; return *this;} 749 _LIBCPP_INLINE_VISIBILITY 750 __hash_map_const_iterator operator++(int) 751 { 752 __hash_map_const_iterator __t(*this); 753 ++(*this); 754 return __t; 755 } 756 757 friend _LIBCPP_INLINE_VISIBILITY 758 bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) 759 {return __x.__i_ == __y.__i_;} 760 friend _LIBCPP_INLINE_VISIBILITY 761 bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) 762 {return __x.__i_ != __y.__i_;} 763 764 template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map; 765 template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap; 766 template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator; 767 template <class> friend class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator; 768}; 769 770template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, 771 class _Alloc = allocator<pair<const _Key, _Tp> > > 772class _LIBCPP_TYPE_VIS_ONLY unordered_map 773{ 774public: 775 // types 776 typedef _Key key_type; 777 typedef _Tp mapped_type; 778 typedef _Hash hasher; 779 typedef _Pred key_equal; 780 typedef _Alloc allocator_type; 781 typedef pair<const key_type, mapped_type> value_type; 782 typedef pair<key_type, mapped_type> __nc_value_type; 783 typedef value_type& reference; 784 typedef const value_type& const_reference; 785 static_assert((is_same<value_type, typename allocator_type::value_type>::value), 786 "Invalid allocator::value_type"); 787 788private: 789 typedef __hash_value_type<key_type, mapped_type> __value_type; 790 typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher; 791 typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal; 792 typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, 793 __value_type>::type __allocator_type; 794 795 typedef __hash_table<__value_type, __hasher, 796 __key_equal, __allocator_type> __table; 797 798 __table __table_; 799 800 typedef typename __table::__node_pointer __node_pointer; 801 typedef typename __table::__node_const_pointer __node_const_pointer; 802 typedef typename __table::__node_traits __node_traits; 803 typedef typename __table::__node_allocator __node_allocator; 804 typedef typename __table::__node __node; 805 typedef __hash_map_node_destructor<__node_allocator> _Dp; 806 typedef unique_ptr<__node, _Dp> __node_holder; 807 typedef allocator_traits<allocator_type> __alloc_traits; 808public: 809 typedef typename __alloc_traits::pointer pointer; 810 typedef typename __alloc_traits::const_pointer const_pointer; 811 typedef typename __alloc_traits::size_type size_type; 812 typedef typename __alloc_traits::difference_type difference_type; 813 814 typedef __hash_map_iterator<typename __table::iterator> iterator; 815 typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator; 816 typedef __hash_map_iterator<typename __table::local_iterator> local_iterator; 817 typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator; 818 819 _LIBCPP_INLINE_VISIBILITY 820 unordered_map() 821 _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) 822 { 823#if _LIBCPP_DEBUG_LEVEL >= 2 824 __get_db()->__insert_c(this); 825#endif 826 } 827 explicit unordered_map(size_type __n, const hasher& __hf = hasher(), 828 const key_equal& __eql = key_equal()); 829 unordered_map(size_type __n, const hasher& __hf, 830 const key_equal& __eql, 831 const allocator_type& __a); 832 template <class _InputIterator> 833 unordered_map(_InputIterator __first, _InputIterator __last); 834 template <class _InputIterator> 835 unordered_map(_InputIterator __first, _InputIterator __last, 836 size_type __n, const hasher& __hf = hasher(), 837 const key_equal& __eql = key_equal()); 838 template <class _InputIterator> 839 unordered_map(_InputIterator __first, _InputIterator __last, 840 size_type __n, const hasher& __hf, 841 const key_equal& __eql, 842 const allocator_type& __a); 843 explicit unordered_map(const allocator_type& __a); 844 unordered_map(const unordered_map& __u); 845 unordered_map(const unordered_map& __u, const allocator_type& __a); 846#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 847 unordered_map(unordered_map&& __u) 848 _NOEXCEPT_(is_nothrow_move_constructible<__table>::value); 849 unordered_map(unordered_map&& __u, const allocator_type& __a); 850#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 851#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 852 unordered_map(initializer_list<value_type> __il); 853 unordered_map(initializer_list<value_type> __il, size_type __n, 854 const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); 855 unordered_map(initializer_list<value_type> __il, size_type __n, 856 const hasher& __hf, const key_equal& __eql, 857 const allocator_type& __a); 858#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 859#if _LIBCPP_STD_VER > 11 860 _LIBCPP_INLINE_VISIBILITY 861 unordered_map(size_type __n, const allocator_type& __a) 862 : unordered_map(__n, hasher(), key_equal(), __a) {} 863 _LIBCPP_INLINE_VISIBILITY 864 unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a) 865 : unordered_map(__n, __hf, key_equal(), __a) {} 866 template <class _InputIterator> 867 _LIBCPP_INLINE_VISIBILITY 868 unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) 869 : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) {} 870 template <class _InputIterator> 871 _LIBCPP_INLINE_VISIBILITY 872 unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, 873 const allocator_type& __a) 874 : unordered_map(__first, __last, __n, __hf, key_equal(), __a) {} 875 _LIBCPP_INLINE_VISIBILITY 876 unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a) 877 : unordered_map(__il, __n, hasher(), key_equal(), __a) {} 878 _LIBCPP_INLINE_VISIBILITY 879 unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf, 880 const allocator_type& __a) 881 : unordered_map(__il, __n, __hf, key_equal(), __a) {} 882#endif 883 // ~unordered_map() = default; 884 _LIBCPP_INLINE_VISIBILITY 885 unordered_map& operator=(const unordered_map& __u) 886 { 887#if __cplusplus >= 201103L 888 __table_ = __u.__table_; 889#else 890 if (this != &__u) { 891 __table_.clear(); 892 __table_.hash_function() = __u.__table_.hash_function(); 893 __table_.key_eq() = __u.__table_.key_eq(); 894 __table_.max_load_factor() = __u.__table_.max_load_factor(); 895 __table_.__copy_assign_alloc(__u.__table_); 896 insert(__u.begin(), __u.end()); 897 } 898#endif 899 return *this; 900 } 901#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 902 unordered_map& operator=(unordered_map&& __u) 903 _NOEXCEPT_(is_nothrow_move_assignable<__table>::value); 904#endif 905#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 906 unordered_map& operator=(initializer_list<value_type> __il); 907#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 908 909 _LIBCPP_INLINE_VISIBILITY 910 allocator_type get_allocator() const _NOEXCEPT 911 {return allocator_type(__table_.__node_alloc());} 912 913 _LIBCPP_INLINE_VISIBILITY 914 bool empty() const _NOEXCEPT {return __table_.size() == 0;} 915 _LIBCPP_INLINE_VISIBILITY 916 size_type size() const _NOEXCEPT {return __table_.size();} 917 _LIBCPP_INLINE_VISIBILITY 918 size_type max_size() const _NOEXCEPT {return __table_.max_size();} 919 920 _LIBCPP_INLINE_VISIBILITY 921 iterator begin() _NOEXCEPT {return __table_.begin();} 922 _LIBCPP_INLINE_VISIBILITY 923 iterator end() _NOEXCEPT {return __table_.end();} 924 _LIBCPP_INLINE_VISIBILITY 925 const_iterator begin() const _NOEXCEPT {return __table_.begin();} 926 _LIBCPP_INLINE_VISIBILITY 927 const_iterator end() const _NOEXCEPT {return __table_.end();} 928 _LIBCPP_INLINE_VISIBILITY 929 const_iterator cbegin() const _NOEXCEPT {return __table_.begin();} 930 _LIBCPP_INLINE_VISIBILITY 931 const_iterator cend() const _NOEXCEPT {return __table_.end();} 932 933#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 934#ifndef _LIBCPP_HAS_NO_VARIADICS 935 936 template <class... _Args> 937 pair<iterator, bool> emplace(_Args&&... __args); 938 939 template <class... _Args> 940 _LIBCPP_INLINE_VISIBILITY 941#if _LIBCPP_DEBUG_LEVEL >= 2 942 iterator emplace_hint(const_iterator __p, _Args&&... __args) 943 { 944 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 945 "unordered_map::emplace_hint(const_iterator, args...) called with an iterator not" 946 " referring to this unordered_map"); 947 return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first; 948 } 949#else 950 iterator emplace_hint(const_iterator, _Args&&... __args) 951 {return emplace(_VSTD::forward<_Args>(__args)...).first;} 952#endif 953#endif // _LIBCPP_HAS_NO_VARIADICS 954#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 955 _LIBCPP_INLINE_VISIBILITY 956 pair<iterator, bool> insert(const value_type& __x) 957 {return __table_.__insert_unique(__x);} 958#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 959 template <class _Pp, 960 class = typename enable_if<is_constructible<value_type, _Pp>::value>::type> 961 _LIBCPP_INLINE_VISIBILITY 962 pair<iterator, bool> insert(_Pp&& __x) 963 {return __table_.__insert_unique(_VSTD::forward<_Pp>(__x));} 964#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 965 _LIBCPP_INLINE_VISIBILITY 966#if _LIBCPP_DEBUG_LEVEL >= 2 967 iterator insert(const_iterator __p, const value_type& __x) 968 { 969 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 970 "unordered_map::insert(const_iterator, const value_type&) called with an iterator not" 971 " referring to this unordered_map"); 972 return insert(__x).first; 973 } 974#else 975 iterator insert(const_iterator, const value_type& __x) 976 {return insert(__x).first;} 977#endif 978#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 979 template <class _Pp, 980 class = typename enable_if<is_constructible<value_type, _Pp>::value>::type> 981 _LIBCPP_INLINE_VISIBILITY 982#if _LIBCPP_DEBUG_LEVEL >= 2 983 iterator insert(const_iterator __p, _Pp&& __x) 984 { 985 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 986 "unordered_map::insert(const_iterator, value_type&&) called with an iterator not" 987 " referring to this unordered_map"); 988 return insert(_VSTD::forward<_Pp>(__x)).first; 989 } 990#else 991 iterator insert(const_iterator, _Pp&& __x) 992 {return insert(_VSTD::forward<_Pp>(__x)).first;} 993#endif 994#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 995 template <class _InputIterator> 996 void insert(_InputIterator __first, _InputIterator __last); 997#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 998 _LIBCPP_INLINE_VISIBILITY 999 void insert(initializer_list<value_type> __il) 1000 {insert(__il.begin(), __il.end());} 1001#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1002 1003#if _LIBCPP_STD_VER > 14 1004#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1005#ifndef _LIBCPP_HAS_NO_VARIADICS 1006 template <class... _Args> 1007 _LIBCPP_INLINE_VISIBILITY 1008 pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) 1009 { 1010 iterator __p = __table_.find(__k); 1011 if ( __p != end()) 1012 return _VSTD::make_pair(__p, false); 1013 else 1014 return _VSTD::make_pair( 1015 emplace_hint(__p, 1016 _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), 1017 _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)), 1018 true); 1019 } 1020 1021 template <class... _Args> 1022 _LIBCPP_INLINE_VISIBILITY 1023 pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) 1024 { 1025 iterator __p = __table_.find(__k); 1026 if ( __p != end()) 1027 return _VSTD::make_pair(__p, false); 1028 else 1029 return _VSTD::make_pair( 1030 emplace_hint(__p, 1031 _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), 1032 _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)), 1033 true); 1034 } 1035 1036 template <class... _Args> 1037 _LIBCPP_INLINE_VISIBILITY 1038 iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args) 1039 { 1040 iterator __p = __table_.find(__k); 1041 if ( __p != end()) 1042 return __p; 1043 else 1044 return emplace_hint(__h, 1045 _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), 1046 _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); 1047 } 1048 1049 template <class... _Args> 1050 _LIBCPP_INLINE_VISIBILITY 1051 iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args) 1052 { 1053 iterator __p = __table_.find(__k); 1054 if ( __p != end()) 1055 return __p; 1056 else 1057 return emplace_hint(__h, 1058 _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), 1059 _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); 1060 } 1061 1062 template <class _Vp> 1063 _LIBCPP_INLINE_VISIBILITY 1064 pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) 1065 { 1066 iterator __p = __table_.find(__k); 1067 if ( __p != end()) 1068 { 1069 __p->second = _VSTD::move(__v); 1070 return _VSTD::make_pair(__p, false); 1071 } 1072 return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true); 1073 } 1074 1075 template <class _Vp> 1076 _LIBCPP_INLINE_VISIBILITY 1077 pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) 1078 { 1079 iterator __p = __table_.find(__k); 1080 if ( __p != end()) 1081 { 1082 __p->second = _VSTD::move(__v); 1083 return _VSTD::make_pair(__p, false); 1084 } 1085 return _VSTD::make_pair(emplace_hint(__p, _VSTD::forward<key_type>(__k), _VSTD::forward<_Vp>(__v)), true); 1086 } 1087 1088 template <class _Vp> 1089 _LIBCPP_INLINE_VISIBILITY 1090 iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v) 1091 { 1092 iterator __p = __table_.find(__k); 1093 if ( __p != end()) 1094 { 1095 __p->second = _VSTD::move(__v); 1096 return __p; 1097 } 1098 return emplace_hint(__h, __k, _VSTD::forward<_Vp>(__v)); 1099 } 1100 1101 template <class _Vp> 1102 _LIBCPP_INLINE_VISIBILITY 1103 iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v) 1104 { 1105 iterator __p = __table_.find(__k); 1106 if ( __p != end()) 1107 { 1108 __p->second = _VSTD::move(__v); 1109 return __p; 1110 } 1111 return emplace_hint(__h, _VSTD::forward<key_type>(__k), _VSTD::forward<_Vp>(__v)); 1112 } 1113#endif 1114#endif 1115#endif 1116 1117 _LIBCPP_INLINE_VISIBILITY 1118 iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);} 1119 _LIBCPP_INLINE_VISIBILITY 1120 iterator erase(iterator __p) {return __table_.erase(__p.__i_);} 1121 _LIBCPP_INLINE_VISIBILITY 1122 size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} 1123 _LIBCPP_INLINE_VISIBILITY 1124 iterator erase(const_iterator __first, const_iterator __last) 1125 {return __table_.erase(__first.__i_, __last.__i_);} 1126 _LIBCPP_INLINE_VISIBILITY 1127 void clear() _NOEXCEPT {__table_.clear();} 1128 1129 _LIBCPP_INLINE_VISIBILITY 1130 void swap(unordered_map& __u) 1131 _NOEXCEPT_(__is_nothrow_swappable<__table>::value) 1132 {__table_.swap(__u.__table_);} 1133 1134 _LIBCPP_INLINE_VISIBILITY 1135 hasher hash_function() const 1136 {return __table_.hash_function().hash_function();} 1137 _LIBCPP_INLINE_VISIBILITY 1138 key_equal key_eq() const 1139 {return __table_.key_eq().key_eq();} 1140 1141 _LIBCPP_INLINE_VISIBILITY 1142 iterator find(const key_type& __k) {return __table_.find(__k);} 1143 _LIBCPP_INLINE_VISIBILITY 1144 const_iterator find(const key_type& __k) const {return __table_.find(__k);} 1145 _LIBCPP_INLINE_VISIBILITY 1146 size_type count(const key_type& __k) const {return __table_.__count_unique(__k);} 1147 _LIBCPP_INLINE_VISIBILITY 1148 pair<iterator, iterator> equal_range(const key_type& __k) 1149 {return __table_.__equal_range_unique(__k);} 1150 _LIBCPP_INLINE_VISIBILITY 1151 pair<const_iterator, const_iterator> equal_range(const key_type& __k) const 1152 {return __table_.__equal_range_unique(__k);} 1153 1154 mapped_type& operator[](const key_type& __k); 1155#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1156 mapped_type& operator[](key_type&& __k); 1157#endif 1158 1159 mapped_type& at(const key_type& __k); 1160 const mapped_type& at(const key_type& __k) const; 1161 1162 _LIBCPP_INLINE_VISIBILITY 1163 size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} 1164 _LIBCPP_INLINE_VISIBILITY 1165 size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();} 1166 1167 _LIBCPP_INLINE_VISIBILITY 1168 size_type bucket_size(size_type __n) const 1169 {return __table_.bucket_size(__n);} 1170 _LIBCPP_INLINE_VISIBILITY 1171 size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} 1172 1173 _LIBCPP_INLINE_VISIBILITY 1174 local_iterator begin(size_type __n) {return __table_.begin(__n);} 1175 _LIBCPP_INLINE_VISIBILITY 1176 local_iterator end(size_type __n) {return __table_.end(__n);} 1177 _LIBCPP_INLINE_VISIBILITY 1178 const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);} 1179 _LIBCPP_INLINE_VISIBILITY 1180 const_local_iterator end(size_type __n) const {return __table_.cend(__n);} 1181 _LIBCPP_INLINE_VISIBILITY 1182 const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} 1183 _LIBCPP_INLINE_VISIBILITY 1184 const_local_iterator cend(size_type __n) const {return __table_.cend(__n);} 1185 1186 _LIBCPP_INLINE_VISIBILITY 1187 float load_factor() const _NOEXCEPT {return __table_.load_factor();} 1188 _LIBCPP_INLINE_VISIBILITY 1189 float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();} 1190 _LIBCPP_INLINE_VISIBILITY 1191 void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} 1192 _LIBCPP_INLINE_VISIBILITY 1193 void rehash(size_type __n) {__table_.rehash(__n);} 1194 _LIBCPP_INLINE_VISIBILITY 1195 void reserve(size_type __n) {__table_.reserve(__n);} 1196 1197#if _LIBCPP_DEBUG_LEVEL >= 2 1198 1199 bool __dereferenceable(const const_iterator* __i) const 1200 {return __table_.__dereferenceable(&__i->__i_);} 1201 bool __decrementable(const const_iterator* __i) const 1202 {return __table_.__decrementable(&__i->__i_);} 1203 bool __addable(const const_iterator* __i, ptrdiff_t __n) const 1204 {return __table_.__addable(&__i->__i_, __n);} 1205 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const 1206 {return __table_.__addable(&__i->__i_, __n);} 1207 1208#endif // _LIBCPP_DEBUG_LEVEL >= 2 1209 1210private: 1211#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1212 __node_holder __construct_node(); 1213 template <class _A0> 1214 __node_holder 1215 __construct_node(_A0&& __a0); 1216 __node_holder __construct_node_with_key(key_type&& __k); 1217#ifndef _LIBCPP_HAS_NO_VARIADICS 1218 template <class _A0, class _A1, class ..._Args> 1219 __node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args); 1220#endif // _LIBCPP_HAS_NO_VARIADICS 1221#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1222 __node_holder __construct_node_with_key(const key_type& __k); 1223}; 1224 1225template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1226unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1227 size_type __n, const hasher& __hf, const key_equal& __eql) 1228 : __table_(__hf, __eql) 1229{ 1230#if _LIBCPP_DEBUG_LEVEL >= 2 1231 __get_db()->__insert_c(this); 1232#endif 1233 __table_.rehash(__n); 1234} 1235 1236template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1237unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1238 size_type __n, const hasher& __hf, const key_equal& __eql, 1239 const allocator_type& __a) 1240 : __table_(__hf, __eql, __a) 1241{ 1242#if _LIBCPP_DEBUG_LEVEL >= 2 1243 __get_db()->__insert_c(this); 1244#endif 1245 __table_.rehash(__n); 1246} 1247 1248template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1249inline _LIBCPP_INLINE_VISIBILITY 1250unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1251 const allocator_type& __a) 1252 : __table_(__a) 1253{ 1254#if _LIBCPP_DEBUG_LEVEL >= 2 1255 __get_db()->__insert_c(this); 1256#endif 1257} 1258 1259template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1260template <class _InputIterator> 1261unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1262 _InputIterator __first, _InputIterator __last) 1263{ 1264#if _LIBCPP_DEBUG_LEVEL >= 2 1265 __get_db()->__insert_c(this); 1266#endif 1267 insert(__first, __last); 1268} 1269 1270template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1271template <class _InputIterator> 1272unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1273 _InputIterator __first, _InputIterator __last, size_type __n, 1274 const hasher& __hf, const key_equal& __eql) 1275 : __table_(__hf, __eql) 1276{ 1277#if _LIBCPP_DEBUG_LEVEL >= 2 1278 __get_db()->__insert_c(this); 1279#endif 1280 __table_.rehash(__n); 1281 insert(__first, __last); 1282} 1283 1284template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1285template <class _InputIterator> 1286unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1287 _InputIterator __first, _InputIterator __last, size_type __n, 1288 const hasher& __hf, const key_equal& __eql, const allocator_type& __a) 1289 : __table_(__hf, __eql, __a) 1290{ 1291#if _LIBCPP_DEBUG_LEVEL >= 2 1292 __get_db()->__insert_c(this); 1293#endif 1294 __table_.rehash(__n); 1295 insert(__first, __last); 1296} 1297 1298template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1299unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1300 const unordered_map& __u) 1301 : __table_(__u.__table_) 1302{ 1303#if _LIBCPP_DEBUG_LEVEL >= 2 1304 __get_db()->__insert_c(this); 1305#endif 1306 __table_.rehash(__u.bucket_count()); 1307 insert(__u.begin(), __u.end()); 1308} 1309 1310template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1311unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1312 const unordered_map& __u, const allocator_type& __a) 1313 : __table_(__u.__table_, __a) 1314{ 1315#if _LIBCPP_DEBUG_LEVEL >= 2 1316 __get_db()->__insert_c(this); 1317#endif 1318 __table_.rehash(__u.bucket_count()); 1319 insert(__u.begin(), __u.end()); 1320} 1321 1322#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1323 1324template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1325inline _LIBCPP_INLINE_VISIBILITY 1326unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1327 unordered_map&& __u) 1328 _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) 1329 : __table_(_VSTD::move(__u.__table_)) 1330{ 1331#if _LIBCPP_DEBUG_LEVEL >= 2 1332 __get_db()->__insert_c(this); 1333 __get_db()->swap(this, &__u); 1334#endif 1335} 1336 1337template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1338unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1339 unordered_map&& __u, const allocator_type& __a) 1340 : __table_(_VSTD::move(__u.__table_), __a) 1341{ 1342#if _LIBCPP_DEBUG_LEVEL >= 2 1343 __get_db()->__insert_c(this); 1344#endif 1345 if (__a != __u.get_allocator()) 1346 { 1347 iterator __i = __u.begin(); 1348 while (__u.size() != 0) 1349 __table_.__insert_unique( 1350 _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_) 1351 ); 1352 } 1353#if _LIBCPP_DEBUG_LEVEL >= 2 1354 else 1355 __get_db()->swap(this, &__u); 1356#endif 1357} 1358 1359#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1360 1361#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1362 1363template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1364unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1365 initializer_list<value_type> __il) 1366{ 1367#if _LIBCPP_DEBUG_LEVEL >= 2 1368 __get_db()->__insert_c(this); 1369#endif 1370 insert(__il.begin(), __il.end()); 1371} 1372 1373template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1374unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1375 initializer_list<value_type> __il, size_type __n, const hasher& __hf, 1376 const key_equal& __eql) 1377 : __table_(__hf, __eql) 1378{ 1379#if _LIBCPP_DEBUG_LEVEL >= 2 1380 __get_db()->__insert_c(this); 1381#endif 1382 __table_.rehash(__n); 1383 insert(__il.begin(), __il.end()); 1384} 1385 1386template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1387unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( 1388 initializer_list<value_type> __il, size_type __n, const hasher& __hf, 1389 const key_equal& __eql, const allocator_type& __a) 1390 : __table_(__hf, __eql, __a) 1391{ 1392#if _LIBCPP_DEBUG_LEVEL >= 2 1393 __get_db()->__insert_c(this); 1394#endif 1395 __table_.rehash(__n); 1396 insert(__il.begin(), __il.end()); 1397} 1398 1399#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1400 1401#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1402 1403template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1404inline _LIBCPP_INLINE_VISIBILITY 1405unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& 1406unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u) 1407 _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) 1408{ 1409 __table_ = _VSTD::move(__u.__table_); 1410 return *this; 1411} 1412 1413#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1414 1415#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1416 1417template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1418inline _LIBCPP_INLINE_VISIBILITY 1419unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& 1420unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=( 1421 initializer_list<value_type> __il) 1422{ 1423 __table_.__assign_unique(__il.begin(), __il.end()); 1424 return *this; 1425} 1426 1427#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1428 1429#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1430 1431template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1432typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 1433unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node() 1434{ 1435 __node_allocator& __na = __table_.__node_alloc(); 1436 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 1437 __node_traits::construct(__na, _VSTD::addressof(__h->__value_)); 1438 __h.get_deleter().__first_constructed = true; 1439 __h.get_deleter().__second_constructed = true; 1440 return __h; 1441} 1442 1443template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1444template <class _A0> 1445typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 1446unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0) 1447{ 1448 __node_allocator& __na = __table_.__node_alloc(); 1449 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 1450 __node_traits::construct(__na, _VSTD::addressof(__h->__value_), 1451 _VSTD::forward<_A0>(__a0)); 1452 __h.get_deleter().__first_constructed = true; 1453 __h.get_deleter().__second_constructed = true; 1454 return __h; 1455} 1456 1457template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1458typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 1459unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(key_type&& __k) 1460{ 1461 __node_allocator& __na = __table_.__node_alloc(); 1462 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 1463 __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), _VSTD::move(__k)); 1464 __h.get_deleter().__first_constructed = true; 1465 __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second)); 1466 __h.get_deleter().__second_constructed = true; 1467 return __h; 1468} 1469 1470#ifndef _LIBCPP_HAS_NO_VARIADICS 1471 1472template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1473template <class _A0, class _A1, class ..._Args> 1474typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 1475unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0, 1476 _A1&& __a1, 1477 _Args&&... __args) 1478{ 1479 __node_allocator& __na = __table_.__node_alloc(); 1480 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 1481 __node_traits::construct(__na, _VSTD::addressof(__h->__value_), 1482 _VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1), 1483 _VSTD::forward<_Args>(__args)...); 1484 __h.get_deleter().__first_constructed = true; 1485 __h.get_deleter().__second_constructed = true; 1486 return __h; 1487} 1488 1489template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1490template <class... _Args> 1491pair<typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator, bool> 1492unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_Args&&... __args) 1493{ 1494 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); 1495 pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get()); 1496 if (__r.second) 1497 __h.release(); 1498 return __r; 1499} 1500 1501#endif // _LIBCPP_HAS_NO_VARIADICS 1502#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1503 1504template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1505typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 1506unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k) 1507{ 1508 __node_allocator& __na = __table_.__node_alloc(); 1509 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 1510 __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), __k); 1511 __h.get_deleter().__first_constructed = true; 1512 __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second)); 1513 __h.get_deleter().__second_constructed = true; 1514 return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03 1515} 1516 1517template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1518template <class _InputIterator> 1519inline _LIBCPP_INLINE_VISIBILITY 1520void 1521unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, 1522 _InputIterator __last) 1523{ 1524 for (; __first != __last; ++__first) 1525 __table_.__insert_unique(*__first); 1526} 1527 1528template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1529_Tp& 1530unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k) 1531{ 1532 iterator __i = find(__k); 1533 if (__i != end()) 1534 return __i->second; 1535 __node_holder __h = __construct_node_with_key(__k); 1536 pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get()); 1537 __h.release(); 1538 return __r.first->second; 1539} 1540 1541#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1542 1543template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1544_Tp& 1545unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k) 1546{ 1547 iterator __i = find(__k); 1548 if (__i != end()) 1549 return __i->second; 1550 __node_holder __h = __construct_node_with_key(_VSTD::move(__k)); 1551 pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get()); 1552 __h.release(); 1553 return __r.first->second; 1554} 1555 1556#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1557 1558template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1559_Tp& 1560unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) 1561{ 1562 iterator __i = find(__k); 1563#ifndef _LIBCPP_NO_EXCEPTIONS 1564 if (__i == end()) 1565 throw out_of_range("unordered_map::at: key not found"); 1566#endif // _LIBCPP_NO_EXCEPTIONS 1567 return __i->second; 1568} 1569 1570template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1571const _Tp& 1572unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const 1573{ 1574 const_iterator __i = find(__k); 1575#ifndef _LIBCPP_NO_EXCEPTIONS 1576 if (__i == end()) 1577 throw out_of_range("unordered_map::at: key not found"); 1578#endif // _LIBCPP_NO_EXCEPTIONS 1579 return __i->second; 1580} 1581 1582template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1583inline _LIBCPP_INLINE_VISIBILITY 1584void 1585swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, 1586 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) 1587 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 1588{ 1589 __x.swap(__y); 1590} 1591 1592template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1593bool 1594operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, 1595 const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) 1596{ 1597 if (__x.size() != __y.size()) 1598 return false; 1599 typedef typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator 1600 const_iterator; 1601 for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); 1602 __i != __ex; ++__i) 1603 { 1604 const_iterator __j = __y.find(__i->first); 1605 if (__j == __ey || !(*__i == *__j)) 1606 return false; 1607 } 1608 return true; 1609} 1610 1611template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1612inline _LIBCPP_INLINE_VISIBILITY 1613bool 1614operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, 1615 const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) 1616{ 1617 return !(__x == __y); 1618} 1619 1620template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, 1621 class _Alloc = allocator<pair<const _Key, _Tp> > > 1622class _LIBCPP_TYPE_VIS_ONLY unordered_multimap 1623{ 1624public: 1625 // types 1626 typedef _Key key_type; 1627 typedef _Tp mapped_type; 1628 typedef _Hash hasher; 1629 typedef _Pred key_equal; 1630 typedef _Alloc allocator_type; 1631 typedef pair<const key_type, mapped_type> value_type; 1632 typedef pair<key_type, mapped_type> __nc_value_type; 1633 typedef value_type& reference; 1634 typedef const value_type& const_reference; 1635 static_assert((is_same<value_type, typename allocator_type::value_type>::value), 1636 "Invalid allocator::value_type"); 1637 1638private: 1639 typedef __hash_value_type<key_type, mapped_type> __value_type; 1640 typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher; 1641 typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal; 1642 typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, 1643 __value_type>::type __allocator_type; 1644 1645 typedef __hash_table<__value_type, __hasher, 1646 __key_equal, __allocator_type> __table; 1647 1648 __table __table_; 1649 1650 typedef typename __table::__node_traits __node_traits; 1651 typedef typename __table::__node_allocator __node_allocator; 1652 typedef typename __table::__node __node; 1653 typedef __hash_map_node_destructor<__node_allocator> _Dp; 1654 typedef unique_ptr<__node, _Dp> __node_holder; 1655 typedef allocator_traits<allocator_type> __alloc_traits; 1656public: 1657 typedef typename __alloc_traits::pointer pointer; 1658 typedef typename __alloc_traits::const_pointer const_pointer; 1659 typedef typename __alloc_traits::size_type size_type; 1660 typedef typename __alloc_traits::difference_type difference_type; 1661 1662 typedef __hash_map_iterator<typename __table::iterator> iterator; 1663 typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator; 1664 typedef __hash_map_iterator<typename __table::local_iterator> local_iterator; 1665 typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator; 1666 1667 _LIBCPP_INLINE_VISIBILITY 1668 unordered_multimap() 1669 _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) 1670 { 1671#if _LIBCPP_DEBUG_LEVEL >= 2 1672 __get_db()->__insert_c(this); 1673#endif 1674 } 1675 explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(), 1676 const key_equal& __eql = key_equal()); 1677 unordered_multimap(size_type __n, const hasher& __hf, 1678 const key_equal& __eql, 1679 const allocator_type& __a); 1680 template <class _InputIterator> 1681 unordered_multimap(_InputIterator __first, _InputIterator __last); 1682 template <class _InputIterator> 1683 unordered_multimap(_InputIterator __first, _InputIterator __last, 1684 size_type __n, const hasher& __hf = hasher(), 1685 const key_equal& __eql = key_equal()); 1686 template <class _InputIterator> 1687 unordered_multimap(_InputIterator __first, _InputIterator __last, 1688 size_type __n, const hasher& __hf, 1689 const key_equal& __eql, 1690 const allocator_type& __a); 1691 explicit unordered_multimap(const allocator_type& __a); 1692 unordered_multimap(const unordered_multimap& __u); 1693 unordered_multimap(const unordered_multimap& __u, const allocator_type& __a); 1694#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1695 unordered_multimap(unordered_multimap&& __u) 1696 _NOEXCEPT_(is_nothrow_move_constructible<__table>::value); 1697 unordered_multimap(unordered_multimap&& __u, const allocator_type& __a); 1698#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1699#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1700 unordered_multimap(initializer_list<value_type> __il); 1701 unordered_multimap(initializer_list<value_type> __il, size_type __n, 1702 const hasher& __hf = hasher(), 1703 const key_equal& __eql = key_equal()); 1704 unordered_multimap(initializer_list<value_type> __il, size_type __n, 1705 const hasher& __hf, const key_equal& __eql, 1706 const allocator_type& __a); 1707#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1708#if _LIBCPP_STD_VER > 11 1709 _LIBCPP_INLINE_VISIBILITY 1710 unordered_multimap(size_type __n, const allocator_type& __a) 1711 : unordered_multimap(__n, hasher(), key_equal(), __a) {} 1712 _LIBCPP_INLINE_VISIBILITY 1713 unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a) 1714 : unordered_multimap(__n, __hf, key_equal(), __a) {} 1715 template <class _InputIterator> 1716 _LIBCPP_INLINE_VISIBILITY 1717 unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) 1718 : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) {} 1719 template <class _InputIterator> 1720 _LIBCPP_INLINE_VISIBILITY 1721 unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, 1722 const allocator_type& __a) 1723 : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) {} 1724 _LIBCPP_INLINE_VISIBILITY 1725 unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a) 1726 : unordered_multimap(__il, __n, hasher(), key_equal(), __a) {} 1727 _LIBCPP_INLINE_VISIBILITY 1728 unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf, 1729 const allocator_type& __a) 1730 : unordered_multimap(__il, __n, __hf, key_equal(), __a) {} 1731#endif 1732 // ~unordered_multimap() = default; 1733 _LIBCPP_INLINE_VISIBILITY 1734 unordered_multimap& operator=(const unordered_multimap& __u) 1735 { 1736#if __cplusplus >= 201103L 1737 __table_ = __u.__table_; 1738#else 1739 if (this != &__u) { 1740 __table_.clear(); 1741 __table_.hash_function() = __u.__table_.hash_function(); 1742 __table_.key_eq() = __u.__table_.key_eq(); 1743 __table_.max_load_factor() = __u.__table_.max_load_factor(); 1744 __table_.__copy_assign_alloc(__u.__table_); 1745 insert(__u.begin(), __u.end()); 1746 } 1747#endif 1748 return *this; 1749 } 1750#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1751 unordered_multimap& operator=(unordered_multimap&& __u) 1752 _NOEXCEPT_(is_nothrow_move_assignable<__table>::value); 1753#endif 1754#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1755 unordered_multimap& operator=(initializer_list<value_type> __il); 1756#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1757 1758 _LIBCPP_INLINE_VISIBILITY 1759 allocator_type get_allocator() const _NOEXCEPT 1760 {return allocator_type(__table_.__node_alloc());} 1761 1762 _LIBCPP_INLINE_VISIBILITY 1763 bool empty() const _NOEXCEPT {return __table_.size() == 0;} 1764 _LIBCPP_INLINE_VISIBILITY 1765 size_type size() const _NOEXCEPT {return __table_.size();} 1766 _LIBCPP_INLINE_VISIBILITY 1767 size_type max_size() const _NOEXCEPT {return __table_.max_size();} 1768 1769 _LIBCPP_INLINE_VISIBILITY 1770 iterator begin() _NOEXCEPT {return __table_.begin();} 1771 _LIBCPP_INLINE_VISIBILITY 1772 iterator end() _NOEXCEPT {return __table_.end();} 1773 _LIBCPP_INLINE_VISIBILITY 1774 const_iterator begin() const _NOEXCEPT {return __table_.begin();} 1775 _LIBCPP_INLINE_VISIBILITY 1776 const_iterator end() const _NOEXCEPT {return __table_.end();} 1777 _LIBCPP_INLINE_VISIBILITY 1778 const_iterator cbegin() const _NOEXCEPT {return __table_.begin();} 1779 _LIBCPP_INLINE_VISIBILITY 1780 const_iterator cend() const _NOEXCEPT {return __table_.end();} 1781 1782#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1783#ifndef _LIBCPP_HAS_NO_VARIADICS 1784 1785 template <class... _Args> 1786 iterator emplace(_Args&&... __args); 1787 1788 template <class... _Args> 1789 iterator emplace_hint(const_iterator __p, _Args&&... __args); 1790#endif // _LIBCPP_HAS_NO_VARIADICS 1791#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1792 _LIBCPP_INLINE_VISIBILITY 1793 iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);} 1794#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1795 template <class _Pp, 1796 class = typename enable_if<is_constructible<value_type, _Pp>::value>::type> 1797 _LIBCPP_INLINE_VISIBILITY 1798 iterator insert(_Pp&& __x) 1799 {return __table_.__insert_multi(_VSTD::forward<_Pp>(__x));} 1800#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1801 _LIBCPP_INLINE_VISIBILITY 1802 iterator insert(const_iterator __p, const value_type& __x) 1803 {return __table_.__insert_multi(__p.__i_, __x);} 1804#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1805 template <class _Pp, 1806 class = typename enable_if<is_constructible<value_type, _Pp>::value>::type> 1807 _LIBCPP_INLINE_VISIBILITY 1808 iterator insert(const_iterator __p, _Pp&& __x) 1809 {return __table_.__insert_multi(__p.__i_, _VSTD::forward<_Pp>(__x));} 1810#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1811 template <class _InputIterator> 1812 void insert(_InputIterator __first, _InputIterator __last); 1813#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1814 _LIBCPP_INLINE_VISIBILITY 1815 void insert(initializer_list<value_type> __il) 1816 {insert(__il.begin(), __il.end());} 1817#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1818 1819 _LIBCPP_INLINE_VISIBILITY 1820 iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);} 1821 _LIBCPP_INLINE_VISIBILITY 1822 iterator erase(iterator __p) {return __table_.erase(__p.__i_);} 1823 _LIBCPP_INLINE_VISIBILITY 1824 size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);} 1825 _LIBCPP_INLINE_VISIBILITY 1826 iterator erase(const_iterator __first, const_iterator __last) 1827 {return __table_.erase(__first.__i_, __last.__i_);} 1828 _LIBCPP_INLINE_VISIBILITY 1829 void clear() _NOEXCEPT {__table_.clear();} 1830 1831 _LIBCPP_INLINE_VISIBILITY 1832 void swap(unordered_multimap& __u) 1833 _NOEXCEPT_(__is_nothrow_swappable<__table>::value) 1834 {__table_.swap(__u.__table_);} 1835 1836 _LIBCPP_INLINE_VISIBILITY 1837 hasher hash_function() const 1838 {return __table_.hash_function().hash_function();} 1839 _LIBCPP_INLINE_VISIBILITY 1840 key_equal key_eq() const 1841 {return __table_.key_eq().key_eq();} 1842 1843 _LIBCPP_INLINE_VISIBILITY 1844 iterator find(const key_type& __k) {return __table_.find(__k);} 1845 _LIBCPP_INLINE_VISIBILITY 1846 const_iterator find(const key_type& __k) const {return __table_.find(__k);} 1847 _LIBCPP_INLINE_VISIBILITY 1848 size_type count(const key_type& __k) const {return __table_.__count_multi(__k);} 1849 _LIBCPP_INLINE_VISIBILITY 1850 pair<iterator, iterator> equal_range(const key_type& __k) 1851 {return __table_.__equal_range_multi(__k);} 1852 _LIBCPP_INLINE_VISIBILITY 1853 pair<const_iterator, const_iterator> equal_range(const key_type& __k) const 1854 {return __table_.__equal_range_multi(__k);} 1855 1856 _LIBCPP_INLINE_VISIBILITY 1857 size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} 1858 _LIBCPP_INLINE_VISIBILITY 1859 size_type max_bucket_count() const _NOEXCEPT 1860 {return __table_.max_bucket_count();} 1861 1862 _LIBCPP_INLINE_VISIBILITY 1863 size_type bucket_size(size_type __n) const 1864 {return __table_.bucket_size(__n);} 1865 _LIBCPP_INLINE_VISIBILITY 1866 size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} 1867 1868 _LIBCPP_INLINE_VISIBILITY 1869 local_iterator begin(size_type __n) {return __table_.begin(__n);} 1870 _LIBCPP_INLINE_VISIBILITY 1871 local_iterator end(size_type __n) {return __table_.end(__n);} 1872 _LIBCPP_INLINE_VISIBILITY 1873 const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);} 1874 _LIBCPP_INLINE_VISIBILITY 1875 const_local_iterator end(size_type __n) const {return __table_.cend(__n);} 1876 _LIBCPP_INLINE_VISIBILITY 1877 const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} 1878 _LIBCPP_INLINE_VISIBILITY 1879 const_local_iterator cend(size_type __n) const {return __table_.cend(__n);} 1880 1881 _LIBCPP_INLINE_VISIBILITY 1882 float load_factor() const _NOEXCEPT {return __table_.load_factor();} 1883 _LIBCPP_INLINE_VISIBILITY 1884 float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();} 1885 _LIBCPP_INLINE_VISIBILITY 1886 void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} 1887 _LIBCPP_INLINE_VISIBILITY 1888 void rehash(size_type __n) {__table_.rehash(__n);} 1889 _LIBCPP_INLINE_VISIBILITY 1890 void reserve(size_type __n) {__table_.reserve(__n);} 1891 1892#if _LIBCPP_DEBUG_LEVEL >= 2 1893 1894 bool __dereferenceable(const const_iterator* __i) const 1895 {return __table_.__dereferenceable(&__i->__i_);} 1896 bool __decrementable(const const_iterator* __i) const 1897 {return __table_.__decrementable(&__i->__i_);} 1898 bool __addable(const const_iterator* __i, ptrdiff_t __n) const 1899 {return __table_.__addable(&__i->__i_, __n);} 1900 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const 1901 {return __table_.__addable(&__i->__i_, __n);} 1902 1903#endif // _LIBCPP_DEBUG_LEVEL >= 2 1904 1905private: 1906#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1907 __node_holder __construct_node(); 1908 template <class _A0> 1909 __node_holder 1910 __construct_node(_A0&& __a0); 1911#ifndef _LIBCPP_HAS_NO_VARIADICS 1912 template <class _A0, class _A1, class ..._Args> 1913 __node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args); 1914#endif // _LIBCPP_HAS_NO_VARIADICS 1915#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1916}; 1917 1918template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1919unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 1920 size_type __n, const hasher& __hf, const key_equal& __eql) 1921 : __table_(__hf, __eql) 1922{ 1923#if _LIBCPP_DEBUG_LEVEL >= 2 1924 __get_db()->__insert_c(this); 1925#endif 1926 __table_.rehash(__n); 1927} 1928 1929template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1930unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 1931 size_type __n, const hasher& __hf, const key_equal& __eql, 1932 const allocator_type& __a) 1933 : __table_(__hf, __eql, __a) 1934{ 1935#if _LIBCPP_DEBUG_LEVEL >= 2 1936 __get_db()->__insert_c(this); 1937#endif 1938 __table_.rehash(__n); 1939} 1940 1941template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1942template <class _InputIterator> 1943unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 1944 _InputIterator __first, _InputIterator __last) 1945{ 1946#if _LIBCPP_DEBUG_LEVEL >= 2 1947 __get_db()->__insert_c(this); 1948#endif 1949 insert(__first, __last); 1950} 1951 1952template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1953template <class _InputIterator> 1954unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 1955 _InputIterator __first, _InputIterator __last, size_type __n, 1956 const hasher& __hf, const key_equal& __eql) 1957 : __table_(__hf, __eql) 1958{ 1959#if _LIBCPP_DEBUG_LEVEL >= 2 1960 __get_db()->__insert_c(this); 1961#endif 1962 __table_.rehash(__n); 1963 insert(__first, __last); 1964} 1965 1966template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1967template <class _InputIterator> 1968unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 1969 _InputIterator __first, _InputIterator __last, size_type __n, 1970 const hasher& __hf, const key_equal& __eql, const allocator_type& __a) 1971 : __table_(__hf, __eql, __a) 1972{ 1973#if _LIBCPP_DEBUG_LEVEL >= 2 1974 __get_db()->__insert_c(this); 1975#endif 1976 __table_.rehash(__n); 1977 insert(__first, __last); 1978} 1979 1980template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1981inline _LIBCPP_INLINE_VISIBILITY 1982unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 1983 const allocator_type& __a) 1984 : __table_(__a) 1985{ 1986#if _LIBCPP_DEBUG_LEVEL >= 2 1987 __get_db()->__insert_c(this); 1988#endif 1989} 1990 1991template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 1992unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 1993 const unordered_multimap& __u) 1994 : __table_(__u.__table_) 1995{ 1996#if _LIBCPP_DEBUG_LEVEL >= 2 1997 __get_db()->__insert_c(this); 1998#endif 1999 __table_.rehash(__u.bucket_count()); 2000 insert(__u.begin(), __u.end()); 2001} 2002 2003template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2004unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 2005 const unordered_multimap& __u, const allocator_type& __a) 2006 : __table_(__u.__table_, __a) 2007{ 2008#if _LIBCPP_DEBUG_LEVEL >= 2 2009 __get_db()->__insert_c(this); 2010#endif 2011 __table_.rehash(__u.bucket_count()); 2012 insert(__u.begin(), __u.end()); 2013} 2014 2015#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2016 2017template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2018inline _LIBCPP_INLINE_VISIBILITY 2019unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 2020 unordered_multimap&& __u) 2021 _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) 2022 : __table_(_VSTD::move(__u.__table_)) 2023{ 2024#if _LIBCPP_DEBUG_LEVEL >= 2 2025 __get_db()->__insert_c(this); 2026 __get_db()->swap(this, &__u); 2027#endif 2028} 2029 2030template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2031unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 2032 unordered_multimap&& __u, const allocator_type& __a) 2033 : __table_(_VSTD::move(__u.__table_), __a) 2034{ 2035#if _LIBCPP_DEBUG_LEVEL >= 2 2036 __get_db()->__insert_c(this); 2037#endif 2038 if (__a != __u.get_allocator()) 2039 { 2040 iterator __i = __u.begin(); 2041 while (__u.size() != 0) 2042 { 2043 __table_.__insert_multi( 2044 _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_) 2045 ); 2046 } 2047 } 2048#if _LIBCPP_DEBUG_LEVEL >= 2 2049 else 2050 __get_db()->swap(this, &__u); 2051#endif 2052} 2053 2054#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2055 2056#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2057 2058template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2059unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 2060 initializer_list<value_type> __il) 2061{ 2062#if _LIBCPP_DEBUG_LEVEL >= 2 2063 __get_db()->__insert_c(this); 2064#endif 2065 insert(__il.begin(), __il.end()); 2066} 2067 2068template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2069unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 2070 initializer_list<value_type> __il, size_type __n, const hasher& __hf, 2071 const key_equal& __eql) 2072 : __table_(__hf, __eql) 2073{ 2074#if _LIBCPP_DEBUG_LEVEL >= 2 2075 __get_db()->__insert_c(this); 2076#endif 2077 __table_.rehash(__n); 2078 insert(__il.begin(), __il.end()); 2079} 2080 2081template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2082unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( 2083 initializer_list<value_type> __il, size_type __n, const hasher& __hf, 2084 const key_equal& __eql, const allocator_type& __a) 2085 : __table_(__hf, __eql, __a) 2086{ 2087#if _LIBCPP_DEBUG_LEVEL >= 2 2088 __get_db()->__insert_c(this); 2089#endif 2090 __table_.rehash(__n); 2091 insert(__il.begin(), __il.end()); 2092} 2093 2094#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2095 2096#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2097 2098template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2099inline _LIBCPP_INLINE_VISIBILITY 2100unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& 2101unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u) 2102 _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) 2103{ 2104 __table_ = _VSTD::move(__u.__table_); 2105 return *this; 2106} 2107 2108#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2109 2110#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2111 2112template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2113inline _LIBCPP_INLINE_VISIBILITY 2114unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& 2115unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=( 2116 initializer_list<value_type> __il) 2117{ 2118 __table_.__assign_multi(__il.begin(), __il.end()); 2119 return *this; 2120} 2121 2122#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2123 2124#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2125 2126template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2127typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 2128unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node() 2129{ 2130 __node_allocator& __na = __table_.__node_alloc(); 2131 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 2132 __node_traits::construct(__na, _VSTD::addressof(__h->__value_)); 2133 __h.get_deleter().__first_constructed = true; 2134 __h.get_deleter().__second_constructed = true; 2135 return __h; 2136} 2137 2138template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2139template <class _A0> 2140typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 2141unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0) 2142{ 2143 __node_allocator& __na = __table_.__node_alloc(); 2144 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 2145 __node_traits::construct(__na, _VSTD::addressof(__h->__value_), 2146 _VSTD::forward<_A0>(__a0)); 2147 __h.get_deleter().__first_constructed = true; 2148 __h.get_deleter().__second_constructed = true; 2149 return __h; 2150} 2151 2152#ifndef _LIBCPP_HAS_NO_VARIADICS 2153 2154template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2155template <class _A0, class _A1, class ..._Args> 2156typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder 2157unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node( 2158 _A0&& __a0, _A1&& __a1, _Args&&... __args) 2159{ 2160 __node_allocator& __na = __table_.__node_alloc(); 2161 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); 2162 __node_traits::construct(__na, _VSTD::addressof(__h->__value_), 2163 _VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1), 2164 _VSTD::forward<_Args>(__args)...); 2165 __h.get_deleter().__first_constructed = true; 2166 __h.get_deleter().__second_constructed = true; 2167 return __h; 2168} 2169 2170template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2171template <class... _Args> 2172typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator 2173unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_Args&&... __args) 2174{ 2175 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); 2176 iterator __r = __table_.__node_insert_multi(__h.get()); 2177 __h.release(); 2178 return __r; 2179} 2180 2181template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2182template <class... _Args> 2183typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator 2184unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace_hint( 2185 const_iterator __p, _Args&&... __args) 2186{ 2187 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); 2188 iterator __r = __table_.__node_insert_multi(__p.__i_, __h.get()); 2189 __h.release(); 2190 return __r; 2191} 2192 2193#endif // _LIBCPP_HAS_NO_VARIADICS 2194#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2195 2196template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2197template <class _InputIterator> 2198inline _LIBCPP_INLINE_VISIBILITY 2199void 2200unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, 2201 _InputIterator __last) 2202{ 2203 for (; __first != __last; ++__first) 2204 __table_.__insert_multi(*__first); 2205} 2206 2207template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2208inline _LIBCPP_INLINE_VISIBILITY 2209void 2210swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, 2211 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) 2212 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 2213{ 2214 __x.swap(__y); 2215} 2216 2217template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2218bool 2219operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, 2220 const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) 2221{ 2222 if (__x.size() != __y.size()) 2223 return false; 2224 typedef typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator 2225 const_iterator; 2226 typedef pair<const_iterator, const_iterator> _EqRng; 2227 for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) 2228 { 2229 _EqRng __xeq = __x.equal_range(__i->first); 2230 _EqRng __yeq = __y.equal_range(__i->first); 2231 if (_VSTD::distance(__xeq.first, __xeq.second) != 2232 _VSTD::distance(__yeq.first, __yeq.second) || 2233 !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first)) 2234 return false; 2235 __i = __xeq.second; 2236 } 2237 return true; 2238} 2239 2240template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> 2241inline _LIBCPP_INLINE_VISIBILITY 2242bool 2243operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, 2244 const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) 2245{ 2246 return !(__x == __y); 2247} 2248 2249_LIBCPP_END_NAMESPACE_STD 2250 2251#endif // _LIBCPP_UNORDERED_MAP 2252