libstdc++: stl_tree.h Source File

libstdc++

stl_tree.h
Go to the documentation of this file.
1// RB tree implementation -*- C++ -*-
2
3// Copyright (C) 2001-2026 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/*
26 *
27 * Copyright (c) 1996,1997
28 * Silicon Graphics Computer Systems, Inc.
29 *
30 * Permission to use, copy, modify, distribute and sell this software
31 * and its documentation for any purpose is hereby granted without fee,
32 * provided that the above copyright notice appear in all copies and
33 * that both that copyright notice and this permission notice appear
34 * in supporting documentation. Silicon Graphics makes no
35 * representations about the suitability of this software for any
36 * purpose. It is provided "as is" without express or implied warranty.
37 *
38 *
39 * Copyright (c) 1994
40 * Hewlett-Packard Company
41 *
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Hewlett-Packard Company makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
49 *
50 *
51 */
52
53/** @file bits/stl_tree.h
54 * This is an internal header file, included by other library headers.
55 * Do not attempt to use it directly. @headername{map,set}
56 */
57
58#ifndef _STL_TREE_H
59#define _STL_TREE_H 1
60
61#ifdef _GLIBCXX_SYSHDR
62#pragma GCC system_header
63#endif
64
65#include <bits/stl_algobase.h>
66#include <bits/allocator.h>
67#include <bits/stl_function.h>
68#include <bits/cpp_type_traits.h>
69#include <bits/ptr_traits.h>
70#include <ext/alloc_traits.h>
71#if __cplusplus >= 201103L
72# include <ext/aligned_buffer.h>
73#endif
74#ifdef __glibcxx_node_extract // >= C++17
75# include <bits/node_handle.h>
76#endif
77
78#if __cplusplus < 201103L
79# undef _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
80# define _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE 0
81#elif ! defined _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
82# define _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE 1
83#endif
84
85namespace std _GLIBCXX_VISIBILITY(default)
86{
87_GLIBCXX_BEGIN_NAMESPACE_VERSION
88
89 // Red-black tree class, designed for use in implementing STL
90 // associative containers (set, multiset, map, and multimap). The
91 // insertion and deletion algorithms are based on those in Cormen,
92 // Leiserson, and Rivest, Introduction to Algorithms (MIT Press,
93 // 1990), except that
94 //
95 // (1) the header cell is maintained with links not only to the root
96 // but also to the leftmost node of the tree, to enable constant
97 // time begin(), and to the rightmost node of the tree, to enable
98 // linear time performance when used with the generic set algorithms
99 // (set_union, etc.)
100 //
101 // (2) when a node being deleted has two children its successor node
102 // is relinked into its place, rather than copied, so that the only
103 // iterators invalidated are those referring to the deleted node.
104
105 enum _Rb_tree_color { _S_red = false, _S_black = true };
106
107 struct _Rb_tree_node_base
108 {
109 typedef _Rb_tree_node_base* _Base_ptr;
110
111 _Rb_tree_color _M_color;
112 _Base_ptr _M_parent;
113 _Base_ptr _M_left;
114 _Base_ptr _M_right;
115
116 static _Base_ptr
117 _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
118 {
119 while (__x->_M_left != 0) __x = __x->_M_left;
120 return __x;
121 }
122
123 static _Base_ptr
124 _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
125 {
126 while (__x->_M_right != 0) __x = __x->_M_right;
127 return __x;
128 }
129
130 // This is not const-correct, but it's only used in a const access path
131 // by std::_Rb_tree::_M_end() where the pointer is used to initialize a
132 // const_iterator and so constness is restored.
133 _Base_ptr
134 _M_base_ptr() const _GLIBCXX_NOEXCEPT
135 { return const_cast<_Rb_tree_node_base*>(this); }
136 };
137
138 // Helper type offering value initialization guarantee on the compare functor.
139 template<typename _Key_compare>
140 struct _Rb_tree_key_compare
141 {
142 _Key_compare _M_key_compare;
143
144 _Rb_tree_key_compare()
145 _GLIBCXX_NOEXCEPT_IF(
146 is_nothrow_default_constructible<_Key_compare>::value)
147 : _M_key_compare()
148 { }
149
150 _Rb_tree_key_compare(const _Key_compare& __comp)
151 : _M_key_compare(__comp)
152 { }
153
154#if __cplusplus >= 201103L
155 // Copy constructor added for consistency with C++98 mode.
156 _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default;
157
158 _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
159 noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
160 : _M_key_compare(__x._M_key_compare)
161 { }
162#endif
163 };
164
165 // Helper type to manage default initialization of node count and header.
166 struct _Rb_tree_header
167 {
168 _Rb_tree_node_base _M_header;
169 size_t _M_node_count; // Keeps track of size of tree.
170
171 _Rb_tree_header() _GLIBCXX_NOEXCEPT
172 {
173 _M_header._M_color = _S_red;
174 _M_reset();
175 }
176
177#if __cplusplus >= 201103L
178 _Rb_tree_header(_Rb_tree_header&& __x) noexcept
179 {
180 if (__x._M_header._M_parent != nullptr)
181 _M_move_data(__x);
182 else
183 {
184 _M_header._M_color = _S_red;
185 _M_reset();
186 }
187 }
188#endif
189
190 void
191 _M_move_data(_Rb_tree_header& __from)
192 {
193 _M_header._M_color = __from._M_header._M_color;
194 _M_header._M_parent = __from._M_header._M_parent;
195 _M_header._M_left = __from._M_header._M_left;
196 _M_header._M_right = __from._M_header._M_right;
197 _M_header._M_parent->_M_parent = &_M_header;
198 _M_node_count = __from._M_node_count;
199
200 __from._M_reset();
201 }
202
203 void
204 _M_reset()
205 {
206 _M_header._M_parent = 0;
207 _M_header._M_left = &_M_header;
208 _M_header._M_right = &_M_header;
209 _M_node_count = 0;
210 }
211 };
212
213 template<typename _Val>
214 struct _Rb_tree_node : public _Rb_tree_node_base
215 {
216#if __cplusplus < 201103L
217 _Val _M_value_field;
218
219 _Val*
220 _M_valptr()
221 { return std::__addressof(_M_value_field); }
222
223 const _Val*
224 _M_valptr() const
225 { return std::__addressof(_M_value_field); }
226#else
227 __gnu_cxx::__aligned_membuf<_Val> _M_storage;
228
229 _Val*
230 _M_valptr()
231 { return _M_storage._M_ptr(); }
232
233 const _Val*
234 _M_valptr() const
235 { return _M_storage._M_ptr(); }
236#endif
237
238 _Rb_tree_node*
239 _M_node_ptr() _GLIBCXX_NOEXCEPT
240 { return this; }
241 };
242
243#if _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
244namespace __rb_tree
245{
246 template<typename _VoidPtr>
247 struct _Node_base
248 {
249 using _Base_ptr = __ptr_rebind<_VoidPtr, _Node_base>;
250
251 _Rb_tree_color _M_color;
252 _Base_ptr _M_parent;
253 _Base_ptr _M_left;
254 _Base_ptr _M_right;
255
256 static _Base_ptr
257 _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
258 {
259 while (__x->_M_left) __x = __x->_M_left;
260 return __x;
261 }
262
263 static _Base_ptr
264 _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
265 {
266 while (__x->_M_right) __x = __x->_M_right;
267 return __x;
268 }
269
270 // This is not const-correct, but it's only used in a const access path
271 // by std::_Rb_tree::_M_end() where the pointer is used to initialize a
272 // const_iterator and so constness is restored.
273 _Base_ptr
274 _M_base_ptr() const noexcept
275 {
276 return pointer_traits<_Base_ptr>::pointer_to
277 (*const_cast<_Node_base*>(this));
278 }
279 };
280
281 // Helper type to manage default initialization of node count and header.
282 template<typename _NodeBase>
283 struct _Header
284 {
285 private:
286 using _Base_ptr = typename _NodeBase::_Base_ptr;
287
288 public:
289 _NodeBase _M_header;
290 size_t _M_node_count; // Keeps track of size of tree.
291
292 _Header() noexcept
293 {
294 _M_header._M_color = _S_red;
295 _M_reset();
296 }
297
298 _Header(_Header&& __x) noexcept
299 {
300 if (__x._M_header._M_parent)
301 _M_move_data(__x);
302 else
303 {
304 _M_header._M_color = _S_red;
305 _M_reset();
306 }
307 }
308
309 void
310 _M_move_data(_Header& __from)
311 {
312 _M_header._M_color = __from._M_header._M_color;
313 _M_header._M_parent = __from._M_header._M_parent;
314 _M_header._M_left = __from._M_header._M_left;
315 _M_header._M_right = __from._M_header._M_right;
316 _M_header._M_parent->_M_parent = _M_header._M_base_ptr();
317 _M_node_count = __from._M_node_count;
318
319 __from._M_reset();
320 }
321
322 void
323 _M_reset()
324 {
325 _M_header._M_parent = nullptr;
326 _M_header._M_left = _M_header._M_right = _M_header._M_base_ptr();
327 _M_node_count = 0;
328 }
329 };
330
331 template<typename _ValPtr>
332 struct _Node : public __rb_tree::_Node_base<__ptr_rebind<_ValPtr, void>>
333 {
334 using value_type = typename pointer_traits<_ValPtr>::element_type;
335 using _Node_ptr = __ptr_rebind<_ValPtr, _Node>;
336
337 _Node() noexcept { }
338 ~_Node() { }
339 _Node(_Node&&) = delete;
340
341 union _Uninit_storage
342 {
343 _Uninit_storage() noexcept { }
344 ~_Uninit_storage() { }
345
346 value_type _M_data;
347 };
348 _Uninit_storage _M_u;
349
350 value_type*
351 _M_valptr()
352 { return std::addressof(_M_u._M_data); }
353
354 value_type const*
355 _M_valptr() const
356 { return std::addressof(_M_u._M_data); }
357
358 _Node_ptr
359 _M_node_ptr() noexcept
360 { return pointer_traits<_Node_ptr>::pointer_to(*this); }
361 };
362} // namespace __rb_tree
363#endif // _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
364
365 _GLIBCXX_PURE _Rb_tree_node_base*
366 _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
367
368 _GLIBCXX_PURE _Rb_tree_node_base*
369 _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
370
371 template<typename _Tp>
372 struct _Rb_tree_iterator
373 {
374 typedef _Tp value_type;
375 typedef _Tp& reference;
376 typedef _Tp* pointer;
377
378 typedef bidirectional_iterator_tag iterator_category;
379 typedef ptrdiff_t difference_type;
380
381 typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
382 typedef _Rb_tree_node<_Tp>* _Node_ptr;
383
384 _Rb_tree_iterator() _GLIBCXX_NOEXCEPT
385 : _M_node() { }
386
387 explicit
388 _Rb_tree_iterator(_Base_ptr __x) _GLIBCXX_NOEXCEPT
389 : _M_node(__x) { }
390
391 reference
392 operator*() const _GLIBCXX_NOEXCEPT
393 { return *static_cast<_Node_ptr>(_M_node)->_M_valptr(); }
394
395 pointer
396 operator->() const _GLIBCXX_NOEXCEPT
397 { return static_cast<_Node_ptr>(_M_node)->_M_valptr(); }
398
399 _Rb_tree_iterator&
400 operator++() _GLIBCXX_NOEXCEPT
401 {
402 _M_node = _Rb_tree_increment(_M_node);
403 return *this;
404 }
405
406 _Rb_tree_iterator
407 operator++(int) _GLIBCXX_NOEXCEPT
408 {
409 _Rb_tree_iterator __tmp = *this;
410 _M_node = _Rb_tree_increment(_M_node);
411 return __tmp;
412 }
413
414 _Rb_tree_iterator&
415 operator--() _GLIBCXX_NOEXCEPT
416 {
417 _M_node = _Rb_tree_decrement(_M_node);
418 return *this;
419 }
420
421 _Rb_tree_iterator
422 operator--(int) _GLIBCXX_NOEXCEPT
423 {
424 _Rb_tree_iterator __tmp = *this;
425 _M_node = _Rb_tree_decrement(_M_node);
426 return __tmp;
427 }
428
429 friend bool
430 operator==(const _Rb_tree_iterator& __x,
431 const _Rb_tree_iterator& __y) _GLIBCXX_NOEXCEPT
432 { return __x._M_node == __y._M_node; }
433
434#if ! __cpp_lib_three_way_comparison
435 friend bool
436 operator!=(const _Rb_tree_iterator& __x,
437 const _Rb_tree_iterator& __y) _GLIBCXX_NOEXCEPT
438 { return __x._M_node != __y._M_node; }
439#endif
440
441 _Base_ptr _M_node;
442 };
443
444 template<typename _Tp>
445 struct _Rb_tree_const_iterator
446 {
447 typedef _Tp value_type;
448 typedef const _Tp& reference;
449 typedef const _Tp* pointer;
450
451 typedef _Rb_tree_iterator<_Tp> iterator;
452
453 typedef bidirectional_iterator_tag iterator_category;
454 typedef ptrdiff_t difference_type;
455
456 typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
457 typedef const _Rb_tree_node<_Tp>* _Node_ptr;
458
459 _Rb_tree_const_iterator() _GLIBCXX_NOEXCEPT
460 : _M_node() { }
461
462 explicit
463 _Rb_tree_const_iterator(_Base_ptr __x) _GLIBCXX_NOEXCEPT
464 : _M_node(__x) { }
465
466 _Rb_tree_const_iterator(const iterator& __it) _GLIBCXX_NOEXCEPT
467 : _M_node(__it._M_node) { }
468
469 reference
470 operator*() const _GLIBCXX_NOEXCEPT
471 { return *static_cast<_Node_ptr>(_M_node)->_M_valptr(); }
472
473 pointer
474 operator->() const _GLIBCXX_NOEXCEPT
475 { return static_cast<_Node_ptr>(_M_node)->_M_valptr(); }
476
477 _Rb_tree_const_iterator&
478 operator++() _GLIBCXX_NOEXCEPT
479 {
480 _M_node = _Rb_tree_increment(_M_node);
481 return *this;
482 }
483
484 _Rb_tree_const_iterator
485 operator++(int) _GLIBCXX_NOEXCEPT
486 {
487 _Rb_tree_const_iterator __tmp = *this;
488 _M_node = _Rb_tree_increment(_M_node);
489 return __tmp;
490 }
491
492 _Rb_tree_const_iterator&
493 operator--() _GLIBCXX_NOEXCEPT
494 {
495 _M_node = _Rb_tree_decrement(_M_node);
496 return *this;
497 }
498
499 _Rb_tree_const_iterator
500 operator--(int) _GLIBCXX_NOEXCEPT
501 {
502 _Rb_tree_const_iterator __tmp = *this;
503 _M_node = _Rb_tree_decrement(_M_node);
504 return __tmp;
505 }
506
507 friend bool
508 operator==(const _Rb_tree_const_iterator& __x,
509 const _Rb_tree_const_iterator& __y) _GLIBCXX_NOEXCEPT
510 { return __x._M_node == __y._M_node; }
511
512#if ! __cpp_lib_three_way_comparison
513 friend bool
514 operator!=(const _Rb_tree_const_iterator& __x,
515 const _Rb_tree_const_iterator& __y) _GLIBCXX_NOEXCEPT
516 { return __x._M_node != __y._M_node; }
517#endif
518
519 _Base_ptr _M_node;
520 };
521
522 __attribute__((__nonnull__))
523 void
524 _Rb_tree_insert_and_rebalance(const bool __insert_left,
525 _Rb_tree_node_base* __x,
526 _Rb_tree_node_base* __p,
527 _Rb_tree_node_base& __header) throw ();
528
529 __attribute__((__nonnull__,__returns_nonnull__))
530 _Rb_tree_node_base*
531 _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
532 _Rb_tree_node_base& __header) throw ();
533
534namespace __rb_tree
535{
536#if _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
537 template<bool _Const, typename _ValPtr>
538 struct _Iterator
539 {
540 template<typename _Tp>
541 using __maybe_const = __conditional_t<_Const, const _Tp, _Tp>;
542
543 using __ptr_traits = pointer_traits<_ValPtr>;
544 using value_type = typename __ptr_traits::element_type;
545 using reference = __maybe_const<value_type>&;
546 using pointer = __maybe_const<value_type>*;
547
548 using iterator_category = bidirectional_iterator_tag;
549 using difference_type = ptrdiff_t;
550
551 using _Node = __rb_tree::_Node<_ValPtr>;
552 using _Node_base = __rb_tree::_Node_base<__ptr_rebind<_ValPtr, void>>;
553 using _Base_ptr = typename _Node_base::_Base_ptr;
554
555 _Iterator() noexcept
556 : _M_node() { }
557
558 constexpr explicit
559 _Iterator(_Base_ptr __x) noexcept
560 : _M_node(__x) { }
561
562 _Iterator(const _Iterator&) = default;
563 _Iterator& operator=(const _Iterator&) = default;
564
565#ifdef __glibcxx_concepts
566 constexpr
567 _Iterator(const _Iterator<false, _ValPtr>& __it) requires _Const
568#else
569 template<bool _OtherConst,
570 typename = __enable_if_t<_Const && !_OtherConst>>
571 constexpr
572 _Iterator(const _Iterator<_OtherConst, _ValPtr>& __it)
573#endif
574 : _M_node(__it._M_node) { }
575
576 [[__nodiscard__]]
577 reference
578 operator*() const noexcept
579 { return *static_cast<_Node&>(*_M_node)._M_valptr(); }
580
581 [[__nodiscard__]]
582 pointer
583 operator->() const noexcept
584 { return static_cast<_Node&>(*_M_node)._M_valptr(); }
585
586 _GLIBCXX14_CONSTEXPR _Iterator&
587 operator++() noexcept
588 {
589 if (_M_node->_M_right)
590 {
591 _M_node = _M_node->_M_right;
592 while (_M_node->_M_left)
593 _M_node = _M_node->_M_left;
594 }
595 else
596 {
597 _Base_ptr __y = _M_node->_M_parent;
598 while (_M_node == __y->_M_right)
599 {
600 _M_node = __y;
601 __y = __y->_M_parent;
602 }
603 if (_M_node->_M_right != __y)
604 _M_node = __y;
605 }
606
607 return *this;
608 }
609
610 _GLIBCXX14_CONSTEXPR _Iterator
611 operator++(int) noexcept
612 {
613 _Iterator __tmp(this->_M_node);
614 ++*this;
615 return __tmp;
616 }
617
618 _GLIBCXX14_CONSTEXPR _Iterator&
619 operator--() noexcept
620 {
621 if (_M_node->_M_color == _S_red
622 && _M_node->_M_parent->_M_parent == _M_node)
623 _M_node = _M_node->_M_right;
624 else if (_M_node->_M_left)
625 {
626 _Base_ptr __y = _M_node->_M_left;
627 while (__y->_M_right)
628 __y = __y->_M_right;
629 _M_node = __y;
630 }
631 else
632 {
633 _Base_ptr __y = _M_node->_M_parent;
634 while (_M_node == __y->_M_left)
635 {
636 _M_node = __y;
637 __y = __y->_M_parent;
638 }
639 _M_node = __y;
640 }
641 return *this;
642 }
643
644 _GLIBCXX14_CONSTEXPR _Iterator
645 operator--(int) noexcept
646 {
647 _Iterator __tmp(this->_M_node);
648 --*this;
649 return __tmp;
650 }
651
652 [[__nodiscard__]]
653 friend bool
654 operator==(const _Iterator& __x, const _Iterator& __y) _GLIBCXX_NOEXCEPT
655 { return __x._M_node == __y._M_node; }
656
657#if ! __cpp_lib_three_way_comparison
658 [[__nodiscard__]]
659 friend bool
660 operator!=(const _Iterator& __x, const _Iterator& __y) _GLIBCXX_NOEXCEPT
661 { return __x._M_node != __y._M_node; }
662#endif
663
664 _Base_ptr _M_node;
665 };
666#endif // USE_ALLOC_PTR_FOR_RB_TREE
667
668 // Determine the node and iterator types used by std::_Rb_tree.
669 template<typename _Val, typename _Ptr>
670 struct _Node_traits;
671
672#if _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE <= 9000
673 // Specialization for the simple case where the allocator's pointer type
674 // is the same type as value_type*.
675 // For ABI compatibility we can't change the types used for this case.
676 template<typename _Val>
677 struct _Node_traits<_Val, _Val*>
678 {
679 typedef _Rb_tree_node<_Val> _Node;
680 typedef _Node* _Node_ptr;
681 typedef _Rb_tree_node_base _Node_base;
682 typedef _Node_base* _Base_ptr;
683 typedef _Rb_tree_header _Header_t;
684 typedef _Rb_tree_iterator<_Val> _Iterator;
685 typedef _Rb_tree_const_iterator<_Val> _Const_iterator;
686
687 __attribute__((__nonnull__))
688 static void
689 _S_insert_and_rebalance(const bool __insert_left,
690 _Node_base* __x, _Node_base* __p,
691 _Node_base& __header) _GLIBCXX_USE_NOEXCEPT
692 {
693 return _Rb_tree_insert_and_rebalance(__insert_left, __x, __p, __header);
694 }
695
696 __attribute__((__nonnull__,__returns_nonnull__))
697 static _Node_base*
698 _S_rebalance_for_erase(_Node_base* const __z,
699 _Node_base& __header) _GLIBCXX_USE_NOEXCEPT
700 { return _Rb_tree_rebalance_for_erase(__z, __header); }
701 };
702#endif
703
704#if ! _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
705 // Always use the T* specialization.
706 template<typename _Val, typename _Ptr>
707 struct _Node_traits
708 : _Node_traits<_Val, _Val*>
709 { };
710#else
711 // Primary template used when the allocator uses fancy pointers.
712 template<typename _Val, typename _ValPtr>
713 struct _Node_traits
714 {
715 using _Node = __rb_tree::_Node<_ValPtr>;
716 using _Node_ptr = __ptr_rebind<_ValPtr, _Node>;
717 using _Node_base = __rb_tree::_Node_base<__ptr_rebind<_ValPtr, void>>;
718 using _Base_ptr = __ptr_rebind<_ValPtr, _Node_base>;
719 using _Header_t = __rb_tree::_Header<_Node_base>;
720 using _Iterator = __rb_tree::_Iterator<false, _ValPtr>;
721 using _Const_iterator = __rb_tree::_Iterator<true, _ValPtr>;
722
723 static void
724 _Rotate_left(_Base_ptr __x, _Base_ptr& __root)
725 {
726 const _Base_ptr __y = __x->_M_right;
727
728 __x->_M_right = __y->_M_left;
729 if (__y->_M_left)
730 __y->_M_left->_M_parent = __x;
731 __y->_M_parent = __x->_M_parent;
732
733 if (__x == __root)
734 __root = __y;
735 else if (__x == __x->_M_parent->_M_left)
736 __x->_M_parent->_M_left = __y;
737 else
738 __x->_M_parent->_M_right = __y;
739 __y->_M_left = __x;
740 __x->_M_parent = __y;
741 }
742
743 static void
744 _Rotate_right(_Base_ptr __x, _Base_ptr& __root)
745 {
746 const _Base_ptr __y = __x->_M_left;
747
748 __x->_M_left = __y->_M_right;
749 if (__y->_M_right)
750 __y->_M_right->_M_parent = __x;
751 __y->_M_parent = __x->_M_parent;
752
753 if (__x == __root)
754 __root = __y;
755 else if (__x == __x->_M_parent->_M_right)
756 __x->_M_parent->_M_right = __y;
757 else
758 __x->_M_parent->_M_left = __y;
759 __y->_M_right = __x;
760 __x->_M_parent = __y;
761 }
762
763 static void
764 _S_insert_and_rebalance(const bool __insert_left,
765 _Base_ptr __x, _Base_ptr __p,
766 _Node_base& __header)
767 {
768 _Base_ptr& __root = __header._M_parent;
769
770 // Initialize fields in new node to insert.
771 __x->_M_parent = __p;
772 __x->_M_left = __x->_M_right = nullptr;
773 __x->_M_color = _S_red;
774
775 // Insert.
776 // Make new node child of parent and maintain root, leftmost and
777 // rightmost nodes.
778 // N.B. First node is always inserted left.
779 if (__insert_left)
780 {
781 __p->_M_left = __x; // also makes leftmost = __x when __p == &__header
782
783 if (std::__to_address(__p) == std::addressof(__header))
784 {
785 __header._M_parent = __x;
786 __header._M_right = __x;
787 }
788 else if (__p == __header._M_left)
789 __header._M_left = __x; // maintain leftmost pointing to min node
790 }
791 else
792 {
793 __p->_M_right = __x;
794
795 if (__p == __header._M_right)
796 __header._M_right = __x; // maintain rightmost pointing to max node
797 }
798 // Rebalance.
799 while (__x != __root
800 && __x->_M_parent->_M_color == _S_red)
801 {
802 const _Base_ptr __xpp = __x->_M_parent->_M_parent;
803
804 if (__x->_M_parent == __xpp->_M_left)
805 {
806 const _Base_ptr __y = __xpp->_M_right;
807 if (__y && __y->_M_color == _S_red)
808 {
809 __x->_M_parent->_M_color = _S_black;
810 __y->_M_color = _S_black;
811 __xpp->_M_color = _S_red;
812 __x = __xpp;
813 }
814 else
815 {
816 if (__x == __x->_M_parent->_M_right)
817 {
818 __x = __x->_M_parent;
819 _Rotate_left(__x, __root);
820 }
821 __x->_M_parent->_M_color = _S_black;
822 __xpp->_M_color = _S_red;
823 _Rotate_right(__xpp, __root);
824 }
825 }
826 else
827 {
828 const _Base_ptr __y = __xpp->_M_left;
829 if (__y && __y->_M_color == _S_red)
830 {
831 __x->_M_parent->_M_color = _S_black;
832 __y->_M_color = _S_black;
833 __xpp->_M_color = _S_red;
834 __x = __xpp;
835 }
836 else
837 {
838 if (__x == __x->_M_parent->_M_left)
839 {
840 __x = __x->_M_parent;
841 _Rotate_right(__x, __root);
842 }
843 __x->_M_parent->_M_color = _S_black;
844 __xpp->_M_color = _S_red;
845 _Rotate_left(__xpp, __root);
846 }
847 }
848 }
849 __root->_M_color = _S_black;
850 }
851
852 static _Base_ptr
853 _S_rebalance_for_erase(_Base_ptr __z, _Node_base& __header)
854 {
855 _Base_ptr& __root = __header._M_parent;
856 _Base_ptr& __leftmost = __header._M_left;
857 _Base_ptr& __rightmost = __header._M_right;
858 _Base_ptr __y = __z;
859 _Base_ptr __x{};
860 _Base_ptr __x_parent{};
861
862 if (!__y->_M_left) // __z has at most one non-null child. y == z.
863 __x = __y->_M_right; // __x might be null.
864 else
865 if (!__y->_M_right) // __z has exactly one non-null child. y == z.
866 __x = __y->_M_left; // __x is not null.
867 else
868 {
869 // __z has two non-null children. Set __y to
870 __y = __y->_M_right; // __z's successor. __x might be null.
871 while (__y->_M_left)
872 __y = __y->_M_left;
873 __x = __y->_M_right;
874 }
875 if (__y != __z)
876 {
877 // relink y in place of z. y is z's successor
878 __z->_M_left->_M_parent = __y;
879 __y->_M_left = __z->_M_left;
880 if (__y != __z->_M_right)
881 {
882 __x_parent = __y->_M_parent;
883 if (__x)
884 __x->_M_parent = __y->_M_parent;
885 __y->_M_parent->_M_left = __x; // __y must be a child of _M_left
886 __y->_M_right = __z->_M_right;
887 __z->_M_right->_M_parent = __y;
888 }
889 else
890 __x_parent = __y;
891 if (__root == __z)
892 __root = __y;
893 else if (__z->_M_parent->_M_left == __z)
894 __z->_M_parent->_M_left = __y;
895 else
896 __z->_M_parent->_M_right = __y;
897 __y->_M_parent = __z->_M_parent;
898 std::swap(__y->_M_color, __z->_M_color);
899 __y = __z;
900 // __y now points to node to be actually deleted
901 }
902 else
903 { // __y == __z
904 __x_parent = __y->_M_parent;
905 if (__x)
906 __x->_M_parent = __y->_M_parent;
907 if (__root == __z)
908 __root = __x;
909 else
910 if (__z->_M_parent->_M_left == __z)
911 __z->_M_parent->_M_left = __x;
912 else
913 __z->_M_parent->_M_right = __x;
914 if (__leftmost == __z)
915 {
916 if (!__z->_M_right) // __z->_M_left must be null also
917 __leftmost = __z->_M_parent;
918 // makes __leftmost == _M_header if __z == __root
919 else
920 __leftmost = _Node_base::_S_minimum(__x);
921 }
922 if (__rightmost == __z)
923 {
924 if (__z->_M_left == 0) // __z->_M_right must be null also
925 __rightmost = __z->_M_parent;
926 // makes __rightmost == _M_header if __z == __root
927 else // __x == __z->_M_left
928 __rightmost = _Node_base::_S_maximum(__x);
929 }
930 }
931 if (__y->_M_color != _S_red)
932 {
933 while (__x != __root && (__x == 0 || __x->_M_color == _S_black))
934 if (__x == __x_parent->_M_left)
935 {
936 _Base_ptr __w = __x_parent->_M_right;
937 if (__w->_M_color == _S_red)
938 {
939 __w->_M_color = _S_black;
940 __x_parent->_M_color = _S_red;
941 _Rotate_left(__x_parent, __root);
942 __w = __x_parent->_M_right;
943 }
944 if ((!__w->_M_left || __w->_M_left->_M_color == _S_black) &&
945 (!__w->_M_right || __w->_M_right->_M_color == _S_black))
946 {
947 __w->_M_color = _S_red;
948 __x = __x_parent;
949 __x_parent = __x_parent->_M_parent;
950 }
951 else
952 {
953 if (!__w->_M_right || __w->_M_right->_M_color == _S_black)
954 {
955 __w->_M_left->_M_color = _S_black;
956 __w->_M_color = _S_red;
957 _Rotate_right(__w, __root);
958 __w = __x_parent->_M_right;
959 }
960 __w->_M_color = __x_parent->_M_color;
961 __x_parent->_M_color = _S_black;
962 if (__w->_M_right)
963 __w->_M_right->_M_color = _S_black;
964 _Rotate_left(__x_parent, __root);
965 break;
966 }
967 }
968 else
969 {
970 // same as above, with _M_right <-> _M_left.
971 _Base_ptr __w = __x_parent->_M_left;
972 if (__w->_M_color == _S_red)
973 {
974 __w->_M_color = _S_black;
975 __x_parent->_M_color = _S_red;
976 _Rotate_right(__x_parent, __root);
977 __w = __x_parent->_M_left;
978 }
979 if ((!__w->_M_right || __w->_M_right->_M_color == _S_black) &&
980 (!__w->_M_left || __w->_M_left->_M_color == _S_black))
981 {
982 __w->_M_color = _S_red;
983 __x = __x_parent;
984 __x_parent = __x_parent->_M_parent;
985 }
986 else
987 {
988 if (!__w->_M_left || __w->_M_left->_M_color == _S_black)
989 {
990 __w->_M_right->_M_color = _S_black;
991 __w->_M_color = _S_red;
992 _Rotate_left(__w, __root);
993 __w = __x_parent->_M_left;
994 }
995 __w->_M_color = __x_parent->_M_color;
996 __x_parent->_M_color = _S_black;
997 if (__w->_M_left)
998 __w->_M_left->_M_color = _S_black;
999 _Rotate_right(__x_parent, __root);
1000 break;
1001 }
1002 }
1003 if (__x)
1004 __x->_M_color = _S_black;
1005 }
1006
1007 return __y;
1008 }
1009 };
1010#endif
1011} // namespace __rb_tree
1012
1013#ifdef __glibcxx_node_extract // >= C++17
1014 template<typename _Tree1, typename _Cmp2>
1015 struct _Rb_tree_merge_helper { };
1016#endif
1017
1018 template<typename _Key, typename _Val, typename _KeyOfValue,
1019 typename _Compare, typename _Alloc = allocator<_Val> >
1020 class _Rb_tree
1021 {
1022 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
1023 rebind<_Val>::other _Val_alloc_type;
1024
1025 typedef __gnu_cxx::__alloc_traits<_Val_alloc_type> _Val_alloc_traits;
1026 typedef typename _Val_alloc_traits::pointer _ValPtr;
1027 typedef __rb_tree::_Node_traits<_Val, _ValPtr> _Node_traits;
1028
1029 typedef typename _Node_traits::_Node_base _Node_base;
1030 typedef typename _Node_traits::_Node _Node;
1031
1032 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
1033 rebind<_Node>::other _Node_allocator;
1034
1035 typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Node_alloc_traits;
1036
1037 protected:
1038 typedef typename _Node_traits::_Base_ptr _Base_ptr;
1039 typedef typename _Node_traits::_Node_ptr _Node_ptr;
1040
1041 private:
1042 // Functor recycling a pool of nodes and using allocation once the pool
1043 // is empty.
1044 struct _Reuse_or_alloc_node
1045 {
1046 _Reuse_or_alloc_node(_Rb_tree& __t)
1047 : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
1048 {
1049 if (_M_root)
1050 {
1051 _M_root->_M_parent = _Base_ptr();
1052
1053 if (_M_nodes->_M_left)
1054 _M_nodes = _M_nodes->_M_left;
1055 }
1056 else
1057 _M_nodes = _Base_ptr();
1058 }
1059
1060#if __cplusplus >= 201103L
1061 _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
1062#endif
1063
1064 ~_Reuse_or_alloc_node()
1065 {
1066 if (_M_root)
1067 _M_t._M_erase(static_cast<_Node&>(*_M_root)._M_node_ptr());
1068 }
1069
1070 template<typename _Arg>
1071 _Node_ptr
1072 operator()(_GLIBCXX_FWDREF(_Arg) __arg)
1073 {
1074 _Base_ptr __base = _M_extract();
1075 if (__base)
1076 {
1077 _Node_ptr __node = static_cast<_Node&>(*__base)._M_node_ptr();
1078 _M_t._M_destroy_node(__node);
1079 _M_t._M_construct_node(__node, _GLIBCXX_FORWARD(_Arg, __arg));
1080 return __node;
1081 }
1082
1083 return _M_t._M_create_node(_GLIBCXX_FORWARD(_Arg, __arg));
1084 }
1085
1086 private:
1087 _Base_ptr
1088 _M_extract()
1089 {
1090 if (!_M_nodes)
1091 return _M_nodes;
1092
1093 _Base_ptr __node = _M_nodes;
1094 _M_nodes = _M_nodes->_M_parent;
1095 if (_M_nodes)
1096 {
1097 if (_M_nodes->_M_right == __node)
1098 {
1099 _M_nodes->_M_right = _Base_ptr();
1100
1101 if (_M_nodes->_M_left)
1102 {
1103 _M_nodes = _M_nodes->_M_left;
1104
1105 while (_M_nodes->_M_right)
1106 _M_nodes = _M_nodes->_M_right;
1107
1108 if (_M_nodes->_M_left)
1109 _M_nodes = _M_nodes->_M_left;
1110 }
1111 }
1112 else // __node is on the left.
1113 _M_nodes->_M_left = _Base_ptr();
1114 }
1115 else
1116 _M_root = _Base_ptr();
1117
1118 return __node;
1119 }
1120
1121 _Base_ptr _M_root;
1122 _Base_ptr _M_nodes;
1123 _Rb_tree& _M_t;
1124 };
1125
1126 // Functor similar to the previous one but without any pool of nodes to
1127 // recycle.
1128 struct _Alloc_node
1129 {
1130 _Alloc_node(_Rb_tree& __t)
1131 : _M_t(__t) { }
1132
1133 template<typename _Arg>
1134 _Node_ptr
1135 operator()(_GLIBCXX_FWDREF(_Arg) __arg) const
1136 { return _M_t._M_create_node(_GLIBCXX_FORWARD(_Arg, __arg)); }
1137
1138 private:
1139 _Rb_tree& _M_t;
1140 };
1141
1142 public:
1143 typedef _Key key_type;
1144 typedef _Val value_type;
1145 typedef value_type* pointer;
1146 typedef const value_type* const_pointer;
1147 typedef value_type& reference;
1148 typedef const value_type& const_reference;
1149 typedef size_t size_type;
1150 typedef ptrdiff_t difference_type;
1151 typedef _Alloc allocator_type;
1152
1153 _Node_allocator&
1154 _M_get_Node_allocator() _GLIBCXX_NOEXCEPT
1155 { return this->_M_impl; }
1156
1157 const _Node_allocator&
1158 _M_get_Node_allocator() const _GLIBCXX_NOEXCEPT
1159 { return this->_M_impl; }
1160
1161 allocator_type
1162 get_allocator() const _GLIBCXX_NOEXCEPT
1163 { return allocator_type(_M_get_Node_allocator()); }
1164
1165 protected:
1166 _Node_ptr
1167 _M_get_node()
1168 {
1169#if __cplusplus < 201102L || _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
1170 return _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1);
1171#else
1172#pragma GCC diagnostic push
1173#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
1174 using __alloc_pointer = typename _Node_alloc_traits::pointer;
1175 if constexpr (is_same<_Node_ptr, __alloc_pointer>::value)
1176 return _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1);
1177 else
1178 {
1179 auto __ptr =
1180 _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1);
1181 return std::__to_address(__ptr);
1182 }
1183#pragma GCC diagnostic pop
1184#endif
1185 }
1186
1187 void
1188 _M_put_node(_Node_ptr __p) _GLIBCXX_NOEXCEPT
1189 {
1190#if __cplusplus < 201102L || _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
1191 _Node_alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1);
1192#else
1193#pragma GCC diagnostic push
1194#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
1195 using __alloc_pointer = typename _Node_alloc_traits::pointer;
1196 if constexpr (is_same<_Node_ptr, __alloc_pointer>::value)
1197 _Node_alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1);
1198 else
1199 {
1200 // When not using the allocator's pointer type internally we must
1201 // convert __p to __alloc_pointer so it can be deallocated.
1202 auto __ap = pointer_traits<__alloc_pointer>::pointer_to(*__p);
1203 _Node_alloc_traits::deallocate(_M_get_Node_allocator(), __ap, 1);
1204 }
1205#pragma GCC diagnostic pop
1206#endif
1207 }
1208
1209#if __cplusplus < 201103L
1210 void
1211 _M_construct_node(_Node_ptr __node, const value_type& __x)
1212 {
1213 __try
1214 { get_allocator().construct(__node->_M_valptr(), __x); }
1215 __catch(...)
1216 {
1217 _M_put_node(__node);
1218 __throw_exception_again;
1219 }
1220 }
1221
1222 _Node_ptr
1223 _M_create_node(const value_type& __x)
1224 {
1225 _Node_ptr __tmp = _M_get_node();
1226 _M_construct_node(__tmp, __x);
1227 return __tmp;
1228 }
1229#else
1230 template<typename... _Args>
1231 void
1232 _M_construct_node(_Node_ptr __node, _Args&&... __args)
1233 {
1234 __try
1235 {
1236 ::new(std::addressof(*__node)) _Node;
1237 _Node_alloc_traits::construct(_M_get_Node_allocator(),
1238 __node->_M_valptr(),
1239 std::forward<_Args>(__args)...);
1240 }
1241 __catch(...)
1242 {
1243 __node->~_Node();
1244 _M_put_node(__node);
1245 __throw_exception_again;
1246 }
1247 }
1248
1249 template<typename... _Args>
1250 _Node_ptr
1251 _M_create_node(_Args&&... __args)
1252 {
1253 _Node_ptr __tmp = _M_get_node();
1254 _M_construct_node(__tmp, std::forward<_Args>(__args)...);
1255 return __tmp;
1256 }
1257#endif
1258
1259 void
1260 _M_destroy_node(_Node_ptr __p) _GLIBCXX_NOEXCEPT
1261 {
1262#if __cplusplus < 201103L
1263 get_allocator().destroy(__p->_M_valptr());
1264#else
1265 _Node_alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
1266 __p->~_Node();
1267#endif
1268 }
1269
1270 void
1271 _M_drop_node(_Node_ptr __p) _GLIBCXX_NOEXCEPT
1272 {
1273 _M_destroy_node(__p);
1274 _M_put_node(__p);
1275 }
1276
1277 template<bool _MoveValue, typename _NodeGen>
1278 _Node_ptr
1279 _M_clone_node(_Node_ptr __x, _NodeGen& __node_gen)
1280 {
1281#if __cplusplus >= 201103L
1282 using _Vp = __conditional_t<_MoveValue,
1283 value_type&&,
1284 const value_type&>;
1285#endif
1286 _Node_ptr __tmp
1287 = __node_gen(_GLIBCXX_FORWARD(_Vp, *__x->_M_valptr()));
1288 __tmp->_M_color = __x->_M_color;
1289 __tmp->_M_left = __tmp->_M_right = _Base_ptr();
1290 return __tmp;
1291 }
1292
1293 protected:
1294 typedef typename _Node_traits::_Header_t _Header_t;
1295
1296#if _GLIBCXX_INLINE_VERSION
1297 template<typename _Key_compare>
1298#else
1299 // Unused _Is_pod_comparator is kept as it is part of mangled name.
1300 template<typename _Key_compare,
1301 bool /* _Is_pod_comparator */ = __is_pod(_Key_compare)>
1302#endif
1303 struct _Rb_tree_impl
1304 : public _Node_allocator
1305 , public _Rb_tree_key_compare<_Key_compare>
1306 , public _Header_t
1307 {
1308 typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare;
1309
1310 _Rb_tree_impl()
1311 _GLIBCXX_NOEXCEPT_IF(
1312 is_nothrow_default_constructible<_Node_allocator>::value
1313 && is_nothrow_default_constructible<_Base_key_compare>::value )
1314 : _Node_allocator()
1315 { }
1316
1317 _Rb_tree_impl(const _Rb_tree_impl& __x)
1318 : _Node_allocator(_Node_alloc_traits::_S_select_on_copy(__x))
1319 , _Base_key_compare(__x._M_key_compare)
1320 , _Header_t()
1321 { }
1322
1323#if __cplusplus < 201103L
1324 _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
1325 : _Node_allocator(__a), _Base_key_compare(__comp)
1326 { }
1327#else
1328 _Rb_tree_impl(_Rb_tree_impl&&)
1329 noexcept( is_nothrow_move_constructible<_Base_key_compare>::value )
1330 = default;
1331
1332 explicit
1333 _Rb_tree_impl(_Node_allocator&& __a)
1334 : _Node_allocator(std::move(__a))
1335 { }
1336
1337 _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a)
1338 : _Node_allocator(std::move(__a)),
1339 _Base_key_compare(std::move(__x)),
1340 _Header_t(std::move(__x))
1341 { }
1342
1343 _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
1344 : _Node_allocator(std::move(__a)), _Base_key_compare(__comp)
1345 { }
1346#endif
1347 };
1348
1349 _Rb_tree_impl<_Compare> _M_impl;
1350
1351 protected:
1352 _Base_ptr&
1353 _M_root() _GLIBCXX_NOEXCEPT
1354 { return this->_M_impl._M_header._M_parent; }
1355
1356 _Base_ptr
1357 _M_root() const _GLIBCXX_NOEXCEPT
1358 { return this->_M_impl._M_header._M_parent; }
1359
1360 _Base_ptr&
1361 _M_leftmost() _GLIBCXX_NOEXCEPT
1362 { return this->_M_impl._M_header._M_left; }
1363
1364 _Base_ptr
1365 _M_leftmost() const _GLIBCXX_NOEXCEPT
1366 { return this->_M_impl._M_header._M_left; }
1367
1368 _Base_ptr&
1369 _M_rightmost() _GLIBCXX_NOEXCEPT
1370 { return this->_M_impl._M_header._M_right; }
1371
1372 _Base_ptr
1373 _M_rightmost() const _GLIBCXX_NOEXCEPT
1374 { return this->_M_impl._M_header._M_right; }
1375
1376 _Base_ptr
1377 _M_begin() const _GLIBCXX_NOEXCEPT
1378 { return this->_M_impl._M_header._M_parent; }
1379
1380 _Node_ptr
1381 _M_begin_node() const _GLIBCXX_NOEXCEPT
1382 {
1383 _Base_ptr __begin = this->_M_impl._M_header._M_parent;
1384 return __begin
1385 ? static_cast<_Node&>(*__begin)._M_node_ptr()
1386 : _Node_ptr();
1387 }
1388
1389 _Base_ptr
1390 _M_end() const _GLIBCXX_NOEXCEPT
1391 { return this->_M_impl._M_header._M_base_ptr(); }
1392
1393 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1394 // 2542. Missing const requirements for associative containers
1395 template<typename _Key1, typename _Key2>
1396 bool
1397 _M_key_compare(const _Key1& __k1, const _Key2& __k2) const
1398 {
1399#if __cplusplus >= 201103L
1400 // Enforce this here with a user-friendly message.
1401 static_assert(
1402 __is_invocable<const _Compare&, const _Key&, const _Key&>::value,
1403 "comparison object must be invocable with arguments of key_type"
1404 );
1405#endif
1406 return _M_impl._M_key_compare(__k1, __k2);
1407 }
1408
1409 static const _Key&
1410 _S_key(const _Node& __node)
1411 { return _KeyOfValue()(*__node._M_valptr()); }
1412
1413 static const _Key&
1414 _S_key(_Base_ptr __x)
1415 { return _S_key(static_cast<const _Node&>(*__x)); }
1416
1417 static const _Key&
1418 _S_key(_Node_ptr __x)
1419 { return _S_key(*__x); }
1420
1421 static _Base_ptr
1422 _S_left(_Base_ptr __x) _GLIBCXX_NOEXCEPT
1423 { return __x->_M_left; }
1424
1425 static _Node_ptr
1426 _S_left(_Node_ptr __x)
1427 {
1428 return __x->_M_left
1429 ? static_cast<_Node&>(*__x->_M_left)._M_node_ptr()
1430 : _Node_ptr();
1431 }
1432
1433 static _Base_ptr
1434 _S_right(_Base_ptr __x) _GLIBCXX_NOEXCEPT
1435 { return __x->_M_right; }
1436
1437 static _Node_ptr
1438 _S_right(_Node_ptr __x) _GLIBCXX_NOEXCEPT
1439 {
1440 return __x->_M_right
1441 ? static_cast<_Node&>(*__x->_M_right)._M_node_ptr()
1442 : _Node_ptr();
1443 }
1444
1445 public:
1446 typedef typename _Node_traits::_Iterator iterator;
1447 typedef typename _Node_traits::_Const_iterator const_iterator;
1448
1449 typedef std::reverse_iterator<iterator> reverse_iterator;
1450 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
1451
1452#ifdef __glibcxx_node_extract // >= C++17
1453 using node_type = _Node_handle<_Key, _Val, _Node_allocator>;
1454 using insert_return_type = _Node_insert_return<
1455 __conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
1456 node_type>;
1457#endif
1458
1459 pair<_Base_ptr, _Base_ptr>
1460 _M_get_insert_unique_pos(const key_type& __k);
1461
1462 pair<_Base_ptr, _Base_ptr>
1463 _M_get_insert_equal_pos(const key_type& __k);
1464
1465 pair<_Base_ptr, _Base_ptr>
1466 _M_get_insert_hint_unique_pos(const_iterator __pos,
1467 const key_type& __k);
1468
1469 pair<_Base_ptr, _Base_ptr>
1470 _M_get_insert_hint_equal_pos(const_iterator __pos,
1471 const key_type& __k);
1472
1473#ifdef __glibcxx_associative_heterogeneous_insertion // C++26
1474 template <typename... _Args>
1475 iterator
1476 _M_emplace_here(bool __place_left, _Base_ptr __node, _Args&&... __args);
1477
1478 template <typename _Kt>
1479 pair<_Base_ptr, _Base_ptr>
1480 _M_get_insert_unique_pos_tr(const _Kt& __k);
1481
1482 template <typename _Kt>
1483 pair<_Base_ptr, _Base_ptr>
1484 _M_get_insert_hint_unique_pos_tr(const_iterator, const _Kt& __k);
1485#endif
1486
1487 private:
1488#if __cplusplus >= 201103L
1489 template<typename _Arg, typename _NodeGen>
1490 iterator
1491 _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);
1492
1493 iterator
1494 _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Node_ptr __z);
1495
1496 template<typename _Arg>
1497 iterator
1498 _M_insert_lower(_Base_ptr __y, _Arg&& __v);
1499
1500 template<typename _Arg>
1501 iterator
1502 _M_insert_equal_lower(_Arg&& __x);
1503
1504 iterator
1505 _M_insert_lower_node(_Base_ptr __p, _Node_ptr __z);
1506
1507 iterator
1508 _M_insert_equal_lower_node(_Node_ptr __z);
1509#else
1510 template<typename _NodeGen>
1511 iterator
1512 _M_insert_(_Base_ptr __x, _Base_ptr __y,
1513 const value_type& __v, _NodeGen&);
1514
1515 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1516 // 233. Insertion hints in associative containers.
1517 iterator
1518 _M_insert_lower(_Base_ptr __y, const value_type& __v);
1519
1520 iterator
1521 _M_insert_equal_lower(const value_type& __x);
1522#endif
1523
1524 enum { __as_lvalue, __as_rvalue };
1525
1526 template<bool _MoveValues, typename _NodeGen>
1527 _Base_ptr
1528 _M_copy(_Node_ptr, _Base_ptr, _NodeGen&);
1529
1530 template<bool _MoveValues, typename _NodeGen>
1531 _Base_ptr
1532 _M_copy(const _Rb_tree& __x, _NodeGen& __gen)
1533 {
1534 _Base_ptr __root =
1535 _M_copy<_MoveValues>(__x._M_begin_node(), _M_end(), __gen);
1536 _M_leftmost() = _Node_base::_S_minimum(__root);
1537 _M_rightmost() = _Node_base::_S_maximum(__root);
1538 _M_impl._M_node_count = __x._M_impl._M_node_count;
1539 return __root;
1540 }
1541
1542 _Base_ptr
1543 _M_copy(const _Rb_tree& __x)
1544 {
1545 _Alloc_node __an(*this);
1546 return _M_copy<__as_lvalue>(__x, __an);
1547 }
1548
1549 void
1550 _M_erase(_Node_ptr __x);
1551
1552 _Base_ptr
1553 _M_lower_bound(_Base_ptr __x, _Base_ptr __y,
1554 const _Key& __k) const;
1555
1556 template <typename _Kt>
1557 _Base_ptr
1558 _M_lower_bound_tr(_Base_ptr __x, _Base_ptr __y, const _Kt& __k) const;
1559
1560 _Base_ptr
1561 _M_upper_bound(_Base_ptr __x, _Base_ptr __y,
1562 const _Key& __k) const;
1563
1564 template <typename _Kt>
1565 _Base_ptr
1566 _M_upper_bound_tr(_Base_ptr __x, _Base_ptr __y, const _Kt& __k) const;
1567
1568 public:
1569 // allocation/deallocation
1570#if __cplusplus < 201103L
1571 _Rb_tree() { }
1572#else
1573 _Rb_tree() = default;
1574#endif
1575
1576 _Rb_tree(const _Compare& __comp,
1577 const allocator_type& __a = allocator_type())
1578 : _M_impl(__comp, _Node_allocator(__a)) { }
1579
1580 _Rb_tree(const _Rb_tree& __x)
1581 : _M_impl(__x._M_impl)
1582 {
1583 if (__x._M_root())
1584 _M_root() = _M_copy(__x);
1585 }
1586
1587#if __cplusplus >= 201103L
1588 _Rb_tree(const allocator_type& __a)
1589 : _M_impl(_Node_allocator(__a))
1590 { }
1591
1592 _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
1593 : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
1594 {
1595 if (__x._M_root())
1596 _M_root() = _M_copy(__x);
1597 }
1598
1599 _Rb_tree(_Rb_tree&&) = default;
1600
1601 _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
1602 : _Rb_tree(std::move(__x), _Node_allocator(__a))
1603 { }
1604
1605 private:
1606 _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type)
1607 noexcept(is_nothrow_default_constructible<_Compare>::value)
1608 : _M_impl(std::move(__x._M_impl), std::move(__a))
1609 { }
1610
1611 _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type)
1612 : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
1613 {
1614 if (__x._M_root())
1615 _M_move_data(__x, false_type{});
1616 }
1617
1618 public:
1619 _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
1620 noexcept( noexcept(
1621 _Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(),
1622 std::declval<typename _Node_alloc_traits::is_always_equal>())) )
1623 : _Rb_tree(std::move(__x), std::move(__a),
1624 typename _Node_alloc_traits::is_always_equal{})
1625 { }
1626#endif
1627
1628 ~_Rb_tree() _GLIBCXX_NOEXCEPT
1629 { _M_erase(_M_begin_node()); }
1630
1631 _Rb_tree&
1632 operator=(const _Rb_tree& __x);
1633
1634 // Accessors.
1635 _Compare
1636 key_comp() const
1637 { return _M_impl._M_key_compare; }
1638
1639 iterator
1640 begin() _GLIBCXX_NOEXCEPT
1641 { return iterator(this->_M_impl._M_header._M_left); }
1642
1643 const_iterator
1644 begin() const _GLIBCXX_NOEXCEPT
1645 { return const_iterator(this->_M_impl._M_header._M_left); }
1646
1647 iterator
1648 end() _GLIBCXX_NOEXCEPT
1649 { return iterator(_M_end()); }
1650
1651 const_iterator
1652 end() const _GLIBCXX_NOEXCEPT
1653 { return const_iterator(_M_end()); }
1654
1655 reverse_iterator
1656 rbegin() _GLIBCXX_NOEXCEPT
1657 { return reverse_iterator(end()); }
1658
1659 const_reverse_iterator
1660 rbegin() const _GLIBCXX_NOEXCEPT
1661 { return const_reverse_iterator(end()); }
1662
1663 reverse_iterator
1664 rend() _GLIBCXX_NOEXCEPT
1665 { return reverse_iterator(begin()); }
1666
1667 const_reverse_iterator
1668 rend() const _GLIBCXX_NOEXCEPT
1669 { return const_reverse_iterator(begin()); }
1670
1671 _GLIBCXX_NODISCARD bool
1672 empty() const _GLIBCXX_NOEXCEPT
1673 { return _M_impl._M_node_count == 0; }
1674
1675 size_type
1676 size() const _GLIBCXX_NOEXCEPT
1677 { return _M_impl._M_node_count; }
1678
1679 size_type
1680 max_size() const _GLIBCXX_NOEXCEPT
1681 { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); }
1682
1683 void
1684 swap(_Rb_tree& __t)
1685 _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value);
1686
1687 // Insert/erase.
1688#if __cplusplus >= 201103L
1689 template<typename _Arg>
1690 pair<iterator, bool>
1691 _M_insert_unique(_Arg&& __x);
1692
1693 template<typename _Arg>
1694 iterator
1695 _M_insert_equal(_Arg&& __x);
1696
1697 template<typename _Arg, typename _NodeGen>
1698 iterator
1699 _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);
1700
1701 template<typename _Arg>
1702 iterator
1703 _M_insert_unique_(const_iterator __pos, _Arg&& __x)
1704 {
1705 _Alloc_node __an(*this);
1706 return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
1707 }
1708
1709 template<typename _Arg, typename _NodeGen>
1710 iterator
1711 _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);
1712
1713 template<typename _Arg>
1714 iterator
1715 _M_insert_equal_(const_iterator __pos, _Arg&& __x)
1716 {
1717 _Alloc_node __an(*this);
1718 return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
1719 }
1720
1721 template<typename... _Args>
1722 pair<iterator, bool>
1723 _M_emplace_unique(_Args&&... __args);
1724
1725 template<typename... _Args>
1726 iterator
1727 _M_emplace_equal(_Args&&... __args);
1728
1729 template<typename... _Args>
1730 iterator
1731 _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
1732
1733 template<typename... _Args>
1734 iterator
1735 _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
1736
1737 template<typename _Iter>
1738 using __same_value_type
1739 = is_same<value_type, typename iterator_traits<_Iter>::value_type>;
1740
1741 template<typename _InputIterator>
1742 __enable_if_t<__same_value_type<_InputIterator>::value>
1743 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
1744 {
1745 _Alloc_node __an(*this);
1746 for (; __first != __last; ++__first)
1747 _M_insert_unique_(end(), *__first, __an);
1748 }
1749
1750 template<typename _InputIterator>
1751 __enable_if_t<!__same_value_type<_InputIterator>::value>
1752 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
1753 {
1754 for (; __first != __last; ++__first)
1755 _M_emplace_unique(*__first);
1756 }
1757
1758 template<typename _InputIterator>
1759 __enable_if_t<__same_value_type<_InputIterator>::value>
1760 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
1761 {
1762 _Alloc_node __an(*this);
1763 for (; __first != __last; ++__first)
1764 _M_insert_equal_(end(), *__first, __an);
1765 }
1766
1767 template<typename _InputIterator>
1768 __enable_if_t<!__same_value_type<_InputIterator>::value>
1769 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
1770 {
1771 for (; __first != __last; ++__first)
1772 _M_emplace_equal(*__first);
1773 }
1774#else
1775 pair<iterator, bool>
1776 _M_insert_unique(const value_type& __x);
1777
1778 iterator
1779 _M_insert_equal(const value_type& __x);
1780
1781 template<typename _NodeGen>
1782 iterator
1783 _M_insert_unique_(const_iterator __pos, const value_type& __x,
1784 _NodeGen&);
1785
1786 iterator
1787 _M_insert_unique_(const_iterator __pos, const value_type& __x)
1788 {
1789 _Alloc_node __an(*this);
1790 return _M_insert_unique_(__pos, __x, __an);
1791 }
1792
1793 template<typename _NodeGen>
1794 iterator
1795 _M_insert_equal_(const_iterator __pos, const value_type& __x,
1796 _NodeGen&);
1797 iterator
1798 _M_insert_equal_(const_iterator __pos, const value_type& __x)
1799 {
1800 _Alloc_node __an(*this);
1801 return _M_insert_equal_(__pos, __x, __an);
1802 }
1803
1804 template<typename _InputIterator>
1805 void
1806 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
1807 {
1808 _Alloc_node __an(*this);
1809 for (; __first != __last; ++__first)
1810 _M_insert_unique_(end(), *__first, __an);
1811 }
1812
1813 template<typename _InputIterator>
1814 void
1815 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
1816 {
1817 _Alloc_node __an(*this);
1818 for (; __first != __last; ++__first)
1819 _M_insert_equal_(end(), *__first, __an);
1820 }
1821#endif
1822
1823 private:
1824 void
1825 _M_erase_aux(const_iterator __position);
1826
1827 void
1828 _M_erase_aux(const_iterator __first, const_iterator __last);
1829
1830 public:
1831#if __cplusplus >= 201103L
1832 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1833 // DR 130. Associative erase should return an iterator.
1834 _GLIBCXX_ABI_TAG_CXX11
1835 iterator
1836 erase(const_iterator __position)
1837 {
1838 __glibcxx_assert(__position != end());
1839 const_iterator __result = __position;
1840 ++__result;
1841 _M_erase_aux(__position);
1842 return iterator(__result._M_node);
1843 }
1844
1845 // LWG 2059.
1846 _GLIBCXX_ABI_TAG_CXX11
1847 iterator
1848 erase(iterator __position)
1849 {
1850 __glibcxx_assert(__position != end());
1851 iterator __result = __position;
1852 ++__result;
1853 _M_erase_aux(__position);
1854 return __result;
1855 }
1856#else
1857 void
1858 erase(iterator __position)
1859 {
1860 __glibcxx_assert(__position != end());
1861 _M_erase_aux(__position);
1862 }
1863
1864 void
1865 erase(const_iterator __position)
1866 {
1867 __glibcxx_assert(__position != end());
1868 _M_erase_aux(__position);
1869 }
1870#endif
1871
1872 size_type
1873 erase(const key_type& __x);
1874
1875 template <typename _Kt>
1876 size_type
1877 _M_erase_tr(const _Kt& __x);
1878
1879 size_type
1880 _M_erase_unique(const key_type& __x);
1881
1882#if __cplusplus >= 201103L
1883 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1884 // DR 130. Associative erase should return an iterator.
1885 _GLIBCXX_ABI_TAG_CXX11
1886 iterator
1887 erase(const_iterator __first, const_iterator __last)
1888 {
1889 _M_erase_aux(__first, __last);
1890 return iterator(__last._M_node);
1891 }
1892#else
1893 void
1894 erase(iterator __first, iterator __last)
1895 { _M_erase_aux(__first, __last); }
1896
1897 void
1898 erase(const_iterator __first, const_iterator __last)
1899 { _M_erase_aux(__first, __last); }
1900#endif
1901
1902 void
1903 clear() _GLIBCXX_NOEXCEPT
1904 {
1905 _M_erase(_M_begin_node());
1906 _M_impl._M_reset();
1907 }
1908
1909 // Set operations.
1910 iterator
1911 find(const key_type& __k);
1912
1913 const_iterator
1914 find(const key_type& __k) const;
1915
1916 size_type
1917 count(const key_type& __k) const;
1918
1919 iterator
1920 lower_bound(const key_type& __k)
1921 { return iterator(_M_lower_bound(_M_begin(), _M_end(), __k)); }
1922
1923 const_iterator
1924 lower_bound(const key_type& __k) const
1925 {
1926 return const_iterator
1927 (_M_lower_bound(_M_begin(), _M_end(), __k));
1928 }
1929
1930 iterator
1931 upper_bound(const key_type& __k)
1932 { return iterator(_M_upper_bound(_M_begin(), _M_end(), __k)); }
1933
1934 const_iterator
1935 upper_bound(const key_type& __k) const
1936 {
1937 return const_iterator
1938 (_M_upper_bound(_M_begin(), _M_end(), __k));
1939 }
1940
1941 pair<iterator, iterator>
1942 equal_range(const key_type& __k);
1943
1944 pair<const_iterator, const_iterator>
1945 equal_range(const key_type& __k) const;
1946
1947#ifdef __glibcxx_generic_associative_lookup // C++ >= 14
1948 template<typename _Kt,
1949 typename _Req = __has_is_transparent_t<_Compare, _Kt>>
1950 iterator
1951 _M_find_tr(const _Kt& __k)
1952 {
1953 const _Rb_tree* __const_this = this;
1954 return iterator(__const_this->_M_find_tr(__k)._M_node);
1955 }
1956
1957 template<typename _Kt,
1958 typename _Req = __has_is_transparent_t<_Compare, _Kt>>
1959 const_iterator
1960 _M_find_tr(const _Kt& __k) const
1961 {
1962 const_iterator __j(_M_lower_bound_tr(__k));
1963 if (__j != end() && _M_key_compare(__k, _S_key(__j._M_node)))
1964 __j = end();
1965 return __j;
1966 }
1967
1968 template<typename _Kt,
1969 typename _Req = __has_is_transparent_t<_Compare, _Kt>>
1970 size_type
1971 _M_count_tr(const _Kt& __k) const
1972 {
1973 auto __p = _M_equal_range_tr(__k);
1974 return std::distance(__p.first, __p.second);
1975 }
1976
1977 template<typename _Kt,
1978 typename _Req = __has_is_transparent_t<_Compare, _Kt>>
1979 _Base_ptr
1980 _M_lower_bound_tr(const _Kt& __k) const
1981 {
1982 auto __x = _M_begin();
1983 auto __y = _M_end();
1984 while (__x)
1985 if (!_M_key_compare(_S_key(__x), __k))
1986 {
1987 __y = __x;
1988 __x = _S_left(__x);
1989 }
1990 else
1991 __x = _S_right(__x);
1992 return __y;
1993 }
1994
1995 template<typename _Kt,
1996 typename _Req = __has_is_transparent_t<_Compare, _Kt>>
1997 _Base_ptr
1998 _M_upper_bound_tr(const _Kt& __k) const
1999 {
2000 auto __x = _M_begin();
2001 auto __y = _M_end();
2002 while (__x)
2003 if (_M_key_compare(__k, _S_key(__x)))
2004 {
2005 __y = __x;
2006 __x = _S_left(__x);
2007 }
2008 else
2009 __x = _S_right(__x);
2010 return __y;
2011 }
2012
2013 template<typename _Kt,
2014 typename _Req = __has_is_transparent_t<_Compare, _Kt>>
2015 pair<iterator, iterator>
2016 _M_equal_range_tr(const _Kt& __k)
2017 {
2018 const _Rb_tree* __const_this = this;
2019 auto __ret = __const_this->_M_equal_range_tr(__k);
2020 return
2021 { iterator(__ret.first._M_node), iterator(__ret.second._M_node) };
2022 }
2023
2024 template<typename _Kt,
2025 typename _Req = __has_is_transparent_t<_Compare, _Kt>>
2026 pair<const_iterator, const_iterator>
2027 _M_equal_range_tr(const _Kt& __k) const
2028 {
2029 auto __x = _M_begin();
2030 auto __y = _M_end();
2031 while (__x)
2032 {
2033 if (_M_key_compare(_S_key(__x), __k))
2034 __x = _S_right(__x);
2035 else if (_M_key_compare(__k, _S_key(__x)))
2036 {
2037 __y = __x;
2038 __x = _S_left(__x);
2039 }
2040 else
2041 {
2042 auto __xu(__x);
2043 auto __yu(__y);
2044 __y = __x;
2045 __x = _S_left(__x);
2046 __xu = _S_right(__xu);
2047 return { const_iterator(_M_lower_bound_tr(__x, __y, __k)),
2048 const_iterator(_M_upper_bound_tr(__xu, __yu, __k)) };
2049 }
2050 }
2051 return { const_iterator(__y), const_iterator(__y) };
2052 }
2053#endif // __glibcxx_generic_associative_lookup
2054
2055 // Debugging.
2056 bool
2057 __rb_verify() const;
2058
2059#if __cplusplus >= 201103L
2060 _Rb_tree&
2061 operator=(_Rb_tree&&)
2062 noexcept(_Node_alloc_traits::_S_nothrow_move()
2063 && is_nothrow_move_assignable<_Compare>::value);
2064
2065 template<typename _Iterator>
2066 void
2067 _M_assign_unique(_Iterator, _Iterator);
2068
2069 template<typename _Iterator>
2070 void
2071 _M_assign_equal(_Iterator, _Iterator);
2072
2073 private:
2074 // Move elements from container with equal allocator.
2075 void
2076 _M_move_data(_Rb_tree& __x, true_type)
2077 { _M_impl._M_move_data(__x._M_impl); }
2078
2079 // Move elements from container with possibly non-equal allocator,
2080 // which might result in a copy not a move.
2081 void
2082 _M_move_data(_Rb_tree&, false_type);
2083
2084 // Move assignment from container with equal allocator.
2085 void
2086 _M_move_assign(_Rb_tree&, true_type);
2087
2088 // Move assignment from container with possibly non-equal allocator,
2089 // which might result in a copy not a move.
2090 void
2091 _M_move_assign(_Rb_tree&, false_type);
2092#endif
2093
2094#ifdef __glibcxx_node_extract // >= C++17
2095 static _Node_ptr
2096 _S_adapt(typename _Node_alloc_traits::pointer __ptr)
2097 {
2098#if _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
2099 return __ptr;
2100#else
2101#pragma GCC diagnostic push
2102#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
2103 using __alloc_ptr = typename _Node_alloc_traits::pointer;
2104 if constexpr (is_same<_Node_ptr, __alloc_ptr>::value)
2105 return __ptr;
2106 else
2107 return std::__to_address(__ptr);
2108#pragma GCC diagnostic pop
2109#endif
2110 }
2111
2112 public:
2113 /// Re-insert an extracted node.
2114 insert_return_type
2115 _M_reinsert_node_unique(node_type&& __nh)
2116 {
2117 insert_return_type __ret;
2118 if (__nh.empty())
2119 __ret.position = end();
2120 else
2121 {
2122 __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);
2123
2124 auto __res = _M_get_insert_unique_pos(__nh._M_key());
2125 if (__res.second)
2126 {
2127 __ret.position
2128 = _M_insert_node(__res.first, __res.second,
2129 _S_adapt(__nh._M_ptr));
2130 __nh.release();
2131 __ret.inserted = true;
2132 }
2133 else
2134 {
2135 __ret.node = std::move(__nh);
2136 __ret.position = iterator(__res.first);
2137 __ret.inserted = false;
2138 }
2139 }
2140 return __ret;
2141 }
2142
2143 /// Re-insert an extracted node.
2144 iterator
2145 _M_reinsert_node_equal(node_type&& __nh)
2146 {
2147 iterator __ret;
2148 if (__nh.empty())
2149 __ret = end();
2150 else
2151 {
2152 __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);
2153 auto __res = _M_get_insert_equal_pos(__nh._M_key());
2154 if (__res.second)
2155 __ret = _M_insert_node(__res.first, __res.second,
2156 _S_adapt(__nh._M_ptr));
2157 else
2158 __ret = _M_insert_equal_lower_node(_S_adapt(__nh._M_ptr));
2159 __nh.release();
2160 }
2161 return __ret;
2162 }
2163
2164 /// Re-insert an extracted node.
2165 iterator
2166 _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh)
2167 {
2168 iterator __ret;
2169 if (__nh.empty())
2170 __ret = end();
2171 else
2172 {
2173 __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);
2174 auto __res = _M_get_insert_hint_unique_pos(__hint, __nh._M_key());
2175 if (__res.second)
2176 {
2177 __ret = _M_insert_node(__res.first, __res.second,
2178 _S_adapt(__nh._M_ptr));
2179 __nh.release();
2180 }
2181 else
2182 __ret = iterator(__res.first);
2183 }
2184 return __ret;
2185 }
2186
2187 /// Re-insert an extracted node.
2188 iterator
2189 _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh)
2190 {
2191 iterator __ret;
2192 if (__nh.empty())
2193 __ret = end();
2194 else
2195 {
2196 __glibcxx_assert(_M_get_Node_allocator() == *__nh._M_alloc);
2197 auto __res = _M_get_insert_hint_equal_pos(__hint, __nh._M_key());
2198 if (__res.second)
2199 __ret = _M_insert_node(__res.first, __res.second,
2200 _S_adapt(__nh._M_ptr));
2201 else
2202 __ret = _M_insert_equal_lower_node(_S_adapt(__nh._M_ptr));
2203 __nh.release();
2204 }
2205 return __ret;
2206 }
2207
2208 /// Extract a node.
2209 node_type
2210 extract(const_iterator __pos)
2211 {
2212 auto __ptr = _Node_traits::_S_rebalance_for_erase
2213 (__pos._M_node, _M_impl._M_header);
2214 --_M_impl._M_node_count;
2215 auto __node_ptr = static_cast<_Node&>(*__ptr)._M_node_ptr();
2216#if _GLIBCXX_USE_ALLOC_PTR_FOR_RB_TREE
2217 return { __node_ptr, _M_get_Node_allocator() };
2218#else
2219#pragma GCC diagnostic push
2220#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
2221 using __alloc_ptr = typename _Node_alloc_traits::pointer;
2222 if constexpr (is_same<_Node_ptr, __alloc_ptr>::value)
2223 return { __node_ptr, _M_get_Node_allocator() };
2224 else
2225 {
2226 auto __ap = pointer_traits<__alloc_ptr>::pointer_to(*__node_ptr);
2227 return { __ap, _M_get_Node_allocator() };
2228 }
2229#pragma GCC diagnostic pop
2230#endif
2231 }
2232
2233 /// Extract a node.
2234 node_type
2235 extract(const key_type& __k)
2236 {
2237 node_type __nh;
2238 auto __pos = find(__k);
2239 if (__pos != end())
2240 __nh = extract(const_iterator(__pos));
2241 return __nh;
2242 }
2243
2244 template <typename _Kt>
2245 node_type
2246 _M_extract_tr(const _Kt& __k)
2247 {
2248 node_type __nh;
2249 auto __pos = _M_find_tr(__k);
2250 if (__pos != end())
2251 __nh = extract(const_iterator(__pos));
2252 return __nh;
2253 }
2254
2255 template<typename _Compare2>
2256 using _Compatible_tree
2257 = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>;
2258
2259 template<typename, typename>
2260 friend struct _Rb_tree_merge_helper;
2261
2262 /// Merge from a compatible container into one with unique keys.
2263 template<typename _Compare2>
2264 void
2265 _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept
2266 {
2267 using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
2268 for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
2269 {
2270 auto __pos = __i++;
2271 auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos));
2272 if (__res.second)
2273 {
2274 auto& __src_impl = _Merge_helper::_S_get_impl(__src);
2275 auto __ptr = _Node_traits::_S_rebalance_for_erase
2276 (__pos._M_node, __src_impl._M_header);
2277 --__src_impl._M_node_count;
2278 auto __node_ptr = static_cast<_Node&>(*__ptr)._M_node_ptr();
2279 _M_insert_node(__res.first, __res.second, __node_ptr);
2280 }
2281 }
2282 }
2283
2284 /// Merge from a compatible container into one with equivalent keys.
2285 template<typename _Compare2>
2286 void
2287 _M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept
2288 {
2289 using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
2290 for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
2291 {
2292 auto __pos = __i++;
2293 auto __res = _M_get_insert_equal_pos(_KeyOfValue()(*__pos));
2294 if (__res.second)
2295 {
2296 auto& __src_impl = _Merge_helper::_S_get_impl(__src);
2297 auto __ptr = _Node_traits::_S_rebalance_for_erase
2298 (__pos._M_node, __src_impl._M_header);
2299 --__src_impl._M_node_count;
2300 auto __node_ptr = static_cast<_Node&>(*__ptr)._M_node_ptr();
2301 _M_insert_node(__res.first, __res.second, __node_ptr);
2302 }
2303 }
2304 }
2305#endif // C++17 node_extract
2306
2307 friend bool
2308 operator==(const _Rb_tree& __x, const _Rb_tree& __y)
2309 {
2310 return __x.size() == __y.size()
2311 && std::equal(__x.begin(), __x.end(), __y.begin());
2312 }
2313
2314#if __cpp_lib_three_way_comparison
2315 friend auto
2316 operator<=>(const _Rb_tree& __x, const _Rb_tree& __y)
2317 {
2318 if constexpr (requires { typename __detail::__synth3way_t<_Val>; })
2319 return std::lexicographical_compare_three_way(__x.begin(), __x.end(),
2320 __y.begin(), __y.end(),
2321 __detail::__synth3way);
2322 }
2323#else
2324 friend bool
2325 operator<(const _Rb_tree& __x, const _Rb_tree& __y)
2326 {
2327 return std::lexicographical_compare(__x.begin(), __x.end(),
2328 __y.begin(), __y.end());
2329 }
2330#endif
2331
2332 private:
2333#if __cplusplus >= 201103L
2334 // An RAII _Node handle
2335 struct _Auto_node
2336 {
2337 template<typename... _Args>
2338 _Auto_node(_Rb_tree& __t, _Args&&... __args)
2339 : _M_t(__t),
2340 _M_node(__t._M_create_node(std::forward<_Args>(__args)...))
2341 { }
2342
2343 ~_Auto_node()
2344 {
2345 if (_M_node)
2346 _M_t._M_drop_node(_M_node);
2347 }
2348
2349 _Auto_node(_Auto_node&& __n)
2350 : _M_t(__n._M_t), _M_node(__n._M_node)
2351 { __n._M_node = nullptr; }
2352
2353 const _Key&
2354 _M_key() const
2355 { return _S_key(_M_node); }
2356
2357 iterator
2358 _M_insert(pair<_Base_ptr, _Base_ptr> __p)
2359 {
2360 auto __it = _M_t._M_insert_node(__p.first, __p.second, _M_node);
2361 _M_node = nullptr;
2362 return __it;
2363 }
2364
2365 iterator
2366 _M_insert_equal_lower()
2367 {
2368 auto __it = _M_t._M_insert_equal_lower_node(_M_node);
2369 _M_node = nullptr;
2370 return __it;
2371 }
2372
2373 _Rb_tree& _M_t;
2374 _Node_ptr _M_node;
2375 };
2376#endif // C++11
2377 };
2378
2379 template<typename _Key, typename _Val, typename _KeyOfValue,
2380 typename _Compare, typename _Alloc>
2381 inline void
2382 swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
2383 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
2384 { __x.swap(__y); }
2385
2386#if __cplusplus >= 201103L
2387 template<typename _Key, typename _Val, typename _KeyOfValue,
2388 typename _Compare, typename _Alloc>
2389 void
2390 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2391 _M_move_data(_Rb_tree& __x, false_type)
2392 {
2393 if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
2394 _M_move_data(__x, true_type());
2395 else
2396 {
2397 constexpr bool __move = !__move_if_noexcept_cond<value_type>::value;
2398 _Alloc_node __an(*this);
2399 _M_root() = _M_copy<__move>(__x, __an);
2400#pragma GCC diagnostic push
2401#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
2402 if constexpr (__move)
2403 __x.clear();
2404#pragma GCC diagnostic pop
2405 }
2406 }
2407
2408 template<typename _Key, typename _Val, typename _KeyOfValue,
2409 typename _Compare, typename _Alloc>
2410 inline void
2411 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2412 _M_move_assign(_Rb_tree& __x, true_type)
2413 {
2414 clear();
2415 if (__x._M_root())
2416 _M_move_data(__x, true_type());
2417 std::__alloc_on_move(_M_get_Node_allocator(),
2418 __x._M_get_Node_allocator());
2419 }
2420
2421 template<typename _Key, typename _Val, typename _KeyOfValue,
2422 typename _Compare, typename _Alloc>
2423 void
2424 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2425 _M_move_assign(_Rb_tree& __x, false_type)
2426 {
2427 if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
2428 return _M_move_assign(__x, true_type{});
2429
2430 // Try to move each node reusing existing nodes and copying __x nodes
2431 // structure.
2432 _Reuse_or_alloc_node __roan(*this);
2433 _M_impl._M_reset();
2434 if (__x._M_root())
2435 {
2436 _M_root() = _M_copy<__as_rvalue>(__x, __roan);
2437 __x.clear();
2438 }
2439 }
2440
2441 template<typename _Key, typename _Val, typename _KeyOfValue,
2442 typename _Compare, typename _Alloc>
2443 inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
2444 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2445 operator=(_Rb_tree&& __x)
2446 noexcept(_Node_alloc_traits::_S_nothrow_move()
2447 && is_nothrow_move_assignable<_Compare>::value)
2448 {
2449 _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
2450 _M_move_assign(__x,
2451 __bool_constant<_Node_alloc_traits::_S_nothrow_move()>());
2452 return *this;
2453 }
2454
2455 template<typename _Key, typename _Val, typename _KeyOfValue,
2456 typename _Compare, typename _Alloc>
2457 template<typename _Iterator>
2458 void
2459 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2460 _M_assign_unique(_Iterator __first, _Iterator __last)
2461 {
2462 _Reuse_or_alloc_node __roan(*this);
2463 _M_impl._M_reset();
2464 for (; __first != __last; ++__first)
2465 _M_insert_unique_(end(), *__first, __roan);
2466 }
2467
2468 template<typename _Key, typename _Val, typename _KeyOfValue,
2469 typename _Compare, typename _Alloc>
2470 template<typename _Iterator>
2471 void
2472 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2473 _M_assign_equal(_Iterator __first, _Iterator __last)
2474 {
2475 _Reuse_or_alloc_node __roan(*this);
2476 _M_impl._M_reset();
2477 for (; __first != __last; ++__first)
2478 _M_insert_equal_(end(), *__first, __roan);
2479 }
2480#endif // C++11
2481
2482 template<typename _Key, typename _Val, typename _KeyOfValue,
2483 typename _Compare, typename _Alloc>
2484 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
2485 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2486 operator=(const _Rb_tree& __x)
2487 {
2488 if (this != std::__addressof(__x))
2489 {
2490 // Note that _Key may be a constant type.
2491#if __cplusplus >= 201103L
2492 if (_Node_alloc_traits::_S_propagate_on_copy_assign())
2493 {
2494 auto& __this_alloc = this->_M_get_Node_allocator();
2495 auto& __that_alloc = __x._M_get_Node_allocator();
2496 if (!_Node_alloc_traits::_S_always_equal()
2497 && __this_alloc != __that_alloc)
2498 {
2499 // Replacement allocator cannot free existing storage, we need
2500 // to erase nodes first.
2501 clear();
2502 std::__alloc_on_copy(__this_alloc, __that_alloc);
2503 }
2504 }
2505#endif
2506
2507 _Reuse_or_alloc_node __roan(*this);
2508 _M_impl._M_reset();
2509 _M_impl._M_key_compare = __x._M_impl._M_key_compare;
2510 if (__x._M_root())
2511 _M_root() = _M_copy<__as_lvalue>(__x, __roan);
2512 }
2513
2514 return *this;
2515 }
2516
2517 template<typename _Key, typename _Val, typename _KeyOfValue,
2518 typename _Compare, typename _Alloc>
2519#if __cplusplus >= 201103L
2520 template<typename _Arg, typename _NodeGen>
2521#else
2522 template<typename _NodeGen>
2523#endif
2524 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
2525 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2526 _M_insert_(_Base_ptr __x, _Base_ptr __p,
2527#if __cplusplus >= 201103L
2528 _Arg&& __v,
2529#else
2530 const _Val& __v,
2531#endif
2532 _NodeGen& __node_gen)
2533 {
2534 bool __insert_left = (__x || __p == _M_end()
2535 || _M_key_compare(_KeyOfValue()(__v),
2536 _S_key(__p)));
2537
2538 _Base_ptr __z =
2539 __node_gen(_GLIBCXX_FORWARD(_Arg, __v))->_M_base_ptr();
2540
2541 _Node_traits::_S_insert_and_rebalance
2542 (__insert_left, __z, __p, this->_M_impl._M_header);
2543 ++_M_impl._M_node_count;
2544 return iterator(__z);
2545 }
2546
2547 template<typename _Key, typename _Val, typename _KeyOfValue,
2548 typename _Compare, typename _Alloc>
2549#if __cplusplus >= 201103L
2550 template<typename _Arg>
2551#endif
2552 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
2553 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2554#if __cplusplus >= 201103L
2555 _M_insert_lower(_Base_ptr __p, _Arg&& __v)
2556#else
2557 _M_insert_lower(_Base_ptr __p, const _Val& __v)
2558#endif
2559 {
2560 bool __insert_left = (__p == _M_end()
2561 || !_M_key_compare(_S_key(__p),
2562 _KeyOfValue()(__v)));
2563
2564 _Base_ptr __z =
2565 _M_create_node(_GLIBCXX_FORWARD(_Arg, __v))->_M_base_ptr();
2566 _Node_traits::_S_insert_and_rebalance
2567 (__insert_left, __z, __p, this->_M_impl._M_header);
2568 ++_M_impl._M_node_count;
2569 return iterator(__z);
2570 }
2571
2572 template<typename _Key, typename _Val, typename _KeyOfValue,
2573 typename _Compare, typename _Alloc>
2574#if __cplusplus >= 201103L
2575 template<typename _Arg>
2576#endif
2577 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
2578 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2579#if __cplusplus >= 201103L
2580 _M_insert_equal_lower(_Arg&& __v)
2581#else
2582 _M_insert_equal_lower(const _Val& __v)
2583#endif
2584 {
2585 _Base_ptr __x = _M_begin();
2586 _Base_ptr __y = _M_end();
2587 while (__x)
2588 {
2589 __y = __x;
2590 __x = !_M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
2591 _S_left(__x) : _S_right(__x);
2592 }
2593 return _M_insert_lower(__y, _GLIBCXX_FORWARD(_Arg, __v));
2594 }
2595
2596 template<typename _Key, typename _Val, typename _KoV,
2597 typename _Compare, typename _Alloc>
2598 template<bool _MoveValues, typename _NodeGen>
2599 typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Base_ptr
2600 _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
2601 _M_copy(_Node_ptr __x, _Base_ptr __p, _NodeGen& __node_gen)
2602 {
2603 // Structural copy. __x and __p must be non-null.
2604 _Node_ptr __top = _M_clone_node<_MoveValues>(__x, __node_gen);
2605 _Base_ptr __top_base = __top->_M_base_ptr();
2606 __top->_M_parent = __p;
2607
2608 __try
2609 {
2610 if (__x->_M_right)
2611 __top->_M_right =
2612 _M_copy<_MoveValues>(_S_right(__x), __top_base, __node_gen);
2613 __p = __top_base;
2614 __x = _S_left(__x);
2615
2616 while (__x)
2617 {
2618 _Base_ptr __y =
2619 _M_clone_node<_MoveValues>(__x, __node_gen)->_M_base_ptr();
2620 __p->_M_left = __y;
2621 __y->_M_parent = __p;
2622 if (__x->_M_right)
2623 __y->_M_right = _M_copy<_MoveValues>(_S_right(__x),
2624 __y, __node_gen);
2625 __p = __y;
2626 __x = _S_left(__x);
2627 }
2628 }
2629 __catch(...)
2630 {
2631 _M_erase(__top);
2632 __throw_exception_again;
2633 }
2634 return __top_base;
2635 }
2636
2637 template<typename _Key, typename _Val, typename _KeyOfValue,
2638 typename _Compare, typename _Alloc>
2639 void
2640 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2641 _M_erase(_Node_ptr __x)
2642 {
2643 // Erase without rebalancing.
2644 while (__x)
2645 {
2646 _M_erase(_S_right(__x));
2647 _Node_ptr __y = _S_left(__x);
2648 _M_drop_node(__x);
2649 __x = __y;
2650 }
2651 }
2652
2653 template<typename _Key, typename _Val, typename _KeyOfValue,
2654 typename _Compare, typename _Alloc>
2655 typename _Rb_tree<_Key, _Val, _KeyOfValue,
2656 _Compare, _Alloc>::_Base_ptr
2657 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2658 _M_lower_bound(_Base_ptr __x, _Base_ptr __y,
2659 const _Key& __k) const
2660 {
2661 while (__x)
2662 if (!_M_key_compare(_S_key(__x), __k))
2663 __y = __x, __x = _S_left(__x);
2664 else
2665 __x = _S_right(__x);
2666 return __y;
2667 }
2668
2669 template<typename _Key, typename _Val, typename _KeyOfValue,
2670 typename _Compare, typename _Alloc>
2671 template <typename _Kt>
2672 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr
2673 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2674 _M_lower_bound_tr(_Base_ptr __x, _Base_ptr __y, const _Kt& __k) const
2675 {
2676 while (__x)
2677 if (!_M_key_compare(_S_key(__x), __k))
2678 __y = __x, __x = _S_left(__x);
2679 else
2680 __x = _S_right(__x);
2681 return __y;
2682 }
2683
2684 template<typename _Key, typename _Val, typename _KeyOfValue,
2685 typename _Compare, typename _Alloc>
2686 typename _Rb_tree<_Key, _Val, _KeyOfValue,
2687 _Compare, _Alloc>::_Base_ptr
2688 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2689 _M_upper_bound(_Base_ptr __x, _Base_ptr __y,
2690 const _Key& __k) const
2691 {
2692 while (__x)
2693 if (_M_key_compare(__k, _S_key(__x)))
2694 __y = __x, __x = _S_left(__x);
2695 else
2696 __x = _S_right(__x);
2697 return __y;
2698 }
2699
2700 template<typename _Key, typename _Val, typename _KeyOfValue,
2701 typename _Compare, typename _Alloc>
2702 template <typename _Kt>
2703 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr
2704 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2705 _M_upper_bound_tr(_Base_ptr __x, _Base_ptr __y, const _Kt& __k) const
2706 {
2707 while (__x)
2708 if (_M_key_compare(__k, _S_key(__x)))
2709 __y = __x, __x = _S_left(__x);
2710 else
2711 __x = _S_right(__x);
2712 return __y;
2713 }
2714
2715 template<typename _Key, typename _Val, typename _KeyOfValue,
2716 typename _Compare, typename _Alloc>
2717 pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
2718 _Compare, _Alloc>::iterator,
2719 typename _Rb_tree<_Key, _Val, _KeyOfValue,
2720 _Compare, _Alloc>::iterator>
2721 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2722 equal_range(const _Key& __k)
2723 {
2724 typedef pair<iterator, iterator> _Ret;
2725
2726 _Base_ptr __x = _M_begin();
2727 _Base_ptr __y = _M_end();
2728 while (__x)
2729 {
2730 if (_M_key_compare(_S_key(__x), __k))
2731 __x = _S_right(__x);
2732 else if (_M_key_compare(__k, _S_key(__x)))
2733 __y = __x, __x = _S_left(__x);
2734 else
2735 {
2736 _Base_ptr __xu(__x);
2737 _Base_ptr __yu(__y);
2738 __y = __x, __x = _S_left(__x);
2739 __xu = _S_right(__xu);
2740 return _Ret(iterator(_M_lower_bound(__x, __y, __k)),
2741 iterator(_M_upper_bound(__xu, __yu, __k)));
2742 }
2743 }
2744 return _Ret(iterator(__y), iterator(__y));
2745 }
2746
2747 template<typename _Key, typename _Val, typename _KeyOfValue,
2748 typename _Compare, typename _Alloc>
2749 pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
2750 _Compare, _Alloc>::const_iterator,
2751 typename _Rb_tree<_Key, _Val, _KeyOfValue,
2752 _Compare, _Alloc>::const_iterator>
2753 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2754 equal_range(const _Key& __k) const
2755 {
2756 typedef pair<const_iterator, const_iterator> _Ret;
2757
2758 _Base_ptr __x = _M_begin();
2759 _Base_ptr __y = _M_end();
2760 while (__x)
2761 {
2762 if (_M_key_compare(_S_key(__x), __k))
2763 __x = _S_right(__x);
2764 else if (_M_key_compare(__k, _S_key(__x)))
2765 __y = __x, __x = _S_left(__x);
2766 else
2767 {
2768 _Base_ptr __xu(__x);
2769 _Base_ptr __yu(__y);
2770 __y = __x, __x = _S_left(__x);
2771 __xu = _S_right(__xu);
2772 return _Ret(const_iterator(_M_lower_bound(__x, __y, __k)),
2773 const_iterator(_M_upper_bound(__xu, __yu, __k)));
2774 }
2775 }
2776 return _Ret(const_iterator(__y), const_iterator(__y));
2777 }
2778
2779 template<typename _Key, typename _Val, typename _KeyOfValue,
2780 typename _Compare, typename _Alloc>
2781 void
2782 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2783 swap(_Rb_tree& __t)
2784 _GLIBCXX_NOEXCEPT_IF(__is_nothrow_swappable<_Compare>::value)
2785 {
2786 if (!_M_root())
2787 {
2788 if (__t._M_root())
2789 _M_impl._M_move_data(__t._M_impl);
2790 }
2791 else if (!__t._M_root())
2792 __t._M_impl._M_move_data(_M_impl);
2793 else
2794 {
2795 std::swap(_M_root(),__t._M_root());
2796 std::swap(_M_leftmost(),__t._M_leftmost());
2797 std::swap(_M_rightmost(),__t._M_rightmost());
2798
2799 _M_root()->_M_parent = _M_end();
2800 __t._M_root()->_M_parent = __t._M_end();
2801 std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
2802 }
2803 // No need to swap header's color as it does not change.
2804
2805 using std::swap;
2806 swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
2807
2808 _Node_alloc_traits::_S_on_swap(_M_get_Node_allocator(),
2809 __t._M_get_Node_allocator());
2810 }
2811
2812 template<typename _Key, typename _Val, typename _KeyOfValue,
2813 typename _Compare, typename _Alloc>
2814 pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
2815 _Compare, _Alloc>::_Base_ptr,
2816 typename _Rb_tree<_Key, _Val, _KeyOfValue,
2817 _Compare, _Alloc>::_Base_ptr>
2818 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2819 _M_get_insert_unique_pos(const key_type& __k)
2820 {
2821 typedef pair<_Base_ptr, _Base_ptr> _Res;
2822 _Base_ptr __x = _M_begin();
2823 _Base_ptr __y = _M_end();
2824 bool __comp = true;
2825 while (__x)
2826 {
2827 __y = __x;
2828 __comp = _M_key_compare(__k, _S_key(__x));
2829 __x = __comp ? _S_left(__x) : _S_right(__x);
2830 }
2831 iterator __j = iterator(__y);
2832 if (__comp)
2833 {
2834 if (__j == begin())
2835 return _Res(__x, __y);
2836 else
2837 --__j;
2838 }
2839 if (_M_key_compare(_S_key(__j._M_node), __k))
2840 return _Res(__x, __y);
2841 return _Res(__j._M_node, _Base_ptr());
2842 }
2843
2844 template<typename _Key, typename _Val, typename _KeyOfValue,
2845 typename _Compare, typename _Alloc>
2846 pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
2847 _Compare, _Alloc>::_Base_ptr,
2848 typename _Rb_tree<_Key, _Val, _KeyOfValue,
2849 _Compare, _Alloc>::_Base_ptr>
2850 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2851 _M_get_insert_equal_pos(const key_type& __k)
2852 {
2853 typedef pair<_Base_ptr, _Base_ptr> _Res;
2854 _Base_ptr __x = _M_begin();
2855 _Base_ptr __y = _M_end();
2856 while (__x)
2857 {
2858 __y = __x;
2859 __x = _M_key_compare(__k, _S_key(__x)) ? _S_left(__x) : _S_right(__x);
2860 }
2861 return _Res(__x, __y);
2862 }
2863
2864#ifdef __glibcxx_associative_heterogeneous_insertion // C++26
2865
2866 // Multiple elements may compare equal to __k. Identify the first
2867 // of any such elements, or insert normally.
2868
2869 template <typename _Key, typename _Val, typename _KeyOfValue,
2870 typename _Compare, typename _Alloc>
2871 template <typename _Kt>
2872 auto
2873 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2874 _M_get_insert_unique_pos_tr(const _Kt& __k)
2875 -> pair<_Base_ptr, _Base_ptr>
2876 {
2877 if (size() == 0)
2878 return { _M_end(), _M_end() }; // Insert as root.
2879
2880 _Base_ptr __x = _M_begin(), __y = __x;
2881 bool __k_le_y = false;
2882 do
2883 {
2884 __y = __x;
2885 __k_le_y = ! _M_key_compare(_S_key(__x), __k);
2886 __x = __k_le_y ? _S_left(__x) : _S_right(__x);
2887 }
2888 while (__x);
2889 // If !__k_le_y, __k > *__y;
2890 // If __y is rightmost, put at _M_right under *__y.
2891 // else if __k < *(__y+1), put at _M_right under *__y.
2892 // else __k == *(__y+1), do not insert, report (__y+1).
2893 // else, __k_le_y, __k <= *__y;
2894 // If __k < *__Y, put at _M_left under *__y.
2895 // else __k == *__y, do not insert, report __y.
2896 auto __j = iterator(__y);
2897 if (! __k_le_y) // k > *__y
2898 {
2899 if (__y == _M_rightmost())
2900 return { {}, __y }; // Place to right under __y.
2901 ++__j;
2902 }
2903 if (_M_key_compare(__k, _S_key(__j._M_node)))
2904 {
2905 if (__k_le_y)
2906 return { __y, __y }; // Place to left under __y.
2907 else
2908 return { {}, __y }; // Place to right under __y.
2909 }
2910 return { __j._M_node, {} }; // No insert.
2911 }
2912#endif
2913
2914 template<typename _Key, typename _Val, typename _KeyOfValue,
2915 typename _Compare, typename _Alloc>
2916#if __cplusplus >= 201103L
2917 template<typename _Arg>
2918#endif
2919 pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
2920 _Compare, _Alloc>::iterator, bool>
2921 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2922#if __cplusplus >= 201103L
2923 _M_insert_unique(_Arg&& __v)
2924#else
2925 _M_insert_unique(const _Val& __v)
2926#endif
2927 {
2928 typedef pair<iterator, bool> _Res;
2929 pair<_Base_ptr, _Base_ptr> __res
2930 = _M_get_insert_unique_pos(_KeyOfValue()(__v));
2931
2932 if (__res.second)
2933 {
2934 _Alloc_node __an(*this);
2935 return _Res(_M_insert_(__res.first, __res.second,
2936 _GLIBCXX_FORWARD(_Arg, __v), __an),
2937 true);
2938 }
2939
2940 return _Res(iterator(__res.first), false);
2941 }
2942
2943 template<typename _Key, typename _Val, typename _KeyOfValue,
2944 typename _Compare, typename _Alloc>
2945#if __cplusplus >= 201103L
2946 template<typename _Arg>
2947#endif
2948 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
2949 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2950#if __cplusplus >= 201103L
2951 _M_insert_equal(_Arg&& __v)
2952#else
2953 _M_insert_equal(const _Val& __v)
2954#endif
2955 {
2956 pair<_Base_ptr, _Base_ptr> __res
2957 = _M_get_insert_equal_pos(_KeyOfValue()(__v));
2958 _Alloc_node __an(*this);
2959 return _M_insert_(__res.first, __res.second,
2960 _GLIBCXX_FORWARD(_Arg, __v), __an);
2961 }
2962
2963 template<typename _Key, typename _Val, typename _KeyOfValue,
2964 typename _Compare, typename _Alloc>
2965 pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
2966 _Compare, _Alloc>::_Base_ptr,
2967 typename _Rb_tree<_Key, _Val, _KeyOfValue,
2968 _Compare, _Alloc>::_Base_ptr>
2969 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
2970 _M_get_insert_hint_unique_pos(const_iterator __position,
2971 const key_type& __k)
2972 {
2973 typedef pair<_Base_ptr, _Base_ptr> _Res;
2974
2975 // end()
2976 if (__position._M_node == _M_end())
2977 {
2978 if (size() > 0 && _M_key_compare(_S_key(_M_rightmost()), __k))
2979 return _Res(_Base_ptr(), _M_rightmost());
2980 else
2981 return _M_get_insert_unique_pos(__k);
2982 }
2983 else if (_M_key_compare(__k, _S_key(__position._M_node)))
2984 {
2985 // First, try before...
2986 iterator __before(__position._M_node);
2987 if (__position._M_node == _M_leftmost()) // begin()
2988 return _Res(_M_leftmost(), _M_leftmost());
2989 else if (_M_key_compare(_S_key((--__before)._M_node), __k))
2990 {
2991 if (!_S_right(__before._M_node))
2992 return _Res(_Base_ptr(), __before._M_node);
2993 else
2994 return _Res(__position._M_node, __position._M_node);
2995 }
2996 else
2997 return _M_get_insert_unique_pos(__k);
2998 }
2999 else if (_M_key_compare(_S_key(__position._M_node), __k))
3000 {
3001 // ... then try after.
3002 iterator __after(__position._M_node);
3003 if (__position._M_node == _M_rightmost())
3004 return _Res(_Base_ptr(), _M_rightmost());
3005 else if (_M_key_compare(__k, _S_key((++__after)._M_node)))
3006 {
3007 if (!_S_right(__position._M_node))
3008 return _Res(_Base_ptr(), __position._M_node);
3009 else
3010 return _Res(__after._M_node, __after._M_node);
3011 }
3012 else
3013 return _M_get_insert_unique_pos(__k);
3014 }
3015 else
3016 // Equivalent keys.
3017 return _Res(__position._M_node, _Base_ptr());
3018 }
3019
3020#ifdef __glibcxx_associative_heterogeneous_insertion // C++26
3021 template <typename _Key, typename _Val, typename _KeyOfValue,
3022 typename _Compare, typename _Alloc>
3023 template <typename _Kt>
3024 auto
3025 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3026 _M_get_insert_hint_unique_pos_tr(const_iterator __hint, const _Kt& __k)
3027 -> pair<_Base_ptr, _Base_ptr>
3028 {
3029 auto __node =__hint._M_node;
3030 if (__node == _M_end())
3031 {
3032 if (size() > 0 && _M_key_compare(_S_key(_M_rightmost()), __k))
3033 return { {}, _M_rightmost() };
3034 return _M_get_insert_unique_pos_tr(__k);
3035 }
3036 if (_M_key_compare(__k, _S_key(__node)))
3037 { // First, try before...
3038 if (__node == _M_leftmost()) // begin()
3039 return { _M_leftmost(), _M_leftmost() };
3040 iterator __before(__node);
3041 --__before;
3042 if (_M_key_compare(_S_key(__before._M_node), __k))
3043 {
3044 if (!_S_right(__before._M_node))
3045 return { {}, __before._M_node }; // put right
3046 return { __node, __node }; // put left;
3047 }
3048 return _M_get_insert_unique_pos_tr(__k);
3049 }
3050 if (_M_key_compare(_S_key(__node), __k))
3051 { // ... then try after.
3052 if (__node == _M_rightmost())
3053 return { {}, _M_rightmost() };
3054 iterator __after(__node);
3055 ++__after;
3056 if (_M_key_compare(__k, _S_key(__after._M_node)))
3057 {
3058 if (!_S_right(__node))
3059 return { {}, __node };
3060 return { __after._M_node, __after._M_node };
3061 }
3062 return _M_get_insert_unique_pos_tr(__k);
3063 }
3064 // Equal to __k; check if any more to the left.
3065 iterator __before(__node);
3066 if (__node == _M_leftmost() ||
3067 _M_key_compare(_S_key((--__before)._M_node), __k))
3068 { return { __node, {} }; }
3069 return _M_get_insert_unique_pos_tr(__k);
3070 }
3071#endif
3072
3073 template<typename _Key, typename _Val, typename _KeyOfValue,
3074 typename _Compare, typename _Alloc>
3075#if __cplusplus >= 201103L
3076 template<typename _Arg, typename _NodeGen>
3077#else
3078 template<typename _NodeGen>
3079#endif
3080 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
3081 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3082 _M_insert_unique_(const_iterator __position,
3083#if __cplusplus >= 201103L
3084 _Arg&& __v,
3085#else
3086 const _Val& __v,
3087#endif
3088 _NodeGen& __node_gen)
3089 {
3090 pair<_Base_ptr, _Base_ptr> __res
3091 = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
3092
3093 if (__res.second)
3094 return _M_insert_(__res.first, __res.second,
3095 _GLIBCXX_FORWARD(_Arg, __v),
3096 __node_gen);
3097 return iterator(__res.first);
3098 }
3099
3100 template<typename _Key, typename _Val, typename _KeyOfValue,
3101 typename _Compare, typename _Alloc>
3102 pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
3103 _Compare, _Alloc>::_Base_ptr,
3104 typename _Rb_tree<_Key, _Val, _KeyOfValue,
3105 _Compare, _Alloc>::_Base_ptr>
3106 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3107 _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
3108 {
3109 typedef pair<_Base_ptr, _Base_ptr> _Res;
3110
3111 // end()
3112 if (__position._M_node == _M_end())
3113 {
3114 if (size() > 0
3115 && !_M_key_compare(__k, _S_key(_M_rightmost())))
3116 return _Res(_Base_ptr(), _M_rightmost());
3117 else
3118 return _M_get_insert_equal_pos(__k);
3119 }
3120 else if (!_M_key_compare(_S_key(__position._M_node), __k))
3121 {
3122 // First, try before...
3123 iterator __before(__position._M_node);
3124 if (__position._M_node == _M_leftmost()) // begin()
3125 return _Res(_M_leftmost(), _M_leftmost());
3126 else if (!_M_key_compare(__k, _S_key((--__before)._M_node)))
3127 {
3128 if (!_S_right(__before._M_node))
3129 return _Res(_Base_ptr(), __before._M_node);
3130 else
3131 return _Res(__position._M_node, __position._M_node);
3132 }
3133 else
3134 return _M_get_insert_equal_pos(__k);
3135 }
3136 else
3137 {
3138 // ... then try after.
3139 iterator __after(__position._M_node);
3140 if (__position._M_node == _M_rightmost())
3141 return _Res(_Base_ptr(), _M_rightmost());
3142 else if (!_M_key_compare(_S_key((++__after)._M_node), __k))
3143 {
3144 if (!_S_right(__position._M_node))
3145 return _Res(_Base_ptr(), __position._M_node);
3146 else
3147 return _Res(__after._M_node, __after._M_node);
3148 }
3149 else
3150 return _Res(_Base_ptr(), _Base_ptr());
3151 }
3152 }
3153
3154 template<typename _Key, typename _Val, typename _KeyOfValue,
3155 typename _Compare, typename _Alloc>
3156#if __cplusplus >= 201103L
3157 template<typename _Arg, typename _NodeGen>
3158#else
3159 template<typename _NodeGen>
3160#endif
3161 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
3162 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3163 _M_insert_equal_(const_iterator __position,
3164#if __cplusplus >= 201103L
3165 _Arg&& __v,
3166#else
3167 const _Val& __v,
3168#endif
3169 _NodeGen& __node_gen)
3170 {
3171 pair<_Base_ptr, _Base_ptr> __res
3172 = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
3173
3174 if (__res.second)
3175 return _M_insert_(__res.first, __res.second,
3176 _GLIBCXX_FORWARD(_Arg, __v),
3177 __node_gen);
3178
3179 return _M_insert_equal_lower(_GLIBCXX_FORWARD(_Arg, __v));
3180 }
3181
3182#if __cplusplus >= 201103L
3183 template<typename _Key, typename _Val, typename _KeyOfValue,
3184 typename _Compare, typename _Alloc>
3185 auto
3186 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3187 _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Node_ptr __z)
3188 -> iterator
3189 {
3190 bool __insert_left = (__x || __p == _M_end()
3191 || _M_key_compare(_S_key(__z), _S_key(__p)));
3192
3193 _Base_ptr __base_z = __z->_M_base_ptr();
3194 _Node_traits::_S_insert_and_rebalance
3195 (__insert_left, __base_z, __p, this->_M_impl._M_header);
3196 ++_M_impl._M_node_count;
3197 return iterator(__base_z);
3198 }
3199
3200 template<typename _Key, typename _Val, typename _KeyOfValue,
3201 typename _Compare, typename _Alloc>
3202 auto
3203 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3204 _M_insert_lower_node(_Base_ptr __p, _Node_ptr __z)
3205 -> iterator
3206 {
3207 bool __insert_left = (__p == _M_end()
3208 || !_M_key_compare(_S_key(__p), _S_key(__z)));
3209
3210 _Base_ptr __base_z = __z->_M_base_ptr();
3211 _Node_traits::_S_insert_and_rebalance
3212 (__insert_left, __base_z, __p, this->_M_impl._M_header);
3213 ++_M_impl._M_node_count;
3214 return iterator(__base_z);
3215 }
3216
3217 template<typename _Key, typename _Val, typename _KeyOfValue,
3218 typename _Compare, typename _Alloc>
3219 auto
3220 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3221 _M_insert_equal_lower_node(_Node_ptr __z)
3222 -> iterator
3223 {
3224 _Base_ptr __x = _M_begin();
3225 _Base_ptr __y = _M_end();
3226 while (__x)
3227 {
3228 __y = __x;
3229 __x = !_M_key_compare(_S_key(__x), _S_key(__z)) ?
3230 _S_left(__x) : _S_right(__x);
3231 }
3232 return _M_insert_lower_node(__y, __z);
3233 }
3234
3235 template<typename _Key, typename _Val, typename _KeyOfValue,
3236 typename _Compare, typename _Alloc>
3237 template<typename... _Args>
3238 auto
3239 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3240 _M_emplace_unique(_Args&&... __args)
3241 -> pair<iterator, bool>
3242 {
3243 _Auto_node __z(*this, std::forward<_Args>(__args)...);
3244 auto __res = _M_get_insert_unique_pos(__z._M_key());
3245 if (__res.second)
3246 return {__z._M_insert(__res), true};
3247 return {iterator(__res.first), false};
3248 }
3249
3250 template<typename _Key, typename _Val, typename _KeyOfValue,
3251 typename _Compare, typename _Alloc>
3252 template<typename... _Args>
3253 auto
3254 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3255 _M_emplace_equal(_Args&&... __args)
3256 -> iterator
3257 {
3258 _Auto_node __z(*this, std::forward<_Args>(__args)...);
3259 auto __res = _M_get_insert_equal_pos(__z._M_key());
3260 return __z._M_insert(__res);
3261 }
3262
3263 template<typename _Key, typename _Val, typename _KeyOfValue,
3264 typename _Compare, typename _Alloc>
3265 template<typename... _Args>
3266 auto
3267 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3268 _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
3269 -> iterator
3270 {
3271 _Auto_node __z(*this, std::forward<_Args>(__args)...);
3272 auto __res = _M_get_insert_hint_unique_pos(__pos, __z._M_key());
3273 if (__res.second)
3274 return __z._M_insert(__res);
3275 return iterator(__res.first);
3276 }
3277
3278 template<typename _Key, typename _Val, typename _KeyOfValue,
3279 typename _Compare, typename _Alloc>
3280 template<typename... _Args>
3281 auto
3282 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3283 _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
3284 -> iterator
3285 {
3286 _Auto_node __z(*this, std::forward<_Args>(__args)...);
3287 auto __res = _M_get_insert_hint_equal_pos(__pos, __z._M_key());
3288 if (__res.second)
3289 return __z._M_insert(__res);
3290 return __z._M_insert_equal_lower();
3291 }
3292
3293#ifdef __glibcxx_associative_heterogeneous_insertion // C++26
3294 template <typename _Key, typename _Val, typename _KeyOfValue,
3295 typename _Compare, typename _Alloc>
3296 template <typename... _Args>
3297 auto
3298 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3299 _M_emplace_here(bool __place_left, _Base_ptr __node, _Args&&... __args)
3300 -> iterator
3301 {
3302 _Auto_node __z(*this, std::forward<_Args>(__args)...);
3303 _Base_ptr __base_z = __z._M_node->_M_base_ptr();
3304 _Node_traits::_S_insert_and_rebalance(
3305 __place_left, __base_z, __node, _M_impl._M_header);
3306 __z._M_node = nullptr;
3307 ++_M_impl._M_node_count;
3308 return iterator(__base_z);
3309 }
3310#endif
3311
3312#endif // >= C++11
3313
3314
3315 template<typename _Key, typename _Val, typename _KeyOfValue,
3316 typename _Compare, typename _Alloc>
3317 void
3318 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3319 _M_erase_aux(const_iterator __position)
3320 {
3321 _Base_ptr __y = _Node_traits::_S_rebalance_for_erase
3322 (__position._M_node, this->_M_impl._M_header);
3323 _M_drop_node(static_cast<_Node&>(*__y)._M_node_ptr());
3324 --_M_impl._M_node_count;
3325 }
3326
3327 template<typename _Key, typename _Val, typename _KeyOfValue,
3328 typename _Compare, typename _Alloc>
3329 void
3330 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3331 _M_erase_aux(const_iterator __first, const_iterator __last)
3332 {
3333 if (__first == begin() && __last == end())
3334 clear();
3335 else
3336 while (__first != __last)
3337 _M_erase_aux(__first++);
3338 }
3339
3340 template<typename _Key, typename _Val, typename _KeyOfValue,
3341 typename _Compare, typename _Alloc>
3342 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
3343 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3344 erase(const _Key& __x)
3345 {
3346 pair<iterator, iterator> __p = equal_range(__x);
3347 const size_type __old_size = size();
3348 _M_erase_aux(__p.first, __p.second);
3349 return __old_size - size();
3350 }
3351
3352 template<typename _Key, typename _Val, typename _KeyOfValue,
3353 typename _Compare, typename _Alloc>
3354 template <typename _Kt>
3355 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
3356 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3357 _M_erase_tr(const _Kt& __x)
3358 {
3359 pair<iterator, iterator> __p = _M_equal_range_tr(__x);
3360 const size_type __old_size = size();
3361 _M_erase_aux(__p.first, __p.second);
3362 return __old_size - size();
3363 }
3364
3365 template<typename _Key, typename _Val, typename _KeyOfValue,
3366 typename _Compare, typename _Alloc>
3367 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
3368 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3369 _M_erase_unique(const _Key& __x)
3370 {
3371 iterator __it = find(__x);
3372 if (__it == end())
3373 return 0;
3374
3375 _M_erase_aux(__it);
3376 return 1;
3377 }
3378
3379 template<typename _Key, typename _Val, typename _KeyOfValue,
3380 typename _Compare, typename _Alloc>
3381 typename _Rb_tree<_Key, _Val, _KeyOfValue,
3382 _Compare, _Alloc>::iterator
3383 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3384 find(const _Key& __k)
3385 {
3386 iterator __j(_M_lower_bound(_M_begin(), _M_end(), __k));
3387 return (__j == end()
3388 || _M_key_compare(__k, _S_key(__j._M_node))) ? end() : __j;
3389 }
3390
3391 template<typename _Key, typename _Val, typename _KeyOfValue,
3392 typename _Compare, typename _Alloc>
3393 typename _Rb_tree<_Key, _Val, _KeyOfValue,
3394 _Compare, _Alloc>::const_iterator
3395 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3396 find(const _Key& __k) const
3397 {
3398 const_iterator __j(_M_lower_bound(_M_begin(), _M_end(), __k));
3399 return (__j == end()
3400 || _M_key_compare(__k, _S_key(__j._M_node))) ? end() : __j;
3401 }
3402
3403 template<typename _Key, typename _Val, typename _KeyOfValue,
3404 typename _Compare, typename _Alloc>
3405 typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
3406 _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
3407 count(const _Key& __k) const
3408 {
3409 pair<const_iterator, const_iterator> __p = equal_range(__k);
3410 const size_type __n = std::distance(__p.first, __p.second);
3411 return __n;
3412 }
3413
3414 _GLIBCXX_PURE unsigned int
3415 _Rb_tree_black_count(const _Rb_tree_node_base* __node,
3416 const _Rb_tree_node_base* __root) throw ();
3417
3418 template<typename _Key, typename _Val, typename _KeyOfValue,
3419 typename _Compare, typename _Alloc>
3420 bool
3421 _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
3422 {
3423 if (_M_impl._M_node_count == 0 || begin() == end())
3424 return _M_impl._M_node_count == 0 && begin() == end()
3425 && this->_M_impl._M_header._M_left == _M_end()
3426 && this->_M_impl._M_header._M_right == _M_end();
3427
3428 unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
3429 for (const_iterator __it = begin(); __it != end(); ++__it)
3430 {
3431 _Base_ptr __x = __it._M_node;
3432 _Base_ptr __L = _S_left(__x);
3433 _Base_ptr __R = _S_right(__x);
3434
3435 if (__x->_M_color == _S_red)
3436 if ((__L && __L->_M_color == _S_red)
3437 || (__R && __R->_M_color == _S_red))
3438 return false;
3439
3440 if (__L && _M_key_compare(_S_key(__x), _S_key(__L)))
3441 return false;
3442 if (__R && _M_key_compare(_S_key(__R), _S_key(__x)))
3443 return false;
3444
3445 if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
3446 return false;
3447 }
3448
3449 if (_M_leftmost() != _Node_base::_S_minimum(_M_root()))
3450 return false;
3451 if (_M_rightmost() != _Node_base::_S_maximum(_M_root()))
3452 return false;
3453 return true;
3454 }
3455
3456#ifdef __glibcxx_node_extract // >= C++17
3457 // Allow access to internals of compatible _Rb_tree specializations.
3458 template<typename _Key, typename _Val, typename _Sel, typename _Cmp1,
3459 typename _Alloc, typename _Cmp2>
3460 struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>,
3461 _Cmp2>
3462 {
3463 private:
3464 friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>;
3465
3466 static auto&
3467 _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree)
3468 { return __tree._M_impl; }
3469 };
3470#endif // C++17
3471
3472#ifdef __glibcxx_associative_heterogeneous_erasure // C++ >= 23
3473template <typename _Kt, typename _Container>
3474 concept __heterogeneous_tree_key =
3475 __transparent_comparator<typename _Container::key_compare> &&
3476 __heterogeneous_key<_Kt, _Container>;
3477#endif
3478
3479_GLIBCXX_END_NAMESPACE_VERSION
3480} // namespace
3481
3482#endif
allocator.h
cpp_type_traits.h
ptr_traits.h
stl_algobase.h
stl_function.h
node_handle.h
aligned_buffer.h
std::chrono::operator<
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
Definition chrono.h:830
std::true_type
__bool_constant< true > true_type
The type used as a compile-time boolean with true value.
Definition type_traits:119
std::false_type
__bool_constant< false > false_type
The type used as a compile-time boolean with false value.
Definition type_traits:122
std::pair::pair
pair(_T1, _T2) -> pair< _T1, _T2 >
Two pairs are equal iff their members are equal.
std::declval
auto declval() noexcept -> decltype(__declval< _Tp >(0))
Definition type_traits:2741
std::addressof
constexpr _Tp * addressof(_Tp &__r) noexcept
Returns the actual address of the object or function referenced by r, even in the presence of an over...
Definition move.h:176
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:138
std::__addressof
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition move.h:52
std::forward
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
Definition move.h:72
std::lexicographical_compare_three_way
constexpr auto lexicographical_compare_three_way(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _Comp __comp) -> decltype(__comp(*__first1, *__first2))
Performs dictionary comparison on ranges.
Definition stl_algobase.h:1867
std
ISO C++ entities toplevel namespace is std.
std::distance
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
Definition stl_iterator_base_funcs.h:177
std::__ptr_rebind
typename pointer_traits< _Ptr >::template rebind< _Tp > __ptr_rebind
Convenience alias for rebinding pointers.
Definition ptr_traits.h:203
std::end
constexpr auto end(_Container &__cont) noexcept(noexcept(__cont.end())) -> decltype(__cont.end())
Return an iterator pointing to one past the last element of the container.
Definition range_access.h:80
std::size
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
Definition range_access.h:294
std::begin
constexpr auto begin(_Container &__cont) noexcept(noexcept(__cont.begin())) -> decltype(__cont.begin())
Return an iterator pointing to the first element of the container.
Definition range_access.h:55
__gnu_debug::__base
constexpr _Iterator __base(_Iterator __it)
Definition helper_functions.h:339
std::is_nothrow_move_assignable
is_nothrow_move_assignable
Definition type_traits:1438
std::size_type
std::allocator
The standard allocator, as per C++03 [20.4.1].
Definition allocator.h:134
std::pair
Struct holding two objects (or references) of arbitrary type.
Definition stl_pair.h:307
std::iterator
Common iterator class.
Definition stl_iterator_base_types.h:133
__gnu_cxx::__alloc_traits< _Node_allocator >::allocate
static constexpr pointer allocate(_Node_allocator &__a, size_type __n)
__gnu_cxx::__alloc_traits< _Node_allocator >::deallocate
static constexpr void deallocate(_Node_allocator &__a, pointer __p, size_type __n)
__gnu_cxx::__alloc_traits< _Node_allocator >::max_size
static constexpr size_type max_size(const _Node_allocator &__a) noexcept
alloc_traits.h