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