1 : // RB tree implementation -*- C++ -*-
2 :
3 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 : // Free Software Foundation, Inc.
5 : //
6 : // This file is part of the GNU ISO C++ Library. This library is free
7 : // software; you can redistribute it and/or modify it under the
8 : // terms of the GNU General Public License as published by the
9 : // Free Software Foundation; either version 3, or (at your option)
10 : // any later version.
11 :
12 : // This library is distributed in the hope that it will be useful,
13 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : // GNU General Public License for more details.
16 :
17 : // Under Section 7 of GPL version 3, you are granted additional
18 : // permissions described in the GCC Runtime Library Exception, version
19 : // 3.1, as published by the Free Software Foundation.
20 :
21 : // You should have received a copy of the GNU General Public License and
22 : // a copy of the GCC Runtime Library Exception along with this program;
23 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 : // <http://www.gnu.org/licenses/>.
25 :
26 : /*
27 : *
28 : * Copyright (c) 1996,1997
29 : * Silicon Graphics Computer Systems, Inc.
30 : *
31 : * Permission to use, copy, modify, distribute and sell this software
32 : * and its documentation for any purpose is hereby granted without fee,
33 : * provided that the above copyright notice appear in all copies and
34 : * that both that copyright notice and this permission notice appear
35 : * in supporting documentation. Silicon Graphics makes no
36 : * representations about the suitability of this software for any
37 : * purpose. It is provided "as is" without express or implied warranty.
38 : *
39 : *
40 : * Copyright (c) 1994
41 : * Hewlett-Packard Company
42 : *
43 : * Permission to use, copy, modify, distribute and sell this software
44 : * and its documentation for any purpose is hereby granted without fee,
45 : * provided that the above copyright notice appear in all copies and
46 : * that both that copyright notice and this permission notice appear
47 : * in supporting documentation. Hewlett-Packard Company makes no
48 : * representations about the suitability of this software for any
49 : * purpose. It is provided "as is" without express or implied warranty.
50 : *
51 : *
52 : */
53 :
54 : /** @file stl_tree.h
55 : * This is an internal header file, included by other library headers.
56 : * You should not attempt to use it directly.
57 : */
58 :
59 : #ifndef _STL_TREE_H
60 : #define _STL_TREE_H 1
61 :
62 : #include <bits/stl_algobase.h>
63 : #include <bits/allocator.h>
64 : #include <bits/stl_function.h>
65 : #include <bits/cpp_type_traits.h>
66 :
67 : _GLIBCXX_BEGIN_NAMESPACE(std)
68 :
69 : // Red-black tree class, designed for use in implementing STL
70 : // associative containers (set, multiset, map, and multimap). The
71 : // insertion and deletion algorithms are based on those in Cormen,
72 : // Leiserson, and Rivest, Introduction to Algorithms (MIT Press,
73 : // 1990), except that
74 : //
75 : // (1) the header cell is maintained with links not only to the root
76 : // but also to the leftmost node of the tree, to enable constant
77 : // time begin(), and to the rightmost node of the tree, to enable
78 : // linear time performance when used with the generic set algorithms
79 : // (set_union, etc.)
80 : //
81 : // (2) when a node being deleted has two children its successor node
82 : // is relinked into its place, rather than copied, so that the only
83 : // iterators invalidated are those referring to the deleted node.
84 :
85 : enum _Rb_tree_color { _S_red = false, _S_black = true };
86 :
87 : struct _Rb_tree_node_base
88 : {
89 : typedef _Rb_tree_node_base* _Base_ptr;
90 : typedef const _Rb_tree_node_base* _Const_Base_ptr;
91 :
92 : _Rb_tree_color _M_color;
93 : _Base_ptr _M_parent;
94 : _Base_ptr _M_left;
95 : _Base_ptr _M_right;
96 :
97 : static _Base_ptr
98 0 : _S_minimum(_Base_ptr __x)
99 : {
100 0 : while (__x->_M_left != 0) __x = __x->_M_left;
101 0 : return __x;
102 : }
103 :
104 : static _Const_Base_ptr
105 : _S_minimum(_Const_Base_ptr __x)
106 : {
107 : while (__x->_M_left != 0) __x = __x->_M_left;
108 : return __x;
109 : }
110 :
111 : static _Base_ptr
112 0 : _S_maximum(_Base_ptr __x)
113 : {
114 0 : while (__x->_M_right != 0) __x = __x->_M_right;
115 0 : return __x;
116 : }
117 :
118 : static _Const_Base_ptr
119 : _S_maximum(_Const_Base_ptr __x)
120 : {
121 : while (__x->_M_right != 0) __x = __x->_M_right;
122 : return __x;
123 : }
124 : };
125 :
126 : template<typename _Val>
127 : struct _Rb_tree_node : public _Rb_tree_node_base
128 16762175 : {
129 : typedef _Rb_tree_node<_Val>* _Link_type;
130 : _Val _M_value_field;
131 :
132 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
133 : template<typename... _Args>
134 16762154 : _Rb_tree_node(_Args&&... __args)
135 : : _Rb_tree_node_base(),
136 16762154 : _M_value_field(std::forward<_Args>(__args)...) { }
137 : #endif
138 : };
139 :
140 : _GLIBCXX_PURE _Rb_tree_node_base*
141 : _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
142 :
143 : _GLIBCXX_PURE const _Rb_tree_node_base*
144 : _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
145 :
146 : _GLIBCXX_PURE _Rb_tree_node_base*
147 : _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
148 :
149 : _GLIBCXX_PURE const _Rb_tree_node_base*
150 : _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
151 :
152 : template<typename _Tp>
153 : struct _Rb_tree_iterator
154 : {
155 : typedef _Tp value_type;
156 : typedef _Tp& reference;
157 : typedef _Tp* pointer;
158 :
159 : typedef bidirectional_iterator_tag iterator_category;
160 : typedef ptrdiff_t difference_type;
161 :
162 : typedef _Rb_tree_iterator<_Tp> _Self;
163 : typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
164 : typedef _Rb_tree_node<_Tp>* _Link_type;
165 :
166 0 : _Rb_tree_iterator()
167 0 : : _M_node() { }
168 :
169 : explicit
170 101098526 : _Rb_tree_iterator(_Link_type __x)
171 101098526 : : _M_node(__x) { }
172 :
173 : reference
174 30278492 : operator*() const
175 30278492 : { return static_cast<_Link_type>(_M_node)->_M_value_field; }
176 :
177 : pointer
178 1504330 : operator->() const
179 1504330 : { return &static_cast<_Link_type>(_M_node)->_M_value_field; }
180 :
181 : _Self&
182 397 : operator++()
183 : {
184 397 : _M_node = _Rb_tree_increment(_M_node);
185 397 : return *this;
186 : }
187 :
188 : _Self
189 92100 : operator++(int)
190 : {
191 92100 : _Self __tmp = *this;
192 92100 : _M_node = _Rb_tree_increment(_M_node);
193 : return __tmp;
194 : }
195 :
196 : _Self&
197 7001949 : operator--()
198 : {
199 7001949 : _M_node = _Rb_tree_decrement(_M_node);
200 7001949 : return *this;
201 : }
202 :
203 : _Self
204 : operator--(int)
205 : {
206 : _Self __tmp = *this;
207 : _M_node = _Rb_tree_decrement(_M_node);
208 : return __tmp;
209 : }
210 :
211 : bool
212 35837266 : operator==(const _Self& __x) const
213 35837266 : { return _M_node == __x._M_node; }
214 :
215 : bool
216 904092 : operator!=(const _Self& __x) const
217 904092 : { return _M_node != __x._M_node; }
218 :
219 : _Base_ptr _M_node;
220 : };
221 :
222 : template<typename _Tp>
223 : struct _Rb_tree_const_iterator
224 : {
225 : typedef _Tp value_type;
226 : typedef const _Tp& reference;
227 : typedef const _Tp* pointer;
228 :
229 : typedef _Rb_tree_iterator<_Tp> iterator;
230 :
231 : typedef bidirectional_iterator_tag iterator_category;
232 : typedef ptrdiff_t difference_type;
233 :
234 : typedef _Rb_tree_const_iterator<_Tp> _Self;
235 : typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
236 : typedef const _Rb_tree_node<_Tp>* _Link_type;
237 :
238 0 : _Rb_tree_const_iterator()
239 0 : : _M_node() { }
240 :
241 : explicit
242 22282052 : _Rb_tree_const_iterator(_Link_type __x)
243 22282052 : : _M_node(__x) { }
244 :
245 35247582 : _Rb_tree_const_iterator(const iterator& __it)
246 35247582 : : _M_node(__it._M_node) { }
247 :
248 : reference
249 13767664 : operator*() const
250 13767664 : { return static_cast<_Link_type>(_M_node)->_M_value_field; }
251 :
252 : pointer
253 20025737 : operator->() const
254 20025737 : { return &static_cast<_Link_type>(_M_node)->_M_value_field; }
255 :
256 : _Self&
257 0 : operator++()
258 : {
259 0 : _M_node = _Rb_tree_increment(_M_node);
260 0 : return *this;
261 : }
262 :
263 : _Self
264 10656997 : operator++(int)
265 : {
266 10656997 : _Self __tmp = *this;
267 10656997 : _M_node = _Rb_tree_increment(_M_node);
268 : return __tmp;
269 : }
270 :
271 : _Self&
272 107643 : operator--()
273 : {
274 107643 : _M_node = _Rb_tree_decrement(_M_node);
275 107643 : return *this;
276 : }
277 :
278 : _Self
279 : operator--(int)
280 : {
281 : _Self __tmp = *this;
282 : _M_node = _Rb_tree_decrement(_M_node);
283 : return __tmp;
284 : }
285 :
286 : bool
287 181851 : operator==(const _Self& __x) const
288 181851 : { return _M_node == __x._M_node; }
289 :
290 : bool
291 22280152 : operator!=(const _Self& __x) const
292 22280152 : { return _M_node != __x._M_node; }
293 :
294 : _Base_ptr _M_node;
295 : };
296 :
297 : template<typename _Val>
298 : inline bool
299 : operator==(const _Rb_tree_iterator<_Val>& __x,
300 : const _Rb_tree_const_iterator<_Val>& __y)
301 : { return __x._M_node == __y._M_node; }
302 :
303 : template<typename _Val>
304 : inline bool
305 : operator!=(const _Rb_tree_iterator<_Val>& __x,
306 : const _Rb_tree_const_iterator<_Val>& __y)
307 : { return __x._M_node != __y._M_node; }
308 :
309 : void
310 : _Rb_tree_insert_and_rebalance(const bool __insert_left,
311 : _Rb_tree_node_base* __x,
312 : _Rb_tree_node_base* __p,
313 : _Rb_tree_node_base& __header) throw ();
314 :
315 : _Rb_tree_node_base*
316 : _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
317 : _Rb_tree_node_base& __header) throw ();
318 :
319 :
320 : template<typename _Key, typename _Val, typename _KeyOfValue,
321 : typename _Compare, typename _Alloc = allocator<_Val> >
322 : class _Rb_tree
323 : {
324 : typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
325 : _Node_allocator;
326 :
327 : protected:
328 : typedef _Rb_tree_node_base* _Base_ptr;
329 : typedef const _Rb_tree_node_base* _Const_Base_ptr;
330 :
331 : public:
332 : typedef _Key key_type;
333 : typedef _Val value_type;
334 : typedef value_type* pointer;
335 : typedef const value_type* const_pointer;
336 : typedef value_type& reference;
337 : typedef const value_type& const_reference;
338 : typedef _Rb_tree_node<_Val>* _Link_type;
339 : typedef const _Rb_tree_node<_Val>* _Const_Link_type;
340 : typedef size_t size_type;
341 : typedef ptrdiff_t difference_type;
342 : typedef _Alloc allocator_type;
343 :
344 : _Node_allocator&
345 36947407 : _M_get_Node_allocator()
346 36947407 : { return *static_cast<_Node_allocator*>(&this->_M_impl); }
347 :
348 : const _Node_allocator&
349 3547950 : _M_get_Node_allocator() const
350 3547950 : { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
351 :
352 : allocator_type
353 : get_allocator() const
354 : { return allocator_type(_M_get_Node_allocator()); }
355 :
356 : protected:
357 : _Link_type
358 16762154 : _M_get_node()
359 16762154 : { return _M_impl._Node_allocator::allocate(1); }
360 :
361 : void
362 16762175 : _M_put_node(_Link_type __p)
363 16762175 : { _M_impl._Node_allocator::deallocate(__p, 1); }
364 :
365 : #ifndef __GXX_EXPERIMENTAL_CXX0X__
366 : _Link_type
367 : _M_create_node(const value_type& __x)
368 : {
369 : _Link_type __tmp = _M_get_node();
370 : __try
371 : { get_allocator().construct(&__tmp->_M_value_field, __x); }
372 : __catch(...)
373 : {
374 : _M_put_node(__tmp);
375 : __throw_exception_again;
376 : }
377 : return __tmp;
378 : }
379 :
380 : void
381 : _M_destroy_node(_Link_type __p)
382 : {
383 : get_allocator().destroy(&__p->_M_value_field);
384 : _M_put_node(__p);
385 : }
386 : #else
387 : template<typename... _Args>
388 : _Link_type
389 16762154 : _M_create_node(_Args&&... __args)
390 : {
391 16762154 : _Link_type __tmp = _M_get_node();
392 : __try
393 : {
394 16762154 : _M_get_Node_allocator().construct(__tmp,
395 : std::forward<_Args>(__args)...);
396 : }
397 : __catch(...)
398 : {
399 : _M_put_node(__tmp);
400 : __throw_exception_again;
401 : }
402 16762154 : return __tmp;
403 : }
404 :
405 : void
406 16762175 : _M_destroy_node(_Link_type __p)
407 : {
408 16762175 : _M_get_Node_allocator().destroy(__p);
409 16762175 : _M_put_node(__p);
410 16762175 : }
411 : #endif
412 :
413 : _Link_type
414 0 : _M_clone_node(_Const_Link_type __x)
415 : {
416 0 : _Link_type __tmp = _M_create_node(__x->_M_value_field);
417 0 : __tmp->_M_color = __x->_M_color;
418 0 : __tmp->_M_left = 0;
419 0 : __tmp->_M_right = 0;
420 0 : return __tmp;
421 : }
422 :
423 : protected:
424 : template<typename _Key_compare,
425 : bool _Is_pod_comparator = __is_pod(_Key_compare)>
426 : struct _Rb_tree_impl : public _Node_allocator
427 11915890 : {
428 : _Key_compare _M_key_compare;
429 : _Rb_tree_node_base _M_header;
430 : size_type _M_node_count; // Keeps track of size of tree.
431 :
432 4957530 : _Rb_tree_impl()
433 : : _Node_allocator(), _M_key_compare(), _M_header(),
434 4957530 : _M_node_count(0)
435 4957530 : { _M_initialize(); }
436 :
437 6971028 : _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
438 : : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
439 6971028 : _M_node_count(0)
440 6971028 : { _M_initialize(); }
441 :
442 : private:
443 : void
444 11928558 : _M_initialize()
445 : {
446 11928558 : this->_M_header._M_color = _S_red;
447 11928558 : this->_M_header._M_parent = 0;
448 11928558 : this->_M_header._M_left = &this->_M_header;
449 11928558 : this->_M_header._M_right = &this->_M_header;
450 11928558 : }
451 : };
452 :
453 : _Rb_tree_impl<_Compare> _M_impl;
454 :
455 : protected:
456 : _Base_ptr&
457 3423078 : _M_root()
458 3423078 : { return this->_M_impl._M_header._M_parent; }
459 :
460 : _Const_Base_ptr
461 3547950 : _M_root() const
462 3547950 : { return this->_M_impl._M_header._M_parent; }
463 :
464 : _Base_ptr&
465 4251846 : _M_leftmost()
466 4251846 : { return this->_M_impl._M_header._M_left; }
467 :
468 : _Const_Base_ptr
469 : _M_leftmost() const
470 : { return this->_M_impl._M_header._M_left; }
471 :
472 : _Base_ptr&
473 19971066 : _M_rightmost()
474 19971066 : { return this->_M_impl._M_header._M_right; }
475 :
476 : _Const_Base_ptr
477 : _M_rightmost() const
478 : { return this->_M_impl._M_header._M_right; }
479 :
480 : _Link_type
481 54161603 : _M_begin()
482 54161603 : { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
483 :
484 : _Const_Link_type
485 157712 : _M_begin() const
486 : {
487 : return static_cast<_Const_Link_type>
488 157712 : (this->_M_impl._M_header._M_parent);
489 : }
490 :
491 : _Link_type
492 73802146 : _M_end()
493 73802146 : { return static_cast<_Link_type>(&this->_M_impl._M_header); }
494 :
495 : _Const_Link_type
496 157712 : _M_end() const
497 157712 : { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
498 :
499 : static const_reference
500 426193344 : _S_value(_Const_Link_type __x)
501 426193344 : { return __x->_M_value_field; }
502 :
503 : static const _Key&
504 426193344 : _S_key(_Const_Link_type __x)
505 426193344 : { return _KeyOfValue()(_S_value(__x)); }
506 :
507 : static _Link_type
508 109170343 : _S_left(_Base_ptr __x)
509 109170343 : { return static_cast<_Link_type>(__x->_M_left); }
510 :
511 : static _Const_Link_type
512 208064 : _S_left(_Const_Base_ptr __x)
513 208064 : { return static_cast<_Const_Link_type>(__x->_M_left); }
514 :
515 : static _Link_type
516 346771758 : _S_right(_Base_ptr __x)
517 346771758 : { return static_cast<_Link_type>(__x->_M_right); }
518 :
519 : static _Const_Link_type
520 3675172 : _S_right(_Const_Base_ptr __x)
521 3675172 : { return static_cast<_Const_Link_type>(__x->_M_right); }
522 :
523 : static const_reference
524 36817826 : _S_value(_Const_Base_ptr __x)
525 36817826 : { return static_cast<_Const_Link_type>(__x)->_M_value_field; }
526 :
527 : static const _Key&
528 36817826 : _S_key(_Const_Base_ptr __x)
529 36817826 : { return _KeyOfValue()(_S_value(__x)); }
530 :
531 : static _Base_ptr
532 0 : _S_minimum(_Base_ptr __x)
533 0 : { return _Rb_tree_node_base::_S_minimum(__x); }
534 :
535 : static _Const_Base_ptr
536 : _S_minimum(_Const_Base_ptr __x)
537 : { return _Rb_tree_node_base::_S_minimum(__x); }
538 :
539 : static _Base_ptr
540 0 : _S_maximum(_Base_ptr __x)
541 0 : { return _Rb_tree_node_base::_S_maximum(__x); }
542 :
543 : static _Const_Base_ptr
544 : _S_maximum(_Const_Base_ptr __x)
545 : { return _Rb_tree_node_base::_S_maximum(__x); }
546 :
547 : public:
548 : typedef _Rb_tree_iterator<value_type> iterator;
549 : typedef _Rb_tree_const_iterator<value_type> const_iterator;
550 :
551 : typedef std::reverse_iterator<iterator> reverse_iterator;
552 : typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
553 :
554 : private:
555 : iterator
556 : _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __y,
557 : const value_type& __v);
558 :
559 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
560 : // 233. Insertion hints in associative containers.
561 : iterator
562 : _M_insert_lower(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
563 :
564 : iterator
565 : _M_insert_equal_lower(const value_type& __x);
566 :
567 : _Link_type
568 : _M_copy(_Const_Link_type __x, _Link_type __p);
569 :
570 : void
571 : _M_erase(_Link_type __x);
572 :
573 : iterator
574 : _M_lower_bound(_Link_type __x, _Link_type __y,
575 : const _Key& __k);
576 :
577 : const_iterator
578 : _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
579 : const _Key& __k) const;
580 :
581 : iterator
582 : _M_upper_bound(_Link_type __x, _Link_type __y,
583 : const _Key& __k);
584 :
585 : const_iterator
586 : _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
587 : const _Key& __k) const;
588 :
589 : public:
590 : // allocation/deallocation
591 4957530 : _Rb_tree() { }
592 :
593 : _Rb_tree(const _Compare& __comp,
594 : const allocator_type& __a = allocator_type())
595 : : _M_impl(__comp, __a) { }
596 :
597 3547950 : _Rb_tree(const _Rb_tree& __x)
598 3547950 : : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
599 : {
600 3547950 : if (__x._M_root() != 0)
601 : {
602 0 : _M_root() = _M_copy(__x._M_begin(), _M_end());
603 0 : _M_leftmost() = _S_minimum(_M_root());
604 0 : _M_rightmost() = _S_maximum(_M_root());
605 0 : _M_impl._M_node_count = __x._M_impl._M_node_count;
606 : }
607 3547950 : }
608 :
609 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
610 : _Rb_tree(_Rb_tree&& __x);
611 : #endif
612 :
613 11915890 : ~_Rb_tree()
614 11915890 : { _M_erase(_M_begin()); }
615 :
616 : _Rb_tree&
617 : operator=(const _Rb_tree& __x);
618 :
619 : // Accessors.
620 : _Compare
621 7754883 : key_comp() const
622 : { return _M_impl._M_key_compare; }
623 :
624 : iterator
625 12604963 : begin()
626 : {
627 : return iterator(static_cast<_Link_type>
628 12604963 : (this->_M_impl._M_header._M_left));
629 : }
630 :
631 : const_iterator
632 10440409 : begin() const
633 : {
634 : return const_iterator(static_cast<_Const_Link_type>
635 10440409 : (this->_M_impl._M_header._M_left));
636 : }
637 :
638 : iterator
639 29485696 : end()
640 29485696 : { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
641 :
642 : const_iterator
643 11683931 : end() const
644 : {
645 : return const_iterator(static_cast<_Const_Link_type>
646 11683931 : (&this->_M_impl._M_header));
647 : }
648 :
649 : reverse_iterator
650 : rbegin()
651 : { return reverse_iterator(end()); }
652 :
653 : const_reverse_iterator
654 : rbegin() const
655 : { return const_reverse_iterator(end()); }
656 :
657 : reverse_iterator
658 : rend()
659 : { return reverse_iterator(begin()); }
660 :
661 : const_reverse_iterator
662 : rend() const
663 : { return const_reverse_iterator(begin()); }
664 :
665 : bool
666 0 : empty() const
667 0 : { return _M_impl._M_node_count == 0; }
668 :
669 : size_type
670 14769591 : size() const
671 14769591 : { return _M_impl._M_node_count; }
672 :
673 : size_type
674 : max_size() const
675 : { return _M_get_Node_allocator().max_size(); }
676 :
677 : void
678 : swap(_Rb_tree& __t);
679 :
680 : // Insert/erase.
681 : pair<iterator, bool>
682 : _M_insert_unique(const value_type& __x);
683 :
684 : iterator
685 : _M_insert_equal(const value_type& __x);
686 :
687 : iterator
688 : _M_insert_unique_(const_iterator __position, const value_type& __x);
689 :
690 : iterator
691 : _M_insert_equal_(const_iterator __position, const value_type& __x);
692 :
693 : template<typename _InputIterator>
694 : void
695 : _M_insert_unique(_InputIterator __first, _InputIterator __last);
696 :
697 : template<typename _InputIterator>
698 : void
699 : _M_insert_equal(_InputIterator __first, _InputIterator __last);
700 :
701 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
702 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
703 : // DR 130. Associative erase should return an iterator.
704 : iterator
705 : erase(iterator __position);
706 :
707 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
708 : // DR 130. Associative erase should return an iterator.
709 : const_iterator
710 : erase(const_iterator __position);
711 : #else
712 : void
713 : erase(iterator __position);
714 :
715 : void
716 : erase(const_iterator __position);
717 : #endif
718 : size_type
719 : erase(const key_type& __x);
720 :
721 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
722 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
723 : // DR 130. Associative erase should return an iterator.
724 : iterator
725 : erase(iterator __first, iterator __last);
726 :
727 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
728 : // DR 130. Associative erase should return an iterator.
729 : const_iterator
730 : erase(const_iterator __first, const_iterator __last);
731 : #else
732 : void
733 : erase(iterator __first, iterator __last);
734 :
735 : void
736 : erase(const_iterator __first, const_iterator __last);
737 : #endif
738 : void
739 : erase(const key_type* __first, const key_type* __last);
740 :
741 : void
742 0 : clear()
743 : {
744 0 : _M_erase(_M_begin());
745 0 : _M_leftmost() = _M_end();
746 0 : _M_root() = 0;
747 0 : _M_rightmost() = _M_end();
748 0 : _M_impl._M_node_count = 0;
749 0 : }
750 :
751 : // Set operations.
752 : iterator
753 : find(const key_type& __k);
754 :
755 : const_iterator
756 : find(const key_type& __k) const;
757 :
758 : size_type
759 : count(const key_type& __k) const;
760 :
761 : iterator
762 22881024 : lower_bound(const key_type& __k)
763 22881024 : { return _M_lower_bound(_M_begin(), _M_end(), __k); }
764 :
765 : const_iterator
766 : lower_bound(const key_type& __k) const
767 : { return _M_lower_bound(_M_begin(), _M_end(), __k); }
768 :
769 : iterator
770 : upper_bound(const key_type& __k)
771 : { return _M_upper_bound(_M_begin(), _M_end(), __k); }
772 :
773 : const_iterator
774 : upper_bound(const key_type& __k) const
775 : { return _M_upper_bound(_M_begin(), _M_end(), __k); }
776 :
777 : pair<iterator, iterator>
778 : equal_range(const key_type& __k);
779 :
780 : pair<const_iterator, const_iterator>
781 : equal_range(const key_type& __k) const;
782 :
783 : // Debugging.
784 : bool
785 : __rb_verify() const;
786 : };
787 :
788 : template<typename _Key, typename _Val, typename _KeyOfValue,
789 : typename _Compare, typename _Alloc>
790 : inline bool
791 : operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
792 : const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
793 : {
794 : return __x.size() == __y.size()
795 : && std::equal(__x.begin(), __x.end(), __y.begin());
796 : }
797 :
798 : template<typename _Key, typename _Val, typename _KeyOfValue,
799 : typename _Compare, typename _Alloc>
800 : inline bool
801 : operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
802 : const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
803 : {
804 : return std::lexicographical_compare(__x.begin(), __x.end(),
805 : __y.begin(), __y.end());
806 : }
807 :
808 : template<typename _Key, typename _Val, typename _KeyOfValue,
809 : typename _Compare, typename _Alloc>
810 : inline bool
811 : operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
812 : const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
813 : { return !(__x == __y); }
814 :
815 : template<typename _Key, typename _Val, typename _KeyOfValue,
816 : typename _Compare, typename _Alloc>
817 : inline bool
818 : operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
819 : const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
820 : { return __y < __x; }
821 :
822 : template<typename _Key, typename _Val, typename _KeyOfValue,
823 : typename _Compare, typename _Alloc>
824 : inline bool
825 : operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
826 : const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
827 : { return !(__y < __x); }
828 :
829 : template<typename _Key, typename _Val, typename _KeyOfValue,
830 : typename _Compare, typename _Alloc>
831 : inline bool
832 : operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
833 : const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
834 : { return !(__x < __y); }
835 :
836 : template<typename _Key, typename _Val, typename _KeyOfValue,
837 : typename _Compare, typename _Alloc>
838 : inline void
839 : swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
840 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
841 : { __x.swap(__y); }
842 :
843 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
844 : template<typename _Key, typename _Val, typename _KeyOfValue,
845 : typename _Compare, typename _Alloc>
846 3423078 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
847 : _Rb_tree(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&& __x)
848 3423078 : : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
849 : {
850 3423078 : if (__x._M_root() != 0)
851 : {
852 0 : _M_root() = __x._M_root();
853 0 : _M_leftmost() = __x._M_leftmost();
854 0 : _M_rightmost() = __x._M_rightmost();
855 0 : _M_root()->_M_parent = _M_end();
856 :
857 0 : __x._M_root() = 0;
858 0 : __x._M_leftmost() = __x._M_end();
859 0 : __x._M_rightmost() = __x._M_end();
860 :
861 0 : this->_M_impl._M_node_count = __x._M_impl._M_node_count;
862 0 : __x._M_impl._M_node_count = 0;
863 : }
864 3423078 : }
865 : #endif
866 :
867 : template<typename _Key, typename _Val, typename _KeyOfValue,
868 : typename _Compare, typename _Alloc>
869 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
870 0 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
871 : operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
872 : {
873 0 : if (this != &__x)
874 : {
875 : // Note that _Key may be a constant type.
876 0 : clear();
877 : _M_impl._M_key_compare = __x._M_impl._M_key_compare;
878 0 : if (__x._M_root() != 0)
879 : {
880 0 : _M_root() = _M_copy(__x._M_begin(), _M_end());
881 0 : _M_leftmost() = _S_minimum(_M_root());
882 0 : _M_rightmost() = _S_maximum(_M_root());
883 0 : _M_impl._M_node_count = __x._M_impl._M_node_count;
884 : }
885 : }
886 0 : return *this;
887 : }
888 :
889 : template<typename _Key, typename _Val, typename _KeyOfValue,
890 : typename _Compare, typename _Alloc>
891 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
892 16762154 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
893 : _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)
894 : {
895 : bool __insert_left = (__x != 0 || __p == _M_end()
896 : || _M_impl._M_key_compare(_KeyOfValue()(__v),
897 16762154 : _S_key(__p)));
898 :
899 16762154 : _Link_type __z = _M_create_node(__v);
900 :
901 16762154 : _Rb_tree_insert_and_rebalance(__insert_left, __z,
902 : const_cast<_Base_ptr>(__p),
903 : this->_M_impl._M_header);
904 16762154 : ++_M_impl._M_node_count;
905 16762154 : return iterator(__z);
906 : }
907 :
908 : template<typename _Key, typename _Val, typename _KeyOfValue,
909 : typename _Compare, typename _Alloc>
910 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
911 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
912 : _M_insert_lower(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
913 : {
914 : bool __insert_left = (__x != 0 || __p == _M_end()
915 : || !_M_impl._M_key_compare(_S_key(__p),
916 : _KeyOfValue()(__v)));
917 :
918 : _Link_type __z = _M_create_node(__v);
919 :
920 : _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
921 : this->_M_impl._M_header);
922 : ++_M_impl._M_node_count;
923 : return iterator(__z);
924 : }
925 :
926 : template<typename _Key, typename _Val, typename _KeyOfValue,
927 : typename _Compare, typename _Alloc>
928 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
929 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
930 : _M_insert_equal_lower(const _Val& __v)
931 : {
932 : _Link_type __x = _M_begin();
933 : _Link_type __y = _M_end();
934 : while (__x != 0)
935 : {
936 : __y = __x;
937 : __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
938 : _S_left(__x) : _S_right(__x);
939 : }
940 : return _M_insert_lower(__x, __y, __v);
941 : }
942 :
943 : template<typename _Key, typename _Val, typename _KoV,
944 : typename _Compare, typename _Alloc>
945 : typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
946 0 : _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
947 : _M_copy(_Const_Link_type __x, _Link_type __p)
948 : {
949 : // Structural copy. __x and __p must be non-null.
950 0 : _Link_type __top = _M_clone_node(__x);
951 0 : __top->_M_parent = __p;
952 :
953 : __try
954 : {
955 0 : if (__x->_M_right)
956 0 : __top->_M_right = _M_copy(_S_right(__x), __top);
957 0 : __p = __top;
958 0 : __x = _S_left(__x);
959 :
960 0 : while (__x != 0)
961 : {
962 0 : _Link_type __y = _M_clone_node(__x);
963 0 : __p->_M_left = __y;
964 0 : __y->_M_parent = __p;
965 0 : if (__x->_M_right)
966 0 : __y->_M_right = _M_copy(_S_right(__x), __y);
967 0 : __p = __y;
968 0 : __x = _S_left(__x);
969 : }
970 : }
971 : __catch(...)
972 : {
973 : _M_erase(__top);
974 : __throw_exception_again;
975 : }
976 0 : return __top;
977 : }
978 :
979 : template<typename _Key, typename _Val, typename _KeyOfValue,
980 : typename _Compare, typename _Alloc>
981 : void
982 28678065 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
983 : _M_erase(_Link_type __x)
984 : {
985 : // Erase without rebalancing.
986 74118305 : while (__x != 0)
987 : {
988 16762175 : _M_erase(_S_right(__x));
989 16762175 : _Link_type __y = _S_left(__x);
990 16762175 : _M_destroy_node(__x);
991 16762175 : __x = __y;
992 : }
993 28678065 : }
994 :
995 : template<typename _Key, typename _Val, typename _KeyOfValue,
996 : typename _Compare, typename _Alloc>
997 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
998 : _Compare, _Alloc>::iterator
999 23984686 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1000 : _M_lower_bound(_Link_type __x, _Link_type __y,
1001 : const _Key& __k)
1002 : {
1003 336310121 : while (__x != 0)
1004 288340749 : if (!_M_impl._M_key_compare(_S_key(__x), __k))
1005 25608446 : __y = __x, __x = _S_left(__x);
1006 : else
1007 262732303 : __x = _S_right(__x);
1008 23984686 : return iterator(__y);
1009 : }
1010 :
1011 : template<typename _Key, typename _Val, typename _KeyOfValue,
1012 : typename _Compare, typename _Alloc>
1013 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
1014 : _Compare, _Alloc>::const_iterator
1015 157712 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1016 : _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
1017 : const _Key& __k) const
1018 : {
1019 4091017 : while (__x != 0)
1020 3775593 : if (!_M_impl._M_key_compare(_S_key(__x), __k))
1021 208064 : __y = __x, __x = _S_left(__x);
1022 : else
1023 3567529 : __x = _S_right(__x);
1024 157712 : return const_iterator(__y);
1025 : }
1026 :
1027 : template<typename _Key, typename _Val, typename _KeyOfValue,
1028 : typename _Compare, typename _Alloc>
1029 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
1030 : _Compare, _Alloc>::iterator
1031 0 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1032 : _M_upper_bound(_Link_type __x, _Link_type __y,
1033 : const _Key& __k)
1034 : {
1035 0 : while (__x != 0)
1036 0 : if (_M_impl._M_key_compare(__k, _S_key(__x)))
1037 0 : __y = __x, __x = _S_left(__x);
1038 : else
1039 0 : __x = _S_right(__x);
1040 0 : return iterator(__y);
1041 : }
1042 :
1043 : template<typename _Key, typename _Val, typename _KeyOfValue,
1044 : typename _Compare, typename _Alloc>
1045 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
1046 : _Compare, _Alloc>::const_iterator
1047 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1048 : _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
1049 : const _Key& __k) const
1050 : {
1051 : while (__x != 0)
1052 : if (_M_impl._M_key_compare(__k, _S_key(__x)))
1053 : __y = __x, __x = _S_left(__x);
1054 : else
1055 : __x = _S_right(__x);
1056 : return const_iterator(__y);
1057 : }
1058 :
1059 : template<typename _Key, typename _Val, typename _KeyOfValue,
1060 : typename _Compare, typename _Alloc>
1061 : pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
1062 : _Compare, _Alloc>::iterator,
1063 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
1064 : _Compare, _Alloc>::iterator>
1065 0 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1066 : equal_range(const _Key& __k)
1067 : {
1068 0 : _Link_type __x = _M_begin();
1069 0 : _Link_type __y = _M_end();
1070 0 : while (__x != 0)
1071 : {
1072 0 : if (_M_impl._M_key_compare(_S_key(__x), __k))
1073 0 : __x = _S_right(__x);
1074 0 : else if (_M_impl._M_key_compare(__k, _S_key(__x)))
1075 0 : __y = __x, __x = _S_left(__x);
1076 : else
1077 : {
1078 0 : _Link_type __xu(__x), __yu(__y);
1079 0 : __y = __x, __x = _S_left(__x);
1080 0 : __xu = _S_right(__xu);
1081 : return pair<iterator,
1082 : iterator>(_M_lower_bound(__x, __y, __k),
1083 0 : _M_upper_bound(__xu, __yu, __k));
1084 : }
1085 : }
1086 : return pair<iterator, iterator>(iterator(__y),
1087 0 : iterator(__y));
1088 : }
1089 :
1090 : template<typename _Key, typename _Val, typename _KeyOfValue,
1091 : typename _Compare, typename _Alloc>
1092 : pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
1093 : _Compare, _Alloc>::const_iterator,
1094 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
1095 : _Compare, _Alloc>::const_iterator>
1096 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1097 : equal_range(const _Key& __k) const
1098 : {
1099 : _Const_Link_type __x = _M_begin();
1100 : _Const_Link_type __y = _M_end();
1101 : while (__x != 0)
1102 : {
1103 : if (_M_impl._M_key_compare(_S_key(__x), __k))
1104 : __x = _S_right(__x);
1105 : else if (_M_impl._M_key_compare(__k, _S_key(__x)))
1106 : __y = __x, __x = _S_left(__x);
1107 : else
1108 : {
1109 : _Const_Link_type __xu(__x), __yu(__y);
1110 : __y = __x, __x = _S_left(__x);
1111 : __xu = _S_right(__xu);
1112 : return pair<const_iterator,
1113 : const_iterator>(_M_lower_bound(__x, __y, __k),
1114 : _M_upper_bound(__xu, __yu, __k));
1115 : }
1116 : }
1117 : return pair<const_iterator, const_iterator>(const_iterator(__y),
1118 : const_iterator(__y));
1119 : }
1120 :
1121 : template<typename _Key, typename _Val, typename _KeyOfValue,
1122 : typename _Compare, typename _Alloc>
1123 : void
1124 0 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1125 : swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
1126 : {
1127 0 : if (_M_root() == 0)
1128 : {
1129 0 : if (__t._M_root() != 0)
1130 : {
1131 0 : _M_root() = __t._M_root();
1132 0 : _M_leftmost() = __t._M_leftmost();
1133 0 : _M_rightmost() = __t._M_rightmost();
1134 0 : _M_root()->_M_parent = _M_end();
1135 :
1136 0 : __t._M_root() = 0;
1137 0 : __t._M_leftmost() = __t._M_end();
1138 0 : __t._M_rightmost() = __t._M_end();
1139 : }
1140 : }
1141 0 : else if (__t._M_root() == 0)
1142 : {
1143 0 : __t._M_root() = _M_root();
1144 0 : __t._M_leftmost() = _M_leftmost();
1145 0 : __t._M_rightmost() = _M_rightmost();
1146 0 : __t._M_root()->_M_parent = __t._M_end();
1147 :
1148 0 : _M_root() = 0;
1149 0 : _M_leftmost() = _M_end();
1150 0 : _M_rightmost() = _M_end();
1151 : }
1152 : else
1153 : {
1154 0 : std::swap(_M_root(),__t._M_root());
1155 0 : std::swap(_M_leftmost(),__t._M_leftmost());
1156 0 : std::swap(_M_rightmost(),__t._M_rightmost());
1157 :
1158 0 : _M_root()->_M_parent = _M_end();
1159 0 : __t._M_root()->_M_parent = __t._M_end();
1160 : }
1161 : // No need to swap header's color as it does not change.
1162 0 : std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
1163 0 : std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
1164 :
1165 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1166 : // 431. Swapping containers with unequal allocators.
1167 0 : std::__alloc_swap<_Node_allocator>::
1168 : _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
1169 0 : }
1170 :
1171 : template<typename _Key, typename _Val, typename _KeyOfValue,
1172 : typename _Compare, typename _Alloc>
1173 : pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
1174 : _Compare, _Alloc>::iterator, bool>
1175 18261027 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1176 : _M_insert_unique(const _Val& __v)
1177 : {
1178 18261027 : _Link_type __x = _M_begin();
1179 18261027 : _Link_type __y = _M_end();
1180 18261027 : bool __comp = true;
1181 170599056 : while (__x != 0)
1182 : {
1183 134077002 : __y = __x;
1184 134077002 : __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
1185 134077002 : __x = __comp ? _S_left(__x) : _S_right(__x);
1186 : }
1187 18261027 : iterator __j = iterator(__y);
1188 18261027 : if (__comp)
1189 : {
1190 11787863 : if (__j == begin())
1191 4785914 : return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
1192 : else
1193 7001949 : --__j;
1194 : }
1195 13475113 : if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
1196 501663 : return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
1197 12973450 : return pair<iterator, bool>(__j, false);
1198 : }
1199 :
1200 : template<typename _Key, typename _Val, typename _KeyOfValue,
1201 : typename _Compare, typename _Alloc>
1202 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
1203 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1204 : _M_insert_equal(const _Val& __v)
1205 : {
1206 : _Link_type __x = _M_begin();
1207 : _Link_type __y = _M_end();
1208 : while (__x != 0)
1209 : {
1210 : __y = __x;
1211 : __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
1212 : _S_left(__x) : _S_right(__x);
1213 : }
1214 : return _M_insert_(__x, __y, __v);
1215 : }
1216 :
1217 : template<typename _Key, typename _Val, typename _KeyOfValue,
1218 : typename _Compare, typename _Alloc>
1219 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
1220 16258635 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1221 : _M_insert_unique_(const_iterator __position, const _Val& __v)
1222 : {
1223 : // end()
1224 16258635 : if (__position._M_node == _M_end())
1225 : {
1226 14769591 : if (size() > 0
1227 : && _M_impl._M_key_compare(_S_key(_M_rightmost()),
1228 : _KeyOfValue()(__v)))
1229 9985533 : return _M_insert_(0, _M_rightmost(), __v);
1230 : else
1231 4784058 : return _M_insert_unique(__v).first;
1232 : }
1233 1489044 : else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
1234 : _S_key(__position._M_node)))
1235 : {
1236 : // First, try before...
1237 1489044 : const_iterator __before = __position;
1238 1489044 : if (__position._M_node == _M_leftmost()) // begin()
1239 1381401 : return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
1240 107643 : else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
1241 : _KeyOfValue()(__v)))
1242 : {
1243 107643 : if (_S_right(__before._M_node) == 0)
1244 24688 : return _M_insert_(0, __before._M_node, __v);
1245 : else
1246 : return _M_insert_(__position._M_node,
1247 82955 : __position._M_node, __v);
1248 : }
1249 : else
1250 0 : return _M_insert_unique(__v).first;
1251 : }
1252 0 : else if (_M_impl._M_key_compare(_S_key(__position._M_node),
1253 : _KeyOfValue()(__v)))
1254 : {
1255 : // ... then try after.
1256 0 : const_iterator __after = __position;
1257 0 : if (__position._M_node == _M_rightmost())
1258 0 : return _M_insert_(0, _M_rightmost(), __v);
1259 0 : else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
1260 : _S_key((++__after)._M_node)))
1261 : {
1262 0 : if (_S_right(__position._M_node) == 0)
1263 0 : return _M_insert_(0, __position._M_node, __v);
1264 : else
1265 0 : return _M_insert_(__after._M_node, __after._M_node, __v);
1266 : }
1267 : else
1268 0 : return _M_insert_unique(__v).first;
1269 : }
1270 : else
1271 : // Equivalent keys.
1272 : return iterator(static_cast<_Link_type>
1273 0 : (const_cast<_Base_ptr>(__position._M_node)));
1274 : }
1275 :
1276 : template<typename _Key, typename _Val, typename _KeyOfValue,
1277 : typename _Compare, typename _Alloc>
1278 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
1279 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1280 : _M_insert_equal_(const_iterator __position, const _Val& __v)
1281 : {
1282 : // end()
1283 : if (__position._M_node == _M_end())
1284 : {
1285 : if (size() > 0
1286 : && !_M_impl._M_key_compare(_KeyOfValue()(__v),
1287 : _S_key(_M_rightmost())))
1288 : return _M_insert_(0, _M_rightmost(), __v);
1289 : else
1290 : return _M_insert_equal(__v);
1291 : }
1292 : else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
1293 : _KeyOfValue()(__v)))
1294 : {
1295 : // First, try before...
1296 : const_iterator __before = __position;
1297 : if (__position._M_node == _M_leftmost()) // begin()
1298 : return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
1299 : else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
1300 : _S_key((--__before)._M_node)))
1301 : {
1302 : if (_S_right(__before._M_node) == 0)
1303 : return _M_insert_(0, __before._M_node, __v);
1304 : else
1305 : return _M_insert_(__position._M_node,
1306 : __position._M_node, __v);
1307 : }
1308 : else
1309 : return _M_insert_equal(__v);
1310 : }
1311 : else
1312 : {
1313 : // ... then try after.
1314 : const_iterator __after = __position;
1315 : if (__position._M_node == _M_rightmost())
1316 : return _M_insert_(0, _M_rightmost(), __v);
1317 : else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
1318 : _KeyOfValue()(__v)))
1319 : {
1320 : if (_S_right(__position._M_node) == 0)
1321 : return _M_insert_(0, __position._M_node, __v);
1322 : else
1323 : return _M_insert_(__after._M_node, __after._M_node, __v);
1324 : }
1325 : else
1326 : return _M_insert_equal_lower(__v);
1327 : }
1328 : }
1329 :
1330 : template<typename _Key, typename _Val, typename _KoV,
1331 : typename _Cmp, typename _Alloc>
1332 : template<class _II>
1333 : void
1334 : _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
1335 : _M_insert_unique(_II __first, _II __last)
1336 : {
1337 : for (; __first != __last; ++__first)
1338 : _M_insert_unique_(end(), *__first);
1339 : }
1340 :
1341 : template<typename _Key, typename _Val, typename _KoV,
1342 : typename _Cmp, typename _Alloc>
1343 : template<class _II>
1344 : void
1345 : _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
1346 : _M_insert_equal(_II __first, _II __last)
1347 : {
1348 : for (; __first != __last; ++__first)
1349 : _M_insert_equal_(end(), *__first);
1350 : }
1351 :
1352 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
1353 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1354 : // DR 130. Associative erase should return an iterator.
1355 : template<typename _Key, typename _Val, typename _KeyOfValue,
1356 : typename _Compare, typename _Alloc>
1357 : inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
1358 0 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1359 : erase(iterator __position)
1360 : {
1361 0 : iterator __result = __position;
1362 0 : ++__result;
1363 : _Link_type __y =
1364 : static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
1365 : (__position._M_node,
1366 0 : this->_M_impl._M_header));
1367 0 : _M_destroy_node(__y);
1368 0 : --_M_impl._M_node_count;
1369 : return __result;
1370 : }
1371 :
1372 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1373 : // DR 130. Associative erase should return an iterator.
1374 : template<typename _Key, typename _Val, typename _KeyOfValue,
1375 : typename _Compare, typename _Alloc>
1376 : inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
1377 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1378 : erase(const_iterator __position)
1379 : {
1380 : const_iterator __result = __position;
1381 : ++__result;
1382 : _Link_type __y =
1383 : static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
1384 : (const_cast<_Base_ptr>(__position._M_node),
1385 : this->_M_impl._M_header));
1386 : _M_destroy_node(__y);
1387 : --_M_impl._M_node_count;
1388 : return __result;
1389 : }
1390 : #else
1391 : template<typename _Key, typename _Val, typename _KeyOfValue,
1392 : typename _Compare, typename _Alloc>
1393 : inline void
1394 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1395 : erase(iterator __position)
1396 : {
1397 : _Link_type __y =
1398 : static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
1399 : (__position._M_node,
1400 : this->_M_impl._M_header));
1401 : _M_destroy_node(__y);
1402 : --_M_impl._M_node_count;
1403 : }
1404 :
1405 : template<typename _Key, typename _Val, typename _KeyOfValue,
1406 : typename _Compare, typename _Alloc>
1407 : inline void
1408 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1409 : erase(const_iterator __position)
1410 : {
1411 : _Link_type __y =
1412 : static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
1413 : (const_cast<_Base_ptr>(__position._M_node),
1414 : this->_M_impl._M_header));
1415 : _M_destroy_node(__y);
1416 : --_M_impl._M_node_count;
1417 : }
1418 : #endif
1419 :
1420 : template<typename _Key, typename _Val, typename _KeyOfValue,
1421 : typename _Compare, typename _Alloc>
1422 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
1423 0 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1424 : erase(const _Key& __x)
1425 : {
1426 0 : pair<iterator, iterator> __p = equal_range(__x);
1427 0 : const size_type __old_size = size();
1428 0 : erase(__p.first, __p.second);
1429 0 : return __old_size - size();
1430 : }
1431 :
1432 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
1433 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1434 : // DR 130. Associative erase should return an iterator.
1435 : template<typename _Key, typename _Val, typename _KeyOfValue,
1436 : typename _Compare, typename _Alloc>
1437 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
1438 0 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1439 : erase(iterator __first, iterator __last)
1440 : {
1441 0 : if (__first == begin() && __last == end())
1442 : {
1443 0 : clear();
1444 0 : return end();
1445 : }
1446 : else
1447 : {
1448 0 : while (__first != __last)
1449 0 : erase(__first++);
1450 0 : return __last;
1451 : }
1452 : }
1453 :
1454 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1455 : // DR 130. Associative erase should return an iterator.
1456 : template<typename _Key, typename _Val, typename _KeyOfValue,
1457 : typename _Compare, typename _Alloc>
1458 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
1459 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1460 : erase(const_iterator __first, const_iterator __last)
1461 : {
1462 : if (__first == begin() && __last == end())
1463 : {
1464 : clear();
1465 : return end();
1466 : }
1467 : else
1468 : {
1469 : while (__first != __last)
1470 : erase(__first++);
1471 : return __last;
1472 : }
1473 : }
1474 : #else
1475 : template<typename _Key, typename _Val, typename _KeyOfValue,
1476 : typename _Compare, typename _Alloc>
1477 : void
1478 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1479 : erase(iterator __first, iterator __last)
1480 : {
1481 : if (__first == begin() && __last == end())
1482 : clear();
1483 : else
1484 : while (__first != __last)
1485 : erase(__first++);
1486 : }
1487 :
1488 : template<typename _Key, typename _Val, typename _KeyOfValue,
1489 : typename _Compare, typename _Alloc>
1490 : void
1491 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1492 : erase(const_iterator __first, const_iterator __last)
1493 : {
1494 : if (__first == begin() && __last == end())
1495 : clear();
1496 : else
1497 : while (__first != __last)
1498 : erase(__first++);
1499 : }
1500 : #endif
1501 :
1502 : template<typename _Key, typename _Val, typename _KeyOfValue,
1503 : typename _Compare, typename _Alloc>
1504 : void
1505 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1506 : erase(const _Key* __first, const _Key* __last)
1507 : {
1508 : while (__first != __last)
1509 : erase(*__first++);
1510 : }
1511 :
1512 : template<typename _Key, typename _Val, typename _KeyOfValue,
1513 : typename _Compare, typename _Alloc>
1514 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
1515 : _Compare, _Alloc>::iterator
1516 1103662 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1517 : find(const _Key& __k)
1518 : {
1519 1103662 : iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
1520 : return (__j == end()
1521 : || _M_impl._M_key_compare(__k,
1522 1103662 : _S_key(__j._M_node))) ? end() : __j;
1523 : }
1524 :
1525 : template<typename _Key, typename _Val, typename _KeyOfValue,
1526 : typename _Compare, typename _Alloc>
1527 : typename _Rb_tree<_Key, _Val, _KeyOfValue,
1528 : _Compare, _Alloc>::const_iterator
1529 157712 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1530 : find(const _Key& __k) const
1531 : {
1532 157712 : const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
1533 : return (__j == end()
1534 : || _M_impl._M_key_compare(__k,
1535 157712 : _S_key(__j._M_node))) ? end() : __j;
1536 : }
1537 :
1538 : template<typename _Key, typename _Val, typename _KeyOfValue,
1539 : typename _Compare, typename _Alloc>
1540 : typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
1541 : _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
1542 : count(const _Key& __k) const
1543 : {
1544 : pair<const_iterator, const_iterator> __p = equal_range(__k);
1545 : const size_type __n = std::distance(__p.first, __p.second);
1546 : return __n;
1547 : }
1548 :
1549 : _GLIBCXX_PURE unsigned int
1550 : _Rb_tree_black_count(const _Rb_tree_node_base* __node,
1551 : const _Rb_tree_node_base* __root) throw ();
1552 :
1553 : template<typename _Key, typename _Val, typename _KeyOfValue,
1554 : typename _Compare, typename _Alloc>
1555 : bool
1556 : _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
1557 : {
1558 : if (_M_impl._M_node_count == 0 || begin() == end())
1559 : return _M_impl._M_node_count == 0 && begin() == end()
1560 : && this->_M_impl._M_header._M_left == _M_end()
1561 : && this->_M_impl._M_header._M_right == _M_end();
1562 :
1563 : unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
1564 : for (const_iterator __it = begin(); __it != end(); ++__it)
1565 : {
1566 : _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
1567 : _Const_Link_type __L = _S_left(__x);
1568 : _Const_Link_type __R = _S_right(__x);
1569 :
1570 : if (__x->_M_color == _S_red)
1571 : if ((__L && __L->_M_color == _S_red)
1572 : || (__R && __R->_M_color == _S_red))
1573 : return false;
1574 :
1575 : if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
1576 : return false;
1577 : if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
1578 : return false;
1579 :
1580 : if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
1581 : return false;
1582 : }
1583 :
1584 : if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
1585 : return false;
1586 : if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
1587 : return false;
1588 : return true;
1589 : }
1590 :
1591 : _GLIBCXX_END_NAMESPACE
1592 :
1593 : #endif
|