vector revision 249998
1// -*- C++ -*- 2//===------------------------------ vector --------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_VECTOR 12#define _LIBCPP_VECTOR 13 14/* 15 vector synopsis 16 17namespace std 18{ 19 20template <class T, class Allocator = allocator<T> > 21class vector 22{ 23public: 24 typedef T value_type; 25 typedef Allocator allocator_type; 26 typedef typename allocator_type::reference reference; 27 typedef typename allocator_type::const_reference const_reference; 28 typedef implementation-defined iterator; 29 typedef implementation-defined const_iterator; 30 typedef typename allocator_type::size_type size_type; 31 typedef typename allocator_type::difference_type difference_type; 32 typedef typename allocator_type::pointer pointer; 33 typedef typename allocator_type::const_pointer const_pointer; 34 typedef std::reverse_iterator<iterator> reverse_iterator; 35 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 36 37 vector() 38 noexcept(is_nothrow_default_constructible<allocator_type>::value); 39 explicit vector(const allocator_type&); 40 explicit vector(size_type n); 41 vector(size_type n, const value_type& value, const allocator_type& = allocator_type()); 42 template <class InputIterator> 43 vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type()); 44 vector(const vector& x); 45 vector(vector&& x) 46 noexcept(is_nothrow_move_constructible<allocator_type>::value); 47 vector(initializer_list<value_type> il); 48 vector(initializer_list<value_type> il, const allocator_type& a); 49 ~vector(); 50 vector& operator=(const vector& x); 51 vector& operator=(vector&& x) 52 noexcept( 53 allocator_type::propagate_on_container_move_assignment::value && 54 is_nothrow_move_assignable<allocator_type>::value); 55 vector& operator=(initializer_list<value_type> il); 56 template <class InputIterator> 57 void assign(InputIterator first, InputIterator last); 58 void assign(size_type n, const value_type& u); 59 void assign(initializer_list<value_type> il); 60 61 allocator_type get_allocator() const noexcept; 62 63 iterator begin() noexcept; 64 const_iterator begin() const noexcept; 65 iterator end() noexcept; 66 const_iterator end() const noexcept; 67 68 reverse_iterator rbegin() noexcept; 69 const_reverse_iterator rbegin() const noexcept; 70 reverse_iterator rend() noexcept; 71 const_reverse_iterator rend() const noexcept; 72 73 const_iterator cbegin() const noexcept; 74 const_iterator cend() const noexcept; 75 const_reverse_iterator crbegin() const noexcept; 76 const_reverse_iterator crend() const noexcept; 77 78 size_type size() const noexcept; 79 size_type max_size() const noexcept; 80 size_type capacity() const noexcept; 81 bool empty() const noexcept; 82 void reserve(size_type n); 83 void shrink_to_fit() noexcept; 84 85 reference operator[](size_type n); 86 const_reference operator[](size_type n) const; 87 reference at(size_type n); 88 const_reference at(size_type n) const; 89 90 reference front(); 91 const_reference front() const; 92 reference back(); 93 const_reference back() const; 94 95 value_type* data() noexcept; 96 const value_type* data() const noexcept; 97 98 void push_back(const value_type& x); 99 void push_back(value_type&& x); 100 template <class... Args> 101 void emplace_back(Args&&... args); 102 void pop_back(); 103 104 template <class... Args> iterator emplace(const_iterator position, Args&&... args); 105 iterator insert(const_iterator position, const value_type& x); 106 iterator insert(const_iterator position, value_type&& x); 107 iterator insert(const_iterator position, size_type n, const value_type& x); 108 template <class InputIterator> 109 iterator insert(const_iterator position, InputIterator first, InputIterator last); 110 iterator insert(const_iterator position, initializer_list<value_type> il); 111 112 iterator erase(const_iterator position); 113 iterator erase(const_iterator first, const_iterator last); 114 115 void clear() noexcept; 116 117 void resize(size_type sz); 118 void resize(size_type sz, const value_type& c); 119 120 void swap(vector&) 121 noexcept(!allocator_type::propagate_on_container_swap::value || 122 __is_nothrow_swappable<allocator_type>::value); 123 124 bool __invariants() const; 125}; 126 127template <class Allocator = allocator<T> > 128class vector<bool, Allocator> 129{ 130public: 131 typedef bool value_type; 132 typedef Allocator allocator_type; 133 typedef implementation-defined iterator; 134 typedef implementation-defined const_iterator; 135 typedef typename allocator_type::size_type size_type; 136 typedef typename allocator_type::difference_type difference_type; 137 typedef iterator pointer; 138 typedef const_iterator const_pointer; 139 typedef std::reverse_iterator<iterator> reverse_iterator; 140 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 141 142 class reference 143 { 144 public: 145 reference(const reference&) noexcept; 146 operator bool() const noexcept; 147 reference& operator=(const bool x) noexcept; 148 reference& operator=(const reference& x) noexcept; 149 iterator operator&() const noexcept; 150 void flip() noexcept; 151 }; 152 153 class const_reference 154 { 155 public: 156 const_reference(const reference&) noexcept; 157 operator bool() const noexcept; 158 const_iterator operator&() const noexcept; 159 }; 160 161 vector() 162 noexcept(is_nothrow_default_constructible<allocator_type>::value); 163 explicit vector(const allocator_type&); 164 explicit vector(size_type n, const value_type& value = value_type(), const allocator_type& = allocator_type()); 165 template <class InputIterator> 166 vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type()); 167 vector(const vector& x); 168 vector(vector&& x) 169 noexcept(is_nothrow_move_constructible<allocator_type>::value); 170 vector(initializer_list<value_type> il); 171 vector(initializer_list<value_type> il, const allocator_type& a); 172 ~vector(); 173 vector& operator=(const vector& x); 174 vector& operator=(vector&& x) 175 noexcept( 176 allocator_type::propagate_on_container_move_assignment::value && 177 is_nothrow_move_assignable<allocator_type>::value); 178 vector& operator=(initializer_list<value_type> il); 179 template <class InputIterator> 180 void assign(InputIterator first, InputIterator last); 181 void assign(size_type n, const value_type& u); 182 void assign(initializer_list<value_type> il); 183 184 allocator_type get_allocator() const noexcept; 185 186 iterator begin() noexcept; 187 const_iterator begin() const noexcept; 188 iterator end() noexcept; 189 const_iterator end() const noexcept; 190 191 reverse_iterator rbegin() noexcept; 192 const_reverse_iterator rbegin() const noexcept; 193 reverse_iterator rend() noexcept; 194 const_reverse_iterator rend() const noexcept; 195 196 const_iterator cbegin() const noexcept; 197 const_iterator cend() const noexcept; 198 const_reverse_iterator crbegin() const noexcept; 199 const_reverse_iterator crend() const noexcept; 200 201 size_type size() const noexcept; 202 size_type max_size() const noexcept; 203 size_type capacity() const noexcept; 204 bool empty() const noexcept; 205 void reserve(size_type n); 206 void shrink_to_fit() noexcept; 207 208 reference operator[](size_type n); 209 const_reference operator[](size_type n) const; 210 reference at(size_type n); 211 const_reference at(size_type n) const; 212 213 reference front(); 214 const_reference front() const; 215 reference back(); 216 const_reference back() const; 217 218 void push_back(const value_type& x); 219 void pop_back(); 220 221 iterator insert(const_iterator position, const value_type& x); 222 iterator insert(const_iterator position, size_type n, const value_type& x); 223 template <class InputIterator> 224 iterator insert(const_iterator position, InputIterator first, InputIterator last); 225 iterator insert(const_iterator position, initializer_list<value_type> il); 226 227 iterator erase(const_iterator position); 228 iterator erase(const_iterator first, const_iterator last); 229 230 void clear() noexcept; 231 232 void resize(size_type sz); 233 void resize(size_type sz, value_type x); 234 235 void swap(vector&) 236 noexcept(!allocator_type::propagate_on_container_swap::value || 237 __is_nothrow_swappable<allocator_type>::value); 238 void flip() noexcept; 239 240 bool __invariants() const; 241}; 242 243template <class Allocator> struct hash<std::vector<bool, Allocator>>; 244 245template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y); 246template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y); 247template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); 248template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y); 249template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); 250template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); 251 252template <class T, class Allocator> 253void swap(vector<T,Allocator>& x, vector<T,Allocator>& y) 254 noexcept(noexcept(x.swap(y))); 255 256} // std 257 258*/ 259 260#include <__config> 261#include <__bit_reference> 262#include <type_traits> 263#include <climits> 264#include <limits> 265#include <initializer_list> 266#include <memory> 267#include <stdexcept> 268#include <algorithm> 269#include <cstring> 270#include <__split_buffer> 271#include <__functional_base> 272 273#include <__undef_min_max> 274 275#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 276#pragma GCC system_header 277#endif 278 279_LIBCPP_BEGIN_NAMESPACE_STD 280 281template <bool> 282class __vector_base_common 283{ 284protected: 285 _LIBCPP_ALWAYS_INLINE __vector_base_common() {} 286 void __throw_length_error() const; 287 void __throw_out_of_range() const; 288}; 289 290template <bool __b> 291void 292__vector_base_common<__b>::__throw_length_error() const 293{ 294#ifndef _LIBCPP_NO_EXCEPTIONS 295 throw length_error("vector"); 296#else 297 assert(!"vector length_error"); 298#endif 299} 300 301template <bool __b> 302void 303__vector_base_common<__b>::__throw_out_of_range() const 304{ 305#ifndef _LIBCPP_NO_EXCEPTIONS 306 throw out_of_range("vector"); 307#else 308 assert(!"vector out_of_range"); 309#endif 310} 311 312#ifdef _MSC_VER 313#pragma warning( push ) 314#pragma warning( disable: 4231 ) 315#endif // _MSC_VER 316_LIBCPP_EXTERN_TEMPLATE(class __vector_base_common<true>) 317#ifdef _MSC_VER 318#pragma warning( pop ) 319#endif // _MSC_VER 320 321template <class _Tp, class _Allocator> 322class __vector_base 323 : protected __vector_base_common<true> 324{ 325protected: 326 typedef _Tp value_type; 327 typedef _Allocator allocator_type; 328 typedef allocator_traits<allocator_type> __alloc_traits; 329 typedef value_type& reference; 330 typedef const value_type& const_reference; 331 typedef typename __alloc_traits::size_type size_type; 332 typedef typename __alloc_traits::difference_type difference_type; 333 typedef typename __alloc_traits::pointer pointer; 334 typedef typename __alloc_traits::const_pointer const_pointer; 335 typedef pointer iterator; 336 typedef const_pointer const_iterator; 337 338 pointer __begin_; 339 pointer __end_; 340 __compressed_pair<pointer, allocator_type> __end_cap_; 341 342 _LIBCPP_INLINE_VISIBILITY 343 allocator_type& __alloc() _NOEXCEPT 344 {return __end_cap_.second();} 345 _LIBCPP_INLINE_VISIBILITY 346 const allocator_type& __alloc() const _NOEXCEPT 347 {return __end_cap_.second();} 348 _LIBCPP_INLINE_VISIBILITY 349 pointer& __end_cap() _NOEXCEPT 350 {return __end_cap_.first();} 351 _LIBCPP_INLINE_VISIBILITY 352 const pointer& __end_cap() const _NOEXCEPT 353 {return __end_cap_.first();} 354 355 _LIBCPP_INLINE_VISIBILITY 356 __vector_base() 357 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); 358 _LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a); 359 ~__vector_base(); 360 361 _LIBCPP_INLINE_VISIBILITY 362 void clear() _NOEXCEPT {__destruct_at_end(__begin_);} 363 _LIBCPP_INLINE_VISIBILITY 364 size_type capacity() const _NOEXCEPT 365 {return static_cast<size_type>(__end_cap() - __begin_);} 366 367 _LIBCPP_INLINE_VISIBILITY 368 void __destruct_at_end(const_pointer __new_last) _NOEXCEPT 369 {__destruct_at_end(__new_last, false_type());} 370 _LIBCPP_INLINE_VISIBILITY 371 void __destruct_at_end(const_pointer __new_last, false_type) _NOEXCEPT; 372 _LIBCPP_INLINE_VISIBILITY 373 void __destruct_at_end(const_pointer __new_last, true_type) _NOEXCEPT; 374 375 _LIBCPP_INLINE_VISIBILITY 376 void __copy_assign_alloc(const __vector_base& __c) 377 {__copy_assign_alloc(__c, integral_constant<bool, 378 __alloc_traits::propagate_on_container_copy_assignment::value>());} 379 380 _LIBCPP_INLINE_VISIBILITY 381 void __move_assign_alloc(__vector_base& __c) 382 _NOEXCEPT_( 383 !__alloc_traits::propagate_on_container_move_assignment::value || 384 is_nothrow_move_assignable<allocator_type>::value) 385 {__move_assign_alloc(__c, integral_constant<bool, 386 __alloc_traits::propagate_on_container_move_assignment::value>());} 387 388 _LIBCPP_INLINE_VISIBILITY 389 static void __swap_alloc(allocator_type& __x, allocator_type& __y) 390 _NOEXCEPT_( 391 !__alloc_traits::propagate_on_container_swap::value || 392 __is_nothrow_swappable<allocator_type>::value) 393 {__swap_alloc(__x, __y, integral_constant<bool, 394 __alloc_traits::propagate_on_container_swap::value>());} 395private: 396 _LIBCPP_INLINE_VISIBILITY 397 void __copy_assign_alloc(const __vector_base& __c, true_type) 398 { 399 if (__alloc() != __c.__alloc()) 400 { 401 clear(); 402 __alloc_traits::deallocate(__alloc(), __begin_, capacity()); 403 __begin_ = __end_ = __end_cap() = nullptr; 404 } 405 __alloc() = __c.__alloc(); 406 } 407 408 _LIBCPP_INLINE_VISIBILITY 409 void __copy_assign_alloc(const __vector_base&, false_type) 410 {} 411 412 _LIBCPP_INLINE_VISIBILITY 413 void __move_assign_alloc(__vector_base& __c, true_type) 414 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 415 { 416 __alloc() = _VSTD::move(__c.__alloc()); 417 } 418 419 _LIBCPP_INLINE_VISIBILITY 420 void __move_assign_alloc(__vector_base&, false_type) 421 _NOEXCEPT 422 {} 423 424 _LIBCPP_INLINE_VISIBILITY 425 static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type) 426 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 427 { 428 using _VSTD::swap; 429 swap(__x, __y); 430 } 431 _LIBCPP_INLINE_VISIBILITY 432 static void __swap_alloc(allocator_type&, allocator_type&, false_type) 433 _NOEXCEPT 434 {} 435}; 436 437template <class _Tp, class _Allocator> 438_LIBCPP_INLINE_VISIBILITY inline 439void 440__vector_base<_Tp, _Allocator>::__destruct_at_end(const_pointer __new_last, false_type) _NOEXCEPT 441{ 442 while (__new_last != __end_) 443 __alloc_traits::destroy(__alloc(), const_cast<pointer>(--__end_)); 444} 445 446template <class _Tp, class _Allocator> 447_LIBCPP_INLINE_VISIBILITY inline 448void 449__vector_base<_Tp, _Allocator>::__destruct_at_end(const_pointer __new_last, true_type) _NOEXCEPT 450{ 451 __end_ = const_cast<pointer>(__new_last); 452} 453 454template <class _Tp, class _Allocator> 455_LIBCPP_INLINE_VISIBILITY inline 456__vector_base<_Tp, _Allocator>::__vector_base() 457 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) 458 : __begin_(0), 459 __end_(0), 460 __end_cap_(0) 461{ 462} 463 464template <class _Tp, class _Allocator> 465_LIBCPP_INLINE_VISIBILITY inline 466__vector_base<_Tp, _Allocator>::__vector_base(const allocator_type& __a) 467 : __begin_(0), 468 __end_(0), 469 __end_cap_(0, __a) 470{ 471} 472 473template <class _Tp, class _Allocator> 474__vector_base<_Tp, _Allocator>::~__vector_base() 475{ 476 if (__begin_ != 0) 477 { 478 clear(); 479 __alloc_traits::deallocate(__alloc(), __begin_, capacity()); 480 } 481} 482 483template <class _Tp, class _Allocator = allocator<_Tp> > 484class _LIBCPP_TYPE_VIS vector 485 : private __vector_base<_Tp, _Allocator> 486{ 487private: 488 typedef __vector_base<_Tp, _Allocator> __base; 489public: 490 typedef vector __self; 491 typedef _Tp value_type; 492 typedef _Allocator allocator_type; 493 typedef typename __base::__alloc_traits __alloc_traits; 494 typedef typename __base::reference reference; 495 typedef typename __base::const_reference const_reference; 496 typedef typename __base::size_type size_type; 497 typedef typename __base::difference_type difference_type; 498 typedef typename __base::pointer pointer; 499 typedef typename __base::const_pointer const_pointer; 500 typedef __wrap_iter<pointer> iterator; 501 typedef __wrap_iter<const_pointer> const_iterator; 502 typedef _VSTD::reverse_iterator<iterator> reverse_iterator; 503 typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; 504 505 static_assert((is_same<typename allocator_type::value_type, value_type>::value), 506 "Allocator::value_type must be same type as value_type"); 507 508 _LIBCPP_INLINE_VISIBILITY 509 vector() 510 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) 511 { 512#if _LIBCPP_DEBUG_LEVEL >= 2 513 __get_db()->__insert_c(this); 514#endif 515 } 516 _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a) 517 : __base(__a) 518 { 519#if _LIBCPP_DEBUG_LEVEL >= 2 520 __get_db()->__insert_c(this); 521#endif 522 } 523 explicit vector(size_type __n); 524 vector(size_type __n, const_reference __x); 525 vector(size_type __n, const_reference __x, const allocator_type& __a); 526 template <class _InputIterator> 527 vector(_InputIterator __first, _InputIterator __last, 528 typename enable_if<__is_input_iterator <_InputIterator>::value && 529 !__is_forward_iterator<_InputIterator>::value && 530 is_constructible< 531 value_type, 532 typename iterator_traits<_InputIterator>::reference>::value>::type* = 0); 533 template <class _InputIterator> 534 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, 535 typename enable_if<__is_input_iterator <_InputIterator>::value && 536 !__is_forward_iterator<_InputIterator>::value && 537 is_constructible< 538 value_type, 539 typename iterator_traits<_InputIterator>::reference>::value>::type* = 0); 540 template <class _ForwardIterator> 541 vector(_ForwardIterator __first, _ForwardIterator __last, 542 typename enable_if<__is_forward_iterator<_ForwardIterator>::value && 543 is_constructible< 544 value_type, 545 typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0); 546 template <class _ForwardIterator> 547 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, 548 typename enable_if<__is_forward_iterator<_ForwardIterator>::value && 549 is_constructible< 550 value_type, 551 typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0); 552#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 553 _LIBCPP_INLINE_VISIBILITY 554 vector(initializer_list<value_type> __il); 555 _LIBCPP_INLINE_VISIBILITY 556 vector(initializer_list<value_type> __il, const allocator_type& __a); 557#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 558#if _LIBCPP_DEBUG_LEVEL >= 2 559 _LIBCPP_INLINE_VISIBILITY 560 ~vector() 561 { 562 __get_db()->__erase_c(this); 563 } 564#endif 565 566 vector(const vector& __x); 567 vector(const vector& __x, const allocator_type& __a); 568 _LIBCPP_INLINE_VISIBILITY 569 vector& operator=(const vector& __x); 570#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 571 _LIBCPP_INLINE_VISIBILITY 572 vector(vector&& __x) 573 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); 574 _LIBCPP_INLINE_VISIBILITY 575 vector(vector&& __x, const allocator_type& __a); 576 _LIBCPP_INLINE_VISIBILITY 577 vector& operator=(vector&& __x) 578 _NOEXCEPT_( 579 __alloc_traits::propagate_on_container_move_assignment::value && 580 is_nothrow_move_assignable<allocator_type>::value); 581#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 582#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 583 _LIBCPP_INLINE_VISIBILITY 584 vector& operator=(initializer_list<value_type> __il) 585 {assign(__il.begin(), __il.end()); return *this;} 586#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 587 588 template <class _InputIterator> 589 typename enable_if 590 < 591 __is_input_iterator <_InputIterator>::value && 592 !__is_forward_iterator<_InputIterator>::value && 593 is_constructible< 594 value_type, 595 typename iterator_traits<_InputIterator>::reference>::value, 596 void 597 >::type 598 assign(_InputIterator __first, _InputIterator __last); 599 template <class _ForwardIterator> 600 typename enable_if 601 < 602 __is_forward_iterator<_ForwardIterator>::value && 603 is_constructible< 604 value_type, 605 typename iterator_traits<_ForwardIterator>::reference>::value, 606 void 607 >::type 608 assign(_ForwardIterator __first, _ForwardIterator __last); 609 610 void assign(size_type __n, const_reference __u); 611#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 612 _LIBCPP_INLINE_VISIBILITY 613 void assign(initializer_list<value_type> __il) 614 {assign(__il.begin(), __il.end());} 615#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 616 617 _LIBCPP_INLINE_VISIBILITY 618 allocator_type get_allocator() const _NOEXCEPT 619 {return this->__alloc();} 620 621 _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT; 622 _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT; 623 _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT; 624 _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT; 625 626 _LIBCPP_INLINE_VISIBILITY 627 reverse_iterator rbegin() _NOEXCEPT 628 {return reverse_iterator(end());} 629 _LIBCPP_INLINE_VISIBILITY 630 const_reverse_iterator rbegin() const _NOEXCEPT 631 {return const_reverse_iterator(end());} 632 _LIBCPP_INLINE_VISIBILITY 633 reverse_iterator rend() _NOEXCEPT 634 {return reverse_iterator(begin());} 635 _LIBCPP_INLINE_VISIBILITY 636 const_reverse_iterator rend() const _NOEXCEPT 637 {return const_reverse_iterator(begin());} 638 639 _LIBCPP_INLINE_VISIBILITY 640 const_iterator cbegin() const _NOEXCEPT 641 {return begin();} 642 _LIBCPP_INLINE_VISIBILITY 643 const_iterator cend() const _NOEXCEPT 644 {return end();} 645 _LIBCPP_INLINE_VISIBILITY 646 const_reverse_iterator crbegin() const _NOEXCEPT 647 {return rbegin();} 648 _LIBCPP_INLINE_VISIBILITY 649 const_reverse_iterator crend() const _NOEXCEPT 650 {return rend();} 651 652 _LIBCPP_INLINE_VISIBILITY 653 size_type size() const _NOEXCEPT 654 {return static_cast<size_type>(this->__end_ - this->__begin_);} 655 _LIBCPP_INLINE_VISIBILITY 656 size_type capacity() const _NOEXCEPT 657 {return __base::capacity();} 658 _LIBCPP_INLINE_VISIBILITY 659 bool empty() const _NOEXCEPT 660 {return this->__begin_ == this->__end_;} 661 size_type max_size() const _NOEXCEPT; 662 void reserve(size_type __n); 663 void shrink_to_fit() _NOEXCEPT; 664 665 _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n); 666 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const; 667 reference at(size_type __n); 668 const_reference at(size_type __n) const; 669 670 _LIBCPP_INLINE_VISIBILITY reference front() 671 { 672 _LIBCPP_ASSERT(!empty(), "front() called for empty vector"); 673 return *this->__begin_; 674 } 675 _LIBCPP_INLINE_VISIBILITY const_reference front() const 676 { 677 _LIBCPP_ASSERT(!empty(), "front() called for empty vector"); 678 return *this->__begin_; 679 } 680 _LIBCPP_INLINE_VISIBILITY reference back() 681 { 682 _LIBCPP_ASSERT(!empty(), "back() called for empty vector"); 683 return *(this->__end_ - 1); 684 } 685 _LIBCPP_INLINE_VISIBILITY const_reference back() const 686 { 687 _LIBCPP_ASSERT(!empty(), "back() called for empty vector"); 688 return *(this->__end_ - 1); 689 } 690 691 _LIBCPP_INLINE_VISIBILITY 692 value_type* data() _NOEXCEPT 693 {return _VSTD::__to_raw_pointer(this->__begin_);} 694 _LIBCPP_INLINE_VISIBILITY 695 const value_type* data() const _NOEXCEPT 696 {return _VSTD::__to_raw_pointer(this->__begin_);} 697 698 _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x); 699#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 700 _LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x); 701#ifndef _LIBCPP_HAS_NO_VARIADICS 702 template <class... _Args> 703 void emplace_back(_Args&&... __args); 704#endif // _LIBCPP_HAS_NO_VARIADICS 705#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 706 void pop_back(); 707 708 iterator insert(const_iterator __position, const_reference __x); 709#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 710 iterator insert(const_iterator __position, value_type&& __x); 711#ifndef _LIBCPP_HAS_NO_VARIADICS 712 template <class... _Args> 713 iterator emplace(const_iterator __position, _Args&&... __args); 714#endif // _LIBCPP_HAS_NO_VARIADICS 715#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 716 iterator insert(const_iterator __position, size_type __n, const_reference __x); 717 template <class _InputIterator> 718 typename enable_if 719 < 720 __is_input_iterator <_InputIterator>::value && 721 !__is_forward_iterator<_InputIterator>::value && 722 is_constructible< 723 value_type, 724 typename iterator_traits<_InputIterator>::reference>::value, 725 iterator 726 >::type 727 insert(const_iterator __position, _InputIterator __first, _InputIterator __last); 728 template <class _ForwardIterator> 729 typename enable_if 730 < 731 __is_forward_iterator<_ForwardIterator>::value && 732 is_constructible< 733 value_type, 734 typename iterator_traits<_ForwardIterator>::reference>::value, 735 iterator 736 >::type 737 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last); 738#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 739 _LIBCPP_INLINE_VISIBILITY 740 iterator insert(const_iterator __position, initializer_list<value_type> __il) 741 {return insert(__position, __il.begin(), __il.end());} 742#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 743 744 _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position); 745 iterator erase(const_iterator __first, const_iterator __last); 746 747 _LIBCPP_INLINE_VISIBILITY 748 void clear() _NOEXCEPT 749 { 750 __base::clear(); 751 __invalidate_all_iterators(); 752 } 753 754 void resize(size_type __sz); 755 void resize(size_type __sz, const_reference __x); 756 757 void swap(vector&) 758 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 759 __is_nothrow_swappable<allocator_type>::value); 760 761 bool __invariants() const; 762 763#if _LIBCPP_DEBUG_LEVEL >= 2 764 765 bool __dereferenceable(const const_iterator* __i) const; 766 bool __decrementable(const const_iterator* __i) const; 767 bool __addable(const const_iterator* __i, ptrdiff_t __n) const; 768 bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const; 769 770#endif // _LIBCPP_DEBUG_LEVEL >= 2 771 772private: 773 _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators(); 774 void allocate(size_type __n); 775 void deallocate() _NOEXCEPT; 776 _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const; 777 void __construct_at_end(size_type __n); 778 void __construct_at_end(size_type __n, const_reference __x); 779 template <class _ForwardIterator> 780 typename enable_if 781 < 782 __is_forward_iterator<_ForwardIterator>::value, 783 void 784 >::type 785 __construct_at_end(_ForwardIterator __first, _ForwardIterator __last); 786 void __move_construct_at_end(pointer __first, pointer __last); 787 void __append(size_type __n); 788 void __append(size_type __n, const_reference __x); 789 _LIBCPP_INLINE_VISIBILITY 790 iterator __make_iter(pointer __p) _NOEXCEPT; 791 _LIBCPP_INLINE_VISIBILITY 792 const_iterator __make_iter(const_pointer __p) const _NOEXCEPT; 793 void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v); 794 pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p); 795 void __move_range(pointer __from_s, pointer __from_e, pointer __to); 796 void __move_assign(vector& __c, true_type) 797 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); 798 void __move_assign(vector& __c, false_type); 799 _LIBCPP_INLINE_VISIBILITY 800 void __destruct_at_end(const_pointer __new_last) _NOEXCEPT 801 { 802#if _LIBCPP_DEBUG_LEVEL >= 2 803 __c_node* __c = __get_db()->__find_c_and_lock(this); 804 for (__i_node** __p = __c->end_; __p != __c->beg_; ) 805 { 806 --__p; 807 const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_); 808 if (__i->base() > __new_last) 809 { 810 (*__p)->__c_ = nullptr; 811 if (--__c->end_ != __p) 812 memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*)); 813 } 814 } 815 __get_db()->unlock(); 816#endif 817 __base::__destruct_at_end(__new_last); 818 } 819 template <class _Up> 820 void 821#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 822 __push_back_slow_path(_Up&& __x); 823#else 824 __push_back_slow_path(_Up& __x); 825#endif 826#if !defined(_LIBCPP_HAS_NO_VARIADICS) && !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 827 template <class... _Args> 828 void 829 __emplace_back_slow_path(_Args&&... __args); 830#endif 831}; 832 833template <class _Tp, class _Allocator> 834void 835vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v) 836{ 837 __alloc_traits::__construct_backward(this->__alloc(), this->__begin_, this->__end_, __v.__begin_); 838 _VSTD::swap(this->__begin_, __v.__begin_); 839 _VSTD::swap(this->__end_, __v.__end_); 840 _VSTD::swap(this->__end_cap(), __v.__end_cap()); 841 __v.__first_ = __v.__begin_; 842 __invalidate_all_iterators(); 843} 844 845template <class _Tp, class _Allocator> 846typename vector<_Tp, _Allocator>::pointer 847vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p) 848{ 849 pointer __r = __v.__begin_; 850 __alloc_traits::__construct_backward(this->__alloc(), this->__begin_, __p, __v.__begin_); 851 __alloc_traits::__construct_forward(this->__alloc(), __p, this->__end_, __v.__end_); 852 _VSTD::swap(this->__begin_, __v.__begin_); 853 _VSTD::swap(this->__end_, __v.__end_); 854 _VSTD::swap(this->__end_cap(), __v.__end_cap()); 855 __v.__first_ = __v.__begin_; 856 __invalidate_all_iterators(); 857 return __r; 858} 859 860// Allocate space for __n objects 861// throws length_error if __n > max_size() 862// throws (probably bad_alloc) if memory run out 863// Precondition: __begin_ == __end_ == __end_cap() == 0 864// Precondition: __n > 0 865// Postcondition: capacity() == __n 866// Postcondition: size() == 0 867template <class _Tp, class _Allocator> 868void 869vector<_Tp, _Allocator>::allocate(size_type __n) 870{ 871 if (__n > max_size()) 872 this->__throw_length_error(); 873 this->__begin_ = this->__end_ = __alloc_traits::allocate(this->__alloc(), __n); 874 this->__end_cap() = this->__begin_ + __n; 875} 876 877template <class _Tp, class _Allocator> 878void 879vector<_Tp, _Allocator>::deallocate() _NOEXCEPT 880{ 881 if (this->__begin_ != 0) 882 { 883 clear(); 884 __alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity()); 885 this->__begin_ = this->__end_ = this->__end_cap() = 0; 886 } 887} 888 889template <class _Tp, class _Allocator> 890typename vector<_Tp, _Allocator>::size_type 891vector<_Tp, _Allocator>::max_size() const _NOEXCEPT 892{ 893 return _VSTD::min<size_type>(__alloc_traits::max_size(this->__alloc()), numeric_limits<size_type>::max() / 2); // end() >= begin(), always 894} 895 896// Precondition: __new_size > capacity() 897template <class _Tp, class _Allocator> 898_LIBCPP_INLINE_VISIBILITY inline 899typename vector<_Tp, _Allocator>::size_type 900vector<_Tp, _Allocator>::__recommend(size_type __new_size) const 901{ 902 const size_type __ms = max_size(); 903 if (__new_size > __ms) 904 this->__throw_length_error(); 905 const size_type __cap = capacity(); 906 if (__cap >= __ms / 2) 907 return __ms; 908 return _VSTD::max<size_type>(2*__cap, __new_size); 909} 910 911// Default constructs __n objects starting at __end_ 912// throws if construction throws 913// Precondition: __n > 0 914// Precondition: size() + __n <= capacity() 915// Postcondition: size() == size() + __n 916template <class _Tp, class _Allocator> 917void 918vector<_Tp, _Allocator>::__construct_at_end(size_type __n) 919{ 920 allocator_type& __a = this->__alloc(); 921 do 922 { 923 __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_)); 924 ++this->__end_; 925 --__n; 926 } while (__n > 0); 927} 928 929// Copy constructs __n objects starting at __end_ from __x 930// throws if construction throws 931// Precondition: __n > 0 932// Precondition: size() + __n <= capacity() 933// Postcondition: size() == old size() + __n 934// Postcondition: [i] == __x for all i in [size() - __n, __n) 935template <class _Tp, class _Allocator> 936_LIBCPP_INLINE_VISIBILITY inline 937void 938vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) 939{ 940 allocator_type& __a = this->__alloc(); 941 do 942 { 943 __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x); 944 ++this->__end_; 945 --__n; 946 } while (__n > 0); 947} 948 949template <class _Tp, class _Allocator> 950template <class _ForwardIterator> 951typename enable_if 952< 953 __is_forward_iterator<_ForwardIterator>::value, 954 void 955>::type 956vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) 957{ 958 allocator_type& __a = this->__alloc(); 959 for (; __first != __last; ++__first) 960 { 961 __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first); 962 ++this->__end_; 963 } 964} 965 966template <class _Tp, class _Allocator> 967void 968vector<_Tp, _Allocator>::__move_construct_at_end(pointer __first, pointer __last) 969{ 970 allocator_type& __a = this->__alloc(); 971 for (; __first != __last; ++__first) 972 { 973 __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), 974 _VSTD::move(*__first)); 975 ++this->__end_; 976 } 977} 978 979// Default constructs __n objects starting at __end_ 980// throws if construction throws 981// Postcondition: size() == size() + __n 982// Exception safety: strong. 983template <class _Tp, class _Allocator> 984void 985vector<_Tp, _Allocator>::__append(size_type __n) 986{ 987 if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n) 988 this->__construct_at_end(__n); 989 else 990 { 991 allocator_type& __a = this->__alloc(); 992 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a); 993 __v.__construct_at_end(__n); 994 __swap_out_circular_buffer(__v); 995 } 996} 997 998// Default constructs __n objects starting at __end_ 999// throws if construction throws 1000// Postcondition: size() == size() + __n 1001// Exception safety: strong. 1002template <class _Tp, class _Allocator> 1003void 1004vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x) 1005{ 1006 if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n) 1007 this->__construct_at_end(__n, __x); 1008 else 1009 { 1010 allocator_type& __a = this->__alloc(); 1011 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a); 1012 __v.__construct_at_end(__n, __x); 1013 __swap_out_circular_buffer(__v); 1014 } 1015} 1016 1017template <class _Tp, class _Allocator> 1018vector<_Tp, _Allocator>::vector(size_type __n) 1019{ 1020#if _LIBCPP_DEBUG_LEVEL >= 2 1021 __get_db()->__insert_c(this); 1022#endif 1023 if (__n > 0) 1024 { 1025 allocate(__n); 1026 __construct_at_end(__n); 1027 } 1028} 1029 1030template <class _Tp, class _Allocator> 1031vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x) 1032{ 1033#if _LIBCPP_DEBUG_LEVEL >= 2 1034 __get_db()->__insert_c(this); 1035#endif 1036 if (__n > 0) 1037 { 1038 allocate(__n); 1039 __construct_at_end(__n, __x); 1040 } 1041} 1042 1043template <class _Tp, class _Allocator> 1044vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x, const allocator_type& __a) 1045 : __base(__a) 1046{ 1047#if _LIBCPP_DEBUG_LEVEL >= 2 1048 __get_db()->__insert_c(this); 1049#endif 1050 if (__n > 0) 1051 { 1052 allocate(__n); 1053 __construct_at_end(__n, __x); 1054 } 1055} 1056 1057template <class _Tp, class _Allocator> 1058template <class _InputIterator> 1059vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, 1060 typename enable_if<__is_input_iterator <_InputIterator>::value && 1061 !__is_forward_iterator<_InputIterator>::value && 1062 is_constructible< 1063 value_type, 1064 typename iterator_traits<_InputIterator>::reference>::value>::type*) 1065{ 1066#if _LIBCPP_DEBUG_LEVEL >= 2 1067 __get_db()->__insert_c(this); 1068#endif 1069 for (; __first != __last; ++__first) 1070 push_back(*__first); 1071} 1072 1073template <class _Tp, class _Allocator> 1074template <class _InputIterator> 1075vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, 1076 typename enable_if<__is_input_iterator <_InputIterator>::value && 1077 !__is_forward_iterator<_InputIterator>::value && 1078 is_constructible< 1079 value_type, 1080 typename iterator_traits<_InputIterator>::reference>::value>::type*) 1081 : __base(__a) 1082{ 1083#if _LIBCPP_DEBUG_LEVEL >= 2 1084 __get_db()->__insert_c(this); 1085#endif 1086 for (; __first != __last; ++__first) 1087 push_back(*__first); 1088} 1089 1090template <class _Tp, class _Allocator> 1091template <class _ForwardIterator> 1092vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, 1093 typename enable_if<__is_forward_iterator<_ForwardIterator>::value && 1094 is_constructible< 1095 value_type, 1096 typename iterator_traits<_ForwardIterator>::reference>::value>::type*) 1097{ 1098#if _LIBCPP_DEBUG_LEVEL >= 2 1099 __get_db()->__insert_c(this); 1100#endif 1101 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 1102 if (__n > 0) 1103 { 1104 allocate(__n); 1105 __construct_at_end(__first, __last); 1106 } 1107} 1108 1109template <class _Tp, class _Allocator> 1110template <class _ForwardIterator> 1111vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, 1112 typename enable_if<__is_forward_iterator<_ForwardIterator>::value && 1113 is_constructible< 1114 value_type, 1115 typename iterator_traits<_ForwardIterator>::reference>::value>::type*) 1116 : __base(__a) 1117{ 1118#if _LIBCPP_DEBUG_LEVEL >= 2 1119 __get_db()->__insert_c(this); 1120#endif 1121 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 1122 if (__n > 0) 1123 { 1124 allocate(__n); 1125 __construct_at_end(__first, __last); 1126 } 1127} 1128 1129template <class _Tp, class _Allocator> 1130vector<_Tp, _Allocator>::vector(const vector& __x) 1131 : __base(__alloc_traits::select_on_container_copy_construction(__x.__alloc())) 1132{ 1133#if _LIBCPP_DEBUG_LEVEL >= 2 1134 __get_db()->__insert_c(this); 1135#endif 1136 size_type __n = __x.size(); 1137 if (__n > 0) 1138 { 1139 allocate(__n); 1140 __construct_at_end(__x.__begin_, __x.__end_); 1141 } 1142} 1143 1144template <class _Tp, class _Allocator> 1145vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a) 1146 : __base(__a) 1147{ 1148#if _LIBCPP_DEBUG_LEVEL >= 2 1149 __get_db()->__insert_c(this); 1150#endif 1151 size_type __n = __x.size(); 1152 if (__n > 0) 1153 { 1154 allocate(__n); 1155 __construct_at_end(__x.__begin_, __x.__end_); 1156 } 1157} 1158 1159#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1160 1161template <class _Tp, class _Allocator> 1162_LIBCPP_INLINE_VISIBILITY inline 1163vector<_Tp, _Allocator>::vector(vector&& __x) 1164 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) 1165 : __base(_VSTD::move(__x.__alloc())) 1166{ 1167#if _LIBCPP_DEBUG_LEVEL >= 2 1168 __get_db()->__insert_c(this); 1169 __get_db()->swap(this, &__x); 1170#endif 1171 this->__begin_ = __x.__begin_; 1172 this->__end_ = __x.__end_; 1173 this->__end_cap() = __x.__end_cap(); 1174 __x.__begin_ = __x.__end_ = __x.__end_cap() = 0; 1175} 1176 1177template <class _Tp, class _Allocator> 1178_LIBCPP_INLINE_VISIBILITY inline 1179vector<_Tp, _Allocator>::vector(vector&& __x, const allocator_type& __a) 1180 : __base(__a) 1181{ 1182#if _LIBCPP_DEBUG_LEVEL >= 2 1183 __get_db()->__insert_c(this); 1184#endif 1185 if (__a == __x.__alloc()) 1186 { 1187 this->__begin_ = __x.__begin_; 1188 this->__end_ = __x.__end_; 1189 this->__end_cap() = __x.__end_cap(); 1190 __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr; 1191#if _LIBCPP_DEBUG_LEVEL >= 2 1192 __get_db()->swap(this, &__x); 1193#endif 1194 } 1195 else 1196 { 1197 typedef move_iterator<iterator> _Ip; 1198 assign(_Ip(__x.begin()), _Ip(__x.end())); 1199 } 1200} 1201 1202#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1203 1204template <class _Tp, class _Allocator> 1205_LIBCPP_INLINE_VISIBILITY inline 1206vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il) 1207{ 1208#if _LIBCPP_DEBUG_LEVEL >= 2 1209 __get_db()->__insert_c(this); 1210#endif 1211 if (__il.size() > 0) 1212 { 1213 allocate(__il.size()); 1214 __construct_at_end(__il.begin(), __il.end()); 1215 } 1216} 1217 1218template <class _Tp, class _Allocator> 1219_LIBCPP_INLINE_VISIBILITY inline 1220vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a) 1221 : __base(__a) 1222{ 1223#if _LIBCPP_DEBUG_LEVEL >= 2 1224 __get_db()->__insert_c(this); 1225#endif 1226 if (__il.size() > 0) 1227 { 1228 allocate(__il.size()); 1229 __construct_at_end(__il.begin(), __il.end()); 1230 } 1231} 1232 1233#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 1234 1235template <class _Tp, class _Allocator> 1236_LIBCPP_INLINE_VISIBILITY inline 1237vector<_Tp, _Allocator>& 1238vector<_Tp, _Allocator>::operator=(vector&& __x) 1239 _NOEXCEPT_( 1240 __alloc_traits::propagate_on_container_move_assignment::value && 1241 is_nothrow_move_assignable<allocator_type>::value) 1242{ 1243 __move_assign(__x, integral_constant<bool, 1244 __alloc_traits::propagate_on_container_move_assignment::value>()); 1245 return *this; 1246} 1247 1248template <class _Tp, class _Allocator> 1249void 1250vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type) 1251{ 1252 if (__base::__alloc() != __c.__alloc()) 1253 { 1254 typedef move_iterator<iterator> _Ip; 1255 assign(_Ip(__c.begin()), _Ip(__c.end())); 1256 } 1257 else 1258 __move_assign(__c, true_type()); 1259} 1260 1261template <class _Tp, class _Allocator> 1262void 1263vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type) 1264 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 1265{ 1266 deallocate(); 1267 this->__begin_ = __c.__begin_; 1268 this->__end_ = __c.__end_; 1269 this->__end_cap() = __c.__end_cap(); 1270 __base::__move_assign_alloc(__c); 1271 __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr; 1272#if _LIBCPP_DEBUG_LEVEL >= 2 1273 __get_db()->swap(this, &__c); 1274#endif 1275} 1276 1277#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1278 1279template <class _Tp, class _Allocator> 1280_LIBCPP_INLINE_VISIBILITY inline 1281vector<_Tp, _Allocator>& 1282vector<_Tp, _Allocator>::operator=(const vector& __x) 1283{ 1284 if (this != &__x) 1285 { 1286 __base::__copy_assign_alloc(__x); 1287 assign(__x.__begin_, __x.__end_); 1288 } 1289 return *this; 1290} 1291 1292template <class _Tp, class _Allocator> 1293template <class _InputIterator> 1294typename enable_if 1295< 1296 __is_input_iterator <_InputIterator>::value && 1297 !__is_forward_iterator<_InputIterator>::value && 1298 is_constructible< 1299 _Tp, 1300 typename iterator_traits<_InputIterator>::reference>::value, 1301 void 1302>::type 1303vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last) 1304{ 1305 clear(); 1306 for (; __first != __last; ++__first) 1307 push_back(*__first); 1308} 1309 1310template <class _Tp, class _Allocator> 1311template <class _ForwardIterator> 1312typename enable_if 1313< 1314 __is_forward_iterator<_ForwardIterator>::value && 1315 is_constructible< 1316 _Tp, 1317 typename iterator_traits<_ForwardIterator>::reference>::value, 1318 void 1319>::type 1320vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) 1321{ 1322 typename iterator_traits<_ForwardIterator>::difference_type __new_size = _VSTD::distance(__first, __last); 1323 if (static_cast<size_type>(__new_size) <= capacity()) 1324 { 1325 _ForwardIterator __mid = __last; 1326 bool __growing = false; 1327 if (static_cast<size_type>(__new_size) > size()) 1328 { 1329 __growing = true; 1330 __mid = __first; 1331 _VSTD::advance(__mid, size()); 1332 } 1333 pointer __m = _VSTD::copy(__first, __mid, this->__begin_); 1334 if (__growing) 1335 __construct_at_end(__mid, __last); 1336 else 1337 this->__destruct_at_end(__m); 1338 } 1339 else 1340 { 1341 deallocate(); 1342 allocate(__recommend(static_cast<size_type>(__new_size))); 1343 __construct_at_end(__first, __last); 1344 } 1345} 1346 1347template <class _Tp, class _Allocator> 1348void 1349vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u) 1350{ 1351 if (__n <= capacity()) 1352 { 1353 size_type __s = size(); 1354 _VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u); 1355 if (__n > __s) 1356 __construct_at_end(__n - __s, __u); 1357 else 1358 this->__destruct_at_end(this->__begin_ + __n); 1359 } 1360 else 1361 { 1362 deallocate(); 1363 allocate(__recommend(static_cast<size_type>(__n))); 1364 __construct_at_end(__n, __u); 1365 } 1366} 1367 1368template <class _Tp, class _Allocator> 1369_LIBCPP_INLINE_VISIBILITY inline 1370typename vector<_Tp, _Allocator>::iterator 1371vector<_Tp, _Allocator>::__make_iter(pointer __p) _NOEXCEPT 1372{ 1373#if _LIBCPP_DEBUG_LEVEL >= 2 1374 return iterator(this, __p); 1375#else 1376 return iterator(__p); 1377#endif 1378} 1379 1380template <class _Tp, class _Allocator> 1381_LIBCPP_INLINE_VISIBILITY inline 1382typename vector<_Tp, _Allocator>::const_iterator 1383vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const _NOEXCEPT 1384{ 1385#if _LIBCPP_DEBUG_LEVEL >= 2 1386 return const_iterator(this, __p); 1387#else 1388 return const_iterator(__p); 1389#endif 1390} 1391 1392template <class _Tp, class _Allocator> 1393_LIBCPP_INLINE_VISIBILITY inline 1394typename vector<_Tp, _Allocator>::iterator 1395vector<_Tp, _Allocator>::begin() _NOEXCEPT 1396{ 1397 return __make_iter(this->__begin_); 1398} 1399 1400template <class _Tp, class _Allocator> 1401_LIBCPP_INLINE_VISIBILITY inline 1402typename vector<_Tp, _Allocator>::const_iterator 1403vector<_Tp, _Allocator>::begin() const _NOEXCEPT 1404{ 1405 return __make_iter(this->__begin_); 1406} 1407 1408template <class _Tp, class _Allocator> 1409_LIBCPP_INLINE_VISIBILITY inline 1410typename vector<_Tp, _Allocator>::iterator 1411vector<_Tp, _Allocator>::end() _NOEXCEPT 1412{ 1413 return __make_iter(this->__end_); 1414} 1415 1416template <class _Tp, class _Allocator> 1417_LIBCPP_INLINE_VISIBILITY inline 1418typename vector<_Tp, _Allocator>::const_iterator 1419vector<_Tp, _Allocator>::end() const _NOEXCEPT 1420{ 1421 return __make_iter(this->__end_); 1422} 1423 1424template <class _Tp, class _Allocator> 1425_LIBCPP_INLINE_VISIBILITY inline 1426typename vector<_Tp, _Allocator>::reference 1427vector<_Tp, _Allocator>::operator[](size_type __n) 1428{ 1429 _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds"); 1430 return this->__begin_[__n]; 1431} 1432 1433template <class _Tp, class _Allocator> 1434_LIBCPP_INLINE_VISIBILITY inline 1435typename vector<_Tp, _Allocator>::const_reference 1436vector<_Tp, _Allocator>::operator[](size_type __n) const 1437{ 1438 _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds"); 1439 return this->__begin_[__n]; 1440} 1441 1442template <class _Tp, class _Allocator> 1443typename vector<_Tp, _Allocator>::reference 1444vector<_Tp, _Allocator>::at(size_type __n) 1445{ 1446 if (__n >= size()) 1447 this->__throw_out_of_range(); 1448 return this->__begin_[__n]; 1449} 1450 1451template <class _Tp, class _Allocator> 1452typename vector<_Tp, _Allocator>::const_reference 1453vector<_Tp, _Allocator>::at(size_type __n) const 1454{ 1455 if (__n >= size()) 1456 this->__throw_out_of_range(); 1457 return this->__begin_[__n]; 1458} 1459 1460template <class _Tp, class _Allocator> 1461void 1462vector<_Tp, _Allocator>::reserve(size_type __n) 1463{ 1464 if (__n > capacity()) 1465 { 1466 allocator_type& __a = this->__alloc(); 1467 __split_buffer<value_type, allocator_type&> __v(__n, size(), __a); 1468 __swap_out_circular_buffer(__v); 1469 } 1470} 1471 1472template <class _Tp, class _Allocator> 1473void 1474vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT 1475{ 1476 if (capacity() > size()) 1477 { 1478#ifndef _LIBCPP_NO_EXCEPTIONS 1479 try 1480 { 1481#endif // _LIBCPP_NO_EXCEPTIONS 1482 allocator_type& __a = this->__alloc(); 1483 __split_buffer<value_type, allocator_type&> __v(size(), size(), __a); 1484 __swap_out_circular_buffer(__v); 1485#ifndef _LIBCPP_NO_EXCEPTIONS 1486 } 1487 catch (...) 1488 { 1489 } 1490#endif // _LIBCPP_NO_EXCEPTIONS 1491 } 1492} 1493 1494template <class _Tp, class _Allocator> 1495template <class _Up> 1496void 1497#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1498vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x) 1499#else 1500vector<_Tp, _Allocator>::__push_back_slow_path(_Up& __x) 1501#endif 1502{ 1503 allocator_type& __a = this->__alloc(); 1504 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a); 1505 // __v.push_back(_VSTD::forward<_Up>(__x)); 1506 __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Up>(__x)); 1507 __v.__end_++; 1508 __swap_out_circular_buffer(__v); 1509} 1510 1511template <class _Tp, class _Allocator> 1512_LIBCPP_INLINE_VISIBILITY inline 1513void 1514vector<_Tp, _Allocator>::push_back(const_reference __x) 1515{ 1516 if (this->__end_ != this->__end_cap()) 1517 { 1518 __alloc_traits::construct(this->__alloc(), 1519 _VSTD::__to_raw_pointer(this->__end_), __x); 1520 ++this->__end_; 1521 } 1522 else 1523 __push_back_slow_path(__x); 1524} 1525 1526#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1527 1528template <class _Tp, class _Allocator> 1529_LIBCPP_INLINE_VISIBILITY inline 1530void 1531vector<_Tp, _Allocator>::push_back(value_type&& __x) 1532{ 1533 if (this->__end_ < this->__end_cap()) 1534 { 1535 __alloc_traits::construct(this->__alloc(), 1536 _VSTD::__to_raw_pointer(this->__end_), 1537 _VSTD::move(__x)); 1538 ++this->__end_; 1539 } 1540 else 1541 __push_back_slow_path(_VSTD::move(__x)); 1542} 1543 1544#ifndef _LIBCPP_HAS_NO_VARIADICS 1545 1546template <class _Tp, class _Allocator> 1547template <class... _Args> 1548void 1549vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args) 1550{ 1551 allocator_type& __a = this->__alloc(); 1552 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a); 1553// __v.emplace_back(_VSTD::forward<_Args>(__args)...); 1554 __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Args>(__args)...); 1555 __v.__end_++; 1556 __swap_out_circular_buffer(__v); 1557} 1558 1559template <class _Tp, class _Allocator> 1560template <class... _Args> 1561_LIBCPP_INLINE_VISIBILITY inline 1562void 1563vector<_Tp, _Allocator>::emplace_back(_Args&&... __args) 1564{ 1565 if (this->__end_ < this->__end_cap()) 1566 { 1567 __alloc_traits::construct(this->__alloc(), 1568 _VSTD::__to_raw_pointer(this->__end_), 1569 _VSTD::forward<_Args>(__args)...); 1570 ++this->__end_; 1571 } 1572 else 1573 __emplace_back_slow_path(_VSTD::forward<_Args>(__args)...); 1574} 1575 1576#endif // _LIBCPP_HAS_NO_VARIADICS 1577#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1578 1579template <class _Tp, class _Allocator> 1580_LIBCPP_INLINE_VISIBILITY inline 1581void 1582vector<_Tp, _Allocator>::pop_back() 1583{ 1584 _LIBCPP_ASSERT(!empty(), "vector::pop_back called for empty vector"); 1585 this->__destruct_at_end(this->__end_ - 1); 1586} 1587 1588template <class _Tp, class _Allocator> 1589_LIBCPP_INLINE_VISIBILITY inline 1590typename vector<_Tp, _Allocator>::iterator 1591vector<_Tp, _Allocator>::erase(const_iterator __position) 1592{ 1593#if _LIBCPP_DEBUG_LEVEL >= 2 1594 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this, 1595 "vector::erase(iterator) called with an iterator not" 1596 " referring to this vector"); 1597#endif 1598 _LIBCPP_ASSERT(__position != end(), 1599 "vector::erase(iterator) called with a non-dereferenceable iterator"); 1600 pointer __p = const_cast<pointer>(&*__position); 1601 iterator __r = __make_iter(__p); 1602 this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p)); 1603 return __r; 1604} 1605 1606template <class _Tp, class _Allocator> 1607typename vector<_Tp, _Allocator>::iterator 1608vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last) 1609{ 1610#if _LIBCPP_DEBUG_LEVEL >= 2 1611 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this, 1612 "vector::erase(iterator, iterator) called with an iterator not" 1613 " referring to this vector"); 1614#endif 1615 _LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range"); 1616 pointer __p = this->__begin_ + (__first - begin()); 1617 iterator __r = __make_iter(__p); 1618 if (__first != __last) 1619 this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p)); 1620 return __r; 1621} 1622 1623template <class _Tp, class _Allocator> 1624void 1625vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to) 1626{ 1627 pointer __old_last = this->__end_; 1628 difference_type __n = __old_last - __to; 1629 for (pointer __i = __from_s + __n; __i < __from_e; ++__i, ++this->__end_) 1630 __alloc_traits::construct(this->__alloc(), 1631 _VSTD::__to_raw_pointer(this->__end_), 1632 _VSTD::move(*__i)); 1633 _VSTD::move_backward(__from_s, __from_s + __n, __old_last); 1634} 1635 1636template <class _Tp, class _Allocator> 1637typename vector<_Tp, _Allocator>::iterator 1638vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x) 1639{ 1640#if _LIBCPP_DEBUG_LEVEL >= 2 1641 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this, 1642 "vector::insert(iterator, x) called with an iterator not" 1643 " referring to this vector"); 1644#endif 1645 pointer __p = this->__begin_ + (__position - begin()); 1646 if (this->__end_ < this->__end_cap()) 1647 { 1648 if (__p == this->__end_) 1649 { 1650 __alloc_traits::construct(this->__alloc(), 1651 _VSTD::__to_raw_pointer(this->__end_), __x); 1652 ++this->__end_; 1653 } 1654 else 1655 { 1656 __move_range(__p, this->__end_, __p + 1); 1657 const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x); 1658 if (__p <= __xr && __xr < this->__end_) 1659 ++__xr; 1660 *__p = *__xr; 1661 } 1662 } 1663 else 1664 { 1665 allocator_type& __a = this->__alloc(); 1666 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a); 1667 __v.push_back(__x); 1668 __p = __swap_out_circular_buffer(__v, __p); 1669 } 1670 return __make_iter(__p); 1671} 1672 1673#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1674 1675template <class _Tp, class _Allocator> 1676typename vector<_Tp, _Allocator>::iterator 1677vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x) 1678{ 1679#if _LIBCPP_DEBUG_LEVEL >= 2 1680 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this, 1681 "vector::insert(iterator, x) called with an iterator not" 1682 " referring to this vector"); 1683#endif 1684 pointer __p = this->__begin_ + (__position - begin()); 1685 if (this->__end_ < this->__end_cap()) 1686 { 1687 if (__p == this->__end_) 1688 { 1689 __alloc_traits::construct(this->__alloc(), 1690 _VSTD::__to_raw_pointer(this->__end_), 1691 _VSTD::move(__x)); 1692 ++this->__end_; 1693 } 1694 else 1695 { 1696 __move_range(__p, this->__end_, __p + 1); 1697 *__p = _VSTD::move(__x); 1698 } 1699 } 1700 else 1701 { 1702 allocator_type& __a = this->__alloc(); 1703 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a); 1704 __v.push_back(_VSTD::move(__x)); 1705 __p = __swap_out_circular_buffer(__v, __p); 1706 } 1707 return __make_iter(__p); 1708} 1709 1710#ifndef _LIBCPP_HAS_NO_VARIADICS 1711 1712template <class _Tp, class _Allocator> 1713template <class... _Args> 1714typename vector<_Tp, _Allocator>::iterator 1715vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args) 1716{ 1717#if _LIBCPP_DEBUG_LEVEL >= 2 1718 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this, 1719 "vector::emplace(iterator, x) called with an iterator not" 1720 " referring to this vector"); 1721#endif 1722 pointer __p = this->__begin_ + (__position - begin()); 1723 if (this->__end_ < this->__end_cap()) 1724 { 1725 if (__p == this->__end_) 1726 { 1727 __alloc_traits::construct(this->__alloc(), 1728 _VSTD::__to_raw_pointer(this->__end_), 1729 _VSTD::forward<_Args>(__args)...); 1730 ++this->__end_; 1731 } 1732 else 1733 { 1734 value_type __tmp(_VSTD::forward<_Args>(__args)...); 1735 __move_range(__p, this->__end_, __p + 1); 1736 *__p = _VSTD::move(__tmp); 1737 } 1738 } 1739 else 1740 { 1741 allocator_type& __a = this->__alloc(); 1742 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a); 1743 __v.emplace_back(_VSTD::forward<_Args>(__args)...); 1744 __p = __swap_out_circular_buffer(__v, __p); 1745 } 1746 return __make_iter(__p); 1747} 1748 1749#endif // _LIBCPP_HAS_NO_VARIADICS 1750#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1751 1752template <class _Tp, class _Allocator> 1753typename vector<_Tp, _Allocator>::iterator 1754vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x) 1755{ 1756#if _LIBCPP_DEBUG_LEVEL >= 2 1757 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this, 1758 "vector::insert(iterator, n, x) called with an iterator not" 1759 " referring to this vector"); 1760#endif 1761 pointer __p = this->__begin_ + (__position - begin()); 1762 if (__n > 0) 1763 { 1764 if (__n <= static_cast<size_type>(this->__end_cap() - this->__end_)) 1765 { 1766 size_type __old_n = __n; 1767 pointer __old_last = this->__end_; 1768 if (__n > static_cast<size_type>(this->__end_ - __p)) 1769 { 1770 size_type __cx = __n - (this->__end_ - __p); 1771 __construct_at_end(__cx, __x); 1772 __n -= __cx; 1773 } 1774 if (__n > 0) 1775 { 1776 __move_range(__p, __old_last, __p + __old_n); 1777 const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x); 1778 if (__p <= __xr && __xr < this->__end_) 1779 __xr += __old_n; 1780 _VSTD::fill_n(__p, __n, *__xr); 1781 } 1782 } 1783 else 1784 { 1785 allocator_type& __a = this->__alloc(); 1786 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a); 1787 __v.__construct_at_end(__n, __x); 1788 __p = __swap_out_circular_buffer(__v, __p); 1789 } 1790 } 1791 return __make_iter(__p); 1792} 1793 1794template <class _Tp, class _Allocator> 1795template <class _InputIterator> 1796typename enable_if 1797< 1798 __is_input_iterator <_InputIterator>::value && 1799 !__is_forward_iterator<_InputIterator>::value && 1800 is_constructible< 1801 _Tp, 1802 typename iterator_traits<_InputIterator>::reference>::value, 1803 typename vector<_Tp, _Allocator>::iterator 1804>::type 1805vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last) 1806{ 1807#if _LIBCPP_DEBUG_LEVEL >= 2 1808 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this, 1809 "vector::insert(iterator, range) called with an iterator not" 1810 " referring to this vector"); 1811#endif 1812 difference_type __off = __position - begin(); 1813 pointer __p = this->__begin_ + __off; 1814 allocator_type& __a = this->__alloc(); 1815 pointer __old_last = this->__end_; 1816 for (; this->__end_ != this->__end_cap() && __first != __last; ++__first) 1817 { 1818 __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), 1819 *__first); 1820 ++this->__end_; 1821 } 1822 __split_buffer<value_type, allocator_type&> __v(__a); 1823 if (__first != __last) 1824 { 1825#ifndef _LIBCPP_NO_EXCEPTIONS 1826 try 1827 { 1828#endif // _LIBCPP_NO_EXCEPTIONS 1829 __v.__construct_at_end(__first, __last); 1830 difference_type __old_size = __old_last - this->__begin_; 1831 difference_type __old_p = __p - this->__begin_; 1832 reserve(__recommend(size() + __v.size())); 1833 __p = this->__begin_ + __old_p; 1834 __old_last = this->__begin_ + __old_size; 1835#ifndef _LIBCPP_NO_EXCEPTIONS 1836 } 1837 catch (...) 1838 { 1839 erase(__make_iter(__old_last), end()); 1840 throw; 1841 } 1842#endif // _LIBCPP_NO_EXCEPTIONS 1843 } 1844 __p = _VSTD::rotate(__p, __old_last, this->__end_); 1845 insert(__make_iter(__p), make_move_iterator(__v.begin()), 1846 make_move_iterator(__v.end())); 1847 return begin() + __off; 1848} 1849 1850template <class _Tp, class _Allocator> 1851template <class _ForwardIterator> 1852typename enable_if 1853< 1854 __is_forward_iterator<_ForwardIterator>::value && 1855 is_constructible< 1856 _Tp, 1857 typename iterator_traits<_ForwardIterator>::reference>::value, 1858 typename vector<_Tp, _Allocator>::iterator 1859>::type 1860vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) 1861{ 1862#if _LIBCPP_DEBUG_LEVEL >= 2 1863 _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this, 1864 "vector::insert(iterator, range) called with an iterator not" 1865 " referring to this vector"); 1866#endif 1867 pointer __p = this->__begin_ + (__position - begin()); 1868 difference_type __n = _VSTD::distance(__first, __last); 1869 if (__n > 0) 1870 { 1871 if (__n <= this->__end_cap() - this->__end_) 1872 { 1873 size_type __old_n = __n; 1874 pointer __old_last = this->__end_; 1875 _ForwardIterator __m = __last; 1876 difference_type __dx = this->__end_ - __p; 1877 if (__n > __dx) 1878 { 1879 __m = __first; 1880 _VSTD::advance(__m, this->__end_ - __p); 1881 __construct_at_end(__m, __last); 1882 __n = __dx; 1883 } 1884 if (__n > 0) 1885 { 1886 __move_range(__p, __old_last, __p + __old_n); 1887 _VSTD::copy(__first, __m, __p); 1888 } 1889 } 1890 else 1891 { 1892 allocator_type& __a = this->__alloc(); 1893 __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a); 1894 __v.__construct_at_end(__first, __last); 1895 __p = __swap_out_circular_buffer(__v, __p); 1896 } 1897 } 1898 return __make_iter(__p); 1899} 1900 1901template <class _Tp, class _Allocator> 1902void 1903vector<_Tp, _Allocator>::resize(size_type __sz) 1904{ 1905 size_type __cs = size(); 1906 if (__cs < __sz) 1907 this->__append(__sz - __cs); 1908 else if (__cs > __sz) 1909 this->__destruct_at_end(this->__begin_ + __sz); 1910} 1911 1912template <class _Tp, class _Allocator> 1913void 1914vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x) 1915{ 1916 size_type __cs = size(); 1917 if (__cs < __sz) 1918 this->__append(__sz - __cs, __x); 1919 else if (__cs > __sz) 1920 this->__destruct_at_end(this->__begin_ + __sz); 1921} 1922 1923template <class _Tp, class _Allocator> 1924void 1925vector<_Tp, _Allocator>::swap(vector& __x) 1926 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 1927 __is_nothrow_swappable<allocator_type>::value) 1928{ 1929 _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value || 1930 this->__alloc() == __x.__alloc(), 1931 "vector::swap: Either propagate_on_container_swap must be true" 1932 " or the allocators must compare equal"); 1933 _VSTD::swap(this->__begin_, __x.__begin_); 1934 _VSTD::swap(this->__end_, __x.__end_); 1935 _VSTD::swap(this->__end_cap(), __x.__end_cap()); 1936 __base::__swap_alloc(this->__alloc(), __x.__alloc()); 1937#if _LIBCPP_DEBUG_LEVEL >= 2 1938 __get_db()->swap(this, &__x); 1939#endif // _LIBCPP_DEBUG_LEVEL >= 2 1940} 1941 1942template <class _Tp, class _Allocator> 1943bool 1944vector<_Tp, _Allocator>::__invariants() const 1945{ 1946 if (this->__begin_ == 0) 1947 { 1948 if (this->__end_ != 0 || this->__end_cap() != 0) 1949 return false; 1950 } 1951 else 1952 { 1953 if (this->__begin_ > this->__end_) 1954 return false; 1955 if (this->__begin_ == this->__end_cap()) 1956 return false; 1957 if (this->__end_ > this->__end_cap()) 1958 return false; 1959 } 1960 return true; 1961} 1962 1963#if _LIBCPP_DEBUG_LEVEL >= 2 1964 1965template <class _Tp, class _Allocator> 1966bool 1967vector<_Tp, _Allocator>::__dereferenceable(const const_iterator* __i) const 1968{ 1969 return this->__begin_ <= __i->base() && __i->base() < this->__end_; 1970} 1971 1972template <class _Tp, class _Allocator> 1973bool 1974vector<_Tp, _Allocator>::__decrementable(const const_iterator* __i) const 1975{ 1976 return this->__begin_ < __i->base() && __i->base() <= this->__end_; 1977} 1978 1979template <class _Tp, class _Allocator> 1980bool 1981vector<_Tp, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const 1982{ 1983 const_pointer __p = __i->base() + __n; 1984 return this->__begin_ <= __p && __p <= this->__end_; 1985} 1986 1987template <class _Tp, class _Allocator> 1988bool 1989vector<_Tp, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const 1990{ 1991 const_pointer __p = __i->base() + __n; 1992 return this->__begin_ <= __p && __p < this->__end_; 1993} 1994 1995#endif // _LIBCPP_DEBUG_LEVEL >= 2 1996 1997template <class _Tp, class _Allocator> 1998_LIBCPP_INLINE_VISIBILITY inline 1999void 2000vector<_Tp, _Allocator>::__invalidate_all_iterators() 2001{ 2002#if _LIBCPP_DEBUG_LEVEL >= 2 2003 __get_db()->__invalidate_all(this); 2004#endif // _LIBCPP_DEBUG_LEVEL >= 2 2005} 2006 2007// vector<bool> 2008 2009template <class _Allocator> class vector<bool, _Allocator>; 2010 2011template <class _Allocator> struct hash<vector<bool, _Allocator> >; 2012 2013template <class _Allocator> 2014struct __has_storage_type<vector<bool, _Allocator> > 2015{ 2016 static const bool value = true; 2017}; 2018 2019template <class _Allocator> 2020class _LIBCPP_TYPE_VIS vector<bool, _Allocator> 2021 : private __vector_base_common<true> 2022{ 2023public: 2024 typedef vector __self; 2025 typedef bool value_type; 2026 typedef _Allocator allocator_type; 2027 typedef allocator_traits<allocator_type> __alloc_traits; 2028 typedef typename __alloc_traits::size_type size_type; 2029 typedef typename __alloc_traits::difference_type difference_type; 2030 typedef size_type __storage_type; 2031 typedef __bit_iterator<vector, false> pointer; 2032 typedef __bit_iterator<vector, true> const_pointer; 2033#ifdef _LIBCPP_DEBUG 2034 typedef __debug_iter<vector, pointer> iterator; 2035 typedef __debug_iter<vector, const_pointer> const_iterator; 2036 2037 friend class __debug_iter<vector, pointer>; 2038 friend class __debug_iter<vector, const_pointer>; 2039 2040 pair<iterator*, const_iterator*> __iterator_list_; 2041 2042 _LIBCPP_INLINE_VISIBILITY iterator*& __get_iterator_list(iterator*) {return __iterator_list_.first;} 2043 _LIBCPP_INLINE_VISIBILITY const_iterator*& __get_iterator_list(const_iterator*) {return __iterator_list_.second;} 2044#else // _LIBCPP_DEBUG 2045 typedef pointer iterator; 2046 typedef const_pointer const_iterator; 2047#endif // _LIBCPP_DEBUG 2048 typedef _VSTD::reverse_iterator<iterator> reverse_iterator; 2049 typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; 2050 2051private: 2052 typedef typename __alloc_traits::template 2053#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 2054 rebind_alloc<__storage_type> 2055#else 2056 rebind_alloc<__storage_type>::other 2057#endif 2058 __storage_allocator; 2059 typedef allocator_traits<__storage_allocator> __storage_traits; 2060 typedef typename __storage_traits::pointer __storage_pointer; 2061 typedef typename __storage_traits::const_pointer __const_storage_pointer; 2062 2063 __storage_pointer __begin_; 2064 size_type __size_; 2065 __compressed_pair<size_type, __storage_allocator> __cap_alloc_; 2066public: 2067 typedef __bit_reference<vector> reference; 2068 typedef __bit_const_reference<vector> const_reference; 2069private: 2070 _LIBCPP_INLINE_VISIBILITY 2071 size_type& __cap() _NOEXCEPT 2072 {return __cap_alloc_.first();} 2073 _LIBCPP_INLINE_VISIBILITY 2074 const size_type& __cap() const _NOEXCEPT 2075 {return __cap_alloc_.first();} 2076 _LIBCPP_INLINE_VISIBILITY 2077 __storage_allocator& __alloc() _NOEXCEPT 2078 {return __cap_alloc_.second();} 2079 _LIBCPP_INLINE_VISIBILITY 2080 const __storage_allocator& __alloc() const _NOEXCEPT 2081 {return __cap_alloc_.second();} 2082 2083 static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT); 2084 2085 _LIBCPP_INLINE_VISIBILITY 2086 static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT 2087 {return __n * __bits_per_word;} 2088 _LIBCPP_INLINE_VISIBILITY 2089 static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT 2090 {return (__n - 1) / __bits_per_word + 1;} 2091 2092public: 2093 _LIBCPP_INLINE_VISIBILITY 2094 vector() 2095 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); 2096 _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a); 2097 ~vector(); 2098 explicit vector(size_type __n); 2099 vector(size_type __n, const value_type& __v); 2100 vector(size_type __n, const value_type& __v, const allocator_type& __a); 2101 template <class _InputIterator> 2102 vector(_InputIterator __first, _InputIterator __last, 2103 typename enable_if<__is_input_iterator <_InputIterator>::value && 2104 !__is_forward_iterator<_InputIterator>::value>::type* = 0); 2105 template <class _InputIterator> 2106 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, 2107 typename enable_if<__is_input_iterator <_InputIterator>::value && 2108 !__is_forward_iterator<_InputIterator>::value>::type* = 0); 2109 template <class _ForwardIterator> 2110 vector(_ForwardIterator __first, _ForwardIterator __last, 2111 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0); 2112 template <class _ForwardIterator> 2113 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, 2114 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0); 2115 2116 vector(const vector& __v); 2117 vector(const vector& __v, const allocator_type& __a); 2118 vector& operator=(const vector& __v); 2119#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2120 vector(initializer_list<value_type> __il); 2121 vector(initializer_list<value_type> __il, const allocator_type& __a); 2122#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2123 2124#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2125 _LIBCPP_INLINE_VISIBILITY 2126 vector(vector&& __v) 2127 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); 2128 vector(vector&& __v, const allocator_type& __a); 2129 _LIBCPP_INLINE_VISIBILITY 2130 vector& operator=(vector&& __v) 2131 _NOEXCEPT_( 2132 __alloc_traits::propagate_on_container_move_assignment::value && 2133 is_nothrow_move_assignable<allocator_type>::value); 2134#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2135#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2136 _LIBCPP_INLINE_VISIBILITY 2137 vector& operator=(initializer_list<value_type> __il) 2138 {assign(__il.begin(), __il.end()); return *this;} 2139#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2140 2141 template <class _InputIterator> 2142 typename enable_if 2143 < 2144 __is_input_iterator<_InputIterator>::value && 2145 !__is_forward_iterator<_InputIterator>::value, 2146 void 2147 >::type 2148 assign(_InputIterator __first, _InputIterator __last); 2149 template <class _ForwardIterator> 2150 typename enable_if 2151 < 2152 __is_forward_iterator<_ForwardIterator>::value, 2153 void 2154 >::type 2155 assign(_ForwardIterator __first, _ForwardIterator __last); 2156 2157 void assign(size_type __n, const value_type& __x); 2158#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2159 _LIBCPP_INLINE_VISIBILITY 2160 void assign(initializer_list<value_type> __il) 2161 {assign(__il.begin(), __il.end());} 2162#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2163 2164 _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const _NOEXCEPT 2165 {return allocator_type(this->__alloc());} 2166 2167 size_type max_size() const _NOEXCEPT; 2168 _LIBCPP_INLINE_VISIBILITY 2169 size_type capacity() const _NOEXCEPT 2170 {return __internal_cap_to_external(__cap());} 2171 _LIBCPP_INLINE_VISIBILITY 2172 size_type size() const _NOEXCEPT 2173 {return __size_;} 2174 _LIBCPP_INLINE_VISIBILITY 2175 bool empty() const _NOEXCEPT 2176 {return __size_ == 0;} 2177 void reserve(size_type __n); 2178 void shrink_to_fit() _NOEXCEPT; 2179 2180 _LIBCPP_INLINE_VISIBILITY 2181 iterator begin() _NOEXCEPT 2182 {return __make_iter(0);} 2183 _LIBCPP_INLINE_VISIBILITY 2184 const_iterator begin() const _NOEXCEPT 2185 {return __make_iter(0);} 2186 _LIBCPP_INLINE_VISIBILITY 2187 iterator end() _NOEXCEPT 2188 {return __make_iter(__size_);} 2189 _LIBCPP_INLINE_VISIBILITY 2190 const_iterator end() const _NOEXCEPT 2191 {return __make_iter(__size_);} 2192 2193 _LIBCPP_INLINE_VISIBILITY 2194 reverse_iterator rbegin() _NOEXCEPT 2195 {return reverse_iterator(end());} 2196 _LIBCPP_INLINE_VISIBILITY 2197 const_reverse_iterator rbegin() const _NOEXCEPT 2198 {return const_reverse_iterator(end());} 2199 _LIBCPP_INLINE_VISIBILITY 2200 reverse_iterator rend() _NOEXCEPT 2201 {return reverse_iterator(begin());} 2202 _LIBCPP_INLINE_VISIBILITY 2203 const_reverse_iterator rend() const _NOEXCEPT 2204 {return const_reverse_iterator(begin());} 2205 2206 _LIBCPP_INLINE_VISIBILITY 2207 const_iterator cbegin() const _NOEXCEPT 2208 {return __make_iter(0);} 2209 _LIBCPP_INLINE_VISIBILITY 2210 const_iterator cend() const _NOEXCEPT 2211 {return __make_iter(__size_);} 2212 _LIBCPP_INLINE_VISIBILITY 2213 const_reverse_iterator crbegin() const _NOEXCEPT 2214 {return rbegin();} 2215 _LIBCPP_INLINE_VISIBILITY 2216 const_reverse_iterator crend() const _NOEXCEPT 2217 {return rend();} 2218 2219 _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) {return __make_ref(__n);} 2220 _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const {return __make_ref(__n);} 2221 reference at(size_type __n); 2222 const_reference at(size_type __n) const; 2223 2224 _LIBCPP_INLINE_VISIBILITY reference front() {return __make_ref(0);} 2225 _LIBCPP_INLINE_VISIBILITY const_reference front() const {return __make_ref(0);} 2226 _LIBCPP_INLINE_VISIBILITY reference back() {return __make_ref(__size_ - 1);} 2227 _LIBCPP_INLINE_VISIBILITY const_reference back() const {return __make_ref(__size_ - 1);} 2228 2229 void push_back(const value_type& __x); 2230 _LIBCPP_INLINE_VISIBILITY void pop_back() {--__size_;} 2231 2232 iterator insert(const_iterator __position, const value_type& __x); 2233 iterator insert(const_iterator __position, size_type __n, const value_type& __x); 2234 iterator insert(const_iterator __position, size_type __n, const_reference __x); 2235 template <class _InputIterator> 2236 typename enable_if 2237 < 2238 __is_input_iterator <_InputIterator>::value && 2239 !__is_forward_iterator<_InputIterator>::value, 2240 iterator 2241 >::type 2242 insert(const_iterator __position, _InputIterator __first, _InputIterator __last); 2243 template <class _ForwardIterator> 2244 typename enable_if 2245 < 2246 __is_forward_iterator<_ForwardIterator>::value, 2247 iterator 2248 >::type 2249 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last); 2250#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2251 _LIBCPP_INLINE_VISIBILITY 2252 iterator insert(const_iterator __position, initializer_list<value_type> __il) 2253 {return insert(__position, __il.begin(), __il.end());} 2254#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2255 2256 _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position); 2257 iterator erase(const_iterator __first, const_iterator __last); 2258 2259 _LIBCPP_INLINE_VISIBILITY 2260 void clear() _NOEXCEPT {__size_ = 0;} 2261 2262 void swap(vector&) 2263 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 2264 __is_nothrow_swappable<allocator_type>::value); 2265 2266 void resize(size_type __sz, value_type __x = false); 2267 void flip() _NOEXCEPT; 2268 2269 bool __invariants() const; 2270 2271private: 2272 _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators(); 2273 void allocate(size_type __n); 2274 void deallocate() _NOEXCEPT; 2275 _LIBCPP_INLINE_VISIBILITY 2276 static size_type __align(size_type __new_size) _NOEXCEPT 2277 {return __new_size + (__bits_per_word-1) & ~(__bits_per_word-1);}; 2278 _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const; 2279 _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x); 2280 template <class _ForwardIterator> 2281 typename enable_if 2282 < 2283 __is_forward_iterator<_ForwardIterator>::value, 2284 void 2285 >::type 2286 __construct_at_end(_ForwardIterator __first, _ForwardIterator __last); 2287 void __append(size_type __n, const_reference __x); 2288 _LIBCPP_INLINE_VISIBILITY 2289 reference __make_ref(size_type __pos) _NOEXCEPT 2290 {return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);} 2291 _LIBCPP_INLINE_VISIBILITY 2292 const_reference __make_ref(size_type __pos) const _NOEXCEPT 2293 {return const_reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);} 2294#ifdef _LIBCPP_DEBUG 2295 _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_type __pos) 2296 {return iterator(this, pointer(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word)));} 2297 _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_type __pos) const 2298 {return const_iterator(this, const_pointer(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word)));} 2299 _LIBCPP_INLINE_VISIBILITY iterator __const_iterator_cast(const_iterator __p) 2300 {return iterator(this, pointer(const_cast<__storage_pointer>(__p.base().__seg_), __p.base().__ctz_));} 2301#else // _LIBCPP_DEBUG 2302 _LIBCPP_INLINE_VISIBILITY 2303 iterator __make_iter(size_type __pos) _NOEXCEPT 2304 {return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));} 2305 _LIBCPP_INLINE_VISIBILITY 2306 const_iterator __make_iter(size_type __pos) const _NOEXCEPT 2307 {return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));} 2308 _LIBCPP_INLINE_VISIBILITY 2309 iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT 2310 {return iterator(const_cast<__storage_pointer>(__p.__seg_), __p.__ctz_);} 2311#endif // _LIBCPP_DEBUG 2312 2313 _LIBCPP_INLINE_VISIBILITY 2314 void __copy_assign_alloc(const vector& __v) 2315 {__copy_assign_alloc(__v, integral_constant<bool, 2316 __storage_traits::propagate_on_container_copy_assignment::value>());} 2317 _LIBCPP_INLINE_VISIBILITY 2318 void __copy_assign_alloc(const vector& __c, true_type) 2319 { 2320 if (__alloc() != __c.__alloc()) 2321 deallocate(); 2322 __alloc() = __c.__alloc(); 2323 } 2324 2325 _LIBCPP_INLINE_VISIBILITY 2326 void __copy_assign_alloc(const vector&, false_type) 2327 {} 2328 2329 void __move_assign(vector& __c, false_type); 2330 void __move_assign(vector& __c, true_type) 2331 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); 2332 _LIBCPP_INLINE_VISIBILITY 2333 void __move_assign_alloc(vector& __c) 2334 _NOEXCEPT_( 2335 !__storage_traits::propagate_on_container_move_assignment::value || 2336 is_nothrow_move_assignable<allocator_type>::value) 2337 {__move_assign_alloc(__c, integral_constant<bool, 2338 __storage_traits::propagate_on_container_move_assignment::value>());} 2339 _LIBCPP_INLINE_VISIBILITY 2340 void __move_assign_alloc(vector& __c, true_type) 2341 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 2342 { 2343 __alloc() = _VSTD::move(__c.__alloc()); 2344 } 2345 2346 _LIBCPP_INLINE_VISIBILITY 2347 void __move_assign_alloc(vector&, false_type) 2348 _NOEXCEPT 2349 {} 2350 2351 _LIBCPP_INLINE_VISIBILITY 2352 static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y) 2353 _NOEXCEPT_( 2354 !__storage_traits::propagate_on_container_swap::value || 2355 __is_nothrow_swappable<allocator_type>::value) 2356 {__swap_alloc(__x, __y, integral_constant<bool, 2357 __storage_traits::propagate_on_container_swap::value>());} 2358 2359 _LIBCPP_INLINE_VISIBILITY 2360 static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y, true_type) 2361 _NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value) 2362 { 2363 using _VSTD::swap; 2364 swap(__x, __y); 2365 } 2366 _LIBCPP_INLINE_VISIBILITY 2367 static void __swap_alloc(__storage_allocator&, __storage_allocator&, false_type) 2368 _NOEXCEPT 2369 {} 2370 2371 size_t __hash_code() const _NOEXCEPT; 2372 2373 friend class __bit_reference<vector>; 2374 friend class __bit_const_reference<vector>; 2375 friend class __bit_iterator<vector, false>; 2376 friend class __bit_iterator<vector, true>; 2377 friend struct __bit_array<vector>; 2378 friend struct _LIBCPP_TYPE_VIS hash<vector>; 2379}; 2380 2381template <class _Allocator> 2382#ifndef _LIBCPP_DEBUG 2383_LIBCPP_INLINE_VISIBILITY inline 2384#endif 2385void 2386vector<bool, _Allocator>::__invalidate_all_iterators() 2387{ 2388#ifdef _LIBCPP_DEBUG 2389 iterator::__remove_all(this); 2390 const_iterator::__remove_all(this); 2391#endif // _LIBCPP_DEBUG 2392} 2393 2394// Allocate space for __n objects 2395// throws length_error if __n > max_size() 2396// throws (probably bad_alloc) if memory run out 2397// Precondition: __begin_ == __end_ == __cap() == 0 2398// Precondition: __n > 0 2399// Postcondition: capacity() == __n 2400// Postcondition: size() == 0 2401template <class _Allocator> 2402void 2403vector<bool, _Allocator>::allocate(size_type __n) 2404{ 2405 if (__n > max_size()) 2406 this->__throw_length_error(); 2407 __n = __external_cap_to_internal(__n); 2408 this->__begin_ = __storage_traits::allocate(this->__alloc(), __n); 2409 this->__size_ = 0; 2410 this->__cap() = __n; 2411} 2412 2413template <class _Allocator> 2414void 2415vector<bool, _Allocator>::deallocate() _NOEXCEPT 2416{ 2417 if (this->__begin_ != 0) 2418 { 2419 __storage_traits::deallocate(this->__alloc(), this->__begin_, __cap()); 2420 __invalidate_all_iterators(); 2421 this->__begin_ = 0; 2422 this->__size_ = this->__cap() = 0; 2423 } 2424} 2425 2426template <class _Allocator> 2427typename vector<bool, _Allocator>::size_type 2428vector<bool, _Allocator>::max_size() const _NOEXCEPT 2429{ 2430 size_type __amax = __storage_traits::max_size(__alloc()); 2431 size_type __nmax = numeric_limits<size_type>::max() / 2; // end() >= begin(), always 2432 if (__nmax / __bits_per_word <= __amax) 2433 return __nmax; 2434 return __internal_cap_to_external(__amax); 2435} 2436 2437// Precondition: __new_size > capacity() 2438template <class _Allocator> 2439_LIBCPP_INLINE_VISIBILITY inline 2440typename vector<bool, _Allocator>::size_type 2441vector<bool, _Allocator>::__recommend(size_type __new_size) const 2442{ 2443 const size_type __ms = max_size(); 2444 if (__new_size > __ms) 2445 this->__throw_length_error(); 2446 const size_type __cap = capacity(); 2447 if (__cap >= __ms / 2) 2448 return __ms; 2449 return _VSTD::max(2*__cap, __align(__new_size)); 2450} 2451 2452// Default constructs __n objects starting at __end_ 2453// Precondition: __n > 0 2454// Precondition: size() + __n <= capacity() 2455// Postcondition: size() == size() + __n 2456template <class _Allocator> 2457_LIBCPP_INLINE_VISIBILITY inline 2458void 2459vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x) 2460{ 2461 size_type __old_size = this->__size_; 2462 this->__size_ += __n; 2463 _VSTD::fill_n(__make_iter(__old_size), __n, __x); 2464} 2465 2466template <class _Allocator> 2467template <class _ForwardIterator> 2468typename enable_if 2469< 2470 __is_forward_iterator<_ForwardIterator>::value, 2471 void 2472>::type 2473vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) 2474{ 2475 size_type __old_size = this->__size_; 2476 this->__size_ += _VSTD::distance(__first, __last); 2477 _VSTD::copy(__first, __last, __make_iter(__old_size)); 2478} 2479 2480template <class _Allocator> 2481_LIBCPP_INLINE_VISIBILITY inline 2482vector<bool, _Allocator>::vector() 2483 _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) 2484 : __begin_(0), 2485 __size_(0), 2486 __cap_alloc_(0) 2487{ 2488} 2489 2490template <class _Allocator> 2491_LIBCPP_INLINE_VISIBILITY inline 2492vector<bool, _Allocator>::vector(const allocator_type& __a) 2493 : __begin_(0), 2494 __size_(0), 2495 __cap_alloc_(0, static_cast<__storage_allocator>(__a)) 2496{ 2497} 2498 2499template <class _Allocator> 2500vector<bool, _Allocator>::vector(size_type __n) 2501 : __begin_(0), 2502 __size_(0), 2503 __cap_alloc_(0) 2504{ 2505 if (__n > 0) 2506 { 2507 allocate(__n); 2508 __construct_at_end(__n, false); 2509 } 2510} 2511 2512template <class _Allocator> 2513vector<bool, _Allocator>::vector(size_type __n, const value_type& __x) 2514 : __begin_(0), 2515 __size_(0), 2516 __cap_alloc_(0) 2517{ 2518 if (__n > 0) 2519 { 2520 allocate(__n); 2521 __construct_at_end(__n, __x); 2522 } 2523} 2524 2525template <class _Allocator> 2526vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a) 2527 : __begin_(0), 2528 __size_(0), 2529 __cap_alloc_(0, static_cast<__storage_allocator>(__a)) 2530{ 2531 if (__n > 0) 2532 { 2533 allocate(__n); 2534 __construct_at_end(__n, __x); 2535 } 2536} 2537 2538template <class _Allocator> 2539template <class _InputIterator> 2540vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, 2541 typename enable_if<__is_input_iterator <_InputIterator>::value && 2542 !__is_forward_iterator<_InputIterator>::value>::type*) 2543 : __begin_(0), 2544 __size_(0), 2545 __cap_alloc_(0) 2546{ 2547#ifndef _LIBCPP_NO_EXCEPTIONS 2548 try 2549 { 2550#endif // _LIBCPP_NO_EXCEPTIONS 2551 for (; __first != __last; ++__first) 2552 push_back(*__first); 2553#ifndef _LIBCPP_NO_EXCEPTIONS 2554 } 2555 catch (...) 2556 { 2557 if (__begin_ != 0) 2558 __storage_traits::deallocate(__alloc(), __begin_, __cap()); 2559 __invalidate_all_iterators(); 2560 throw; 2561 } 2562#endif // _LIBCPP_NO_EXCEPTIONS 2563} 2564 2565template <class _Allocator> 2566template <class _InputIterator> 2567vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, 2568 typename enable_if<__is_input_iterator <_InputIterator>::value && 2569 !__is_forward_iterator<_InputIterator>::value>::type*) 2570 : __begin_(0), 2571 __size_(0), 2572 __cap_alloc_(0, static_cast<__storage_allocator>(__a)) 2573{ 2574#ifndef _LIBCPP_NO_EXCEPTIONS 2575 try 2576 { 2577#endif // _LIBCPP_NO_EXCEPTIONS 2578 for (; __first != __last; ++__first) 2579 push_back(*__first); 2580#ifndef _LIBCPP_NO_EXCEPTIONS 2581 } 2582 catch (...) 2583 { 2584 if (__begin_ != 0) 2585 __storage_traits::deallocate(__alloc(), __begin_, __cap()); 2586 __invalidate_all_iterators(); 2587 throw; 2588 } 2589#endif // _LIBCPP_NO_EXCEPTIONS 2590} 2591 2592template <class _Allocator> 2593template <class _ForwardIterator> 2594vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, 2595 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*) 2596 : __begin_(0), 2597 __size_(0), 2598 __cap_alloc_(0) 2599{ 2600 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 2601 if (__n > 0) 2602 { 2603 allocate(__n); 2604 __construct_at_end(__first, __last); 2605 } 2606} 2607 2608template <class _Allocator> 2609template <class _ForwardIterator> 2610vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, 2611 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*) 2612 : __begin_(0), 2613 __size_(0), 2614 __cap_alloc_(0, static_cast<__storage_allocator>(__a)) 2615{ 2616 size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last)); 2617 if (__n > 0) 2618 { 2619 allocate(__n); 2620 __construct_at_end(__first, __last); 2621 } 2622} 2623 2624#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2625 2626template <class _Allocator> 2627vector<bool, _Allocator>::vector(initializer_list<value_type> __il) 2628 : __begin_(0), 2629 __size_(0), 2630 __cap_alloc_(0) 2631{ 2632 size_type __n = static_cast<size_type>(__il.size()); 2633 if (__n > 0) 2634 { 2635 allocate(__n); 2636 __construct_at_end(__il.begin(), __il.end()); 2637 } 2638} 2639 2640template <class _Allocator> 2641vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a) 2642 : __begin_(0), 2643 __size_(0), 2644 __cap_alloc_(0, static_cast<__storage_allocator>(__a)) 2645{ 2646 size_type __n = static_cast<size_type>(__il.size()); 2647 if (__n > 0) 2648 { 2649 allocate(__n); 2650 __construct_at_end(__il.begin(), __il.end()); 2651 } 2652} 2653 2654#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS 2655 2656template <class _Allocator> 2657vector<bool, _Allocator>::~vector() 2658{ 2659 if (__begin_ != 0) 2660 __storage_traits::deallocate(__alloc(), __begin_, __cap()); 2661#ifdef _LIBCPP_DEBUG 2662 __invalidate_all_iterators(); 2663#endif 2664} 2665 2666template <class _Allocator> 2667vector<bool, _Allocator>::vector(const vector& __v) 2668 : __begin_(0), 2669 __size_(0), 2670 __cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc())) 2671{ 2672 if (__v.size() > 0) 2673 { 2674 allocate(__v.size()); 2675 __construct_at_end(__v.begin(), __v.end()); 2676 } 2677} 2678 2679template <class _Allocator> 2680vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a) 2681 : __begin_(0), 2682 __size_(0), 2683 __cap_alloc_(0, __a) 2684{ 2685 if (__v.size() > 0) 2686 { 2687 allocate(__v.size()); 2688 __construct_at_end(__v.begin(), __v.end()); 2689 } 2690} 2691 2692template <class _Allocator> 2693vector<bool, _Allocator>& 2694vector<bool, _Allocator>::operator=(const vector& __v) 2695{ 2696 if (this != &__v) 2697 { 2698 __copy_assign_alloc(__v); 2699 if (__v.__size_) 2700 { 2701 if (__v.__size_ > capacity()) 2702 { 2703 deallocate(); 2704 allocate(__v.__size_); 2705 } 2706 _VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_); 2707 } 2708 __size_ = __v.__size_; 2709 } 2710 return *this; 2711} 2712 2713#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2714 2715template <class _Allocator> 2716_LIBCPP_INLINE_VISIBILITY inline 2717vector<bool, _Allocator>::vector(vector&& __v) 2718 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) 2719 : __begin_(__v.__begin_), 2720 __size_(__v.__size_), 2721 __cap_alloc_(__v.__cap_alloc_) 2722{ 2723 __v.__begin_ = 0; 2724 __v.__size_ = 0; 2725 __v.__cap() = 0; 2726} 2727 2728template <class _Allocator> 2729vector<bool, _Allocator>::vector(vector&& __v, const allocator_type& __a) 2730 : __begin_(0), 2731 __size_(0), 2732 __cap_alloc_(0, __a) 2733{ 2734 if (__a == allocator_type(__v.__alloc())) 2735 { 2736 this->__begin_ = __v.__begin_; 2737 this->__size_ = __v.__size_; 2738 this->__cap() = __v.__cap(); 2739 __v.__begin_ = nullptr; 2740 __v.__cap() = __v.__size_ = 0; 2741 } 2742 else if (__v.size() > 0) 2743 { 2744 allocate(__v.size()); 2745 __construct_at_end(__v.begin(), __v.end()); 2746 } 2747} 2748 2749template <class _Allocator> 2750_LIBCPP_INLINE_VISIBILITY inline 2751vector<bool, _Allocator>& 2752vector<bool, _Allocator>::operator=(vector&& __v) 2753 _NOEXCEPT_( 2754 __alloc_traits::propagate_on_container_move_assignment::value && 2755 is_nothrow_move_assignable<allocator_type>::value) 2756{ 2757 __move_assign(__v, integral_constant<bool, 2758 __storage_traits::propagate_on_container_move_assignment::value>()); 2759 return *this; 2760} 2761 2762template <class _Allocator> 2763void 2764vector<bool, _Allocator>::__move_assign(vector& __c, false_type) 2765{ 2766 if (__alloc() != __c.__alloc()) 2767 assign(__c.begin(), __c.end()); 2768 else 2769 __move_assign(__c, true_type()); 2770} 2771 2772template <class _Allocator> 2773void 2774vector<bool, _Allocator>::__move_assign(vector& __c, true_type) 2775 _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) 2776{ 2777 deallocate(); 2778 this->__begin_ = __c.__begin_; 2779 this->__size_ = __c.__size_; 2780 this->__cap() = __c.__cap(); 2781 __move_assign_alloc(__c); 2782 __c.__begin_ = nullptr; 2783 __c.__cap() = __c.__size_ = 0; 2784} 2785 2786#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2787 2788template <class _Allocator> 2789void 2790vector<bool, _Allocator>::assign(size_type __n, const value_type& __x) 2791{ 2792 __size_ = 0; 2793 if (__n > 0) 2794 { 2795 size_type __c = capacity(); 2796 if (__n <= __c) 2797 __size_ = __n; 2798 else 2799 { 2800 vector __v(__alloc()); 2801 __v.reserve(__recommend(__n)); 2802 __v.__size_ = __n; 2803 swap(__v); 2804 } 2805 _VSTD::fill_n(begin(), __n, __x); 2806 } 2807} 2808 2809template <class _Allocator> 2810template <class _InputIterator> 2811typename enable_if 2812< 2813 __is_input_iterator<_InputIterator>::value && 2814 !__is_forward_iterator<_InputIterator>::value, 2815 void 2816>::type 2817vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last) 2818{ 2819 clear(); 2820 for (; __first != __last; ++__first) 2821 push_back(*__first); 2822} 2823 2824template <class _Allocator> 2825template <class _ForwardIterator> 2826typename enable_if 2827< 2828 __is_forward_iterator<_ForwardIterator>::value, 2829 void 2830>::type 2831vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) 2832{ 2833 clear(); 2834 difference_type __n = _VSTD::distance(__first, __last); 2835 if (__n) 2836 { 2837 if (__n > capacity()) 2838 { 2839 deallocate(); 2840 allocate(__n); 2841 } 2842 __construct_at_end(__first, __last); 2843 } 2844} 2845 2846template <class _Allocator> 2847void 2848vector<bool, _Allocator>::reserve(size_type __n) 2849{ 2850 if (__n > capacity()) 2851 { 2852 vector __v(this->__alloc()); 2853 __v.allocate(__n); 2854 __v.__construct_at_end(this->begin(), this->end()); 2855 swap(__v); 2856 __invalidate_all_iterators(); 2857 } 2858} 2859 2860template <class _Allocator> 2861void 2862vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT 2863{ 2864 if (__external_cap_to_internal(size()) > __cap()) 2865 { 2866#ifndef _LIBCPP_NO_EXCEPTIONS 2867 try 2868 { 2869#endif // _LIBCPP_NO_EXCEPTIONS 2870 vector(*this, allocator_type(__alloc())).swap(*this); 2871#ifndef _LIBCPP_NO_EXCEPTIONS 2872 } 2873 catch (...) 2874 { 2875 } 2876#endif // _LIBCPP_NO_EXCEPTIONS 2877 } 2878} 2879 2880template <class _Allocator> 2881typename vector<bool, _Allocator>::reference 2882vector<bool, _Allocator>::at(size_type __n) 2883{ 2884 if (__n >= size()) 2885 this->__throw_out_of_range(); 2886 return (*this)[__n]; 2887} 2888 2889template <class _Allocator> 2890typename vector<bool, _Allocator>::const_reference 2891vector<bool, _Allocator>::at(size_type __n) const 2892{ 2893 if (__n >= size()) 2894 this->__throw_out_of_range(); 2895 return (*this)[__n]; 2896} 2897 2898template <class _Allocator> 2899void 2900vector<bool, _Allocator>::push_back(const value_type& __x) 2901{ 2902 if (this->__size_ == this->capacity()) 2903 reserve(__recommend(this->__size_ + 1)); 2904 ++this->__size_; 2905 back() = __x; 2906} 2907 2908template <class _Allocator> 2909typename vector<bool, _Allocator>::iterator 2910vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x) 2911{ 2912 iterator __r; 2913 if (size() < capacity()) 2914 { 2915 const_iterator __old_end = end(); 2916 ++__size_; 2917 _VSTD::copy_backward(__position, __old_end, end()); 2918 __r = __const_iterator_cast(__position); 2919 } 2920 else 2921 { 2922 vector __v(__alloc()); 2923 __v.reserve(__recommend(__size_ + 1)); 2924 __v.__size_ = __size_ + 1; 2925 __r = _VSTD::copy(cbegin(), __position, __v.begin()); 2926 _VSTD::copy_backward(__position, cend(), __v.end()); 2927 swap(__v); 2928 } 2929 *__r = __x; 2930 return __r; 2931} 2932 2933template <class _Allocator> 2934typename vector<bool, _Allocator>::iterator 2935vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x) 2936{ 2937 iterator __r; 2938 size_type __c = capacity(); 2939 if (__n <= __c && size() <= __c - __n) 2940 { 2941 const_iterator __old_end = end(); 2942 __size_ += __n; 2943 _VSTD::copy_backward(__position, __old_end, end()); 2944 __r = __const_iterator_cast(__position); 2945 } 2946 else 2947 { 2948 vector __v(__alloc()); 2949 __v.reserve(__recommend(__size_ + __n)); 2950 __v.__size_ = __size_ + __n; 2951 __r = _VSTD::copy(cbegin(), __position, __v.begin()); 2952 _VSTD::copy_backward(__position, cend(), __v.end()); 2953 swap(__v); 2954 } 2955 _VSTD::fill_n(__r, __n, __x); 2956 return __r; 2957} 2958 2959template <class _Allocator> 2960template <class _InputIterator> 2961typename enable_if 2962< 2963 __is_input_iterator <_InputIterator>::value && 2964 !__is_forward_iterator<_InputIterator>::value, 2965 typename vector<bool, _Allocator>::iterator 2966>::type 2967vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last) 2968{ 2969 difference_type __off = __position - begin(); 2970 iterator __p = __const_iterator_cast(__position); 2971 iterator __old_end = end(); 2972 for (; size() != capacity() && __first != __last; ++__first) 2973 { 2974 ++this->__size_; 2975 back() = *__first; 2976 } 2977 vector __v(__alloc()); 2978 if (__first != __last) 2979 { 2980#ifndef _LIBCPP_NO_EXCEPTIONS 2981 try 2982 { 2983#endif // _LIBCPP_NO_EXCEPTIONS 2984 __v.assign(__first, __last); 2985 difference_type __old_size = static_cast<difference_type>(__old_end - begin()); 2986 difference_type __old_p = __p - begin(); 2987 reserve(__recommend(size() + __v.size())); 2988 __p = begin() + __old_p; 2989 __old_end = begin() + __old_size; 2990#ifndef _LIBCPP_NO_EXCEPTIONS 2991 } 2992 catch (...) 2993 { 2994 erase(__old_end, end()); 2995 throw; 2996 } 2997#endif // _LIBCPP_NO_EXCEPTIONS 2998 } 2999 __p = _VSTD::rotate(__p, __old_end, end()); 3000 insert(__p, __v.begin(), __v.end()); 3001 return begin() + __off; 3002} 3003 3004template <class _Allocator> 3005template <class _ForwardIterator> 3006typename enable_if 3007< 3008 __is_forward_iterator<_ForwardIterator>::value, 3009 typename vector<bool, _Allocator>::iterator 3010>::type 3011vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) 3012{ 3013 difference_type __n = _VSTD::distance(__first, __last); 3014 iterator __r; 3015 size_type __c = capacity(); 3016 if (__n <= __c && size() <= __c - __n) 3017 { 3018 const_iterator __old_end = end(); 3019 __size_ += __n; 3020 _VSTD::copy_backward(__position, __old_end, end()); 3021 __r = __const_iterator_cast(__position); 3022 } 3023 else 3024 { 3025 vector __v(__alloc()); 3026 __v.reserve(__recommend(__size_ + __n)); 3027 __v.__size_ = __size_ + __n; 3028 __r = _VSTD::copy(cbegin(), __position, __v.begin()); 3029 _VSTD::copy_backward(__position, cend(), __v.end()); 3030 swap(__v); 3031 } 3032 _VSTD::copy(__first, __last, __r); 3033 return __r; 3034} 3035 3036template <class _Allocator> 3037_LIBCPP_INLINE_VISIBILITY inline 3038typename vector<bool, _Allocator>::iterator 3039vector<bool, _Allocator>::erase(const_iterator __position) 3040{ 3041 iterator __r = __const_iterator_cast(__position); 3042 _VSTD::copy(__position + 1, this->cend(), __r); 3043 --__size_; 3044 return __r; 3045} 3046 3047template <class _Allocator> 3048typename vector<bool, _Allocator>::iterator 3049vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last) 3050{ 3051 iterator __r = __const_iterator_cast(__first); 3052 difference_type __d = __last - __first; 3053 _VSTD::copy(__last, this->cend(), __r); 3054 __size_ -= __d; 3055 return __r; 3056} 3057 3058template <class _Allocator> 3059void 3060vector<bool, _Allocator>::swap(vector& __x) 3061 _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 3062 __is_nothrow_swappable<allocator_type>::value) 3063{ 3064 _VSTD::swap(this->__begin_, __x.__begin_); 3065 _VSTD::swap(this->__size_, __x.__size_); 3066 _VSTD::swap(this->__cap(), __x.__cap()); 3067 __swap_alloc(this->__alloc(), __x.__alloc()); 3068#ifdef _LIBCPP_DEBUG 3069 iterator::swap(this, &__x); 3070 const_iterator::swap(this, &__x); 3071#endif // _LIBCPP_DEBUG 3072} 3073 3074template <class _Allocator> 3075void 3076vector<bool, _Allocator>::resize(size_type __sz, value_type __x) 3077{ 3078 size_type __cs = size(); 3079 if (__cs < __sz) 3080 { 3081 iterator __r; 3082 size_type __c = capacity(); 3083 size_type __n = __sz - __cs; 3084 if (__n <= __c && __cs <= __c - __n) 3085 { 3086 __r = end(); 3087 __size_ += __n; 3088 } 3089 else 3090 { 3091 vector __v(__alloc()); 3092 __v.reserve(__recommend(__size_ + __n)); 3093 __v.__size_ = __size_ + __n; 3094 __r = _VSTD::copy(cbegin(), cend(), __v.begin()); 3095 swap(__v); 3096 } 3097 _VSTD::fill_n(__r, __n, __x); 3098 } 3099 else 3100 __size_ = __sz; 3101} 3102 3103template <class _Allocator> 3104void 3105vector<bool, _Allocator>::flip() _NOEXCEPT 3106{ 3107 // do middle whole words 3108 size_type __n = __size_; 3109 __storage_pointer __p = __begin_; 3110 for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word) 3111 *__p = ~*__p; 3112 // do last partial word 3113 if (__n > 0) 3114 { 3115 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 3116 __storage_type __b = *__p & __m; 3117 *__p &= ~__m; 3118 *__p |= ~__b & __m; 3119 } 3120} 3121 3122template <class _Allocator> 3123bool 3124vector<bool, _Allocator>::__invariants() const 3125{ 3126 if (this->__begin_ == 0) 3127 { 3128 if (this->__size_ != 0 || this->__cap() != 0) 3129 return false; 3130 } 3131 else 3132 { 3133 if (this->__cap() == 0) 3134 return false; 3135 if (this->__size_ > this->capacity()) 3136 return false; 3137 } 3138 return true; 3139} 3140 3141template <class _Allocator> 3142size_t 3143vector<bool, _Allocator>::__hash_code() const _NOEXCEPT 3144{ 3145 size_t __h = 0; 3146 // do middle whole words 3147 size_type __n = __size_; 3148 __storage_pointer __p = __begin_; 3149 for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word) 3150 __h ^= *__p; 3151 // do last partial word 3152 if (__n > 0) 3153 { 3154 const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 3155 __h ^= *__p & __m; 3156 } 3157 return __h; 3158} 3159 3160template <class _Allocator> 3161struct _LIBCPP_TYPE_VIS hash<vector<bool, _Allocator> > 3162 : public unary_function<vector<bool, _Allocator>, size_t> 3163{ 3164 _LIBCPP_INLINE_VISIBILITY 3165 size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT 3166 {return __vec.__hash_code();} 3167}; 3168 3169template <class _Tp, class _Allocator> 3170_LIBCPP_INLINE_VISIBILITY inline 3171bool 3172operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) 3173{ 3174 const typename vector<_Tp, _Allocator>::size_type __sz = __x.size(); 3175 return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); 3176} 3177 3178template <class _Tp, class _Allocator> 3179_LIBCPP_INLINE_VISIBILITY inline 3180bool 3181operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) 3182{ 3183 return !(__x == __y); 3184} 3185 3186template <class _Tp, class _Allocator> 3187_LIBCPP_INLINE_VISIBILITY inline 3188bool 3189operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) 3190{ 3191 return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); 3192} 3193 3194template <class _Tp, class _Allocator> 3195_LIBCPP_INLINE_VISIBILITY inline 3196bool 3197operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) 3198{ 3199 return __y < __x; 3200} 3201 3202template <class _Tp, class _Allocator> 3203_LIBCPP_INLINE_VISIBILITY inline 3204bool 3205operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) 3206{ 3207 return !(__x < __y); 3208} 3209 3210template <class _Tp, class _Allocator> 3211_LIBCPP_INLINE_VISIBILITY inline 3212bool 3213operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) 3214{ 3215 return !(__y < __x); 3216} 3217 3218template <class _Tp, class _Allocator> 3219_LIBCPP_INLINE_VISIBILITY inline 3220void 3221swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y) 3222 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 3223{ 3224 __x.swap(__y); 3225} 3226 3227_LIBCPP_END_NAMESPACE_STD 3228 3229#endif // _LIBCPP_VECTOR 3230