1// Debugging list implementation -*- C++ -*- 2 3// Copyright (C) 2003-2015 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/** @file debug/list 26 * This file is a GNU debug extension to the Standard C++ Library. 27 */ 28 29#ifndef _GLIBCXX_DEBUG_LIST 30#define _GLIBCXX_DEBUG_LIST 1 31 32#include <list> 33#include <debug/safe_sequence.h> 34#include <debug/safe_container.h> 35#include <debug/safe_iterator.h> 36 37namespace std _GLIBCXX_VISIBILITY(default) 38{ 39namespace __debug 40{ 41 /// Class std::list with safety/checking/debug instrumentation. 42 template<typename _Tp, typename _Allocator = std::allocator<_Tp> > 43 class list 44 : public __gnu_debug::_Safe_container< 45 list<_Tp, _Allocator>, _Allocator, 46 __gnu_debug::_Safe_node_sequence, false>, 47 public _GLIBCXX_STD_C::list<_Tp, _Allocator> 48 { 49 typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base; 50 typedef __gnu_debug::_Safe_container< 51 list, _Allocator, __gnu_debug::_Safe_node_sequence, false> _Safe; 52 53 typedef typename _Base::iterator _Base_iterator; 54 typedef typename _Base::const_iterator _Base_const_iterator; 55 typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; 56 typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; 57 58 public: 59 typedef typename _Base::reference reference; 60 typedef typename _Base::const_reference const_reference; 61 62 typedef __gnu_debug::_Safe_iterator<_Base_iterator, list> 63 iterator; 64 typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, list> 65 const_iterator; 66 67 typedef typename _Base::size_type size_type; 68 typedef typename _Base::difference_type difference_type; 69 70 typedef _Tp value_type; 71 typedef _Allocator allocator_type; 72 typedef typename _Base::pointer pointer; 73 typedef typename _Base::const_pointer const_pointer; 74 typedef std::reverse_iterator<iterator> reverse_iterator; 75 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 76 77 // 23.2.2.1 construct/copy/destroy: 78 79#if __cplusplus < 201103L 80 list() 81 : _Base() { } 82 83 list(const list& __x) 84 : _Base(__x) { } 85 86 ~list() { } 87#else 88 list() = default; 89 list(const list&) = default; 90 list(list&&) = default; 91 92 list(initializer_list<value_type> __l, 93 const allocator_type& __a = allocator_type()) 94 : _Base(__l, __a) { } 95 96 ~list() = default; 97#endif 98 99 explicit 100 list(const _Allocator& __a) _GLIBCXX_NOEXCEPT 101 : _Base(__a) { } 102 103#if __cplusplus >= 201103L 104 explicit 105 list(size_type __n) 106 : _Base(__n) { } 107 108 list(size_type __n, const _Tp& __value, 109 const _Allocator& __a = _Allocator()) 110 : _Base(__n, __value, __a) { } 111#else 112 explicit 113 list(size_type __n, const _Tp& __value = _Tp(), 114 const _Allocator& __a = _Allocator()) 115 : _Base(__n, __value, __a) { } 116#endif 117 118#if __cplusplus >= 201103L 119 template<class _InputIterator, 120 typename = std::_RequireInputIter<_InputIterator>> 121#else 122 template<class _InputIterator> 123#endif 124 list(_InputIterator __first, _InputIterator __last, 125 const _Allocator& __a = _Allocator()) 126 : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, 127 __last)), 128 __gnu_debug::__base(__last), __a) 129 { } 130 131 list(const _Base& __x) 132 : _Base(__x) { } 133 134#if __cplusplus < 201103L 135 list& 136 operator=(const list& __x) 137 { 138 this->_M_safe() = __x; 139 _M_base() = __x; 140 return *this; 141 } 142#else 143 list& 144 operator=(const list&) = default; 145 146 list& 147 operator=(list&&) = default; 148 149 list& 150 operator=(initializer_list<value_type> __l) 151 { 152 this->_M_invalidate_all(); 153 _M_base() = __l; 154 return *this; 155 } 156 157 void 158 assign(initializer_list<value_type> __l) 159 { 160 _Base::assign(__l); 161 this->_M_invalidate_all(); 162 } 163#endif 164 165#if __cplusplus >= 201103L 166 template<class _InputIterator, 167 typename = std::_RequireInputIter<_InputIterator>> 168#else 169 template<class _InputIterator> 170#endif 171 void 172 assign(_InputIterator __first, _InputIterator __last) 173 { 174 __glibcxx_check_valid_range(__first, __last); 175 _Base::assign(__gnu_debug::__base(__first), 176 __gnu_debug::__base(__last)); 177 this->_M_invalidate_all(); 178 } 179 180 void 181 assign(size_type __n, const _Tp& __t) 182 { 183 _Base::assign(__n, __t); 184 this->_M_invalidate_all(); 185 } 186 187 using _Base::get_allocator; 188 189 // iterators: 190 iterator 191 begin() _GLIBCXX_NOEXCEPT 192 { return iterator(_Base::begin(), this); } 193 194 const_iterator 195 begin() const _GLIBCXX_NOEXCEPT 196 { return const_iterator(_Base::begin(), this); } 197 198 iterator 199 end() _GLIBCXX_NOEXCEPT 200 { return iterator(_Base::end(), this); } 201 202 const_iterator 203 end() const _GLIBCXX_NOEXCEPT 204 { return const_iterator(_Base::end(), this); } 205 206 reverse_iterator 207 rbegin() _GLIBCXX_NOEXCEPT 208 { return reverse_iterator(end()); } 209 210 const_reverse_iterator 211 rbegin() const _GLIBCXX_NOEXCEPT 212 { return const_reverse_iterator(end()); } 213 214 reverse_iterator 215 rend() _GLIBCXX_NOEXCEPT 216 { return reverse_iterator(begin()); } 217 218 const_reverse_iterator 219 rend() const _GLIBCXX_NOEXCEPT 220 { return const_reverse_iterator(begin()); } 221 222#if __cplusplus >= 201103L 223 const_iterator 224 cbegin() const noexcept 225 { return const_iterator(_Base::begin(), this); } 226 227 const_iterator 228 cend() const noexcept 229 { return const_iterator(_Base::end(), this); } 230 231 const_reverse_iterator 232 crbegin() const noexcept 233 { return const_reverse_iterator(end()); } 234 235 const_reverse_iterator 236 crend() const noexcept 237 { return const_reverse_iterator(begin()); } 238#endif 239 240 // 23.2.2.2 capacity: 241 using _Base::empty; 242 using _Base::size; 243 using _Base::max_size; 244 245#if __cplusplus >= 201103L 246 void 247 resize(size_type __sz) 248 { 249 this->_M_detach_singular(); 250 251 // if __sz < size(), invalidate all iterators in [begin + __sz, end()) 252 _Base_iterator __victim = _Base::begin(); 253 _Base_iterator __end = _Base::end(); 254 for (size_type __i = __sz; __victim != __end && __i > 0; --__i) 255 ++__victim; 256 257 for (; __victim != __end; ++__victim) 258 this->_M_invalidate_if(_Equal(__victim)); 259 260 __try 261 { 262 _Base::resize(__sz); 263 } 264 __catch(...) 265 { 266 this->_M_revalidate_singular(); 267 __throw_exception_again; 268 } 269 } 270 271 void 272 resize(size_type __sz, const _Tp& __c) 273 { 274 this->_M_detach_singular(); 275 276 // if __sz < size(), invalidate all iterators in [begin + __sz, end()) 277 _Base_iterator __victim = _Base::begin(); 278 _Base_iterator __end = _Base::end(); 279 for (size_type __i = __sz; __victim != __end && __i > 0; --__i) 280 ++__victim; 281 282 for (; __victim != __end; ++__victim) 283 this->_M_invalidate_if(_Equal(__victim)); 284 285 __try 286 { 287 _Base::resize(__sz, __c); 288 } 289 __catch(...) 290 { 291 this->_M_revalidate_singular(); 292 __throw_exception_again; 293 } 294 } 295#else 296 void 297 resize(size_type __sz, _Tp __c = _Tp()) 298 { 299 this->_M_detach_singular(); 300 301 // if __sz < size(), invalidate all iterators in [begin + __sz, end()) 302 _Base_iterator __victim = _Base::begin(); 303 _Base_iterator __end = _Base::end(); 304 for (size_type __i = __sz; __victim != __end && __i > 0; --__i) 305 ++__victim; 306 307 for (; __victim != __end; ++__victim) 308 this->_M_invalidate_if(_Equal(__victim)); 309 310 __try 311 { 312 _Base::resize(__sz, __c); 313 } 314 __catch(...) 315 { 316 this->_M_revalidate_singular(); 317 __throw_exception_again; 318 } 319 } 320#endif 321 322 // element access: 323 reference 324 front() _GLIBCXX_NOEXCEPT 325 { 326 __glibcxx_check_nonempty(); 327 return _Base::front(); 328 } 329 330 const_reference 331 front() const _GLIBCXX_NOEXCEPT 332 { 333 __glibcxx_check_nonempty(); 334 return _Base::front(); 335 } 336 337 reference 338 back() _GLIBCXX_NOEXCEPT 339 { 340 __glibcxx_check_nonempty(); 341 return _Base::back(); 342 } 343 344 const_reference 345 back() const _GLIBCXX_NOEXCEPT 346 { 347 __glibcxx_check_nonempty(); 348 return _Base::back(); 349 } 350 351 // 23.2.2.3 modifiers: 352 using _Base::push_front; 353 354#if __cplusplus >= 201103L 355 using _Base::emplace_front; 356#endif 357 358 void 359 pop_front() _GLIBCXX_NOEXCEPT 360 { 361 __glibcxx_check_nonempty(); 362 this->_M_invalidate_if(_Equal(_Base::begin())); 363 _Base::pop_front(); 364 } 365 366 using _Base::push_back; 367 368#if __cplusplus >= 201103L 369 using _Base::emplace_back; 370#endif 371 372 void 373 pop_back() _GLIBCXX_NOEXCEPT 374 { 375 __glibcxx_check_nonempty(); 376 this->_M_invalidate_if(_Equal(--_Base::end())); 377 _Base::pop_back(); 378 } 379 380#if __cplusplus >= 201103L 381 template<typename... _Args> 382 iterator 383 emplace(const_iterator __position, _Args&&... __args) 384 { 385 __glibcxx_check_insert(__position); 386 return iterator(_Base::emplace(__position.base(), 387 std::forward<_Args>(__args)...), this); 388 } 389#endif 390 391 iterator 392#if __cplusplus >= 201103L 393 insert(const_iterator __position, const _Tp& __x) 394#else 395 insert(iterator __position, const _Tp& __x) 396#endif 397 { 398 __glibcxx_check_insert(__position); 399 return iterator(_Base::insert(__position.base(), __x), this); 400 } 401 402#if __cplusplus >= 201103L 403 iterator 404 insert(const_iterator __position, _Tp&& __x) 405 { return emplace(__position, std::move(__x)); } 406 407 iterator 408 insert(const_iterator __p, initializer_list<value_type> __l) 409 { 410 __glibcxx_check_insert(__p); 411 return iterator(_Base::insert(__p.base(), __l), this); 412 } 413#endif 414 415#if __cplusplus >= 201103L 416 iterator 417 insert(const_iterator __position, size_type __n, const _Tp& __x) 418 { 419 __glibcxx_check_insert(__position); 420 return iterator(_Base::insert(__position.base(), __n, __x), this); 421 } 422#else 423 void 424 insert(iterator __position, size_type __n, const _Tp& __x) 425 { 426 __glibcxx_check_insert(__position); 427 _Base::insert(__position.base(), __n, __x); 428 } 429#endif 430 431#if __cplusplus >= 201103L 432 template<class _InputIterator, 433 typename = std::_RequireInputIter<_InputIterator>> 434 iterator 435 insert(const_iterator __position, _InputIterator __first, 436 _InputIterator __last) 437 { 438 __glibcxx_check_insert_range(__position, __first, __last); 439 return iterator(_Base::insert(__position.base(), 440 __gnu_debug::__base(__first), 441 __gnu_debug::__base(__last)), 442 this); 443 } 444#else 445 template<class _InputIterator> 446 void 447 insert(iterator __position, _InputIterator __first, 448 _InputIterator __last) 449 { 450 __glibcxx_check_insert_range(__position, __first, __last); 451 _Base::insert(__position.base(), __gnu_debug::__base(__first), 452 __gnu_debug::__base(__last)); 453 } 454#endif 455 456 private: 457 _Base_iterator 458#if __cplusplus >= 201103L 459 _M_erase(_Base_const_iterator __position) noexcept 460#else 461 _M_erase(_Base_iterator __position) 462#endif 463 { 464 this->_M_invalidate_if(_Equal(__position)); 465 return _Base::erase(__position); 466 } 467 468 public: 469 iterator 470#if __cplusplus >= 201103L 471 erase(const_iterator __position) noexcept 472#else 473 erase(iterator __position) 474#endif 475 { 476 __glibcxx_check_erase(__position); 477 return iterator(_M_erase(__position.base()), this); 478 } 479 480 iterator 481#if __cplusplus >= 201103L 482 erase(const_iterator __first, const_iterator __last) noexcept 483#else 484 erase(iterator __first, iterator __last) 485#endif 486 { 487 // _GLIBCXX_RESOLVE_LIB_DEFECTS 488 // 151. can't currently clear() empty container 489 __glibcxx_check_erase_range(__first, __last); 490 for (_Base_const_iterator __victim = __first.base(); 491 __victim != __last.base(); ++__victim) 492 { 493 _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), 494 _M_message(__gnu_debug::__msg_valid_range) 495 ._M_iterator(__first, "position") 496 ._M_iterator(__last, "last")); 497 this->_M_invalidate_if(_Equal(__victim)); 498 } 499 return iterator(_Base::erase(__first.base(), __last.base()), this); 500 } 501 502 void 503 swap(list& __x) 504#if __cplusplus >= 201103L 505 noexcept( noexcept(declval<_Base>().swap(__x)) ) 506#endif 507 { 508 _Safe::_M_swap(__x); 509 _Base::swap(__x); 510 } 511 512 void 513 clear() _GLIBCXX_NOEXCEPT 514 { 515 _Base::clear(); 516 this->_M_invalidate_all(); 517 } 518 519 // 23.2.2.4 list operations: 520 void 521#if __cplusplus >= 201103L 522 splice(const_iterator __position, list&& __x) noexcept 523#else 524 splice(iterator __position, list& __x) 525#endif 526 { 527 _GLIBCXX_DEBUG_VERIFY(&__x != this, 528 _M_message(__gnu_debug::__msg_self_splice) 529 ._M_sequence(*this, "this")); 530 this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end())); 531 _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base())); 532 } 533 534#if __cplusplus >= 201103L 535 void 536 splice(const_iterator __position, list& __x) noexcept 537 { splice(__position, std::move(__x)); } 538#endif 539 540 void 541#if __cplusplus >= 201103L 542 splice(const_iterator __position, list&& __x, const_iterator __i) noexcept 543#else 544 splice(iterator __position, list& __x, iterator __i) 545#endif 546 { 547 __glibcxx_check_insert(__position); 548 549 // We used to perform the splice_alloc check: not anymore, redundant 550 // after implementing the relevant bits of N1599. 551 552 _GLIBCXX_DEBUG_VERIFY(__i._M_dereferenceable(), 553 _M_message(__gnu_debug::__msg_splice_bad) 554 ._M_iterator(__i, "__i")); 555 _GLIBCXX_DEBUG_VERIFY(__i._M_attached_to(&__x), 556 _M_message(__gnu_debug::__msg_splice_other) 557 ._M_iterator(__i, "__i")._M_sequence(__x, "__x")); 558 559 // _GLIBCXX_RESOLVE_LIB_DEFECTS 560 // 250. splicing invalidates iterators 561 this->_M_transfer_from_if(__x, _Equal(__i.base())); 562 _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()), 563 __i.base()); 564 } 565 566#if __cplusplus >= 201103L 567 void 568 splice(const_iterator __position, list& __x, const_iterator __i) noexcept 569 { splice(__position, std::move(__x), __i); } 570#endif 571 572 void 573#if __cplusplus >= 201103L 574 splice(const_iterator __position, list&& __x, const_iterator __first, 575 const_iterator __last) noexcept 576#else 577 splice(iterator __position, list& __x, iterator __first, 578 iterator __last) 579#endif 580 { 581 __glibcxx_check_insert(__position); 582 __glibcxx_check_valid_range(__first, __last); 583 _GLIBCXX_DEBUG_VERIFY(__first._M_attached_to(&__x), 584 _M_message(__gnu_debug::__msg_splice_other) 585 ._M_sequence(__x, "x") 586 ._M_iterator(__first, "first")); 587 588 // We used to perform the splice_alloc check: not anymore, redundant 589 // after implementing the relevant bits of N1599. 590 591 for (_Base_const_iterator __tmp = __first.base(); 592 __tmp != __last.base(); ++__tmp) 593 { 594 _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(), 595 _M_message(__gnu_debug::__msg_valid_range) 596 ._M_iterator(__first, "first") 597 ._M_iterator(__last, "last")); 598 _GLIBCXX_DEBUG_VERIFY(&__x != this || __tmp != __position.base(), 599 _M_message(__gnu_debug::__msg_splice_overlap) 600 ._M_iterator(__tmp, "position") 601 ._M_iterator(__first, "first") 602 ._M_iterator(__last, "last")); 603 // _GLIBCXX_RESOLVE_LIB_DEFECTS 604 // 250. splicing invalidates iterators 605 this->_M_transfer_from_if(__x, _Equal(__tmp)); 606 } 607 608 _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()), 609 __first.base(), __last.base()); 610 } 611 612#if __cplusplus >= 201103L 613 void 614 splice(const_iterator __position, list& __x, 615 const_iterator __first, const_iterator __last) noexcept 616 { splice(__position, std::move(__x), __first, __last); } 617#endif 618 619 void 620 remove(const _Tp& __value) 621 { 622 for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); ) 623 { 624 if (*__x == __value) 625 __x = _M_erase(__x); 626 else 627 ++__x; 628 } 629 } 630 631 template<class _Predicate> 632 void 633 remove_if(_Predicate __pred) 634 { 635 for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); ) 636 { 637 if (__pred(*__x)) 638 __x = _M_erase(__x); 639 else 640 ++__x; 641 } 642 } 643 644 void 645 unique() 646 { 647 _Base_iterator __first = _Base::begin(); 648 _Base_iterator __last = _Base::end(); 649 if (__first == __last) 650 return; 651 _Base_iterator __next = __first; ++__next; 652 while (__next != __last) 653 { 654 if (*__first == *__next) 655 __next = _M_erase(__next); 656 else 657 __first = __next++; 658 } 659 } 660 661 template<class _BinaryPredicate> 662 void 663 unique(_BinaryPredicate __binary_pred) 664 { 665 _Base_iterator __first = _Base::begin(); 666 _Base_iterator __last = _Base::end(); 667 if (__first == __last) 668 return; 669 _Base_iterator __next = __first; ++__next; 670 while (__next != __last) 671 { 672 if (__binary_pred(*__first, *__next)) 673 __next = _M_erase(__next); 674 else 675 __first = __next++; 676 } 677 } 678 679 void 680#if __cplusplus >= 201103L 681 merge(list&& __x) 682#else 683 merge(list& __x) 684#endif 685 { 686 // _GLIBCXX_RESOLVE_LIB_DEFECTS 687 // 300. list::merge() specification incomplete 688 if (this != &__x) 689 { 690 __glibcxx_check_sorted(_Base::begin(), _Base::end()); 691 __glibcxx_check_sorted(__x.begin().base(), __x.end().base()); 692 this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end())); 693 _Base::merge(_GLIBCXX_MOVE(__x._M_base())); 694 } 695 } 696 697#if __cplusplus >= 201103L 698 void 699 merge(list& __x) 700 { merge(std::move(__x)); } 701#endif 702 703 template<class _Compare> 704 void 705#if __cplusplus >= 201103L 706 merge(list&& __x, _Compare __comp) 707#else 708 merge(list& __x, _Compare __comp) 709#endif 710 { 711 // _GLIBCXX_RESOLVE_LIB_DEFECTS 712 // 300. list::merge() specification incomplete 713 if (this != &__x) 714 { 715 __glibcxx_check_sorted_pred(_Base::begin(), _Base::end(), 716 __comp); 717 __glibcxx_check_sorted_pred(__x.begin().base(), __x.end().base(), 718 __comp); 719 this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end())); 720 _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); 721 } 722 } 723 724#if __cplusplus >= 201103L 725 template<typename _Compare> 726 void 727 merge(list& __x, _Compare __comp) 728 { merge(std::move(__x), __comp); } 729#endif 730 731 void 732 sort() { _Base::sort(); } 733 734 template<typename _StrictWeakOrdering> 735 void 736 sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); } 737 738 using _Base::reverse; 739 740 _Base& 741 _M_base() _GLIBCXX_NOEXCEPT { return *this; } 742 743 const _Base& 744 _M_base() const _GLIBCXX_NOEXCEPT { return *this; } 745 }; 746 747 template<typename _Tp, typename _Alloc> 748 inline bool 749 operator==(const list<_Tp, _Alloc>& __lhs, 750 const list<_Tp, _Alloc>& __rhs) 751 { return __lhs._M_base() == __rhs._M_base(); } 752 753 template<typename _Tp, typename _Alloc> 754 inline bool 755 operator!=(const list<_Tp, _Alloc>& __lhs, 756 const list<_Tp, _Alloc>& __rhs) 757 { return __lhs._M_base() != __rhs._M_base(); } 758 759 template<typename _Tp, typename _Alloc> 760 inline bool 761 operator<(const list<_Tp, _Alloc>& __lhs, 762 const list<_Tp, _Alloc>& __rhs) 763 { return __lhs._M_base() < __rhs._M_base(); } 764 765 template<typename _Tp, typename _Alloc> 766 inline bool 767 operator<=(const list<_Tp, _Alloc>& __lhs, 768 const list<_Tp, _Alloc>& __rhs) 769 { return __lhs._M_base() <= __rhs._M_base(); } 770 771 template<typename _Tp, typename _Alloc> 772 inline bool 773 operator>=(const list<_Tp, _Alloc>& __lhs, 774 const list<_Tp, _Alloc>& __rhs) 775 { return __lhs._M_base() >= __rhs._M_base(); } 776 777 template<typename _Tp, typename _Alloc> 778 inline bool 779 operator>(const list<_Tp, _Alloc>& __lhs, 780 const list<_Tp, _Alloc>& __rhs) 781 { return __lhs._M_base() > __rhs._M_base(); } 782 783 template<typename _Tp, typename _Alloc> 784 inline void 785 swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs) 786 { __lhs.swap(__rhs); } 787 788} // namespace __debug 789} // namespace std 790 791#ifndef _GLIBCXX_DEBUG_PEDANTIC 792namespace __gnu_debug 793{ 794 template<class _Tp, class _Alloc> 795 struct _Insert_range_from_self_is_safe<std::__debug::list<_Tp, _Alloc> > 796 { enum { __value = 1 }; }; 797} 798#endif 799 800#endif 801