1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP___TREE
11#define _LIBCPP___TREE
12
13#include <__config>
14#include <iterator>
15#include <memory>
16#include <stdexcept>
17#include <algorithm>
18
19#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20#pragma GCC system_header
21#endif
22
23_LIBCPP_PUSH_MACROS
24#include <__undef_macros>
25
26
27_LIBCPP_BEGIN_NAMESPACE_STD
28
29#if defined(__GNUC__) && !defined(__clang__) // gcc.gnu.org/PR37804
30template <class, class, class, class> class _LIBCPP_TEMPLATE_VIS map;
31template <class, class, class, class> class _LIBCPP_TEMPLATE_VIS multimap;
32template <class, class, class> class _LIBCPP_TEMPLATE_VIS set;
33template <class, class, class> class _LIBCPP_TEMPLATE_VIS multiset;
34#endif
35
36template <class _Tp, class _Compare, class _Allocator> class __tree;
37template <class _Tp, class _NodePtr, class _DiffType>
38 class _LIBCPP_TEMPLATE_VIS __tree_iterator;
39template <class _Tp, class _ConstNodePtr, class _DiffType>
40 class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
41
42template <class _Pointer> class __tree_end_node;
43template <class _VoidPtr> class __tree_node_base;
44template <class _Tp, class _VoidPtr> class __tree_node;
45
46template <class _Key, class _Value>
47struct __value_type;
48
49template <class _Allocator> class __map_node_destructor;
50template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_iterator;
51template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
52
53/*
54
55_NodePtr algorithms
56
57The algorithms taking _NodePtr are red black tree algorithms. Those
58algorithms taking a parameter named __root should assume that __root
59points to a proper red black tree (unless otherwise specified).
60
61Each algorithm herein assumes that __root->__parent_ points to a non-null
62structure which has a member __left_ which points back to __root. No other
63member is read or written to at __root->__parent_.
64
65__root->__parent_ will be referred to below (in comments only) as end_node.
66end_node->__left_ is an externably accessible lvalue for __root, and can be
67changed by node insertion and removal (without explicit reference to end_node).
68
69All nodes (with the exception of end_node), even the node referred to as
70__root, have a non-null __parent_ field.
71
72*/
73
74// Returns: true if __x is a left child of its parent, else false
75// Precondition: __x != nullptr.
76template <class _NodePtr>
77inline _LIBCPP_INLINE_VISIBILITY
78bool
79__tree_is_left_child(_NodePtr __x) _NOEXCEPT
80{
81 return __x == __x->__parent_->__left_;
82}
83
84// Determines if the subtree rooted at __x is a proper red black subtree. If
85// __x is a proper subtree, returns the black height (null counts as 1). If
86// __x is an improper subtree, returns 0.
87template <class _NodePtr>
88unsigned
89__tree_sub_invariant(_NodePtr __x)
90{
91 if (__x == nullptr)
92 return 1;
93 // parent consistency checked by caller
94 // check __x->__left_ consistency
95 if (__x->__left_ != nullptr && __x->__left_->__parent_ != __x)
96 return 0;
97 // check __x->__right_ consistency
98 if (__x->__right_ != nullptr && __x->__right_->__parent_ != __x)
99 return 0;
100 // check __x->__left_ != __x->__right_ unless both are nullptr
101 if (__x->__left_ == __x->__right_ && __x->__left_ != nullptr)
102 return 0;
103 // If this is red, neither child can be red
104 if (!__x->__is_black_)
105 {
106 if (__x->__left_ && !__x->__left_->__is_black_)
107 return 0;
108 if (__x->__right_ && !__x->__right_->__is_black_)
109 return 0;
110 }
111 unsigned __h = __tree_sub_invariant(__x->__left_);
112 if (__h == 0)
113 return 0; // invalid left subtree
114 if (__h != __tree_sub_invariant(__x->__right_))
115 return 0; // invalid or different height right subtree
116 return __h + __x->__is_black_; // return black height of this node
117}
118
119// Determines if the red black tree rooted at __root is a proper red black tree.
120// __root == nullptr is a proper tree. Returns true is __root is a proper
121// red black tree, else returns false.
122template <class _NodePtr>
123bool
124__tree_invariant(_NodePtr __root)
125{
126 if (__root == nullptr)
127 return true;
128 // check __x->__parent_ consistency
129 if (__root->__parent_ == nullptr)
130 return false;
131 if (!__tree_is_left_child(__root))
132 return false;
133 // root must be black
134 if (!__root->__is_black_)
135 return false;
136 // do normal node checks
137 return __tree_sub_invariant(__root) != 0;
138}
139
140// Returns: pointer to the left-most node under __x.
141// Precondition: __x != nullptr.
142template <class _NodePtr>
143inline _LIBCPP_INLINE_VISIBILITY
144_NodePtr
145__tree_min(_NodePtr __x) _NOEXCEPT
146{
147 while (__x->__left_ != nullptr)
148 __x = __x->__left_;
149 return __x;
150}
151
152// Returns: pointer to the right-most node under __x.
153// Precondition: __x != nullptr.
154template <class _NodePtr>
155inline _LIBCPP_INLINE_VISIBILITY
156_NodePtr
157__tree_max(_NodePtr __x) _NOEXCEPT
158{
159 while (__x->__right_ != nullptr)
160 __x = __x->__right_;
161 return __x;
162}
163
164// Returns: pointer to the next in-order node after __x.
165// Precondition: __x != nullptr.
166template <class _NodePtr>
167_NodePtr
168__tree_next(_NodePtr __x) _NOEXCEPT
169{
170 if (__x->__right_ != nullptr)
171 return __tree_min(__x->__right_);
172 while (!__tree_is_left_child(__x))
173 __x = __x->__parent_unsafe();
174 return __x->__parent_unsafe();
175}
176
177template <class _EndNodePtr, class _NodePtr>
178inline _LIBCPP_INLINE_VISIBILITY
179_EndNodePtr
180__tree_next_iter(_NodePtr __x) _NOEXCEPT
181{
182 if (__x->__right_ != nullptr)
183 return static_cast<_EndNodePtr>(__tree_min(__x->__right_));
184 while (!__tree_is_left_child(__x))
185 __x = __x->__parent_unsafe();
186 return static_cast<_EndNodePtr>(__x->__parent_);
187}
188
189// Returns: pointer to the previous in-order node before __x.
190// Precondition: __x != nullptr.
191// Note: __x may be the end node.
192template <class _NodePtr, class _EndNodePtr>
193inline _LIBCPP_INLINE_VISIBILITY
194_NodePtr
195__tree_prev_iter(_EndNodePtr __x) _NOEXCEPT
196{
197 if (__x->__left_ != nullptr)
198 return __tree_max(__x->__left_);
199 _NodePtr __xx = static_cast<_NodePtr>(__x);
200 while (__tree_is_left_child(__xx))
201 __xx = __xx->__parent_unsafe();
202 return __xx->__parent_unsafe();
203}
204
205// Returns: pointer to a node which has no children
206// Precondition: __x != nullptr.
207template <class _NodePtr>
208_NodePtr
209__tree_leaf(_NodePtr __x) _NOEXCEPT
210{
211 while (true)
212 {
213 if (__x->__left_ != nullptr)
214 {
215 __x = __x->__left_;
216 continue;
217 }
218 if (__x->__right_ != nullptr)
219 {
220 __x = __x->__right_;
221 continue;
222 }
223 break;
224 }
225 return __x;
226}
227
228// Effects: Makes __x->__right_ the subtree root with __x as its left child
229// while preserving in-order order.
230// Precondition: __x->__right_ != nullptr
231template <class _NodePtr>
232void
233__tree_left_rotate(_NodePtr __x) _NOEXCEPT
234{
235 _NodePtr __y = __x->__right_;
236 __x->__right_ = __y->__left_;
237 if (__x->__right_ != nullptr)
238 __x->__right_->__set_parent(__x);
239 __y->__parent_ = __x->__parent_;
240 if (__tree_is_left_child(__x))
241 __x->__parent_->__left_ = __y;
242 else
243 __x->__parent_unsafe()->__right_ = __y;
244 __y->__left_ = __x;
245 __x->__set_parent(__y);
246}
247
248// Effects: Makes __x->__left_ the subtree root with __x as its right child
249// while preserving in-order order.
250// Precondition: __x->__left_ != nullptr
251template <class _NodePtr>
252void
253__tree_right_rotate(_NodePtr __x) _NOEXCEPT
254{
255 _NodePtr __y = __x->__left_;
256 __x->__left_ = __y->__right_;
257 if (__x->__left_ != nullptr)
258 __x->__left_->__set_parent(__x);
259 __y->__parent_ = __x->__parent_;
260 if (__tree_is_left_child(__x))
261 __x->__parent_->__left_ = __y;
262 else
263 __x->__parent_unsafe()->__right_ = __y;
264 __y->__right_ = __x;
265 __x->__set_parent(__y);
266}
267
268// Effects: Rebalances __root after attaching __x to a leaf.
269// Precondition: __root != nulptr && __x != nullptr.
270// __x has no children.
271// __x == __root or == a direct or indirect child of __root.
272// If __x were to be unlinked from __root (setting __root to
273// nullptr if __root == __x), __tree_invariant(__root) == true.
274// Postcondition: __tree_invariant(end_node->__left_) == true. end_node->__left_
275// may be different than the value passed in as __root.
276template <class _NodePtr>
277void
278__tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
279{
280 __x->__is_black_ = __x == __root;
281 while (__x != __root && !__x->__parent_unsafe()->__is_black_)
282 {
283 // __x->__parent_ != __root because __x->__parent_->__is_black == false
284 if (__tree_is_left_child(__x->__parent_unsafe()))
285 {
286 _NodePtr __y = __x->__parent_unsafe()->__parent_unsafe()->__right_;
287 if (__y != nullptr && !__y->__is_black_)
288 {
289 __x = __x->__parent_unsafe();
290 __x->__is_black_ = true;
291 __x = __x->__parent_unsafe();
292 __x->__is_black_ = __x == __root;
293 __y->__is_black_ = true;
294 }
295 else
296 {
297 if (!__tree_is_left_child(__x))
298 {
299 __x = __x->__parent_unsafe();
300 __tree_left_rotate(__x);
301 }
302 __x = __x->__parent_unsafe();
303 __x->__is_black_ = true;
304 __x = __x->__parent_unsafe();
305 __x->__is_black_ = false;
306 __tree_right_rotate(__x);
307 break;
308 }
309 }
310 else
311 {
312 _NodePtr __y = __x->__parent_unsafe()->__parent_->__left_;
313 if (__y != nullptr && !__y->__is_black_)
314 {
315 __x = __x->__parent_unsafe();
316 __x->__is_black_ = true;
317 __x = __x->__parent_unsafe();
318 __x->__is_black_ = __x == __root;
319 __y->__is_black_ = true;
320 }
321 else
322 {
323 if (__tree_is_left_child(__x))
324 {
325 __x = __x->__parent_unsafe();
326 __tree_right_rotate(__x);
327 }
328 __x = __x->__parent_unsafe();
329 __x->__is_black_ = true;
330 __x = __x->__parent_unsafe();
331 __x->__is_black_ = false;
332 __tree_left_rotate(__x);
333 break;
334 }
335 }
336 }
337}
338
339// Precondition: __root != nullptr && __z != nullptr.
340// __tree_invariant(__root) == true.
341// __z == __root or == a direct or indirect child of __root.
342// Effects: unlinks __z from the tree rooted at __root, rebalancing as needed.
343// Postcondition: __tree_invariant(end_node->__left_) == true && end_node->__left_
344// nor any of its children refer to __z. end_node->__left_
345// may be different than the value passed in as __root.
346template <class _NodePtr>
347void
348__tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
349{
350 // __z will be removed from the tree. Client still needs to destruct/deallocate it
351 // __y is either __z, or if __z has two children, __tree_next(__z).
352 // __y will have at most one child.
353 // __y will be the initial hole in the tree (make the hole at a leaf)
354 _NodePtr __y = (__z->__left_ == nullptr || __z->__right_ == nullptr) ?
355 __z : __tree_next(__z);
356 // __x is __y's possibly null single child
357 _NodePtr __x = __y->__left_ != nullptr ? __y->__left_ : __y->__right_;
358 // __w is __x's possibly null uncle (will become __x's sibling)
359 _NodePtr __w = nullptr;
360 // link __x to __y's parent, and find __w
361 if (__x != nullptr)
362 __x->__parent_ = __y->__parent_;
363 if (__tree_is_left_child(__y))
364 {
365 __y->__parent_->__left_ = __x;
366 if (__y != __root)
367 __w = __y->__parent_unsafe()->__right_;
368 else
369 __root = __x; // __w == nullptr
370 }
371 else
372 {
373 __y->__parent_unsafe()->__right_ = __x;
374 // __y can't be root if it is a right child
375 __w = __y->__parent_->__left_;
376 }
377 bool __removed_black = __y->__is_black_;
378 // If we didn't remove __z, do so now by splicing in __y for __z,
379 // but copy __z's color. This does not impact __x or __w.
380 if (__y != __z)
381 {
382 // __z->__left_ != nulptr but __z->__right_ might == __x == nullptr
383 __y->__parent_ = __z->__parent_;
384 if (__tree_is_left_child(__z))
385 __y->__parent_->__left_ = __y;
386 else
387 __y->__parent_unsafe()->__right_ = __y;
388 __y->__left_ = __z->__left_;
389 __y->__left_->__set_parent(__y);
390 __y->__right_ = __z->__right_;
391 if (__y->__right_ != nullptr)
392 __y->__right_->__set_parent(__y);
393 __y->__is_black_ = __z->__is_black_;
394 if (__root == __z)
395 __root = __y;
396 }
397 // There is no need to rebalance if we removed a red, or if we removed
398 // the last node.
399 if (__removed_black && __root != nullptr)
400 {
401 // Rebalance:
402 // __x has an implicit black color (transferred from the removed __y)
403 // associated with it, no matter what its color is.
404 // If __x is __root (in which case it can't be null), it is supposed
405 // to be black anyway, and if it is doubly black, then the double
406 // can just be ignored.
407 // If __x is red (in which case it can't be null), then it can absorb
408 // the implicit black just by setting its color to black.
409 // Since __y was black and only had one child (which __x points to), __x
410 // is either red with no children, else null, otherwise __y would have
411 // different black heights under left and right pointers.
412 // if (__x == __root || __x != nullptr && !__x->__is_black_)
413 if (__x != nullptr)
414 __x->__is_black_ = true;
415 else
416 {
417 // Else __x isn't root, and is "doubly black", even though it may
418 // be null. __w can not be null here, else the parent would
419 // see a black height >= 2 on the __x side and a black height
420 // of 1 on the __w side (__w must be a non-null black or a red
421 // with a non-null black child).
422 while (true)
423 {
424 if (!__tree_is_left_child(__w)) // if x is left child
425 {
426 if (!__w->__is_black_)
427 {
428 __w->__is_black_ = true;
429 __w->__parent_unsafe()->__is_black_ = false;
430 __tree_left_rotate(__w->__parent_unsafe());
431 // __x is still valid
432 // reset __root only if necessary
433 if (__root == __w->__left_)
434 __root = __w;
435 // reset sibling, and it still can't be null
436 __w = __w->__left_->__right_;
437 }
438 // __w->__is_black_ is now true, __w may have null children
439 if ((__w->__left_ == nullptr || __w->__left_->__is_black_) &&
440 (__w->__right_ == nullptr || __w->__right_->__is_black_))
441 {
442 __w->__is_black_ = false;
443 __x = __w->__parent_unsafe();
444 // __x can no longer be null
445 if (__x == __root || !__x->__is_black_)
446 {
447 __x->__is_black_ = true;
448 break;
449 }
450 // reset sibling, and it still can't be null
451 __w = __tree_is_left_child(__x) ?
452 __x->__parent_unsafe()->__right_ :
453 __x->__parent_->__left_;
454 // continue;
455 }
456 else // __w has a red child
457 {
458 if (__w->__right_ == nullptr || __w->__right_->__is_black_)
459 {
460 // __w left child is non-null and red
461 __w->__left_->__is_black_ = true;
462 __w->__is_black_ = false;
463 __tree_right_rotate(__w);
464 // __w is known not to be root, so root hasn't changed
465 // reset sibling, and it still can't be null
466 __w = __w->__parent_unsafe();
467 }
468 // __w has a right red child, left child may be null
469 __w->__is_black_ = __w->__parent_unsafe()->__is_black_;
470 __w->__parent_unsafe()->__is_black_ = true;
471 __w->__right_->__is_black_ = true;
472 __tree_left_rotate(__w->__parent_unsafe());
473 break;
474 }
475 }
476 else
477 {
478 if (!__w->__is_black_)
479 {
480 __w->__is_black_ = true;
481 __w->__parent_unsafe()->__is_black_ = false;
482 __tree_right_rotate(__w->__parent_unsafe());
483 // __x is still valid
484 // reset __root only if necessary
485 if (__root == __w->__right_)
486 __root = __w;
487 // reset sibling, and it still can't be null
488 __w = __w->__right_->__left_;
489 }
490 // __w->__is_black_ is now true, __w may have null children
491 if ((__w->__left_ == nullptr || __w->__left_->__is_black_) &&
492 (__w->__right_ == nullptr || __w->__right_->__is_black_))
493 {
494 __w->__is_black_ = false;
495 __x = __w->__parent_unsafe();
496 // __x can no longer be null
497 if (!__x->__is_black_ || __x == __root)
498 {
499 __x->__is_black_ = true;
500 break;
501 }
502 // reset sibling, and it still can't be null
503 __w = __tree_is_left_child(__x) ?
504 __x->__parent_unsafe()->__right_ :
505 __x->__parent_->__left_;
506 // continue;
507 }
508 else // __w has a red child
509 {
510 if (__w->__left_ == nullptr || __w->__left_->__is_black_)
511 {
512 // __w right child is non-null and red
513 __w->__right_->__is_black_ = true;
514 __w->__is_black_ = false;
515 __tree_left_rotate(__w);
516 // __w is known not to be root, so root hasn't changed
517 // reset sibling, and it still can't be null
518 __w = __w->__parent_unsafe();
519 }
520 // __w has a left red child, right child may be null
521 __w->__is_black_ = __w->__parent_unsafe()->__is_black_;
522 __w->__parent_unsafe()->__is_black_ = true;
523 __w->__left_->__is_black_ = true;
524 __tree_right_rotate(__w->__parent_unsafe());
525 break;
526 }
527 }
528 }
529 }
530 }
531}
532
533// node traits
534
535
536#ifndef _LIBCPP_CXX03_LANG
537template <class _Tp>
538struct __is_tree_value_type_imp : false_type {};
539
540template <class _Key, class _Value>
541struct __is_tree_value_type_imp<__value_type<_Key, _Value>> : true_type {};
542
543template <class ..._Args>
544struct __is_tree_value_type : false_type {};
545
546template <class _One>
547struct __is_tree_value_type<_One> : __is_tree_value_type_imp<typename __uncvref<_One>::type> {};
548#endif
549
550template <class _Tp>
551struct __tree_key_value_types {
552 typedef _Tp key_type;
553 typedef _Tp __node_value_type;
554 typedef _Tp __container_value_type;
555 static const bool __is_map = false;
556
557 _LIBCPP_INLINE_VISIBILITY
558 static key_type const& __get_key(_Tp const& __v) {
559 return __v;
560 }
561 _LIBCPP_INLINE_VISIBILITY
562 static __container_value_type const& __get_value(__node_value_type const& __v) {
563 return __v;
564 }
565 _LIBCPP_INLINE_VISIBILITY
566 static __container_value_type* __get_ptr(__node_value_type& __n) {
567 return _VSTD::addressof(__n);
568 }
569#ifndef _LIBCPP_CXX03_LANG
570 _LIBCPP_INLINE_VISIBILITY
571 static __container_value_type&& __move(__node_value_type& __v) {
572 return _VSTD::move(__v);
573 }
574#endif
575};
576
577template <class _Key, class _Tp>
578struct __tree_key_value_types<__value_type<_Key, _Tp> > {
579 typedef _Key key_type;
580 typedef _Tp mapped_type;
581 typedef __value_type<_Key, _Tp> __node_value_type;
582 typedef pair<const _Key, _Tp> __container_value_type;
583 typedef __container_value_type __map_value_type;
584 static const bool __is_map = true;
585
586 _LIBCPP_INLINE_VISIBILITY
587 static key_type const&
588 __get_key(__node_value_type const& __t) {
589 return __t.__get_value().first;
590 }
591
592 template <class _Up>
593 _LIBCPP_INLINE_VISIBILITY
594 static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
595 key_type const&>::type
596 __get_key(_Up& __t) {
597 return __t.first;
598 }
599
600 _LIBCPP_INLINE_VISIBILITY
601 static __container_value_type const&
602 __get_value(__node_value_type const& __t) {
603 return __t.__get_value();
604 }
605
606 template <class _Up>
607 _LIBCPP_INLINE_VISIBILITY
608 static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
609 __container_value_type const&>::type
610 __get_value(_Up& __t) {
611 return __t;
612 }
613
614 _LIBCPP_INLINE_VISIBILITY
615 static __container_value_type* __get_ptr(__node_value_type& __n) {
616 return _VSTD::addressof(__n.__get_value());
617 }
618
619#ifndef _LIBCPP_CXX03_LANG
620 _LIBCPP_INLINE_VISIBILITY
621 static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) {
622 return __v.__move();
623 }
624#endif
625};
626
627template <class _VoidPtr>
628struct __tree_node_base_types {
629 typedef _VoidPtr __void_pointer;
630
631 typedef __tree_node_base<__void_pointer> __node_base_type;
632 typedef typename __rebind_pointer<_VoidPtr, __node_base_type>::type
633 __node_base_pointer;
634
635 typedef __tree_end_node<__node_base_pointer> __end_node_type;
636 typedef typename __rebind_pointer<_VoidPtr, __end_node_type>::type
637 __end_node_pointer;
638#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
639 typedef __end_node_pointer __parent_pointer;
640#else
641 typedef typename conditional<
642 is_pointer<__end_node_pointer>::value,
643 __end_node_pointer,
644 __node_base_pointer>::type __parent_pointer;
645#endif
646
647private:
648 static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
649 "_VoidPtr does not point to unqualified void type");
650};
651
652template <class _Tp, class _AllocPtr, class _KVTypes = __tree_key_value_types<_Tp>,
653 bool = _KVTypes::__is_map>
654struct __tree_map_pointer_types {};
655
656template <class _Tp, class _AllocPtr, class _KVTypes>
657struct __tree_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
658 typedef typename _KVTypes::__map_value_type _Mv;
659 typedef typename __rebind_pointer<_AllocPtr, _Mv>::type
660 __map_value_type_pointer;
661 typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type
662 __const_map_value_type_pointer;
663};
664
665template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
666struct __tree_node_types;
667
668template <class _NodePtr, class _Tp, class _VoidPtr>
669struct __tree_node_types<_NodePtr, __tree_node<_Tp, _VoidPtr> >
670 : public __tree_node_base_types<_VoidPtr>,
671 __tree_key_value_types<_Tp>,
672 __tree_map_pointer_types<_Tp, _VoidPtr>
673{
674 typedef __tree_node_base_types<_VoidPtr> __base;
675 typedef __tree_key_value_types<_Tp> __key_base;
676 typedef __tree_map_pointer_types<_Tp, _VoidPtr> __map_pointer_base;
677public:
678
679 typedef typename pointer_traits<_NodePtr>::element_type __node_type;
680 typedef _NodePtr __node_pointer;
681
682 typedef _Tp __node_value_type;
683 typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type
684 __node_value_type_pointer;
685 typedef typename __rebind_pointer<_VoidPtr, const __node_value_type>::type
686 __const_node_value_type_pointer;
687#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
688 typedef typename __base::__end_node_pointer __iter_pointer;
689#else
690 typedef typename conditional<
691 is_pointer<__node_pointer>::value,
692 typename __base::__end_node_pointer,
693 __node_pointer>::type __iter_pointer;
694#endif
695private:
696 static_assert(!is_const<__node_type>::value,
697 "_NodePtr should never be a pointer to const");
698 static_assert((is_same<typename __rebind_pointer<_VoidPtr, __node_type>::type,
699 _NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
700};
701
702template <class _ValueTp, class _VoidPtr>
703struct __make_tree_node_types {
704 typedef typename __rebind_pointer<_VoidPtr, __tree_node<_ValueTp, _VoidPtr> >::type
705 _NodePtr;
706 typedef __tree_node_types<_NodePtr> type;
707};
708
709// node
710
711template <class _Pointer>
712class __tree_end_node
713{
714public:
715 typedef _Pointer pointer;
716 pointer __left_;
717
718 _LIBCPP_INLINE_VISIBILITY
719 __tree_end_node() _NOEXCEPT : __left_() {}
720};
721
722template <class _VoidPtr>
723class __tree_node_base
724 : public __tree_node_base_types<_VoidPtr>::__end_node_type
725{
726 typedef __tree_node_base_types<_VoidPtr> _NodeBaseTypes;
727
728public:
729 typedef typename _NodeBaseTypes::__node_base_pointer pointer;
730 typedef typename _NodeBaseTypes::__parent_pointer __parent_pointer;
731
732 pointer __right_;
733 __parent_pointer __parent_;
734 bool __is_black_;
735
736 _LIBCPP_INLINE_VISIBILITY
737 pointer __parent_unsafe() const { return static_cast<pointer>(__parent_);}
738
739 _LIBCPP_INLINE_VISIBILITY
740 void __set_parent(pointer __p) {
741 __parent_ = static_cast<__parent_pointer>(__p);
742 }
743
744private:
745 ~__tree_node_base() _LIBCPP_EQUAL_DELETE;
746 __tree_node_base(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
747 __tree_node_base& operator=(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
748};
749
750template <class _Tp, class _VoidPtr>
751class __tree_node
752 : public __tree_node_base<_VoidPtr>
753{
754public:
755 typedef _Tp __node_value_type;
756
757 __node_value_type __value_;
758
759private:
760 ~__tree_node() _LIBCPP_EQUAL_DELETE;
761 __tree_node(__tree_node const&) _LIBCPP_EQUAL_DELETE;
762 __tree_node& operator=(__tree_node const&) _LIBCPP_EQUAL_DELETE;
763};
764
765
766template <class _Allocator>
767class __tree_node_destructor
768{
769 typedef _Allocator allocator_type;
770 typedef allocator_traits<allocator_type> __alloc_traits;
771
772public:
773 typedef typename __alloc_traits::pointer pointer;
774private:
775 typedef __tree_node_types<pointer> _NodeTypes;
776 allocator_type& __na_;
777
778 __tree_node_destructor& operator=(const __tree_node_destructor&);
779
780public:
781 bool __value_constructed;
782
783 _LIBCPP_INLINE_VISIBILITY
784 explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
785 : __na_(__na),
786 __value_constructed(__val)
787 {}
788
789 _LIBCPP_INLINE_VISIBILITY
790 void operator()(pointer __p) _NOEXCEPT
791 {
792 if (__value_constructed)
793 __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
794 if (__p)
795 __alloc_traits::deallocate(__na_, __p, 1);
796 }
797
798 template <class> friend class __map_node_destructor;
799};
800
801#if _LIBCPP_STD_VER > 14
802template <class _NodeType, class _Alloc>
803struct __generic_container_node_destructor;
804template <class _Tp, class _VoidPtr, class _Alloc>
805struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc>
806 : __tree_node_destructor<_Alloc>
807{
808 using __tree_node_destructor<_Alloc>::__tree_node_destructor;
809};
810#endif
811
812template <class _Tp, class _NodePtr, class _DiffType>
813class _LIBCPP_TEMPLATE_VIS __tree_iterator
814{
815 typedef __tree_node_types<_NodePtr> _NodeTypes;
816 typedef _NodePtr __node_pointer;
817 typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
818 typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
819 typedef typename _NodeTypes::__iter_pointer __iter_pointer;
820 typedef pointer_traits<__node_pointer> __pointer_traits;
821
822 __iter_pointer __ptr_;
823
824public:
825 typedef bidirectional_iterator_tag iterator_category;
826 typedef _Tp value_type;
827 typedef _DiffType difference_type;
828 typedef value_type& reference;
829 typedef typename _NodeTypes::__node_value_type_pointer pointer;
830
831 _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT
832#if _LIBCPP_STD_VER > 11
833 : __ptr_(nullptr)
834#endif
835 {}
836
837 _LIBCPP_INLINE_VISIBILITY reference operator*() const
838 {return __get_np()->__value_;}
839 _LIBCPP_INLINE_VISIBILITY pointer operator->() const
840 {return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}
841
842 _LIBCPP_INLINE_VISIBILITY
843 __tree_iterator& operator++() {
844 __ptr_ = static_cast<__iter_pointer>(
845 __tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
846 return *this;
847 }
848 _LIBCPP_INLINE_VISIBILITY
849 __tree_iterator operator++(int)
850 {__tree_iterator __t(*this); ++(*this); return __t;}
851
852 _LIBCPP_INLINE_VISIBILITY
853 __tree_iterator& operator--() {
854 __ptr_ = static_cast<__iter_pointer>(__tree_prev_iter<__node_base_pointer>(
855 static_cast<__end_node_pointer>(__ptr_)));
856 return *this;
857 }
858 _LIBCPP_INLINE_VISIBILITY
859 __tree_iterator operator--(int)
860 {__tree_iterator __t(*this); --(*this); return __t;}
861
862 friend _LIBCPP_INLINE_VISIBILITY
863 bool operator==(const __tree_iterator& __x, const __tree_iterator& __y)
864 {return __x.__ptr_ == __y.__ptr_;}
865 friend _LIBCPP_INLINE_VISIBILITY
866 bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y)
867 {return !(__x == __y);}
868
869private:
870 _LIBCPP_INLINE_VISIBILITY
871 explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
872 _LIBCPP_INLINE_VISIBILITY
873 explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
874 _LIBCPP_INLINE_VISIBILITY
875 __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
876 template <class, class, class> friend class __tree;
877 template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
878 template <class> friend class _LIBCPP_TEMPLATE_VIS __map_iterator;
879 template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
880 template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
881 template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
882 template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
883};
884
885template <class _Tp, class _NodePtr, class _DiffType>
886class _LIBCPP_TEMPLATE_VIS __tree_const_iterator
887{
888 typedef __tree_node_types<_NodePtr> _NodeTypes;
889 typedef typename _NodeTypes::__node_pointer __node_pointer;
890 typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
891 typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
892 typedef typename _NodeTypes::__iter_pointer __iter_pointer;
893 typedef pointer_traits<__node_pointer> __pointer_traits;
894
895 __iter_pointer __ptr_;
896
897public:
898 typedef bidirectional_iterator_tag iterator_category;
899 typedef _Tp value_type;
900 typedef _DiffType difference_type;
901 typedef const value_type& reference;
902 typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
903
904 _LIBCPP_INLINE_VISIBILITY __tree_const_iterator() _NOEXCEPT
905#if _LIBCPP_STD_VER > 11
906 : __ptr_(nullptr)
907#endif
908 {}
909
910private:
911 typedef __tree_iterator<value_type, __node_pointer, difference_type>
912 __non_const_iterator;
913public:
914 _LIBCPP_INLINE_VISIBILITY
915 __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT
916 : __ptr_(__p.__ptr_) {}
917
918 _LIBCPP_INLINE_VISIBILITY reference operator*() const
919 {return __get_np()->__value_;}
920 _LIBCPP_INLINE_VISIBILITY pointer operator->() const
921 {return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}
922
923 _LIBCPP_INLINE_VISIBILITY
924 __tree_const_iterator& operator++() {
925 __ptr_ = static_cast<__iter_pointer>(
926 __tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
927 return *this;
928 }
929
930 _LIBCPP_INLINE_VISIBILITY
931 __tree_const_iterator operator++(int)
932 {__tree_const_iterator __t(*this); ++(*this); return __t;}
933
934 _LIBCPP_INLINE_VISIBILITY
935 __tree_const_iterator& operator--() {
936 __ptr_ = static_cast<__iter_pointer>(__tree_prev_iter<__node_base_pointer>(
937 static_cast<__end_node_pointer>(__ptr_)));
938 return *this;
939 }
940
941 _LIBCPP_INLINE_VISIBILITY
942 __tree_const_iterator operator--(int)
943 {__tree_const_iterator __t(*this); --(*this); return __t;}
944
945 friend _LIBCPP_INLINE_VISIBILITY
946 bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
947 {return __x.__ptr_ == __y.__ptr_;}
948 friend _LIBCPP_INLINE_VISIBILITY
949 bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
950 {return !(__x == __y);}
951
952private:
953 _LIBCPP_INLINE_VISIBILITY
954 explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
955 : __ptr_(__p) {}
956 _LIBCPP_INLINE_VISIBILITY
957 explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT
958 : __ptr_(__p) {}
959 _LIBCPP_INLINE_VISIBILITY
960 __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
961
962 template <class, class, class> friend class __tree;
963 template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
964 template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
965 template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
966 template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
967 template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
968
969};
970
971template<class _Tp, class _Compare>
972#ifndef _LIBCPP_CXX03_LANG
973 _LIBCPP_DIAGNOSE_WARNING(!std::__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
974 "the specified comparator type does not provide a viable const call operator")
975#endif
976int __diagnose_non_const_comparator();
977
978template <class _Tp, class _Compare, class _Allocator>
979class __tree
980{
981public:
982 typedef _Tp value_type;
983 typedef _Compare value_compare;
984 typedef _Allocator allocator_type;
985
986private:
987 typedef allocator_traits<allocator_type> __alloc_traits;
988 typedef typename __make_tree_node_types<value_type,
989 typename __alloc_traits::void_pointer>::type
990 _NodeTypes;
991 typedef typename _NodeTypes::key_type key_type;
992public:
993 typedef typename _NodeTypes::__node_value_type __node_value_type;
994 typedef typename _NodeTypes::__container_value_type __container_value_type;
995
996 typedef typename __alloc_traits::pointer pointer;
997 typedef typename __alloc_traits::const_pointer const_pointer;
998 typedef typename __alloc_traits::size_type size_type;
999 typedef typename __alloc_traits::difference_type difference_type;
1000
1001public:
1002 typedef typename _NodeTypes::__void_pointer __void_pointer;
1003
1004 typedef typename _NodeTypes::__node_type __node;
1005 typedef typename _NodeTypes::__node_pointer __node_pointer;
1006
1007 typedef typename _NodeTypes::__node_base_type __node_base;
1008 typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
1009
1010 typedef typename _NodeTypes::__end_node_type __end_node_t;
1011 typedef typename _NodeTypes::__end_node_pointer __end_node_ptr;
1012
1013 typedef typename _NodeTypes::__parent_pointer __parent_pointer;
1014 typedef typename _NodeTypes::__iter_pointer __iter_pointer;
1015
1016 typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator;
1017 typedef allocator_traits<__node_allocator> __node_traits;
1018
1019private:
1020 // check for sane allocator pointer rebinding semantics. Rebinding the
1021 // allocator for a new pointer type should be exactly the same as rebinding
1022 // the pointer using 'pointer_traits'.
1023 static_assert((is_same<__node_pointer, typename __node_traits::pointer>::value),
1024 "Allocator does not rebind pointers in a sane manner.");
1025 typedef typename __rebind_alloc_helper<__node_traits, __node_base>::type
1026 __node_base_allocator;
1027 typedef allocator_traits<__node_base_allocator> __node_base_traits;
1028 static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
1029 "Allocator does not rebind pointers in a sane manner.");
1030
1031private:
1032 __iter_pointer __begin_node_;
1033 __compressed_pair<__end_node_t, __node_allocator> __pair1_;
1034 __compressed_pair<size_type, value_compare> __pair3_;
1035
1036public:
1037 _LIBCPP_INLINE_VISIBILITY
1038 __iter_pointer __end_node() _NOEXCEPT
1039 {
1040 return static_cast<__iter_pointer>(
1041 pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
1042 );
1043 }
1044 _LIBCPP_INLINE_VISIBILITY
1045 __iter_pointer __end_node() const _NOEXCEPT
1046 {
1047 return static_cast<__iter_pointer>(
1048 pointer_traits<__end_node_ptr>::pointer_to(
1049 const_cast<__end_node_t&>(__pair1_.first())
1050 )
1051 );
1052 }
1053 _LIBCPP_INLINE_VISIBILITY
1054 __node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}
1055private:
1056 _LIBCPP_INLINE_VISIBILITY
1057 const __node_allocator& __node_alloc() const _NOEXCEPT
1058 {return __pair1_.second();}
1059 _LIBCPP_INLINE_VISIBILITY
1060 __iter_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
1061 _LIBCPP_INLINE_VISIBILITY
1062 const __iter_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
1063public:
1064 _LIBCPP_INLINE_VISIBILITY
1065 allocator_type __alloc() const _NOEXCEPT
1066 {return allocator_type(__node_alloc());}
1067private:
1068 _LIBCPP_INLINE_VISIBILITY
1069 size_type& size() _NOEXCEPT {return __pair3_.first();}
1070public:
1071 _LIBCPP_INLINE_VISIBILITY
1072 const size_type& size() const _NOEXCEPT {return __pair3_.first();}
1073 _LIBCPP_INLINE_VISIBILITY
1074 value_compare& value_comp() _NOEXCEPT {return __pair3_.second();}
1075 _LIBCPP_INLINE_VISIBILITY
1076 const value_compare& value_comp() const _NOEXCEPT
1077 {return __pair3_.second();}
1078public:
1079
1080 _LIBCPP_INLINE_VISIBILITY
1081 __node_pointer __root() const _NOEXCEPT
1082 {return static_cast<__node_pointer>(__end_node()->__left_);}
1083
1084 __node_base_pointer* __root_ptr() const _NOEXCEPT {
1085 return _VSTD::addressof(__end_node()->__left_);
1086 }
1087
1088 typedef __tree_iterator<value_type, __node_pointer, difference_type> iterator;
1089 typedef __tree_const_iterator<value_type, __node_pointer, difference_type> const_iterator;
1090
1091 explicit __tree(const value_compare& __comp)
1092 _NOEXCEPT_(
1093 is_nothrow_default_constructible<__node_allocator>::value &&
1094 is_nothrow_copy_constructible<value_compare>::value);
1095 explicit __tree(const allocator_type& __a);
1096 __tree(const value_compare& __comp, const allocator_type& __a);
1097 __tree(const __tree& __t);
1098 __tree& operator=(const __tree& __t);
1099 template <class _ForwardIterator>
1100 void __assign_unique(_ForwardIterator __first, _ForwardIterator __last);
1101 template <class _InputIterator>
1102 void __assign_multi(_InputIterator __first, _InputIterator __last);
1103#ifndef _LIBCPP_CXX03_LANG
1104 __tree(__tree&& __t)
1105 _NOEXCEPT_(
1106 is_nothrow_move_constructible<__node_allocator>::value &&
1107 is_nothrow_move_constructible<value_compare>::value);
1108 __tree(__tree&& __t, const allocator_type& __a);
1109 __tree& operator=(__tree&& __t)
1110 _NOEXCEPT_(
1111 __node_traits::propagate_on_container_move_assignment::value &&
1112 is_nothrow_move_assignable<value_compare>::value &&
1113 is_nothrow_move_assignable<__node_allocator>::value);
1114#endif // _LIBCPP_CXX03_LANG
1115
1116 ~__tree();
1117
1118 _LIBCPP_INLINE_VISIBILITY
1119 iterator begin() _NOEXCEPT {return iterator(__begin_node());}
1120 _LIBCPP_INLINE_VISIBILITY
1121 const_iterator begin() const _NOEXCEPT {return const_iterator(__begin_node());}
1122 _LIBCPP_INLINE_VISIBILITY
1123 iterator end() _NOEXCEPT {return iterator(__end_node());}
1124 _LIBCPP_INLINE_VISIBILITY
1125 const_iterator end() const _NOEXCEPT {return const_iterator(__end_node());}
1126
1127 _LIBCPP_INLINE_VISIBILITY
1128 size_type max_size() const _NOEXCEPT
1129 {return std::min<size_type>(
1130 __node_traits::max_size(__node_alloc()),
1131 numeric_limits<difference_type >::max());}
1132
1133 void clear() _NOEXCEPT;
1134
1135 void swap(__tree& __t)
1136#if _LIBCPP_STD_VER <= 11
1137 _NOEXCEPT_(
1138 __is_nothrow_swappable<value_compare>::value
1139 && (!__node_traits::propagate_on_container_swap::value ||
1140 __is_nothrow_swappable<__node_allocator>::value)
1141 );
1142#else
1143 _NOEXCEPT_(__is_nothrow_swappable<value_compare>::value);
1144#endif
1145
1146#ifndef _LIBCPP_CXX03_LANG
1147 template <class _Key, class ..._Args>
1148 pair<iterator, bool>
1149 __emplace_unique_key_args(_Key const&, _Args&&... __args);
1150 template <class _Key, class ..._Args>
1151 iterator
1152 __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&&...);
1153
1154 template <class... _Args>
1155 pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
1156
1157 template <class... _Args>
1158 iterator __emplace_hint_unique_impl(const_iterator __p, _Args&&... __args);
1159
1160 template <class... _Args>
1161 iterator __emplace_multi(_Args&&... __args);
1162
1163 template <class... _Args>
1164 iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
1165
1166 template <class _Pp>
1167 _LIBCPP_INLINE_VISIBILITY
1168 pair<iterator, bool> __emplace_unique(_Pp&& __x) {
1169 return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x),
1170 __can_extract_key<_Pp, key_type>());
1171 }
1172
1173 template <class _First, class _Second>
1174 _LIBCPP_INLINE_VISIBILITY
1175 typename enable_if<
1176 __can_extract_map_key<_First, key_type, __container_value_type>::value,
1177 pair<iterator, bool>
1178 >::type __emplace_unique(_First&& __f, _Second&& __s) {
1179 return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f),
1180 _VSTD::forward<_Second>(__s));
1181 }
1182
1183 template <class... _Args>
1184 _LIBCPP_INLINE_VISIBILITY
1185 pair<iterator, bool> __emplace_unique(_Args&&... __args) {
1186 return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...);
1187 }
1188
1189 template <class _Pp>
1190 _LIBCPP_INLINE_VISIBILITY
1191 pair<iterator, bool>
1192 __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
1193 return __emplace_unique_impl(_VSTD::forward<_Pp>(__x));
1194 }
1195
1196 template <class _Pp>
1197 _LIBCPP_INLINE_VISIBILITY
1198 pair<iterator, bool>
1199 __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
1200 return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x));
1201 }
1202
1203 template <class _Pp>
1204 _LIBCPP_INLINE_VISIBILITY
1205 pair<iterator, bool>
1206 __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
1207 return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x));
1208 }
1209
1210 template <class _Pp>
1211 _LIBCPP_INLINE_VISIBILITY
1212 iterator __emplace_hint_unique(const_iterator __p, _Pp&& __x) {
1213 return __emplace_hint_unique_extract_key(__p, _VSTD::forward<_Pp>(__x),
1214 __can_extract_key<_Pp, key_type>());
1215 }
1216
1217 template <class _First, class _Second>
1218 _LIBCPP_INLINE_VISIBILITY
1219 typename enable_if<
1220 __can_extract_map_key<_First, key_type, __container_value_type>::value,
1221 iterator
1222 >::type __emplace_hint_unique(const_iterator __p, _First&& __f, _Second&& __s) {
1223 return __emplace_hint_unique_key_args(__p, __f,
1224 _VSTD::forward<_First>(__f),
1225 _VSTD::forward<_Second>(__s));
1226 }
1227
1228 template <class... _Args>
1229 _LIBCPP_INLINE_VISIBILITY
1230 iterator __emplace_hint_unique(const_iterator __p, _Args&&... __args) {
1231 return __emplace_hint_unique_impl(__p, _VSTD::forward<_Args>(__args)...);
1232 }
1233
1234 template <class _Pp>
1235 _LIBCPP_INLINE_VISIBILITY
1236 iterator
1237 __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_fail_tag) {
1238 return __emplace_hint_unique_impl(__p, _VSTD::forward<_Pp>(__x));
1239 }
1240
1241 template <class _Pp>
1242 _LIBCPP_INLINE_VISIBILITY
1243 iterator
1244 __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_self_tag) {
1245 return __emplace_hint_unique_key_args(__p, __x, _VSTD::forward<_Pp>(__x));
1246 }
1247
1248 template <class _Pp>
1249 _LIBCPP_INLINE_VISIBILITY
1250 iterator
1251 __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_first_tag) {
1252 return __emplace_hint_unique_key_args(__p, __x.first, _VSTD::forward<_Pp>(__x));
1253 }
1254
1255#else
1256 template <class _Key, class _Args>
1257 _LIBCPP_INLINE_VISIBILITY
1258 pair<iterator, bool> __emplace_unique_key_args(_Key const&, _Args& __args);
1259 template <class _Key, class _Args>
1260 _LIBCPP_INLINE_VISIBILITY
1261 iterator __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&);
1262#endif
1263
1264 _LIBCPP_INLINE_VISIBILITY
1265 pair<iterator, bool> __insert_unique(const __container_value_type& __v) {
1266 return __emplace_unique_key_args(_NodeTypes::__get_key(__v), __v);
1267 }
1268
1269 _LIBCPP_INLINE_VISIBILITY
1270 iterator __insert_unique(const_iterator __p, const __container_value_type& __v) {
1271 return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), __v);
1272 }
1273
1274#ifdef _LIBCPP_CXX03_LANG
1275 _LIBCPP_INLINE_VISIBILITY
1276 iterator __insert_multi(const __container_value_type& __v);
1277 _LIBCPP_INLINE_VISIBILITY
1278 iterator __insert_multi(const_iterator __p, const __container_value_type& __v);
1279#else
1280 _LIBCPP_INLINE_VISIBILITY
1281 pair<iterator, bool> __insert_unique(__container_value_type&& __v) {
1282 return __emplace_unique_key_args(_NodeTypes::__get_key(__v), _VSTD::move(__v));
1283 }
1284
1285 _LIBCPP_INLINE_VISIBILITY
1286 iterator __insert_unique(const_iterator __p, __container_value_type&& __v) {
1287 return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), _VSTD::move(__v));
1288 }
1289
1290 template <class _Vp, class = typename enable_if<
1291 !is_same<typename __unconstref<_Vp>::type,
1292 __container_value_type
1293 >::value
1294 >::type>
1295 _LIBCPP_INLINE_VISIBILITY
1296 pair<iterator, bool> __insert_unique(_Vp&& __v) {
1297 return __emplace_unique(_VSTD::forward<_Vp>(__v));
1298 }
1299
1300 template <class _Vp, class = typename enable_if<
1301 !is_same<typename __unconstref<_Vp>::type,
1302 __container_value_type
1303 >::value
1304 >::type>
1305 _LIBCPP_INLINE_VISIBILITY
1306 iterator __insert_unique(const_iterator __p, _Vp&& __v) {
1307 return __emplace_hint_unique(__p, _VSTD::forward<_Vp>(__v));
1308 }
1309
1310 _LIBCPP_INLINE_VISIBILITY
1311 iterator __insert_multi(__container_value_type&& __v) {
1312 return __emplace_multi(_VSTD::move(__v));
1313 }
1314
1315 _LIBCPP_INLINE_VISIBILITY
1316 iterator __insert_multi(const_iterator __p, __container_value_type&& __v) {
1317 return __emplace_hint_multi(__p, _VSTD::move(__v));
1318 }
1319
1320 template <class _Vp>
1321 _LIBCPP_INLINE_VISIBILITY
1322 iterator __insert_multi(_Vp&& __v) {
1323 return __emplace_multi(_VSTD::forward<_Vp>(__v));
1324 }
1325
1326 template <class _Vp>
1327 _LIBCPP_INLINE_VISIBILITY
1328 iterator __insert_multi(const_iterator __p, _Vp&& __v) {
1329 return __emplace_hint_multi(__p, _VSTD::forward<_Vp>(__v));
1330 }
1331
1332#endif // !_LIBCPP_CXX03_LANG
1333
1334 _LIBCPP_INLINE_VISIBILITY
1335 pair<iterator, bool> __node_assign_unique(const __container_value_type& __v, __node_pointer __dest);
1336
1337 _LIBCPP_INLINE_VISIBILITY
1338 iterator __node_insert_multi(__node_pointer __nd);
1339 _LIBCPP_INLINE_VISIBILITY
1340 iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);
1341
1342
1343 _LIBCPP_INLINE_VISIBILITY iterator
1344 __remove_node_pointer(__node_pointer) _NOEXCEPT;
1345
1346#if _LIBCPP_STD_VER > 14
1347 template <class _NodeHandle, class _InsertReturnType>
1348 _LIBCPP_INLINE_VISIBILITY
1349 _InsertReturnType __node_handle_insert_unique(_NodeHandle&&);
1350 template <class _NodeHandle>
1351 _LIBCPP_INLINE_VISIBILITY
1352 iterator __node_handle_insert_unique(const_iterator, _NodeHandle&&);
1353 template <class _Tree>
1354 _LIBCPP_INLINE_VISIBILITY
1355 void __node_handle_merge_unique(_Tree& __source);
1356
1357 template <class _NodeHandle>
1358 _LIBCPP_INLINE_VISIBILITY
1359 iterator __node_handle_insert_multi(_NodeHandle&&);
1360 template <class _NodeHandle>
1361 _LIBCPP_INLINE_VISIBILITY
1362 iterator __node_handle_insert_multi(const_iterator, _NodeHandle&&);
1363 template <class _Tree>
1364 _LIBCPP_INLINE_VISIBILITY
1365 void __node_handle_merge_multi(_Tree& __source);
1366
1367
1368 template <class _NodeHandle>
1369 _LIBCPP_INLINE_VISIBILITY
1370 _NodeHandle __node_handle_extract(key_type const&);
1371 template <class _NodeHandle>
1372 _LIBCPP_INLINE_VISIBILITY
1373 _NodeHandle __node_handle_extract(const_iterator);
1374#endif
1375
1376 iterator erase(const_iterator __p);
1377 iterator erase(const_iterator __f, const_iterator __l);
1378 template <class _Key>
1379 size_type __erase_unique(const _Key& __k);
1380 template <class _Key>
1381 size_type __erase_multi(const _Key& __k);
1382
1383 void __insert_node_at(__parent_pointer __parent,
1384 __node_base_pointer& __child,
1385 __node_base_pointer __new_node) _NOEXCEPT;
1386
1387 template <class _Key>
1388 iterator find(const _Key& __v);
1389 template <class _Key>
1390 const_iterator find(const _Key& __v) const;
1391
1392 template <class _Key>
1393 size_type __count_unique(const _Key& __k) const;
1394 template <class _Key>
1395 size_type __count_multi(const _Key& __k) const;
1396
1397 template <class _Key>
1398 _LIBCPP_INLINE_VISIBILITY
1399 iterator lower_bound(const _Key& __v)
1400 {return __lower_bound(__v, __root(), __end_node());}
1401 template <class _Key>
1402 iterator __lower_bound(const _Key& __v,
1403 __node_pointer __root,
1404 __iter_pointer __result);
1405 template <class _Key>
1406 _LIBCPP_INLINE_VISIBILITY
1407 const_iterator lower_bound(const _Key& __v) const
1408 {return __lower_bound(__v, __root(), __end_node());}
1409 template <class _Key>
1410 const_iterator __lower_bound(const _Key& __v,
1411 __node_pointer __root,
1412 __iter_pointer __result) const;
1413 template <class _Key>
1414 _LIBCPP_INLINE_VISIBILITY
1415 iterator upper_bound(const _Key& __v)
1416 {return __upper_bound(__v, __root(), __end_node());}
1417 template <class _Key>
1418 iterator __upper_bound(const _Key& __v,
1419 __node_pointer __root,
1420 __iter_pointer __result);
1421 template <class _Key>
1422 _LIBCPP_INLINE_VISIBILITY
1423 const_iterator upper_bound(const _Key& __v) const
1424 {return __upper_bound(__v, __root(), __end_node());}
1425 template <class _Key>
1426 const_iterator __upper_bound(const _Key& __v,
1427 __node_pointer __root,
1428 __iter_pointer __result) const;
1429 template <class _Key>
1430 pair<iterator, iterator>
1431 __equal_range_unique(const _Key& __k);
1432 template <class _Key>
1433 pair<const_iterator, const_iterator>
1434 __equal_range_unique(const _Key& __k) const;
1435
1436 template <class _Key>
1437 pair<iterator, iterator>
1438 __equal_range_multi(const _Key& __k);
1439 template <class _Key>
1440 pair<const_iterator, const_iterator>
1441 __equal_range_multi(const _Key& __k) const;
1442
1443 typedef __tree_node_destructor<__node_allocator> _Dp;
1444 typedef unique_ptr<__node, _Dp> __node_holder;
1445
1446 __node_holder remove(const_iterator __p) _NOEXCEPT;
1447private:
1448 __node_base_pointer&
1449 __find_leaf_low(__parent_pointer& __parent, const key_type& __v);
1450 __node_base_pointer&
1451 __find_leaf_high(__parent_pointer& __parent, const key_type& __v);
1452 __node_base_pointer&
1453 __find_leaf(const_iterator __hint,
1454 __parent_pointer& __parent, const key_type& __v);
1455 // FIXME: Make this function const qualified. Unfortunetly doing so
1456 // breaks existing code which uses non-const callable comparators.
1457 template <class _Key>
1458 __node_base_pointer&
1459 __find_equal(__parent_pointer& __parent, const _Key& __v);
1460 template <class _Key>
1461 _LIBCPP_INLINE_VISIBILITY __node_base_pointer&
1462 __find_equal(__parent_pointer& __parent, const _Key& __v) const {
1463 return const_cast<__tree*>(this)->__find_equal(__parent, __v);
1464 }
1465 template <class _Key>
1466 __node_base_pointer&
1467 __find_equal(const_iterator __hint, __parent_pointer& __parent,
1468 __node_base_pointer& __dummy,
1469 const _Key& __v);
1470
1471#ifndef _LIBCPP_CXX03_LANG
1472 template <class ..._Args>
1473 __node_holder __construct_node(_Args&& ...__args);
1474#else
1475 __node_holder __construct_node(const __container_value_type& __v);
1476#endif
1477
1478 void destroy(__node_pointer __nd) _NOEXCEPT;
1479
1480 _LIBCPP_INLINE_VISIBILITY
1481 void __copy_assign_alloc(const __tree& __t)
1482 {__copy_assign_alloc(__t, integral_constant<bool,
1483 __node_traits::propagate_on_container_copy_assignment::value>());}
1484
1485 _LIBCPP_INLINE_VISIBILITY
1486 void __copy_assign_alloc(const __tree& __t, true_type)
1487 {
1488 if (__node_alloc() != __t.__node_alloc())
1489 clear();
1490 __node_alloc() = __t.__node_alloc();
1491 }
1492 _LIBCPP_INLINE_VISIBILITY
1493 void __copy_assign_alloc(const __tree&, false_type) {}
1494
1495 void __move_assign(__tree& __t, false_type);
1496 void __move_assign(__tree& __t, true_type)
1497 _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
1498 is_nothrow_move_assignable<__node_allocator>::value);
1499
1500 _LIBCPP_INLINE_VISIBILITY
1501 void __move_assign_alloc(__tree& __t)
1502 _NOEXCEPT_(
1503 !__node_traits::propagate_on_container_move_assignment::value ||
1504 is_nothrow_move_assignable<__node_allocator>::value)
1505 {__move_assign_alloc(__t, integral_constant<bool,
1506 __node_traits::propagate_on_container_move_assignment::value>());}
1507
1508 _LIBCPP_INLINE_VISIBILITY
1509 void __move_assign_alloc(__tree& __t, true_type)
1510 _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
1511 {__node_alloc() = _VSTD::move(__t.__node_alloc());}
1512 _LIBCPP_INLINE_VISIBILITY
1513 void __move_assign_alloc(__tree&, false_type) _NOEXCEPT {}
1514
1515 struct _DetachedTreeCache {
1516 _LIBCPP_INLINE_VISIBILITY
1517 explicit _DetachedTreeCache(__tree *__t) _NOEXCEPT : __t_(__t),
1518 __cache_root_(__detach_from_tree(__t)) {
1519 __advance();
1520 }
1521
1522 _LIBCPP_INLINE_VISIBILITY
1523 __node_pointer __get() const _NOEXCEPT {
1524 return __cache_elem_;
1525 }
1526
1527 _LIBCPP_INLINE_VISIBILITY
1528 void __advance() _NOEXCEPT {
1529 __cache_elem_ = __cache_root_;
1530 if (__cache_root_) {
1531 __cache_root_ = __detach_next(__cache_root_);
1532 }
1533 }
1534
1535 _LIBCPP_INLINE_VISIBILITY
1536 ~_DetachedTreeCache() {
1537 __t_->destroy(__cache_elem_);
1538 if (__cache_root_) {
1539 while (__cache_root_->__parent_ != nullptr)
1540 __cache_root_ = static_cast<__node_pointer>(__cache_root_->__parent_);
1541 __t_->destroy(__cache_root_);
1542 }
1543 }
1544
1545 _DetachedTreeCache(_DetachedTreeCache const&) = delete;
1546 _DetachedTreeCache& operator=(_DetachedTreeCache const&) = delete;
1547
1548 private:
1549 _LIBCPP_INLINE_VISIBILITY
1550 static __node_pointer __detach_from_tree(__tree *__t) _NOEXCEPT;
1551 _LIBCPP_INLINE_VISIBILITY
1552 static __node_pointer __detach_next(__node_pointer) _NOEXCEPT;
1553
1554 __tree *__t_;
1555 __node_pointer __cache_root_;
1556 __node_pointer __cache_elem_;
1557 };
1558
1559
1560 template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
1561 template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
1562};
1563
1564template <class _Tp, class _Compare, class _Allocator>
1565__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
1566 _NOEXCEPT_(
1567 is_nothrow_default_constructible<__node_allocator>::value &&
1568 is_nothrow_copy_constructible<value_compare>::value)
1569 : __pair3_(0, __comp)
1570{
1571 __begin_node() = __end_node();
1572}
1573
1574template <class _Tp, class _Compare, class _Allocator>
1575__tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)
1576 : __begin_node_(__iter_pointer()),
1577 __pair1_(__second_tag(), __node_allocator(__a)),
1578 __pair3_(0)
1579{
1580 __begin_node() = __end_node();
1581}
1582
1583template <class _Tp, class _Compare, class _Allocator>
1584__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp,
1585 const allocator_type& __a)
1586 : __begin_node_(__iter_pointer()),
1587 __pair1_(__second_tag(), __node_allocator(__a)),
1588 __pair3_(0, __comp)
1589{
1590 __begin_node() = __end_node();
1591}
1592
1593// Precondition: size() != 0
1594template <class _Tp, class _Compare, class _Allocator>
1595typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
1596__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_from_tree(__tree *__t) _NOEXCEPT
1597{
1598 __node_pointer __cache = static_cast<__node_pointer>(__t->__begin_node());
1599 __t->__begin_node() = __t->__end_node();
1600 __t->__end_node()->__left_->__parent_ = nullptr;
1601 __t->__end_node()->__left_ = nullptr;
1602 __t->size() = 0;
1603 // __cache->__left_ == nullptr
1604 if (__cache->__right_ != nullptr)
1605 __cache = static_cast<__node_pointer>(__cache->__right_);
1606 // __cache->__left_ == nullptr
1607 // __cache->__right_ == nullptr
1608 return __cache;
1609}
1610
1611// Precondition: __cache != nullptr
1612// __cache->left_ == nullptr
1613// __cache->right_ == nullptr
1614// This is no longer a red-black tree
1615template <class _Tp, class _Compare, class _Allocator>
1616typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
1617__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_next(__node_pointer __cache) _NOEXCEPT
1618{
1619 if (__cache->__parent_ == nullptr)
1620 return nullptr;
1621 if (__tree_is_left_child(static_cast<__node_base_pointer>(__cache)))
1622 {
1623 __cache->__parent_->__left_ = nullptr;
1624 __cache = static_cast<__node_pointer>(__cache->__parent_);
1625 if (__cache->__right_ == nullptr)
1626 return __cache;
1627 return static_cast<__node_pointer>(__tree_leaf(__cache->__right_));
1628 }
1629 // __cache is right child
1630 __cache->__parent_unsafe()->__right_ = nullptr;
1631 __cache = static_cast<__node_pointer>(__cache->__parent_);
1632 if (__cache->__left_ == nullptr)
1633 return __cache;
1634 return static_cast<__node_pointer>(__tree_leaf(__cache->__left_));
1635}
1636
1637template <class _Tp, class _Compare, class _Allocator>
1638__tree<_Tp, _Compare, _Allocator>&
1639__tree<_Tp, _Compare, _Allocator>::operator=(const __tree& __t)
1640{
1641 if (this != &__t)
1642 {
1643 value_comp() = __t.value_comp();
1644 __copy_assign_alloc(__t);
1645 __assign_multi(__t.begin(), __t.end());
1646 }
1647 return *this;
1648}
1649
1650template <class _Tp, class _Compare, class _Allocator>
1651template <class _ForwardIterator>
1652void
1653__tree<_Tp, _Compare, _Allocator>::__assign_unique(_ForwardIterator __first, _ForwardIterator __last)
1654{
1655 typedef iterator_traits<_ForwardIterator> _ITraits;
1656 typedef typename _ITraits::value_type _ItValueType;
1657 static_assert((is_same<_ItValueType, __container_value_type>::value),
1658 "__assign_unique may only be called with the containers value type");
1659 static_assert(__is_forward_iterator<_ForwardIterator>::value,
1660 "__assign_unique requires a forward iterator");
1661 if (size() != 0)
1662 {
1663 _DetachedTreeCache __cache(this);
1664 for (; __cache.__get() != nullptr && __first != __last; ++__first) {
1665 if (__node_assign_unique(*__first, __cache.__get()).second)
1666 __cache.__advance();
1667 }
1668 }
1669 for (; __first != __last; ++__first)
1670 __insert_unique(*__first);
1671}
1672
1673template <class _Tp, class _Compare, class _Allocator>
1674template <class _InputIterator>
1675void
1676__tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _InputIterator __last)
1677{
1678 typedef iterator_traits<_InputIterator> _ITraits;
1679 typedef typename _ITraits::value_type _ItValueType;
1680 static_assert((is_same<_ItValueType, __container_value_type>::value ||
1681 is_same<_ItValueType, __node_value_type>::value),
1682 "__assign_multi may only be called with the containers value type"
1683 " or the nodes value type");
1684 if (size() != 0)
1685 {
1686 _DetachedTreeCache __cache(this);
1687 for (; __cache.__get() && __first != __last; ++__first) {
1688 __cache.__get()->__value_ = *__first;
1689 __node_insert_multi(__cache.__get());
1690 __cache.__advance();
1691 }
1692 }
1693 for (; __first != __last; ++__first)
1694 __insert_multi(_NodeTypes::__get_value(*__first));
1695}
1696
1697template <class _Tp, class _Compare, class _Allocator>
1698__tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
1699 : __begin_node_(__iter_pointer()),
1700 __pair1_(__second_tag(), __node_traits::select_on_container_copy_construction(__t.__node_alloc())),
1701 __pair3_(0, __t.value_comp())
1702{
1703 __begin_node() = __end_node();
1704}
1705
1706#ifndef _LIBCPP_CXX03_LANG
1707
1708template <class _Tp, class _Compare, class _Allocator>
1709__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
1710 _NOEXCEPT_(
1711 is_nothrow_move_constructible<__node_allocator>::value &&
1712 is_nothrow_move_constructible<value_compare>::value)
1713 : __begin_node_(_VSTD::move(__t.__begin_node_)),
1714 __pair1_(_VSTD::move(__t.__pair1_)),
1715 __pair3_(_VSTD::move(__t.__pair3_))
1716{
1717 if (size() == 0)
1718 __begin_node() = __end_node();
1719 else
1720 {
1721 __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
1722 __t.__begin_node() = __t.__end_node();
1723 __t.__end_node()->__left_ = nullptr;
1724 __t.size() = 0;
1725 }
1726}
1727
1728template <class _Tp, class _Compare, class _Allocator>
1729__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
1730 : __pair1_(__second_tag(), __node_allocator(__a)),
1731 __pair3_(0, _VSTD::move(__t.value_comp()))
1732{
1733 if (__a == __t.__alloc())
1734 {
1735 if (__t.size() == 0)
1736 __begin_node() = __end_node();
1737 else
1738 {
1739 __begin_node() = __t.__begin_node();
1740 __end_node()->__left_ = __t.__end_node()->__left_;
1741 __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
1742 size() = __t.size();
1743 __t.__begin_node() = __t.__end_node();
1744 __t.__end_node()->__left_ = nullptr;
1745 __t.size() = 0;
1746 }
1747 }
1748 else
1749 {
1750 __begin_node() = __end_node();
1751 }
1752}
1753
1754template <class _Tp, class _Compare, class _Allocator>
1755void
1756__tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
1757 _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
1758 is_nothrow_move_assignable<__node_allocator>::value)
1759{
1760 destroy(static_cast<__node_pointer>(__end_node()->__left_));
1761 __begin_node_ = __t.__begin_node_;
1762 __pair1_.first() = __t.__pair1_.first();
1763 __move_assign_alloc(__t);
1764 __pair3_ = _VSTD::move(__t.__pair3_);
1765 if (size() == 0)
1766 __begin_node() = __end_node();
1767 else
1768 {
1769 __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
1770 __t.__begin_node() = __t.__end_node();
1771 __t.__end_node()->__left_ = nullptr;
1772 __t.size() = 0;
1773 }
1774}
1775
1776template <class _Tp, class _Compare, class _Allocator>
1777void
1778__tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
1779{
1780 if (__node_alloc() == __t.__node_alloc())
1781 __move_assign(__t, true_type());
1782 else
1783 {
1784 value_comp() = _VSTD::move(__t.value_comp());
1785 const_iterator __e = end();
1786 if (size() != 0)
1787 {
1788 _DetachedTreeCache __cache(this);
1789 while (__cache.__get() != nullptr && __t.size() != 0) {
1790 __cache.__get()->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_);
1791 __node_insert_multi(__cache.__get());
1792 __cache.__advance();
1793 }
1794 }
1795 while (__t.size() != 0)
1796 __insert_multi(__e, _NodeTypes::__move(__t.remove(__t.begin())->__value_));
1797 }
1798}
1799
1800template <class _Tp, class _Compare, class _Allocator>
1801__tree<_Tp, _Compare, _Allocator>&
1802__tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
1803 _NOEXCEPT_(
1804 __node_traits::propagate_on_container_move_assignment::value &&
1805 is_nothrow_move_assignable<value_compare>::value &&
1806 is_nothrow_move_assignable<__node_allocator>::value)
1807
1808{
1809 __move_assign(__t, integral_constant<bool,
1810 __node_traits::propagate_on_container_move_assignment::value>());
1811 return *this;
1812}
1813
1814#endif // _LIBCPP_CXX03_LANG
1815
1816template <class _Tp, class _Compare, class _Allocator>
1817__tree<_Tp, _Compare, _Allocator>::~__tree()
1818{
1819 static_assert((is_copy_constructible<value_compare>::value),
1820 "Comparator must be copy-constructible.");
1821 destroy(__root());
1822}
1823
1824template <class _Tp, class _Compare, class _Allocator>
1825void
1826__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
1827{
1828 if (__nd != nullptr)
1829 {
1830 destroy(static_cast<__node_pointer>(__nd->__left_));
1831 destroy(static_cast<__node_pointer>(__nd->__right_));
1832 __node_allocator& __na = __node_alloc();
1833 __node_traits::destroy(__na, _NodeTypes::__get_ptr(__nd->__value_));
1834 __node_traits::deallocate(__na, __nd, 1);
1835 }
1836}
1837
1838template <class _Tp, class _Compare, class _Allocator>
1839void
1840__tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
1841#if _LIBCPP_STD_VER <= 11
1842 _NOEXCEPT_(
1843 __is_nothrow_swappable<value_compare>::value
1844 && (!__node_traits::propagate_on_container_swap::value ||
1845 __is_nothrow_swappable<__node_allocator>::value)
1846 )
1847#else
1848 _NOEXCEPT_(__is_nothrow_swappable<value_compare>::value)
1849#endif
1850{
1851 using _VSTD::swap;
1852 swap(__begin_node_, __t.__begin_node_);
1853 swap(__pair1_.first(), __t.__pair1_.first());
1854 __swap_allocator(__node_alloc(), __t.__node_alloc());
1855 __pair3_.swap(__t.__pair3_);
1856 if (size() == 0)
1857 __begin_node() = __end_node();
1858 else
1859 __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
1860 if (__t.size() == 0)
1861 __t.__begin_node() = __t.__end_node();
1862 else
1863 __t.__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__t.__end_node());
1864}
1865
1866template <class _Tp, class _Compare, class _Allocator>
1867void
1868__tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
1869{
1870 destroy(__root());
1871 size() = 0;
1872 __begin_node() = __end_node();
1873 __end_node()->__left_ = nullptr;
1874}
1875
1876// Find lower_bound place to insert
1877// Set __parent to parent of null leaf
1878// Return reference to null leaf
1879template <class _Tp, class _Compare, class _Allocator>
1880typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
1881__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__parent_pointer& __parent,
1882 const key_type& __v)
1883{
1884 __node_pointer __nd = __root();
1885 if (__nd != nullptr)
1886 {
1887 while (true)
1888 {
1889 if (value_comp()(__nd->__value_, __v))
1890 {
1891 if (__nd->__right_ != nullptr)
1892 __nd = static_cast<__node_pointer>(__nd->__right_);
1893 else
1894 {
1895 __parent = static_cast<__parent_pointer>(__nd);
1896 return __nd->__right_;
1897 }
1898 }
1899 else
1900 {
1901 if (__nd->__left_ != nullptr)
1902 __nd = static_cast<__node_pointer>(__nd->__left_);
1903 else
1904 {
1905 __parent = static_cast<__parent_pointer>(__nd);
1906 return __parent->__left_;
1907 }
1908 }
1909 }
1910 }
1911 __parent = static_cast<__parent_pointer>(__end_node());
1912 return __parent->__left_;
1913}
1914
1915// Find upper_bound place to insert
1916// Set __parent to parent of null leaf
1917// Return reference to null leaf
1918template <class _Tp, class _Compare, class _Allocator>
1919typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
1920__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__parent_pointer& __parent,
1921 const key_type& __v)
1922{
1923 __node_pointer __nd = __root();
1924 if (__nd != nullptr)
1925 {
1926 while (true)
1927 {
1928 if (value_comp()(__v, __nd->__value_))
1929 {
1930 if (__nd->__left_ != nullptr)
1931 __nd = static_cast<__node_pointer>(__nd->__left_);
1932 else
1933 {
1934 __parent = static_cast<__parent_pointer>(__nd);
1935 return __parent->__left_;
1936 }
1937 }
1938 else
1939 {
1940 if (__nd->__right_ != nullptr)
1941 __nd = static_cast<__node_pointer>(__nd->__right_);
1942 else
1943 {
1944 __parent = static_cast<__parent_pointer>(__nd);
1945 return __nd->__right_;
1946 }
1947 }
1948 }
1949 }
1950 __parent = static_cast<__parent_pointer>(__end_node());
1951 return __parent->__left_;
1952}
1953
1954// Find leaf place to insert closest to __hint
1955// First check prior to __hint.
1956// Next check after __hint.
1957// Next do O(log N) search.
1958// Set __parent to parent of null leaf
1959// Return reference to null leaf
1960template <class _Tp, class _Compare, class _Allocator>
1961typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
1962__tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
1963 __parent_pointer& __parent,
1964 const key_type& __v)
1965{
1966 if (__hint == end() || !value_comp()(*__hint, __v)) // check before
1967 {
1968 // __v <= *__hint
1969 const_iterator __prior = __hint;
1970 if (__prior == begin() || !value_comp()(__v, *--__prior))
1971 {
1972 // *prev(__hint) <= __v <= *__hint
1973 if (__hint.__ptr_->__left_ == nullptr)
1974 {
1975 __parent = static_cast<__parent_pointer>(__hint.__ptr_);
1976 return __parent->__left_;
1977 }
1978 else
1979 {
1980 __parent = static_cast<__parent_pointer>(__prior.__ptr_);
1981 return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
1982 }
1983 }
1984 // __v < *prev(__hint)
1985 return __find_leaf_high(__parent, __v);
1986 }
1987 // else __v > *__hint
1988 return __find_leaf_low(__parent, __v);
1989}
1990
1991// Find place to insert if __v doesn't exist
1992// Set __parent to parent of null leaf
1993// Return reference to null leaf
1994// If __v exists, set parent to node of __v and return reference to node of __v
1995template <class _Tp, class _Compare, class _Allocator>
1996template <class _Key>
1997typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
1998__tree<_Tp, _Compare, _Allocator>::__find_equal(__parent_pointer& __parent,
1999 const _Key& __v)
2000{
2001 __node_pointer __nd = __root();
2002 __node_base_pointer* __nd_ptr = __root_ptr();
2003 if (__nd != nullptr)
2004 {
2005 while (true)
2006 {
2007 if (value_comp()(__v, __nd->__value_))
2008 {
2009 if (__nd->__left_ != nullptr) {
2010 __nd_ptr = _VSTD::addressof(__nd->__left_);
2011 __nd = static_cast<__node_pointer>(__nd->__left_);
2012 } else {
2013 __parent = static_cast<__parent_pointer>(__nd);
2014 return __parent->__left_;
2015 }
2016 }
2017 else if (value_comp()(__nd->__value_, __v))
2018 {
2019 if (__nd->__right_ != nullptr) {
2020 __nd_ptr = _VSTD::addressof(__nd->__right_);
2021 __nd = static_cast<__node_pointer>(__nd->__right_);
2022 } else {
2023 __parent = static_cast<__parent_pointer>(__nd);
2024 return __nd->__right_;
2025 }
2026 }
2027 else
2028 {
2029 __parent = static_cast<__parent_pointer>(__nd);
2030 return *__nd_ptr;
2031 }
2032 }
2033 }
2034 __parent = static_cast<__parent_pointer>(__end_node());
2035 return __parent->__left_;
2036}
2037
2038// Find place to insert if __v doesn't exist
2039// First check prior to __hint.
2040// Next check after __hint.
2041// Next do O(log N) search.
2042// Set __parent to parent of null leaf
2043// Return reference to null leaf
2044// If __v exists, set parent to node of __v and return reference to node of __v
2045template <class _Tp, class _Compare, class _Allocator>
2046template <class _Key>
2047typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
2048__tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
2049 __parent_pointer& __parent,
2050 __node_base_pointer& __dummy,
2051 const _Key& __v)
2052{
2053 if (__hint == end() || value_comp()(__v, *__hint)) // check before
2054 {
2055 // __v < *__hint
2056 const_iterator __prior = __hint;
2057 if (__prior == begin() || value_comp()(*--__prior, __v))
2058 {
2059 // *prev(__hint) < __v < *__hint
2060 if (__hint.__ptr_->__left_ == nullptr)
2061 {
2062 __parent = static_cast<__parent_pointer>(__hint.__ptr_);
2063 return __parent->__left_;
2064 }
2065 else
2066 {
2067 __parent = static_cast<__parent_pointer>(__prior.__ptr_);
2068 return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
2069 }
2070 }
2071 // __v <= *prev(__hint)
2072 return __find_equal(__parent, __v);
2073 }
2074 else if (value_comp()(*__hint, __v)) // check after
2075 {
2076 // *__hint < __v
2077 const_iterator __next = _VSTD::next(__hint);
2078 if (__next == end() || value_comp()(__v, *__next))
2079 {
2080 // *__hint < __v < *_VSTD::next(__hint)
2081 if (__hint.__get_np()->__right_ == nullptr)
2082 {
2083 __parent = static_cast<__parent_pointer>(__hint.__ptr_);
2084 return static_cast<__node_base_pointer>(__hint.__ptr_)->__right_;
2085 }
2086 else
2087 {
2088 __parent = static_cast<__parent_pointer>(__next.__ptr_);
2089 return __parent->__left_;
2090 }
2091 }
2092 // *next(__hint) <= __v
2093 return __find_equal(__parent, __v);
2094 }
2095 // else __v == *__hint
2096 __parent = static_cast<__parent_pointer>(__hint.__ptr_);
2097 __dummy = static_cast<__node_base_pointer>(__hint.__ptr_);
2098 return __dummy;
2099}
2100
2101template <class _Tp, class _Compare, class _Allocator>
2102void __tree<_Tp, _Compare, _Allocator>::__insert_node_at(
2103 __parent_pointer __parent, __node_base_pointer& __child,
2104 __node_base_pointer __new_node) _NOEXCEPT
2105{
2106 __new_node->__left_ = nullptr;
2107 __new_node->__right_ = nullptr;
2108 __new_node->__parent_ = __parent;
2109 // __new_node->__is_black_ is initialized in __tree_balance_after_insert
2110 __child = __new_node;
2111 if (__begin_node()->__left_ != nullptr)
2112 __begin_node() = static_cast<__iter_pointer>(__begin_node()->__left_);
2113 __tree_balance_after_insert(__end_node()->__left_, __child);
2114 ++size();
2115}
2116
2117#ifndef _LIBCPP_CXX03_LANG
2118template <class _Tp, class _Compare, class _Allocator>
2119template <class _Key, class... _Args>
2120pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
2121__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
2122#else
2123template <class _Tp, class _Compare, class _Allocator>
2124template <class _Key, class _Args>
2125pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
2126__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args& __args)
2127#endif
2128{
2129 __parent_pointer __parent;
2130 __node_base_pointer& __child = __find_equal(__parent, __k);
2131 __node_pointer __r = static_cast<__node_pointer>(__child);
2132 bool __inserted = false;
2133 if (__child == nullptr)
2134 {
2135#ifndef _LIBCPP_CXX03_LANG
2136 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
2137#else
2138 __node_holder __h = __construct_node(__args);
2139#endif
2140 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2141 __r = __h.release();
2142 __inserted = true;
2143 }
2144 return pair<iterator, bool>(iterator(__r), __inserted);
2145}
2146
2147
2148#ifndef _LIBCPP_CXX03_LANG
2149template <class _Tp, class _Compare, class _Allocator>
2150template <class _Key, class... _Args>
2151typename __tree<_Tp, _Compare, _Allocator>::iterator
2152__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
2153 const_iterator __p, _Key const& __k, _Args&&... __args)
2154#else
2155template <class _Tp, class _Compare, class _Allocator>
2156template <class _Key, class _Args>
2157typename __tree<_Tp, _Compare, _Allocator>::iterator
2158__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
2159 const_iterator __p, _Key const& __k, _Args& __args)
2160#endif
2161{
2162 __parent_pointer __parent;
2163 __node_base_pointer __dummy;
2164 __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __k);
2165 __node_pointer __r = static_cast<__node_pointer>(__child);
2166 if (__child == nullptr)
2167 {
2168#ifndef _LIBCPP_CXX03_LANG
2169 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
2170#else
2171 __node_holder __h = __construct_node(__args);
2172#endif
2173 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2174 __r = __h.release();
2175 }
2176 return iterator(__r);
2177}
2178
2179
2180#ifndef _LIBCPP_CXX03_LANG
2181
2182template <class _Tp, class _Compare, class _Allocator>
2183template <class ..._Args>
2184typename __tree<_Tp, _Compare, _Allocator>::__node_holder
2185__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
2186{
2187 static_assert(!__is_tree_value_type<_Args...>::value,
2188 "Cannot construct from __value_type");
2189 __node_allocator& __na = __node_alloc();
2190 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
2191 __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
2192 __h.get_deleter().__value_constructed = true;
2193 return __h;
2194}
2195
2196
2197template <class _Tp, class _Compare, class _Allocator>
2198template <class... _Args>
2199pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
2200__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args)
2201{
2202 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
2203 __parent_pointer __parent;
2204 __node_base_pointer& __child = __find_equal(__parent, __h->__value_);
2205 __node_pointer __r = static_cast<__node_pointer>(__child);
2206 bool __inserted = false;
2207 if (__child == nullptr)
2208 {
2209 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2210 __r = __h.release();
2211 __inserted = true;
2212 }
2213 return pair<iterator, bool>(iterator(__r), __inserted);
2214}
2215
2216template <class _Tp, class _Compare, class _Allocator>
2217template <class... _Args>
2218typename __tree<_Tp, _Compare, _Allocator>::iterator
2219__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p, _Args&&... __args)
2220{
2221 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
2222 __parent_pointer __parent;
2223 __node_base_pointer __dummy;
2224 __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
2225 __node_pointer __r = static_cast<__node_pointer>(__child);
2226 if (__child == nullptr)
2227 {
2228 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2229 __r = __h.release();
2230 }
2231 return iterator(__r);
2232}
2233
2234template <class _Tp, class _Compare, class _Allocator>
2235template <class... _Args>
2236typename __tree<_Tp, _Compare, _Allocator>::iterator
2237__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args)
2238{
2239 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
2240 __parent_pointer __parent;
2241 __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__h->__value_));
2242 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2243 return iterator(static_cast<__node_pointer>(__h.release()));
2244}
2245
2246template <class _Tp, class _Compare, class _Allocator>
2247template <class... _Args>
2248typename __tree<_Tp, _Compare, _Allocator>::iterator
2249__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
2250 _Args&&... __args)
2251{
2252 __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
2253 __parent_pointer __parent;
2254 __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__h->__value_));
2255 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2256 return iterator(static_cast<__node_pointer>(__h.release()));
2257}
2258
2259
2260#else // _LIBCPP_CXX03_LANG
2261
2262template <class _Tp, class _Compare, class _Allocator>
2263typename __tree<_Tp, _Compare, _Allocator>::__node_holder
2264__tree<_Tp, _Compare, _Allocator>::__construct_node(const __container_value_type& __v)
2265{
2266 __node_allocator& __na = __node_alloc();
2267 __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
2268 __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), __v);
2269 __h.get_deleter().__value_constructed = true;
2270 return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
2271}
2272
2273#endif // _LIBCPP_CXX03_LANG
2274
2275#ifdef _LIBCPP_CXX03_LANG
2276template <class _Tp, class _Compare, class _Allocator>
2277typename __tree<_Tp, _Compare, _Allocator>::iterator
2278__tree<_Tp, _Compare, _Allocator>::__insert_multi(const __container_value_type& __v)
2279{
2280 __parent_pointer __parent;
2281 __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__v));
2282 __node_holder __h = __construct_node(__v);
2283 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2284 return iterator(__h.release());
2285}
2286
2287template <class _Tp, class _Compare, class _Allocator>
2288typename __tree<_Tp, _Compare, _Allocator>::iterator
2289__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, const __container_value_type& __v)
2290{
2291 __parent_pointer __parent;
2292 __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__v));
2293 __node_holder __h = __construct_node(__v);
2294 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
2295 return iterator(__h.release());
2296}
2297#endif
2298
2299template <class _Tp, class _Compare, class _Allocator>
2300pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
2301__tree<_Tp, _Compare, _Allocator>::__node_assign_unique(const __container_value_type& __v, __node_pointer __nd)
2302{
2303 __parent_pointer __parent;
2304 __node_base_pointer& __child = __find_equal(__parent, _NodeTypes::__get_key(__v));
2305 __node_pointer __r = static_cast<__node_pointer>(__child);
2306 bool __inserted = false;
2307 if (__child == nullptr)
2308 {
2309 __nd->__value_ = __v;
2310 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
2311 __r = __nd;
2312 __inserted = true;
2313 }
2314 return pair<iterator, bool>(iterator(__r), __inserted);
2315}
2316
2317
2318template <class _Tp, class _Compare, class _Allocator>
2319typename __tree<_Tp, _Compare, _Allocator>::iterator
2320__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd)
2321{
2322 __parent_pointer __parent;
2323 __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__nd->__value_));
2324 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
2325 return iterator(__nd);
2326}
2327
2328template <class _Tp, class _Compare, class _Allocator>
2329typename __tree<_Tp, _Compare, _Allocator>::iterator
2330__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p,
2331 __node_pointer __nd)
2332{
2333 __parent_pointer __parent;
2334 __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__nd->__value_));
2335 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
2336 return iterator(__nd);
2337}
2338
2339template <class _Tp, class _Compare, class _Allocator>
2340typename __tree<_Tp, _Compare, _Allocator>::iterator
2341__tree<_Tp, _Compare, _Allocator>::__remove_node_pointer(__node_pointer __ptr) _NOEXCEPT
2342{
2343 iterator __r(__ptr);
2344 ++__r;
2345 if (__begin_node() == __ptr)
2346 __begin_node() = __r.__ptr_;
2347 --size();
2348 __tree_remove(__end_node()->__left_,
2349 static_cast<__node_base_pointer>(__ptr));
2350 return __r;
2351}
2352
2353#if _LIBCPP_STD_VER > 14
2354template <class _Tp, class _Compare, class _Allocator>
2355template <class _NodeHandle, class _InsertReturnType>
2356_LIBCPP_INLINE_VISIBILITY
2357_InsertReturnType
2358__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(
2359 _NodeHandle&& __nh)
2360{
2361 if (__nh.empty())
2362 return _InsertReturnType{end(), false, _NodeHandle()};
2363
2364 __node_pointer __ptr = __nh.__ptr_;
2365 __parent_pointer __parent;
2366 __node_base_pointer& __child = __find_equal(__parent,
2367 __ptr->__value_);
2368 if (__child != nullptr)
2369 return _InsertReturnType{
2370 iterator(static_cast<__node_pointer>(__child)),
2371 false, _VSTD::move(__nh)};
2372
2373 __insert_node_at(__parent, __child,
2374 static_cast<__node_base_pointer>(__ptr));
2375 __nh.__release_ptr();
2376 return _InsertReturnType{iterator(__ptr), true, _NodeHandle()};
2377}
2378
2379template <class _Tp, class _Compare, class _Allocator>
2380template <class _NodeHandle>
2381_LIBCPP_INLINE_VISIBILITY
2382typename __tree<_Tp, _Compare, _Allocator>::iterator
2383__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(
2384 const_iterator __hint, _NodeHandle&& __nh)
2385{
2386 if (__nh.empty())
2387 return end();
2388
2389 __node_pointer __ptr = __nh.__ptr_;
2390 __parent_pointer __parent;
2391 __node_base_pointer __dummy;
2392 __node_base_pointer& __child = __find_equal(__hint, __parent, __dummy,
2393 __ptr->__value_);
2394 __node_pointer __r = static_cast<__node_pointer>(__child);
2395 if (__child == nullptr)
2396 {
2397 __insert_node_at(__parent, __child,
2398 static_cast<__node_base_pointer>(__ptr));
2399 __r = __ptr;
2400 __nh.__release_ptr();
2401 }
2402 return iterator(__r);
2403}
2404
2405template <class _Tp, class _Compare, class _Allocator>
2406template <class _NodeHandle>
2407_LIBCPP_INLINE_VISIBILITY
2408_NodeHandle
2409__tree<_Tp, _Compare, _Allocator>::__node_handle_extract(key_type const& __key)
2410{
2411 iterator __it = find(__key);
2412 if (__it == end())
2413 return _NodeHandle();
2414 return __node_handle_extract<_NodeHandle>(__it);
2415}
2416
2417template <class _Tp, class _Compare, class _Allocator>
2418template <class _NodeHandle>
2419_LIBCPP_INLINE_VISIBILITY
2420_NodeHandle
2421__tree<_Tp, _Compare, _Allocator>::__node_handle_extract(const_iterator __p)
2422{
2423 __node_pointer __np = __p.__get_np();
2424 __remove_node_pointer(__np);
2425 return _NodeHandle(__np, __alloc());
2426}
2427
2428template <class _Tp, class _Compare, class _Allocator>
2429template <class _Tree>
2430_LIBCPP_INLINE_VISIBILITY
2431void
2432__tree<_Tp, _Compare, _Allocator>::__node_handle_merge_unique(_Tree& __source)
2433{
2434 static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");
2435
2436 for (typename _Tree::iterator __i = __source.begin();
2437 __i != __source.end();)
2438 {
2439 __node_pointer __src_ptr = __i.__get_np();
2440 __parent_pointer __parent;
2441 __node_base_pointer& __child =
2442 __find_equal(__parent, _NodeTypes::__get_key(__src_ptr->__value_));
2443 ++__i;
2444 if (__child != nullptr)
2445 continue;
2446 __source.__remove_node_pointer(__src_ptr);
2447 __insert_node_at(__parent, __child,
2448 static_cast<__node_base_pointer>(__src_ptr));
2449 }
2450}
2451
2452template <class _Tp, class _Compare, class _Allocator>
2453template <class _NodeHandle>
2454_LIBCPP_INLINE_VISIBILITY
2455typename __tree<_Tp, _Compare, _Allocator>::iterator
2456__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh)
2457{
2458 if (__nh.empty())
2459 return end();
2460 __node_pointer __ptr = __nh.__ptr_;
2461 __parent_pointer __parent;
2462 __node_base_pointer& __child = __find_leaf_high(
2463 __parent, _NodeTypes::__get_key(__ptr->__value_));
2464 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
2465 __nh.__release_ptr();
2466 return iterator(__ptr);
2467}
2468
2469template <class _Tp, class _Compare, class _Allocator>
2470template <class _NodeHandle>
2471_LIBCPP_INLINE_VISIBILITY
2472typename __tree<_Tp, _Compare, _Allocator>::iterator
2473__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(
2474 const_iterator __hint, _NodeHandle&& __nh)
2475{
2476 if (__nh.empty())
2477 return end();
2478
2479 __node_pointer __ptr = __nh.__ptr_;
2480 __parent_pointer __parent;
2481 __node_base_pointer& __child = __find_leaf(__hint, __parent,
2482 _NodeTypes::__get_key(__ptr->__value_));
2483 __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
2484 __nh.__release_ptr();
2485 return iterator(__ptr);
2486}
2487
2488template <class _Tp, class _Compare, class _Allocator>
2489template <class _Tree>
2490_LIBCPP_INLINE_VISIBILITY
2491void
2492__tree<_Tp, _Compare, _Allocator>::__node_handle_merge_multi(_Tree& __source)
2493{
2494 static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");
2495
2496 for (typename _Tree::iterator __i = __source.begin();
2497 __i != __source.end();)
2498 {
2499 __node_pointer __src_ptr = __i.__get_np();
2500 __parent_pointer __parent;
2501 __node_base_pointer& __child = __find_leaf_high(
2502 __parent, _NodeTypes::__get_key(__src_ptr->__value_));
2503 ++__i;
2504 __source.__remove_node_pointer(__src_ptr);
2505 __insert_node_at(__parent, __child,
2506 static_cast<__node_base_pointer>(__src_ptr));
2507 }
2508}
2509
2510#endif // _LIBCPP_STD_VER > 14
2511
2512template <class _Tp, class _Compare, class _Allocator>
2513typename __tree<_Tp, _Compare, _Allocator>::iterator
2514__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
2515{
2516 __node_pointer __np = __p.__get_np();
2517 iterator __r = __remove_node_pointer(__np);
2518 __node_allocator& __na = __node_alloc();
2519 __node_traits::destroy(__na, _NodeTypes::__get_ptr(
2520 const_cast<__node_value_type&>(*__p)));
2521 __node_traits::deallocate(__na, __np, 1);
2522 return __r;
2523}
2524
2525template <class _Tp, class _Compare, class _Allocator>
2526typename __tree<_Tp, _Compare, _Allocator>::iterator
2527__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __f, const_iterator __l)
2528{
2529 while (__f != __l)
2530 __f = erase(__f);
2531 return iterator(__l.__ptr_);
2532}
2533
2534template <class _Tp, class _Compare, class _Allocator>
2535template <class _Key>
2536typename __tree<_Tp, _Compare, _Allocator>::size_type
2537__tree<_Tp, _Compare, _Allocator>::__erase_unique(const _Key& __k)
2538{
2539 iterator __i = find(__k);
2540 if (__i == end())
2541 return 0;
2542 erase(__i);
2543 return 1;
2544}
2545
2546template <class _Tp, class _Compare, class _Allocator>
2547template <class _Key>
2548typename __tree<_Tp, _Compare, _Allocator>::size_type
2549__tree<_Tp, _Compare, _Allocator>::__erase_multi(const _Key& __k)
2550{
2551 pair<iterator, iterator> __p = __equal_range_multi(__k);
2552 size_type __r = 0;
2553 for (; __p.first != __p.second; ++__r)
2554 __p.first = erase(__p.first);
2555 return __r;
2556}
2557
2558template <class _Tp, class _Compare, class _Allocator>
2559template <class _Key>
2560typename __tree<_Tp, _Compare, _Allocator>::iterator
2561__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v)
2562{
2563 iterator __p = __lower_bound(__v, __root(), __end_node());
2564 if (__p != end() && !value_comp()(__v, *__p))
2565 return __p;
2566 return end();
2567}
2568
2569template <class _Tp, class _Compare, class _Allocator>
2570template <class _Key>
2571typename __tree<_Tp, _Compare, _Allocator>::const_iterator
2572__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v) const
2573{
2574 const_iterator __p = __lower_bound(__v, __root(), __end_node());
2575 if (__p != end() && !value_comp()(__v, *__p))
2576 return __p;
2577 return end();
2578}
2579
2580template <class _Tp, class _Compare, class _Allocator>
2581template <class _Key>
2582typename __tree<_Tp, _Compare, _Allocator>::size_type
2583__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const
2584{
2585 __node_pointer __rt = __root();
2586 while (__rt != nullptr)
2587 {
2588 if (value_comp()(__k, __rt->__value_))
2589 {
2590 __rt = static_cast<__node_pointer>(__rt->__left_);
2591 }
2592 else if (value_comp()(__rt->__value_, __k))
2593 __rt = static_cast<__node_pointer>(__rt->__right_);
2594 else
2595 return 1;
2596 }
2597 return 0;
2598}
2599
2600template <class _Tp, class _Compare, class _Allocator>
2601template <class _Key>
2602typename __tree<_Tp, _Compare, _Allocator>::size_type
2603__tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const
2604{
2605 __iter_pointer __result = __end_node();
2606 __node_pointer __rt = __root();
2607 while (__rt != nullptr)
2608 {
2609 if (value_comp()(__k, __rt->__value_))
2610 {
2611 __result = static_cast<__iter_pointer>(__rt);
2612 __rt = static_cast<__node_pointer>(__rt->__left_);
2613 }
2614 else if (value_comp()(__rt->__value_, __k))
2615 __rt = static_cast<__node_pointer>(__rt->__right_);
2616 else
2617 return _VSTD::distance(
2618 __lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
2619 __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result)
2620 );
2621 }
2622 return 0;
2623}
2624
2625template <class _Tp, class _Compare, class _Allocator>
2626template <class _Key>
2627typename __tree<_Tp, _Compare, _Allocator>::iterator
2628__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
2629 __node_pointer __root,
2630 __iter_pointer __result)
2631{
2632 while (__root != nullptr)
2633 {
2634 if (!value_comp()(__root->__value_, __v))
2635 {
2636 __result = static_cast<__iter_pointer>(__root);
2637 __root = static_cast<__node_pointer>(__root->__left_);
2638 }
2639 else
2640 __root = static_cast<__node_pointer>(__root->__right_);
2641 }
2642 return iterator(__result);
2643}
2644
2645template <class _Tp, class _Compare, class _Allocator>
2646template <class _Key>
2647typename __tree<_Tp, _Compare, _Allocator>::const_iterator
2648__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
2649 __node_pointer __root,
2650 __iter_pointer __result) const
2651{
2652 while (__root != nullptr)
2653 {
2654 if (!value_comp()(__root->__value_, __v))
2655 {
2656 __result = static_cast<__iter_pointer>(__root);
2657 __root = static_cast<__node_pointer>(__root->__left_);
2658 }
2659 else
2660 __root = static_cast<__node_pointer>(__root->__right_);
2661 }
2662 return const_iterator(__result);
2663}
2664
2665template <class _Tp, class _Compare, class _Allocator>
2666template <class _Key>
2667typename __tree<_Tp, _Compare, _Allocator>::iterator
2668__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
2669 __node_pointer __root,
2670 __iter_pointer __result)
2671{
2672 while (__root != nullptr)
2673 {
2674 if (value_comp()(__v, __root->__value_))
2675 {
2676 __result = static_cast<__iter_pointer>(__root);
2677 __root = static_cast<__node_pointer>(__root->__left_);
2678 }
2679 else
2680 __root = static_cast<__node_pointer>(__root->__right_);
2681 }
2682 return iterator(__result);
2683}
2684
2685template <class _Tp, class _Compare, class _Allocator>
2686template <class _Key>
2687typename __tree<_Tp, _Compare, _Allocator>::const_iterator
2688__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
2689 __node_pointer __root,
2690 __iter_pointer __result) const
2691{
2692 while (__root != nullptr)
2693 {
2694 if (value_comp()(__v, __root->__value_))
2695 {
2696 __result = static_cast<__iter_pointer>(__root);
2697 __root = static_cast<__node_pointer>(__root->__left_);
2698 }
2699 else
2700 __root = static_cast<__node_pointer>(__root->__right_);
2701 }
2702 return const_iterator(__result);
2703}
2704
2705template <class _Tp, class _Compare, class _Allocator>
2706template <class _Key>
2707pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
2708 typename __tree<_Tp, _Compare, _Allocator>::iterator>
2709__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k)
2710{
2711 typedef pair<iterator, iterator> _Pp;
2712 __iter_pointer __result = __end_node();
2713 __node_pointer __rt = __root();
2714 while (__rt != nullptr)
2715 {
2716 if (value_comp()(__k, __rt->__value_))
2717 {
2718 __result = static_cast<__iter_pointer>(__rt);
2719 __rt = static_cast<__node_pointer>(__rt->__left_);
2720 }
2721 else if (value_comp()(__rt->__value_, __k))
2722 __rt = static_cast<__node_pointer>(__rt->__right_);
2723 else
2724 return _Pp(iterator(__rt),
2725 iterator(
2726 __rt->__right_ != nullptr ?
2727 static_cast<__iter_pointer>(__tree_min(__rt->__right_))
2728 : __result));
2729 }
2730 return _Pp(iterator(__result), iterator(__result));
2731}
2732
2733template <class _Tp, class _Compare, class _Allocator>
2734template <class _Key>
2735pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
2736 typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
2737__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const
2738{
2739 typedef pair<const_iterator, const_iterator> _Pp;
2740 __iter_pointer __result = __end_node();
2741 __node_pointer __rt = __root();
2742 while (__rt != nullptr)
2743 {
2744 if (value_comp()(__k, __rt->__value_))
2745 {
2746 __result = static_cast<__iter_pointer>(__rt);
2747 __rt = static_cast<__node_pointer>(__rt->__left_);
2748 }
2749 else if (value_comp()(__rt->__value_, __k))
2750 __rt = static_cast<__node_pointer>(__rt->__right_);
2751 else
2752 return _Pp(const_iterator(__rt),
2753 const_iterator(
2754 __rt->__right_ != nullptr ?
2755 static_cast<__iter_pointer>(__tree_min(__rt->__right_))
2756 : __result));
2757 }
2758 return _Pp(const_iterator(__result), const_iterator(__result));
2759}
2760
2761template <class _Tp, class _Compare, class _Allocator>
2762template <class _Key>
2763pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
2764 typename __tree<_Tp, _Compare, _Allocator>::iterator>
2765__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k)
2766{
2767 typedef pair<iterator, iterator> _Pp;
2768 __iter_pointer __result = __end_node();
2769 __node_pointer __rt = __root();
2770 while (__rt != nullptr)
2771 {
2772 if (value_comp()(__k, __rt->__value_))
2773 {
2774 __result = static_cast<__iter_pointer>(__rt);
2775 __rt = static_cast<__node_pointer>(__rt->__left_);
2776 }
2777 else if (value_comp()(__rt->__value_, __k))
2778 __rt = static_cast<__node_pointer>(__rt->__right_);
2779 else
2780 return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
2781 __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
2782 }
2783 return _Pp(iterator(__result), iterator(__result));
2784}
2785
2786template <class _Tp, class _Compare, class _Allocator>
2787template <class _Key>
2788pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
2789 typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
2790__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const
2791{
2792 typedef pair<const_iterator, const_iterator> _Pp;
2793 __iter_pointer __result = __end_node();
2794 __node_pointer __rt = __root();
2795 while (__rt != nullptr)
2796 {
2797 if (value_comp()(__k, __rt->__value_))
2798 {
2799 __result = static_cast<__iter_pointer>(__rt);
2800 __rt = static_cast<__node_pointer>(__rt->__left_);
2801 }
2802 else if (value_comp()(__rt->__value_, __k))
2803 __rt = static_cast<__node_pointer>(__rt->__right_);
2804 else
2805 return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
2806 __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
2807 }
2808 return _Pp(const_iterator(__result), const_iterator(__result));
2809}
2810
2811template <class _Tp, class _Compare, class _Allocator>
2812typename __tree<_Tp, _Compare, _Allocator>::__node_holder
2813__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
2814{
2815 __node_pointer __np = __p.__get_np();
2816 if (__begin_node() == __p.__ptr_)
2817 {
2818 if (__np->__right_ != nullptr)
2819 __begin_node() = static_cast<__iter_pointer>(__np->__right_);
2820 else
2821 __begin_node() = static_cast<__iter_pointer>(__np->__parent_);
2822 }
2823 --size();
2824 __tree_remove(__end_node()->__left_,
2825 static_cast<__node_base_pointer>(__np));
2826 return __node_holder(__np, _Dp(__node_alloc(), true));
2827}
2828
2829template <class _Tp, class _Compare, class _Allocator>
2830inline _LIBCPP_INLINE_VISIBILITY
2831void
2832swap(__tree<_Tp, _Compare, _Allocator>& __x,
2833 __tree<_Tp, _Compare, _Allocator>& __y)
2834 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
2835{
2836 __x.swap(__y);
2837}
2838
2839_LIBCPP_END_NAMESPACE_STD
2840
2841_LIBCPP_POP_MACROS
2842
2843#endif // _LIBCPP___TREE
2844