1 // -*- C++ -*- 2 //===-------------------------- memory ------------------------------------===// 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_MEMORY 12 #define _LIBCPP_MEMORY 13 14 /* 15 memory synopsis 16 17 namespace std 18 { 19 20 struct allocator_arg_t { }; 21 inline constexpr allocator_arg_t allocator_arg = allocator_arg_t(); 22 23 template <class T, class Alloc> struct uses_allocator; 24 25 template <class Ptr> 26 struct pointer_traits 27 { 28 typedef Ptr pointer; 29 typedef <details> element_type; 30 typedef <details> difference_type; 31 32 template <class U> using rebind = <details>; 33 34 static pointer pointer_to(<details>); 35 }; 36 37 template <class T> 38 struct pointer_traits<T*> 39 { 40 typedef T* pointer; 41 typedef T element_type; 42 typedef ptrdiff_t difference_type; 43 44 template <class U> using rebind = U*; 45 46 static pointer pointer_to(<details>) noexcept; 47 }; 48 49 template <class T> constexpr T* to_address(T* p) noexcept; // C++20 50 template <class Ptr> auto to_address(const Ptr& p) noexcept; // C++20 51 52 template <class Alloc> 53 struct allocator_traits 54 { 55 typedef Alloc allocator_type; 56 typedef typename allocator_type::value_type 57 value_type; 58 59 typedef Alloc::pointer | value_type* pointer; 60 typedef Alloc::const_pointer 61 | pointer_traits<pointer>::rebind<const value_type> 62 const_pointer; 63 typedef Alloc::void_pointer 64 | pointer_traits<pointer>::rebind<void> 65 void_pointer; 66 typedef Alloc::const_void_pointer 67 | pointer_traits<pointer>::rebind<const void> 68 const_void_pointer; 69 typedef Alloc::difference_type 70 | pointer_traits<pointer>::difference_type 71 difference_type; 72 typedef Alloc::size_type 73 | make_unsigned<difference_type>::type 74 size_type; 75 typedef Alloc::propagate_on_container_copy_assignment 76 | false_type propagate_on_container_copy_assignment; 77 typedef Alloc::propagate_on_container_move_assignment 78 | false_type propagate_on_container_move_assignment; 79 typedef Alloc::propagate_on_container_swap 80 | false_type propagate_on_container_swap; 81 typedef Alloc::is_always_equal 82 | is_empty is_always_equal; 83 84 template <class T> using rebind_alloc = Alloc::rebind<U>::other | Alloc<T, Args...>; 85 template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>; 86 87 static pointer allocate(allocator_type& a, size_type n); // [[nodiscard]] in C++20 88 static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); // [[nodiscard]] in C++20 89 90 static void deallocate(allocator_type& a, pointer p, size_type n) noexcept; 91 92 template <class T, class... Args> 93 static void construct(allocator_type& a, T* p, Args&&... args); 94 95 template <class T> 96 static void destroy(allocator_type& a, T* p); 97 98 static size_type max_size(const allocator_type& a); // noexcept in C++14 99 100 static allocator_type 101 select_on_container_copy_construction(const allocator_type& a); 102 }; 103 104 template <> 105 class allocator<void> 106 { 107 public: 108 typedef void* pointer; 109 typedef const void* const_pointer; 110 typedef void value_type; 111 112 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 113 }; 114 115 template <class T> 116 class allocator 117 { 118 public: 119 typedef size_t size_type; 120 typedef ptrdiff_t difference_type; 121 typedef T* pointer; 122 typedef const T* const_pointer; 123 typedef typename add_lvalue_reference<T>::type reference; 124 typedef typename add_lvalue_reference<const T>::type const_reference; 125 typedef T value_type; 126 127 template <class U> struct rebind {typedef allocator<U> other;}; 128 129 allocator() noexcept; 130 allocator(const allocator&) noexcept; 131 template <class U> allocator(const allocator<U>&) noexcept; 132 ~allocator(); 133 pointer address(reference x) const noexcept; 134 const_pointer address(const_reference x) const noexcept; 135 pointer allocate(size_type, allocator<void>::const_pointer hint = 0); 136 void deallocate(pointer p, size_type n) noexcept; 137 size_type max_size() const noexcept; 138 template<class U, class... Args> 139 void construct(U* p, Args&&... args); 140 template <class U> 141 void destroy(U* p); 142 }; 143 144 template <class T, class U> 145 bool operator==(const allocator<T>&, const allocator<U>&) noexcept; 146 147 template <class T, class U> 148 bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; 149 150 template <class OutputIterator, class T> 151 class raw_storage_iterator 152 : public iterator<output_iterator_tag, 153 T, // purposefully not C++03 154 ptrdiff_t, // purposefully not C++03 155 T*, // purposefully not C++03 156 raw_storage_iterator&> // purposefully not C++03 157 { 158 public: 159 explicit raw_storage_iterator(OutputIterator x); 160 raw_storage_iterator& operator*(); 161 raw_storage_iterator& operator=(const T& element); 162 raw_storage_iterator& operator++(); 163 raw_storage_iterator operator++(int); 164 }; 165 166 template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept; 167 template <class T> void return_temporary_buffer(T* p) noexcept; 168 169 template <class T> T* addressof(T& r) noexcept; 170 template <class T> T* addressof(const T&& r) noexcept = delete; 171 172 template <class InputIterator, class ForwardIterator> 173 ForwardIterator 174 uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); 175 176 template <class InputIterator, class Size, class ForwardIterator> 177 ForwardIterator 178 uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result); 179 180 template <class ForwardIterator, class T> 181 void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); 182 183 template <class ForwardIterator, class Size, class T> 184 ForwardIterator 185 uninitialized_fill_n(ForwardIterator first, Size n, const T& x); 186 187 template <class T> 188 void destroy_at(T* location); 189 190 template <class ForwardIterator> 191 void destroy(ForwardIterator first, ForwardIterator last); 192 193 template <class ForwardIterator, class Size> 194 ForwardIterator destroy_n(ForwardIterator first, Size n); 195 196 template <class InputIterator, class ForwardIterator> 197 ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result); 198 199 template <class InputIterator, class Size, class ForwardIterator> 200 pair<InputIterator,ForwardIterator> uninitialized_move_n(InputIterator first, Size n, ForwardIterator result); 201 202 template <class ForwardIterator> 203 void uninitialized_value_construct(ForwardIterator first, ForwardIterator last); 204 205 template <class ForwardIterator, class Size> 206 ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n); 207 208 template <class ForwardIterator> 209 void uninitialized_default_construct(ForwardIterator first, ForwardIterator last); 210 211 template <class ForwardIterator, class Size> 212 ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n); 213 214 template <class Y> struct auto_ptr_ref {}; // removed in C++17 215 216 template<class X> 217 class auto_ptr // removed in C++17 218 { 219 public: 220 typedef X element_type; 221 222 explicit auto_ptr(X* p =0) throw(); 223 auto_ptr(auto_ptr&) throw(); 224 template<class Y> auto_ptr(auto_ptr<Y>&) throw(); 225 auto_ptr& operator=(auto_ptr&) throw(); 226 template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw(); 227 auto_ptr& operator=(auto_ptr_ref<X> r) throw(); 228 ~auto_ptr() throw(); 229 230 typename add_lvalue_reference<X>::type operator*() const throw(); 231 X* operator->() const throw(); 232 X* get() const throw(); 233 X* release() throw(); 234 void reset(X* p =0) throw(); 235 236 auto_ptr(auto_ptr_ref<X>) throw(); 237 template<class Y> operator auto_ptr_ref<Y>() throw(); 238 template<class Y> operator auto_ptr<Y>() throw(); 239 }; 240 241 template <class T> 242 struct default_delete 243 { 244 constexpr default_delete() noexcept = default; 245 template <class U> default_delete(const default_delete<U>&) noexcept; 246 247 void operator()(T*) const noexcept; 248 }; 249 250 template <class T> 251 struct default_delete<T[]> 252 { 253 constexpr default_delete() noexcept = default; 254 void operator()(T*) const noexcept; 255 template <class U> void operator()(U*) const = delete; 256 }; 257 258 template <class T, class D = default_delete<T>> 259 class unique_ptr 260 { 261 public: 262 typedef see below pointer; 263 typedef T element_type; 264 typedef D deleter_type; 265 266 // constructors 267 constexpr unique_ptr() noexcept; 268 explicit unique_ptr(pointer p) noexcept; 269 unique_ptr(pointer p, see below d1) noexcept; 270 unique_ptr(pointer p, see below d2) noexcept; 271 unique_ptr(unique_ptr&& u) noexcept; 272 unique_ptr(nullptr_t) noexcept : unique_ptr() { } 273 template <class U, class E> 274 unique_ptr(unique_ptr<U, E>&& u) noexcept; 275 template <class U> 276 unique_ptr(auto_ptr<U>&& u) noexcept; // removed in C++17 277 278 // destructor 279 ~unique_ptr(); 280 281 // assignment 282 unique_ptr& operator=(unique_ptr&& u) noexcept; 283 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept; 284 unique_ptr& operator=(nullptr_t) noexcept; 285 286 // observers 287 typename add_lvalue_reference<T>::type operator*() const; 288 pointer operator->() const noexcept; 289 pointer get() const noexcept; 290 deleter_type& get_deleter() noexcept; 291 const deleter_type& get_deleter() const noexcept; 292 explicit operator bool() const noexcept; 293 294 // modifiers 295 pointer release() noexcept; 296 void reset(pointer p = pointer()) noexcept; 297 void swap(unique_ptr& u) noexcept; 298 }; 299 300 template <class T, class D> 301 class unique_ptr<T[], D> 302 { 303 public: 304 typedef implementation-defined pointer; 305 typedef T element_type; 306 typedef D deleter_type; 307 308 // constructors 309 constexpr unique_ptr() noexcept; 310 explicit unique_ptr(pointer p) noexcept; 311 unique_ptr(pointer p, see below d) noexcept; 312 unique_ptr(pointer p, see below d) noexcept; 313 unique_ptr(unique_ptr&& u) noexcept; 314 unique_ptr(nullptr_t) noexcept : unique_ptr() { } 315 316 // destructor 317 ~unique_ptr(); 318 319 // assignment 320 unique_ptr& operator=(unique_ptr&& u) noexcept; 321 unique_ptr& operator=(nullptr_t) noexcept; 322 323 // observers 324 T& operator[](size_t i) const; 325 pointer get() const noexcept; 326 deleter_type& get_deleter() noexcept; 327 const deleter_type& get_deleter() const noexcept; 328 explicit operator bool() const noexcept; 329 330 // modifiers 331 pointer release() noexcept; 332 void reset(pointer p = pointer()) noexcept; 333 void reset(nullptr_t) noexcept; 334 template <class U> void reset(U) = delete; 335 void swap(unique_ptr& u) noexcept; 336 }; 337 338 template <class T, class D> 339 void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; 340 341 template <class T1, class D1, class T2, class D2> 342 bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 343 template <class T1, class D1, class T2, class D2> 344 bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 345 template <class T1, class D1, class T2, class D2> 346 bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 347 template <class T1, class D1, class T2, class D2> 348 bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 349 template <class T1, class D1, class T2, class D2> 350 bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 351 template <class T1, class D1, class T2, class D2> 352 bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 353 354 template <class T, class D> 355 bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; 356 template <class T, class D> 357 bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept; 358 template <class T, class D> 359 bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept; 360 template <class T, class D> 361 bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept; 362 363 template <class T, class D> 364 bool operator<(const unique_ptr<T, D>& x, nullptr_t); 365 template <class T, class D> 366 bool operator<(nullptr_t, const unique_ptr<T, D>& y); 367 template <class T, class D> 368 bool operator<=(const unique_ptr<T, D>& x, nullptr_t); 369 template <class T, class D> 370 bool operator<=(nullptr_t, const unique_ptr<T, D>& y); 371 template <class T, class D> 372 bool operator>(const unique_ptr<T, D>& x, nullptr_t); 373 template <class T, class D> 374 bool operator>(nullptr_t, const unique_ptr<T, D>& y); 375 template <class T, class D> 376 bool operator>=(const unique_ptr<T, D>& x, nullptr_t); 377 template <class T, class D> 378 bool operator>=(nullptr_t, const unique_ptr<T, D>& y); 379 380 class bad_weak_ptr 381 : public std::exception 382 { 383 bad_weak_ptr() noexcept; 384 }; 385 386 template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args); // C++14 387 template<class T> unique_ptr<T> make_unique(size_t n); // C++14 388 template<class T, class... Args> unspecified make_unique(Args&&...) = delete; // C++14, T == U[N] 389 390 template<class E, class T, class Y, class D> 391 basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, unique_ptr<Y, D> const& p); 392 393 template<class T> 394 class shared_ptr 395 { 396 public: 397 typedef T element_type; 398 typedef weak_ptr<T> weak_type; // C++17 399 400 // constructors: 401 constexpr shared_ptr() noexcept; 402 template<class Y> explicit shared_ptr(Y* p); 403 template<class Y, class D> shared_ptr(Y* p, D d); 404 template<class Y, class D, class A> shared_ptr(Y* p, D d, A a); 405 template <class D> shared_ptr(nullptr_t p, D d); 406 template <class D, class A> shared_ptr(nullptr_t p, D d, A a); 407 template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept; 408 shared_ptr(const shared_ptr& r) noexcept; 409 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept; 410 shared_ptr(shared_ptr&& r) noexcept; 411 template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept; 412 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r); 413 template<class Y> shared_ptr(auto_ptr<Y>&& r); // removed in C++17 414 template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r); 415 shared_ptr(nullptr_t) : shared_ptr() { } 416 417 // destructor: 418 ~shared_ptr(); 419 420 // assignment: 421 shared_ptr& operator=(const shared_ptr& r) noexcept; 422 template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept; 423 shared_ptr& operator=(shared_ptr&& r) noexcept; 424 template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r); 425 template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); // removed in C++17 426 template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r); 427 428 // modifiers: 429 void swap(shared_ptr& r) noexcept; 430 void reset() noexcept; 431 template<class Y> void reset(Y* p); 432 template<class Y, class D> void reset(Y* p, D d); 433 template<class Y, class D, class A> void reset(Y* p, D d, A a); 434 435 // observers: 436 T* get() const noexcept; 437 T& operator*() const noexcept; 438 T* operator->() const noexcept; 439 long use_count() const noexcept; 440 bool unique() const noexcept; 441 explicit operator bool() const noexcept; 442 template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept; 443 template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept; 444 }; 445 446 // shared_ptr comparisons: 447 template<class T, class U> 448 bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 449 template<class T, class U> 450 bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 451 template<class T, class U> 452 bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 453 template<class T, class U> 454 bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 455 template<class T, class U> 456 bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 457 template<class T, class U> 458 bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 459 460 template <class T> 461 bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept; 462 template <class T> 463 bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept; 464 template <class T> 465 bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept; 466 template <class T> 467 bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept; 468 template <class T> 469 bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept; 470 template <class T> 471 bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept; 472 template <class T> 473 bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept; 474 template <class T> 475 bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept; 476 template <class T> 477 bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept; 478 template <class T> 479 bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept; 480 template <class T> 481 bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept; 482 template <class T> 483 bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept; 484 485 // shared_ptr specialized algorithms: 486 template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept; 487 488 // shared_ptr casts: 489 template<class T, class U> 490 shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept; 491 template<class T, class U> 492 shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept; 493 template<class T, class U> 494 shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept; 495 496 // shared_ptr I/O: 497 template<class E, class T, class Y> 498 basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p); 499 500 // shared_ptr get_deleter: 501 template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept; 502 503 template<class T, class... Args> 504 shared_ptr<T> make_shared(Args&&... args); 505 template<class T, class A, class... Args> 506 shared_ptr<T> allocate_shared(const A& a, Args&&... args); 507 508 template<class T> 509 class weak_ptr 510 { 511 public: 512 typedef T element_type; 513 514 // constructors 515 constexpr weak_ptr() noexcept; 516 template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept; 517 weak_ptr(weak_ptr const& r) noexcept; 518 template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept; 519 weak_ptr(weak_ptr&& r) noexcept; // C++14 520 template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept; // C++14 521 522 // destructor 523 ~weak_ptr(); 524 525 // assignment 526 weak_ptr& operator=(weak_ptr const& r) noexcept; 527 template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept; 528 template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept; 529 weak_ptr& operator=(weak_ptr&& r) noexcept; // C++14 530 template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept; // C++14 531 532 // modifiers 533 void swap(weak_ptr& r) noexcept; 534 void reset() noexcept; 535 536 // observers 537 long use_count() const noexcept; 538 bool expired() const noexcept; 539 shared_ptr<T> lock() const noexcept; 540 template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept; 541 template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept; 542 }; 543 544 // weak_ptr specialized algorithms: 545 template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept; 546 547 // class owner_less: 548 template<class T> struct owner_less; 549 550 template<class T> 551 struct owner_less<shared_ptr<T>> 552 : binary_function<shared_ptr<T>, shared_ptr<T>, bool> 553 { 554 typedef bool result_type; 555 bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const noexcept; 556 bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept; 557 bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept; 558 }; 559 560 template<class T> 561 struct owner_less<weak_ptr<T>> 562 : binary_function<weak_ptr<T>, weak_ptr<T>, bool> 563 { 564 typedef bool result_type; 565 bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const noexcept; 566 bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept; 567 bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept; 568 }; 569 570 template <> // Added in C++14 571 struct owner_less<void> 572 { 573 template <class _Tp, class _Up> 574 bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const noexcept; 575 template <class _Tp, class _Up> 576 bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const noexcept; 577 template <class _Tp, class _Up> 578 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const noexcept; 579 template <class _Tp, class _Up> 580 bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const noexcept; 581 582 typedef void is_transparent; 583 }; 584 585 template<class T> 586 class enable_shared_from_this 587 { 588 protected: 589 constexpr enable_shared_from_this() noexcept; 590 enable_shared_from_this(enable_shared_from_this const&) noexcept; 591 enable_shared_from_this& operator=(enable_shared_from_this const&) noexcept; 592 ~enable_shared_from_this(); 593 public: 594 shared_ptr<T> shared_from_this(); 595 shared_ptr<T const> shared_from_this() const; 596 }; 597 598 template<class T> 599 bool atomic_is_lock_free(const shared_ptr<T>* p); 600 template<class T> 601 shared_ptr<T> atomic_load(const shared_ptr<T>* p); 602 template<class T> 603 shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo); 604 template<class T> 605 void atomic_store(shared_ptr<T>* p, shared_ptr<T> r); 606 template<class T> 607 void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 608 template<class T> 609 shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r); 610 template<class T> 611 shared_ptr<T> 612 atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 613 template<class T> 614 bool 615 atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 616 template<class T> 617 bool 618 atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 619 template<class T> 620 bool 621 atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 622 shared_ptr<T> w, memory_order success, 623 memory_order failure); 624 template<class T> 625 bool 626 atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 627 shared_ptr<T> w, memory_order success, 628 memory_order failure); 629 // Hash support 630 template <class T> struct hash; 631 template <class T, class D> struct hash<unique_ptr<T, D> >; 632 template <class T> struct hash<shared_ptr<T> >; 633 634 template <class T, class Alloc> 635 inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value; 636 637 // Pointer safety 638 enum class pointer_safety { relaxed, preferred, strict }; 639 void declare_reachable(void *p); 640 template <class T> T *undeclare_reachable(T *p); 641 void declare_no_pointers(char *p, size_t n); 642 void undeclare_no_pointers(char *p, size_t n); 643 pointer_safety get_pointer_safety() noexcept; 644 645 void* align(size_t alignment, size_t size, void*& ptr, size_t& space); 646 647 } // std 648 649 */ 650 651 #include <__config> 652 #include <type_traits> 653 #include <typeinfo> 654 #include <cstddef> 655 #include <cstdint> 656 #include <new> 657 #include <utility> 658 #include <limits> 659 #include <iterator> 660 #include <__functional_base> 661 #include <iosfwd> 662 #include <tuple> 663 #include <stdexcept> 664 #include <cstring> 665 #include <cassert> 666 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) 667 # include <atomic> 668 #endif 669 670 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 671 #pragma GCC system_header 672 #endif 673 674 _LIBCPP_PUSH_MACROS 675 #include <__undef_macros> 676 677 678 _LIBCPP_BEGIN_NAMESPACE_STD 679 680 template <class _ValueType> 681 inline _LIBCPP_ALWAYS_INLINE 682 _ValueType __libcpp_relaxed_load(_ValueType const* __value) { 683 #if !defined(_LIBCPP_HAS_NO_THREADS) && \ 684 defined(__ATOMIC_RELAXED) && \ 685 (__has_builtin(__atomic_load_n) || _GNUC_VER >= 407) 686 return __atomic_load_n(__value, __ATOMIC_RELAXED); 687 #else 688 return *__value; 689 #endif 690 } 691 692 template <class _ValueType> 693 inline _LIBCPP_ALWAYS_INLINE 694 _ValueType __libcpp_acquire_load(_ValueType const* __value) { 695 #if !defined(_LIBCPP_HAS_NO_THREADS) && \ 696 defined(__ATOMIC_ACQUIRE) && \ 697 (__has_builtin(__atomic_load_n) || _GNUC_VER >= 407) 698 return __atomic_load_n(__value, __ATOMIC_ACQUIRE); 699 #else 700 return *__value; 701 #endif 702 } 703 704 // addressof moved to <type_traits> 705 706 template <class _Tp> class allocator; 707 708 template <> 709 class _LIBCPP_TEMPLATE_VIS allocator<void> 710 { 711 public: 712 typedef void* pointer; 713 typedef const void* const_pointer; 714 typedef void value_type; 715 716 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 717 }; 718 719 template <> 720 class _LIBCPP_TEMPLATE_VIS allocator<const void> 721 { 722 public: 723 typedef const void* pointer; 724 typedef const void* const_pointer; 725 typedef const void value_type; 726 727 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 728 }; 729 730 // pointer_traits 731 732 template <class _Tp, class = void> 733 struct __has_element_type : false_type {}; 734 735 template <class _Tp> 736 struct __has_element_type<_Tp, 737 typename __void_t<typename _Tp::element_type>::type> : true_type {}; 738 739 template <class _Ptr, bool = __has_element_type<_Ptr>::value> 740 struct __pointer_traits_element_type; 741 742 template <class _Ptr> 743 struct __pointer_traits_element_type<_Ptr, true> 744 { 745 typedef typename _Ptr::element_type type; 746 }; 747 748 #ifndef _LIBCPP_HAS_NO_VARIADICS 749 750 template <template <class, class...> class _Sp, class _Tp, class ..._Args> 751 struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true> 752 { 753 typedef typename _Sp<_Tp, _Args...>::element_type type; 754 }; 755 756 template <template <class, class...> class _Sp, class _Tp, class ..._Args> 757 struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false> 758 { 759 typedef _Tp type; 760 }; 761 762 #else // _LIBCPP_HAS_NO_VARIADICS 763 764 template <template <class> class _Sp, class _Tp> 765 struct __pointer_traits_element_type<_Sp<_Tp>, true> 766 { 767 typedef typename _Sp<_Tp>::element_type type; 768 }; 769 770 template <template <class> class _Sp, class _Tp> 771 struct __pointer_traits_element_type<_Sp<_Tp>, false> 772 { 773 typedef _Tp type; 774 }; 775 776 template <template <class, class> class _Sp, class _Tp, class _A0> 777 struct __pointer_traits_element_type<_Sp<_Tp, _A0>, true> 778 { 779 typedef typename _Sp<_Tp, _A0>::element_type type; 780 }; 781 782 template <template <class, class> class _Sp, class _Tp, class _A0> 783 struct __pointer_traits_element_type<_Sp<_Tp, _A0>, false> 784 { 785 typedef _Tp type; 786 }; 787 788 template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1> 789 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, true> 790 { 791 typedef typename _Sp<_Tp, _A0, _A1>::element_type type; 792 }; 793 794 template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1> 795 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, false> 796 { 797 typedef _Tp type; 798 }; 799 800 template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 801 class _A1, class _A2> 802 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, true> 803 { 804 typedef typename _Sp<_Tp, _A0, _A1, _A2>::element_type type; 805 }; 806 807 template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 808 class _A1, class _A2> 809 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, false> 810 { 811 typedef _Tp type; 812 }; 813 814 #endif // _LIBCPP_HAS_NO_VARIADICS 815 816 template <class _Tp, class = void> 817 struct __has_difference_type : false_type {}; 818 819 template <class _Tp> 820 struct __has_difference_type<_Tp, 821 typename __void_t<typename _Tp::difference_type>::type> : true_type {}; 822 823 template <class _Ptr, bool = __has_difference_type<_Ptr>::value> 824 struct __pointer_traits_difference_type 825 { 826 typedef ptrdiff_t type; 827 }; 828 829 template <class _Ptr> 830 struct __pointer_traits_difference_type<_Ptr, true> 831 { 832 typedef typename _Ptr::difference_type type; 833 }; 834 835 template <class _Tp, class _Up> 836 struct __has_rebind 837 { 838 private: 839 struct __two {char __lx; char __lxx;}; 840 template <class _Xp> static __two __test(...); 841 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0); 842 public: 843 static const bool value = sizeof(__test<_Tp>(0)) == 1; 844 }; 845 846 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> 847 struct __pointer_traits_rebind 848 { 849 #ifndef _LIBCPP_CXX03_LANG 850 typedef typename _Tp::template rebind<_Up> type; 851 #else 852 typedef typename _Tp::template rebind<_Up>::other type; 853 #endif 854 }; 855 856 #ifndef _LIBCPP_HAS_NO_VARIADICS 857 858 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 859 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true> 860 { 861 #ifndef _LIBCPP_CXX03_LANG 862 typedef typename _Sp<_Tp, _Args...>::template rebind<_Up> type; 863 #else 864 typedef typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type; 865 #endif 866 }; 867 868 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 869 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false> 870 { 871 typedef _Sp<_Up, _Args...> type; 872 }; 873 874 #else // _LIBCPP_HAS_NO_VARIADICS 875 876 template <template <class> class _Sp, class _Tp, class _Up> 877 struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true> 878 { 879 #ifndef _LIBCPP_CXX03_LANG 880 typedef typename _Sp<_Tp>::template rebind<_Up> type; 881 #else 882 typedef typename _Sp<_Tp>::template rebind<_Up>::other type; 883 #endif 884 }; 885 886 template <template <class> class _Sp, class _Tp, class _Up> 887 struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false> 888 { 889 typedef _Sp<_Up> type; 890 }; 891 892 template <template <class, class> class _Sp, class _Tp, class _A0, class _Up> 893 struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true> 894 { 895 #ifndef _LIBCPP_CXX03_LANG 896 typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type; 897 #else 898 typedef typename _Sp<_Tp, _A0>::template rebind<_Up>::other type; 899 #endif 900 }; 901 902 template <template <class, class> class _Sp, class _Tp, class _A0, class _Up> 903 struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false> 904 { 905 typedef _Sp<_Up, _A0> type; 906 }; 907 908 template <template <class, class, class> class _Sp, class _Tp, class _A0, 909 class _A1, class _Up> 910 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true> 911 { 912 #ifndef _LIBCPP_CXX03_LANG 913 typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type; 914 #else 915 typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up>::other type; 916 #endif 917 }; 918 919 template <template <class, class, class> class _Sp, class _Tp, class _A0, 920 class _A1, class _Up> 921 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false> 922 { 923 typedef _Sp<_Up, _A0, _A1> type; 924 }; 925 926 template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 927 class _A1, class _A2, class _Up> 928 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true> 929 { 930 #ifndef _LIBCPP_CXX03_LANG 931 typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type; 932 #else 933 typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type; 934 #endif 935 }; 936 937 template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 938 class _A1, class _A2, class _Up> 939 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false> 940 { 941 typedef _Sp<_Up, _A0, _A1, _A2> type; 942 }; 943 944 #endif // _LIBCPP_HAS_NO_VARIADICS 945 946 template <class _Ptr> 947 struct _LIBCPP_TEMPLATE_VIS pointer_traits 948 { 949 typedef _Ptr pointer; 950 typedef typename __pointer_traits_element_type<pointer>::type element_type; 951 typedef typename __pointer_traits_difference_type<pointer>::type difference_type; 952 953 #ifndef _LIBCPP_CXX03_LANG 954 template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type; 955 #else 956 template <class _Up> struct rebind 957 {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;}; 958 #endif // _LIBCPP_CXX03_LANG 959 960 private: 961 struct __nat {}; 962 public: 963 _LIBCPP_INLINE_VISIBILITY 964 static pointer pointer_to(typename conditional<is_void<element_type>::value, 965 __nat, element_type>::type& __r) 966 {return pointer::pointer_to(__r);} 967 }; 968 969 template <class _Tp> 970 struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*> 971 { 972 typedef _Tp* pointer; 973 typedef _Tp element_type; 974 typedef ptrdiff_t difference_type; 975 976 #ifndef _LIBCPP_CXX03_LANG 977 template <class _Up> using rebind = _Up*; 978 #else 979 template <class _Up> struct rebind {typedef _Up* other;}; 980 #endif 981 982 private: 983 struct __nat {}; 984 public: 985 _LIBCPP_INLINE_VISIBILITY 986 static pointer pointer_to(typename conditional<is_void<element_type>::value, 987 __nat, element_type>::type& __r) _NOEXCEPT 988 {return _VSTD::addressof(__r);} 989 }; 990 991 template <class _From, class _To> 992 struct __rebind_pointer { 993 #ifndef _LIBCPP_CXX03_LANG 994 typedef typename pointer_traits<_From>::template rebind<_To> type; 995 #else 996 typedef typename pointer_traits<_From>::template rebind<_To>::other type; 997 #endif 998 }; 999 1000 // allocator_traits 1001 1002 template <class _Tp, class = void> 1003 struct __has_pointer_type : false_type {}; 1004 1005 template <class _Tp> 1006 struct __has_pointer_type<_Tp, 1007 typename __void_t<typename _Tp::pointer>::type> : true_type {}; 1008 1009 namespace __pointer_type_imp 1010 { 1011 1012 template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value> 1013 struct __pointer_type 1014 { 1015 typedef typename _Dp::pointer type; 1016 }; 1017 1018 template <class _Tp, class _Dp> 1019 struct __pointer_type<_Tp, _Dp, false> 1020 { 1021 typedef _Tp* type; 1022 }; 1023 1024 } // __pointer_type_imp 1025 1026 template <class _Tp, class _Dp> 1027 struct __pointer_type 1028 { 1029 typedef typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type; 1030 }; 1031 1032 template <class _Tp, class = void> 1033 struct __has_const_pointer : false_type {}; 1034 1035 template <class _Tp> 1036 struct __has_const_pointer<_Tp, 1037 typename __void_t<typename _Tp::const_pointer>::type> : true_type {}; 1038 1039 template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value> 1040 struct __const_pointer 1041 { 1042 typedef typename _Alloc::const_pointer type; 1043 }; 1044 1045 template <class _Tp, class _Ptr, class _Alloc> 1046 struct __const_pointer<_Tp, _Ptr, _Alloc, false> 1047 { 1048 #ifndef _LIBCPP_CXX03_LANG 1049 typedef typename pointer_traits<_Ptr>::template rebind<const _Tp> type; 1050 #else 1051 typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type; 1052 #endif 1053 }; 1054 1055 template <class _Tp, class = void> 1056 struct __has_void_pointer : false_type {}; 1057 1058 template <class _Tp> 1059 struct __has_void_pointer<_Tp, 1060 typename __void_t<typename _Tp::void_pointer>::type> : true_type {}; 1061 1062 template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value> 1063 struct __void_pointer 1064 { 1065 typedef typename _Alloc::void_pointer type; 1066 }; 1067 1068 template <class _Ptr, class _Alloc> 1069 struct __void_pointer<_Ptr, _Alloc, false> 1070 { 1071 #ifndef _LIBCPP_CXX03_LANG 1072 typedef typename pointer_traits<_Ptr>::template rebind<void> type; 1073 #else 1074 typedef typename pointer_traits<_Ptr>::template rebind<void>::other type; 1075 #endif 1076 }; 1077 1078 template <class _Tp, class = void> 1079 struct __has_const_void_pointer : false_type {}; 1080 1081 template <class _Tp> 1082 struct __has_const_void_pointer<_Tp, 1083 typename __void_t<typename _Tp::const_void_pointer>::type> : true_type {}; 1084 1085 template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value> 1086 struct __const_void_pointer 1087 { 1088 typedef typename _Alloc::const_void_pointer type; 1089 }; 1090 1091 template <class _Ptr, class _Alloc> 1092 struct __const_void_pointer<_Ptr, _Alloc, false> 1093 { 1094 #ifndef _LIBCPP_CXX03_LANG 1095 typedef typename pointer_traits<_Ptr>::template rebind<const void> type; 1096 #else 1097 typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type; 1098 #endif 1099 }; 1100 1101 template <class _Tp> 1102 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1103 _Tp* 1104 __to_raw_pointer(_Tp* __p) _NOEXCEPT 1105 { 1106 return __p; 1107 } 1108 1109 #if _LIBCPP_STD_VER <= 17 1110 template <class _Pointer> 1111 inline _LIBCPP_INLINE_VISIBILITY 1112 typename pointer_traits<_Pointer>::element_type* 1113 __to_raw_pointer(_Pointer __p) _NOEXCEPT 1114 { 1115 return _VSTD::__to_raw_pointer(__p.operator->()); 1116 } 1117 #else 1118 template <class _Pointer> 1119 inline _LIBCPP_INLINE_VISIBILITY 1120 auto 1121 __to_raw_pointer(const _Pointer& __p) _NOEXCEPT 1122 -> decltype(pointer_traits<_Pointer>::to_address(__p)) 1123 { 1124 return pointer_traits<_Pointer>::to_address(__p); 1125 } 1126 1127 template <class _Pointer, class... _None> 1128 inline _LIBCPP_INLINE_VISIBILITY 1129 auto 1130 __to_raw_pointer(const _Pointer& __p, _None...) _NOEXCEPT 1131 { 1132 return _VSTD::__to_raw_pointer(__p.operator->()); 1133 } 1134 1135 template <class _Tp> 1136 inline _LIBCPP_INLINE_VISIBILITY constexpr 1137 _Tp* 1138 to_address(_Tp* __p) _NOEXCEPT 1139 { 1140 static_assert(!is_function_v<_Tp>, "_Tp is a function type"); 1141 return __p; 1142 } 1143 1144 template <class _Pointer> 1145 inline _LIBCPP_INLINE_VISIBILITY 1146 auto 1147 to_address(const _Pointer& __p) _NOEXCEPT 1148 { 1149 return _VSTD::__to_raw_pointer(__p); 1150 } 1151 #endif 1152 1153 template <class _Tp, class = void> 1154 struct __has_size_type : false_type {}; 1155 1156 template <class _Tp> 1157 struct __has_size_type<_Tp, 1158 typename __void_t<typename _Tp::size_type>::type> : true_type {}; 1159 1160 template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value> 1161 struct __size_type 1162 { 1163 typedef typename make_unsigned<_DiffType>::type type; 1164 }; 1165 1166 template <class _Alloc, class _DiffType> 1167 struct __size_type<_Alloc, _DiffType, true> 1168 { 1169 typedef typename _Alloc::size_type type; 1170 }; 1171 1172 template <class _Tp, class = void> 1173 struct __has_propagate_on_container_copy_assignment : false_type {}; 1174 1175 template <class _Tp> 1176 struct __has_propagate_on_container_copy_assignment<_Tp, 1177 typename __void_t<typename _Tp::propagate_on_container_copy_assignment>::type> 1178 : true_type {}; 1179 1180 template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value> 1181 struct __propagate_on_container_copy_assignment 1182 { 1183 typedef false_type type; 1184 }; 1185 1186 template <class _Alloc> 1187 struct __propagate_on_container_copy_assignment<_Alloc, true> 1188 { 1189 typedef typename _Alloc::propagate_on_container_copy_assignment type; 1190 }; 1191 1192 template <class _Tp, class = void> 1193 struct __has_propagate_on_container_move_assignment : false_type {}; 1194 1195 template <class _Tp> 1196 struct __has_propagate_on_container_move_assignment<_Tp, 1197 typename __void_t<typename _Tp::propagate_on_container_move_assignment>::type> 1198 : true_type {}; 1199 1200 template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value> 1201 struct __propagate_on_container_move_assignment 1202 { 1203 typedef false_type type; 1204 }; 1205 1206 template <class _Alloc> 1207 struct __propagate_on_container_move_assignment<_Alloc, true> 1208 { 1209 typedef typename _Alloc::propagate_on_container_move_assignment type; 1210 }; 1211 1212 template <class _Tp, class = void> 1213 struct __has_propagate_on_container_swap : false_type {}; 1214 1215 template <class _Tp> 1216 struct __has_propagate_on_container_swap<_Tp, 1217 typename __void_t<typename _Tp::propagate_on_container_swap>::type> 1218 : true_type {}; 1219 1220 template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value> 1221 struct __propagate_on_container_swap 1222 { 1223 typedef false_type type; 1224 }; 1225 1226 template <class _Alloc> 1227 struct __propagate_on_container_swap<_Alloc, true> 1228 { 1229 typedef typename _Alloc::propagate_on_container_swap type; 1230 }; 1231 1232 template <class _Tp, class = void> 1233 struct __has_is_always_equal : false_type {}; 1234 1235 template <class _Tp> 1236 struct __has_is_always_equal<_Tp, 1237 typename __void_t<typename _Tp::is_always_equal>::type> 1238 : true_type {}; 1239 1240 template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value> 1241 struct __is_always_equal 1242 { 1243 typedef typename _VSTD::is_empty<_Alloc>::type type; 1244 }; 1245 1246 template <class _Alloc> 1247 struct __is_always_equal<_Alloc, true> 1248 { 1249 typedef typename _Alloc::is_always_equal type; 1250 }; 1251 1252 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> 1253 struct __has_rebind_other 1254 { 1255 private: 1256 struct __two {char __lx; char __lxx;}; 1257 template <class _Xp> static __two __test(...); 1258 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0); 1259 public: 1260 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1261 }; 1262 1263 template <class _Tp, class _Up> 1264 struct __has_rebind_other<_Tp, _Up, false> 1265 { 1266 static const bool value = false; 1267 }; 1268 1269 template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value> 1270 struct __allocator_traits_rebind 1271 { 1272 typedef typename _Tp::template rebind<_Up>::other type; 1273 }; 1274 1275 #ifndef _LIBCPP_HAS_NO_VARIADICS 1276 1277 template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> 1278 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> 1279 { 1280 typedef typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type; 1281 }; 1282 1283 template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> 1284 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> 1285 { 1286 typedef _Alloc<_Up, _Args...> type; 1287 }; 1288 1289 #else // _LIBCPP_HAS_NO_VARIADICS 1290 1291 template <template <class> class _Alloc, class _Tp, class _Up> 1292 struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, true> 1293 { 1294 typedef typename _Alloc<_Tp>::template rebind<_Up>::other type; 1295 }; 1296 1297 template <template <class> class _Alloc, class _Tp, class _Up> 1298 struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, false> 1299 { 1300 typedef _Alloc<_Up> type; 1301 }; 1302 1303 template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up> 1304 struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, true> 1305 { 1306 typedef typename _Alloc<_Tp, _A0>::template rebind<_Up>::other type; 1307 }; 1308 1309 template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up> 1310 struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, false> 1311 { 1312 typedef _Alloc<_Up, _A0> type; 1313 }; 1314 1315 template <template <class, class, class> class _Alloc, class _Tp, class _A0, 1316 class _A1, class _Up> 1317 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, true> 1318 { 1319 typedef typename _Alloc<_Tp, _A0, _A1>::template rebind<_Up>::other type; 1320 }; 1321 1322 template <template <class, class, class> class _Alloc, class _Tp, class _A0, 1323 class _A1, class _Up> 1324 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, false> 1325 { 1326 typedef _Alloc<_Up, _A0, _A1> type; 1327 }; 1328 1329 template <template <class, class, class, class> class _Alloc, class _Tp, class _A0, 1330 class _A1, class _A2, class _Up> 1331 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, true> 1332 { 1333 typedef typename _Alloc<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type; 1334 }; 1335 1336 template <template <class, class, class, class> class _Alloc, class _Tp, class _A0, 1337 class _A1, class _A2, class _Up> 1338 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false> 1339 { 1340 typedef _Alloc<_Up, _A0, _A1, _A2> type; 1341 }; 1342 1343 #endif // _LIBCPP_HAS_NO_VARIADICS 1344 1345 #ifndef _LIBCPP_CXX03_LANG 1346 1347 template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1348 auto 1349 __has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) 1350 -> decltype((void)__a.allocate(__sz, __p), true_type()); 1351 1352 template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1353 auto 1354 __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) 1355 -> false_type; 1356 1357 template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1358 struct __has_allocate_hint 1359 : integral_constant<bool, 1360 is_same< 1361 decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(), 1362 declval<_SizeType>(), 1363 declval<_ConstVoidPtr>())), 1364 true_type>::value> 1365 { 1366 }; 1367 1368 #else // _LIBCPP_CXX03_LANG 1369 1370 template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1371 struct __has_allocate_hint 1372 : true_type 1373 { 1374 }; 1375 1376 #endif // _LIBCPP_CXX03_LANG 1377 1378 #if !defined(_LIBCPP_CXX03_LANG) 1379 1380 template <class _Alloc, class _Tp, class ..._Args> 1381 decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(), 1382 _VSTD::declval<_Args>()...), 1383 true_type()) 1384 __has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args); 1385 1386 template <class _Alloc, class _Pointer, class ..._Args> 1387 false_type 1388 __has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args); 1389 1390 template <class _Alloc, class _Pointer, class ..._Args> 1391 struct __has_construct 1392 : integral_constant<bool, 1393 is_same< 1394 decltype(_VSTD::__has_construct_test(declval<_Alloc>(), 1395 declval<_Pointer>(), 1396 declval<_Args>()...)), 1397 true_type>::value> 1398 { 1399 }; 1400 1401 template <class _Alloc, class _Pointer> 1402 auto 1403 __has_destroy_test(_Alloc&& __a, _Pointer&& __p) 1404 -> decltype(__a.destroy(__p), true_type()); 1405 1406 template <class _Alloc, class _Pointer> 1407 auto 1408 __has_destroy_test(const _Alloc& __a, _Pointer&& __p) 1409 -> false_type; 1410 1411 template <class _Alloc, class _Pointer> 1412 struct __has_destroy 1413 : integral_constant<bool, 1414 is_same< 1415 decltype(_VSTD::__has_destroy_test(declval<_Alloc>(), 1416 declval<_Pointer>())), 1417 true_type>::value> 1418 { 1419 }; 1420 1421 template <class _Alloc> 1422 auto 1423 __has_max_size_test(_Alloc&& __a) 1424 -> decltype(__a.max_size(), true_type()); 1425 1426 template <class _Alloc> 1427 auto 1428 __has_max_size_test(const volatile _Alloc& __a) 1429 -> false_type; 1430 1431 template <class _Alloc> 1432 struct __has_max_size 1433 : integral_constant<bool, 1434 is_same< 1435 decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())), 1436 true_type>::value> 1437 { 1438 }; 1439 1440 template <class _Alloc> 1441 auto 1442 __has_select_on_container_copy_construction_test(_Alloc&& __a) 1443 -> decltype(__a.select_on_container_copy_construction(), true_type()); 1444 1445 template <class _Alloc> 1446 auto 1447 __has_select_on_container_copy_construction_test(const volatile _Alloc& __a) 1448 -> false_type; 1449 1450 template <class _Alloc> 1451 struct __has_select_on_container_copy_construction 1452 : integral_constant<bool, 1453 is_same< 1454 decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())), 1455 true_type>::value> 1456 { 1457 }; 1458 1459 #else // _LIBCPP_CXX03_LANG 1460 1461 #ifndef _LIBCPP_HAS_NO_VARIADICS 1462 1463 template <class _Alloc, class _Pointer, class ..._Args> 1464 struct __has_construct 1465 : false_type 1466 { 1467 }; 1468 1469 #else // _LIBCPP_HAS_NO_VARIADICS 1470 1471 template <class _Alloc, class _Pointer, class _Args> 1472 struct __has_construct 1473 : false_type 1474 { 1475 }; 1476 1477 #endif // _LIBCPP_HAS_NO_VARIADICS 1478 1479 template <class _Alloc, class _Pointer> 1480 struct __has_destroy 1481 : false_type 1482 { 1483 }; 1484 1485 template <class _Alloc> 1486 struct __has_max_size 1487 : true_type 1488 { 1489 }; 1490 1491 template <class _Alloc> 1492 struct __has_select_on_container_copy_construction 1493 : false_type 1494 { 1495 }; 1496 1497 #endif // _LIBCPP_CXX03_LANG 1498 1499 template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value> 1500 struct __alloc_traits_difference_type 1501 { 1502 typedef typename pointer_traits<_Ptr>::difference_type type; 1503 }; 1504 1505 template <class _Alloc, class _Ptr> 1506 struct __alloc_traits_difference_type<_Alloc, _Ptr, true> 1507 { 1508 typedef typename _Alloc::difference_type type; 1509 }; 1510 1511 template <class _Alloc> 1512 struct _LIBCPP_TEMPLATE_VIS allocator_traits 1513 { 1514 typedef _Alloc allocator_type; 1515 typedef typename allocator_type::value_type value_type; 1516 1517 typedef typename __pointer_type<value_type, allocator_type>::type pointer; 1518 typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer; 1519 typedef typename __void_pointer<pointer, allocator_type>::type void_pointer; 1520 typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer; 1521 1522 typedef typename __alloc_traits_difference_type<allocator_type, pointer>::type difference_type; 1523 typedef typename __size_type<allocator_type, difference_type>::type size_type; 1524 1525 typedef typename __propagate_on_container_copy_assignment<allocator_type>::type 1526 propagate_on_container_copy_assignment; 1527 typedef typename __propagate_on_container_move_assignment<allocator_type>::type 1528 propagate_on_container_move_assignment; 1529 typedef typename __propagate_on_container_swap<allocator_type>::type 1530 propagate_on_container_swap; 1531 typedef typename __is_always_equal<allocator_type>::type 1532 is_always_equal; 1533 1534 #ifndef _LIBCPP_CXX03_LANG 1535 template <class _Tp> using rebind_alloc = 1536 typename __allocator_traits_rebind<allocator_type, _Tp>::type; 1537 template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>; 1538 #else // _LIBCPP_CXX03_LANG 1539 template <class _Tp> struct rebind_alloc 1540 {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;}; 1541 template <class _Tp> struct rebind_traits 1542 {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;}; 1543 #endif // _LIBCPP_CXX03_LANG 1544 1545 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 1546 static pointer allocate(allocator_type& __a, size_type __n) 1547 {return __a.allocate(__n);} 1548 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 1549 static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) 1550 {return __allocate(__a, __n, __hint, 1551 __has_allocate_hint<allocator_type, size_type, const_void_pointer>());} 1552 1553 _LIBCPP_INLINE_VISIBILITY 1554 static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT 1555 {__a.deallocate(__p, __n);} 1556 1557 #ifndef _LIBCPP_HAS_NO_VARIADICS 1558 template <class _Tp, class... _Args> 1559 _LIBCPP_INLINE_VISIBILITY 1560 static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) 1561 {__construct(__has_construct<allocator_type, _Tp*, _Args...>(), 1562 __a, __p, _VSTD::forward<_Args>(__args)...);} 1563 #else // _LIBCPP_HAS_NO_VARIADICS 1564 template <class _Tp> 1565 _LIBCPP_INLINE_VISIBILITY 1566 static void construct(allocator_type&, _Tp* __p) 1567 { 1568 ::new ((void*)__p) _Tp(); 1569 } 1570 template <class _Tp, class _A0> 1571 _LIBCPP_INLINE_VISIBILITY 1572 static void construct(allocator_type&, _Tp* __p, const _A0& __a0) 1573 { 1574 ::new ((void*)__p) _Tp(__a0); 1575 } 1576 template <class _Tp, class _A0, class _A1> 1577 _LIBCPP_INLINE_VISIBILITY 1578 static void construct(allocator_type&, _Tp* __p, const _A0& __a0, 1579 const _A1& __a1) 1580 { 1581 ::new ((void*)__p) _Tp(__a0, __a1); 1582 } 1583 template <class _Tp, class _A0, class _A1, class _A2> 1584 _LIBCPP_INLINE_VISIBILITY 1585 static void construct(allocator_type&, _Tp* __p, const _A0& __a0, 1586 const _A1& __a1, const _A2& __a2) 1587 { 1588 ::new ((void*)__p) _Tp(__a0, __a1, __a2); 1589 } 1590 #endif // _LIBCPP_HAS_NO_VARIADICS 1591 1592 template <class _Tp> 1593 _LIBCPP_INLINE_VISIBILITY 1594 static void destroy(allocator_type& __a, _Tp* __p) 1595 {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);} 1596 1597 _LIBCPP_INLINE_VISIBILITY 1598 static size_type max_size(const allocator_type& __a) _NOEXCEPT 1599 {return __max_size(__has_max_size<const allocator_type>(), __a);} 1600 1601 _LIBCPP_INLINE_VISIBILITY 1602 static allocator_type 1603 select_on_container_copy_construction(const allocator_type& __a) 1604 {return __select_on_container_copy_construction( 1605 __has_select_on_container_copy_construction<const allocator_type>(), 1606 __a);} 1607 1608 template <class _Ptr> 1609 _LIBCPP_INLINE_VISIBILITY 1610 static 1611 void 1612 __construct_forward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) 1613 { 1614 for (; __begin1 != __end1; ++__begin1, ++__begin2) 1615 construct(__a, _VSTD::__to_raw_pointer(__begin2), _VSTD::move_if_noexcept(*__begin1)); 1616 } 1617 1618 template <class _Tp> 1619 _LIBCPP_INLINE_VISIBILITY 1620 static 1621 typename enable_if 1622 < 1623 (is_same<allocator_type, allocator<_Tp> >::value 1624 || !__has_construct<allocator_type, _Tp*, _Tp>::value) && 1625 is_trivially_move_constructible<_Tp>::value, 1626 void 1627 >::type 1628 __construct_forward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) 1629 { 1630 ptrdiff_t _Np = __end1 - __begin1; 1631 if (_Np > 0) 1632 { 1633 _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp)); 1634 __begin2 += _Np; 1635 } 1636 } 1637 1638 template <class _Iter, class _Ptr> 1639 _LIBCPP_INLINE_VISIBILITY 1640 static 1641 void 1642 __construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2) 1643 { 1644 for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) 1645 construct(__a, _VSTD::__to_raw_pointer(__begin2), *__begin1); 1646 } 1647 1648 template <class _Tp> 1649 _LIBCPP_INLINE_VISIBILITY 1650 static 1651 typename enable_if 1652 < 1653 (is_same<allocator_type, allocator<_Tp> >::value 1654 || !__has_construct<allocator_type, _Tp*, _Tp>::value) && 1655 is_trivially_move_constructible<_Tp>::value, 1656 void 1657 >::type 1658 __construct_range_forward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) 1659 { 1660 typedef typename remove_const<_Tp>::type _Vp; 1661 ptrdiff_t _Np = __end1 - __begin1; 1662 if (_Np > 0) 1663 { 1664 _VSTD::memcpy(const_cast<_Vp*>(__begin2), __begin1, _Np * sizeof(_Tp)); 1665 __begin2 += _Np; 1666 } 1667 } 1668 1669 template <class _Ptr> 1670 _LIBCPP_INLINE_VISIBILITY 1671 static 1672 void 1673 __construct_backward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2) 1674 { 1675 while (__end1 != __begin1) 1676 { 1677 construct(__a, _VSTD::__to_raw_pointer(__end2-1), _VSTD::move_if_noexcept(*--__end1)); 1678 --__end2; 1679 } 1680 } 1681 1682 template <class _Tp> 1683 _LIBCPP_INLINE_VISIBILITY 1684 static 1685 typename enable_if 1686 < 1687 (is_same<allocator_type, allocator<_Tp> >::value 1688 || !__has_construct<allocator_type, _Tp*, _Tp>::value) && 1689 is_trivially_move_constructible<_Tp>::value, 1690 void 1691 >::type 1692 __construct_backward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2) 1693 { 1694 ptrdiff_t _Np = __end1 - __begin1; 1695 __end2 -= _Np; 1696 if (_Np > 0) 1697 _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); 1698 } 1699 1700 private: 1701 1702 _LIBCPP_INLINE_VISIBILITY 1703 static pointer __allocate(allocator_type& __a, size_type __n, 1704 const_void_pointer __hint, true_type) 1705 {return __a.allocate(__n, __hint);} 1706 _LIBCPP_INLINE_VISIBILITY 1707 static pointer __allocate(allocator_type& __a, size_type __n, 1708 const_void_pointer, false_type) 1709 {return __a.allocate(__n);} 1710 1711 #ifndef _LIBCPP_HAS_NO_VARIADICS 1712 template <class _Tp, class... _Args> 1713 _LIBCPP_INLINE_VISIBILITY 1714 static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args) 1715 {__a.construct(__p, _VSTD::forward<_Args>(__args)...);} 1716 template <class _Tp, class... _Args> 1717 _LIBCPP_INLINE_VISIBILITY 1718 static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args) 1719 { 1720 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); 1721 } 1722 #endif // _LIBCPP_HAS_NO_VARIADICS 1723 1724 template <class _Tp> 1725 _LIBCPP_INLINE_VISIBILITY 1726 static void __destroy(true_type, allocator_type& __a, _Tp* __p) 1727 {__a.destroy(__p);} 1728 template <class _Tp> 1729 _LIBCPP_INLINE_VISIBILITY 1730 static void __destroy(false_type, allocator_type&, _Tp* __p) 1731 { 1732 __p->~_Tp(); 1733 } 1734 1735 _LIBCPP_INLINE_VISIBILITY 1736 static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT 1737 {return __a.max_size();} 1738 _LIBCPP_INLINE_VISIBILITY 1739 static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT 1740 {return numeric_limits<size_type>::max() / sizeof(value_type);} 1741 1742 _LIBCPP_INLINE_VISIBILITY 1743 static allocator_type 1744 __select_on_container_copy_construction(true_type, const allocator_type& __a) 1745 {return __a.select_on_container_copy_construction();} 1746 _LIBCPP_INLINE_VISIBILITY 1747 static allocator_type 1748 __select_on_container_copy_construction(false_type, const allocator_type& __a) 1749 {return __a;} 1750 }; 1751 1752 template <class _Traits, class _Tp> 1753 struct __rebind_alloc_helper 1754 { 1755 #ifndef _LIBCPP_CXX03_LANG 1756 typedef typename _Traits::template rebind_alloc<_Tp> type; 1757 #else 1758 typedef typename _Traits::template rebind_alloc<_Tp>::other type; 1759 #endif 1760 }; 1761 1762 // allocator 1763 1764 template <class _Tp> 1765 class _LIBCPP_TEMPLATE_VIS allocator 1766 { 1767 public: 1768 typedef size_t size_type; 1769 typedef ptrdiff_t difference_type; 1770 typedef _Tp* pointer; 1771 typedef const _Tp* const_pointer; 1772 typedef _Tp& reference; 1773 typedef const _Tp& const_reference; 1774 typedef _Tp value_type; 1775 1776 typedef true_type propagate_on_container_move_assignment; 1777 typedef true_type is_always_equal; 1778 1779 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 1780 1781 _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {} 1782 template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {} 1783 _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT 1784 {return _VSTD::addressof(__x);} 1785 _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT 1786 {return _VSTD::addressof(__x);} 1787 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 1788 pointer allocate(size_type __n, allocator<void>::const_pointer = 0) 1789 { 1790 if (__n > max_size()) 1791 __throw_length_error("allocator<T>::allocate(size_t n)" 1792 " 'n' exceeds maximum supported size"); 1793 return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp))); 1794 } 1795 _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT 1796 {_VSTD::__libcpp_deallocate((void*)__p);} 1797 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT 1798 {return size_type(~0) / sizeof(_Tp);} 1799 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1800 template <class _Up, class... _Args> 1801 _LIBCPP_INLINE_VISIBILITY 1802 void 1803 construct(_Up* __p, _Args&&... __args) 1804 { 1805 ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); 1806 } 1807 #else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1808 _LIBCPP_INLINE_VISIBILITY 1809 void 1810 construct(pointer __p) 1811 { 1812 ::new((void*)__p) _Tp(); 1813 } 1814 # if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1815 1816 template <class _A0> 1817 _LIBCPP_INLINE_VISIBILITY 1818 void 1819 construct(pointer __p, _A0& __a0) 1820 { 1821 ::new((void*)__p) _Tp(__a0); 1822 } 1823 template <class _A0> 1824 _LIBCPP_INLINE_VISIBILITY 1825 void 1826 construct(pointer __p, const _A0& __a0) 1827 { 1828 ::new((void*)__p) _Tp(__a0); 1829 } 1830 # endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1831 template <class _A0, class _A1> 1832 _LIBCPP_INLINE_VISIBILITY 1833 void 1834 construct(pointer __p, _A0& __a0, _A1& __a1) 1835 { 1836 ::new((void*)__p) _Tp(__a0, __a1); 1837 } 1838 template <class _A0, class _A1> 1839 _LIBCPP_INLINE_VISIBILITY 1840 void 1841 construct(pointer __p, const _A0& __a0, _A1& __a1) 1842 { 1843 ::new((void*)__p) _Tp(__a0, __a1); 1844 } 1845 template <class _A0, class _A1> 1846 _LIBCPP_INLINE_VISIBILITY 1847 void 1848 construct(pointer __p, _A0& __a0, const _A1& __a1) 1849 { 1850 ::new((void*)__p) _Tp(__a0, __a1); 1851 } 1852 template <class _A0, class _A1> 1853 _LIBCPP_INLINE_VISIBILITY 1854 void 1855 construct(pointer __p, const _A0& __a0, const _A1& __a1) 1856 { 1857 ::new((void*)__p) _Tp(__a0, __a1); 1858 } 1859 #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1860 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} 1861 }; 1862 1863 template <class _Tp> 1864 class _LIBCPP_TEMPLATE_VIS allocator<const _Tp> 1865 { 1866 public: 1867 typedef size_t size_type; 1868 typedef ptrdiff_t difference_type; 1869 typedef const _Tp* pointer; 1870 typedef const _Tp* const_pointer; 1871 typedef const _Tp& reference; 1872 typedef const _Tp& const_reference; 1873 typedef const _Tp value_type; 1874 1875 typedef true_type propagate_on_container_move_assignment; 1876 typedef true_type is_always_equal; 1877 1878 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 1879 1880 _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {} 1881 template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {} 1882 _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT 1883 {return _VSTD::addressof(__x);} 1884 _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0) 1885 { 1886 if (__n > max_size()) 1887 __throw_length_error("allocator<const T>::allocate(size_t n)" 1888 " 'n' exceeds maximum supported size"); 1889 return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp))); 1890 } 1891 _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT 1892 {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p));} 1893 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT 1894 {return size_type(~0) / sizeof(_Tp);} 1895 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1896 template <class _Up, class... _Args> 1897 _LIBCPP_INLINE_VISIBILITY 1898 void 1899 construct(_Up* __p, _Args&&... __args) 1900 { 1901 ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); 1902 } 1903 #else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1904 _LIBCPP_INLINE_VISIBILITY 1905 void 1906 construct(pointer __p) 1907 { 1908 ::new((void*) const_cast<_Tp *>(__p)) _Tp(); 1909 } 1910 # if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1911 1912 template <class _A0> 1913 _LIBCPP_INLINE_VISIBILITY 1914 void 1915 construct(pointer __p, _A0& __a0) 1916 { 1917 ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0); 1918 } 1919 template <class _A0> 1920 _LIBCPP_INLINE_VISIBILITY 1921 void 1922 construct(pointer __p, const _A0& __a0) 1923 { 1924 ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0); 1925 } 1926 # endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1927 template <class _A0, class _A1> 1928 _LIBCPP_INLINE_VISIBILITY 1929 void 1930 construct(pointer __p, _A0& __a0, _A1& __a1) 1931 { 1932 ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); 1933 } 1934 template <class _A0, class _A1> 1935 _LIBCPP_INLINE_VISIBILITY 1936 void 1937 construct(pointer __p, const _A0& __a0, _A1& __a1) 1938 { 1939 ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); 1940 } 1941 template <class _A0, class _A1> 1942 _LIBCPP_INLINE_VISIBILITY 1943 void 1944 construct(pointer __p, _A0& __a0, const _A1& __a1) 1945 { 1946 ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); 1947 } 1948 template <class _A0, class _A1> 1949 _LIBCPP_INLINE_VISIBILITY 1950 void 1951 construct(pointer __p, const _A0& __a0, const _A1& __a1) 1952 { 1953 ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1); 1954 } 1955 #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1956 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} 1957 }; 1958 1959 template <class _Tp, class _Up> 1960 inline _LIBCPP_INLINE_VISIBILITY 1961 bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;} 1962 1963 template <class _Tp, class _Up> 1964 inline _LIBCPP_INLINE_VISIBILITY 1965 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;} 1966 1967 template <class _OutputIterator, class _Tp> 1968 class _LIBCPP_TEMPLATE_VIS raw_storage_iterator 1969 : public iterator<output_iterator_tag, 1970 _Tp, // purposefully not C++03 1971 ptrdiff_t, // purposefully not C++03 1972 _Tp*, // purposefully not C++03 1973 raw_storage_iterator<_OutputIterator, _Tp>&> // purposefully not C++03 1974 { 1975 private: 1976 _OutputIterator __x_; 1977 public: 1978 _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {} 1979 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;} 1980 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element) 1981 {::new(&*__x_) _Tp(__element); return *this;} 1982 #if _LIBCPP_STD_VER >= 14 1983 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element) 1984 {::new(&*__x_) _Tp(_VSTD::move(__element)); return *this;} 1985 #endif 1986 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;} 1987 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator operator++(int) 1988 {raw_storage_iterator __t(*this); ++__x_; return __t;} 1989 #if _LIBCPP_STD_VER >= 14 1990 _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; } 1991 #endif 1992 }; 1993 1994 template <class _Tp> 1995 _LIBCPP_NO_CFI 1996 pair<_Tp*, ptrdiff_t> 1997 get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT 1998 { 1999 pair<_Tp*, ptrdiff_t> __r(0, 0); 2000 const ptrdiff_t __m = (~ptrdiff_t(0) ^ 2001 ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1))) 2002 / sizeof(_Tp); 2003 if (__n > __m) 2004 __n = __m; 2005 while (__n > 0) 2006 { 2007 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) 2008 #if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__) 2009 if (std::alignment_of<_Tp>::value > __STDCPP_DEFAULT_NEW_ALIGNMENT__) 2010 #else 2011 if (std::alignment_of<_Tp>::value > 2012 std::alignment_of<std::max_align_t>::value) 2013 #endif 2014 { 2015 std::align_val_t __al = 2016 std::align_val_t(std::alignment_of<_Tp>::value); 2017 __r.first = static_cast<_Tp*>(::operator new( 2018 __n * sizeof(_Tp), __al, nothrow)); 2019 } else { 2020 __r.first = static_cast<_Tp*>(::operator new( 2021 __n * sizeof(_Tp), nothrow)); 2022 } 2023 #else 2024 #if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__) 2025 if (std::alignment_of<_Tp>::value > __STDCPP_DEFAULT_NEW_ALIGNMENT__) 2026 #else 2027 if (std::alignment_of<_Tp>::value > 2028 std::alignment_of<std::max_align_t>::value) 2029 #endif 2030 { 2031 // Since aligned operator new is unavailable, return an empty 2032 // buffer rather than one with invalid alignment. 2033 return __r; 2034 } 2035 2036 __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow)); 2037 #endif 2038 2039 if (__r.first) 2040 { 2041 __r.second = __n; 2042 break; 2043 } 2044 __n /= 2; 2045 } 2046 return __r; 2047 } 2048 2049 template <class _Tp> 2050 inline _LIBCPP_INLINE_VISIBILITY 2051 void return_temporary_buffer(_Tp* __p) _NOEXCEPT 2052 { 2053 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) 2054 #if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__) 2055 if (std::alignment_of<_Tp>::value > __STDCPP_DEFAULT_NEW_ALIGNMENT__) 2056 #else 2057 if (std::alignment_of<_Tp>::value > 2058 std::alignment_of<std::max_align_t>::value) 2059 #endif 2060 { 2061 std::align_val_t __al = std::align_val_t(std::alignment_of<_Tp>::value); 2062 ::operator delete(__p, __al); 2063 return; 2064 } 2065 #endif 2066 ::operator delete(__p); 2067 } 2068 2069 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 2070 template <class _Tp> 2071 struct auto_ptr_ref 2072 { 2073 _Tp* __ptr_; 2074 }; 2075 2076 template<class _Tp> 2077 class _LIBCPP_TEMPLATE_VIS auto_ptr 2078 { 2079 private: 2080 _Tp* __ptr_; 2081 public: 2082 typedef _Tp element_type; 2083 2084 _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {} 2085 _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {} 2086 template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) throw() 2087 : __ptr_(__p.release()) {} 2088 _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) throw() 2089 {reset(__p.release()); return *this;} 2090 template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) throw() 2091 {reset(__p.release()); return *this;} 2092 _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) throw() 2093 {reset(__p.__ptr_); return *this;} 2094 _LIBCPP_INLINE_VISIBILITY ~auto_ptr() throw() {delete __ptr_;} 2095 2096 _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const throw() 2097 {return *__ptr_;} 2098 _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const throw() {return __ptr_;} 2099 _LIBCPP_INLINE_VISIBILITY _Tp* get() const throw() {return __ptr_;} 2100 _LIBCPP_INLINE_VISIBILITY _Tp* release() throw() 2101 { 2102 _Tp* __t = __ptr_; 2103 __ptr_ = 0; 2104 return __t; 2105 } 2106 _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) throw() 2107 { 2108 if (__ptr_ != __p) 2109 delete __ptr_; 2110 __ptr_ = __p; 2111 } 2112 2113 _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {} 2114 template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() throw() 2115 {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;} 2116 template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() throw() 2117 {return auto_ptr<_Up>(release());} 2118 }; 2119 2120 template <> 2121 class _LIBCPP_TEMPLATE_VIS auto_ptr<void> 2122 { 2123 public: 2124 typedef void element_type; 2125 }; 2126 #endif 2127 2128 template <class _Tp, int _Idx, 2129 bool _CanBeEmptyBase = 2130 is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value> 2131 struct __compressed_pair_elem { 2132 typedef _Tp _ParamT; 2133 typedef _Tp& reference; 2134 typedef const _Tp& const_reference; 2135 2136 #ifndef _LIBCPP_CXX03_LANG 2137 _LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() : __value_() {} 2138 2139 template <class _Up, class = typename enable_if< 2140 !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value 2141 >::type> 2142 _LIBCPP_INLINE_VISIBILITY 2143 constexpr explicit 2144 __compressed_pair_elem(_Up&& __u) 2145 : __value_(_VSTD::forward<_Up>(__u)){}; 2146 2147 template <class... _Args, size_t... _Indexes> 2148 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 2149 __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, 2150 __tuple_indices<_Indexes...>) 2151 : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} 2152 #else 2153 _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_() {} 2154 _LIBCPP_INLINE_VISIBILITY 2155 __compressed_pair_elem(_ParamT __p) : __value_(std::forward<_ParamT>(__p)) {} 2156 #endif 2157 2158 _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; } 2159 _LIBCPP_INLINE_VISIBILITY 2160 const_reference __get() const _NOEXCEPT { return __value_; } 2161 2162 private: 2163 _Tp __value_; 2164 }; 2165 2166 template <class _Tp, int _Idx> 2167 struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp { 2168 typedef _Tp _ParamT; 2169 typedef _Tp& reference; 2170 typedef const _Tp& const_reference; 2171 typedef _Tp __value_type; 2172 2173 #ifndef _LIBCPP_CXX03_LANG 2174 _LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() = default; 2175 2176 template <class _Up, class = typename enable_if< 2177 !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value 2178 >::type> 2179 _LIBCPP_INLINE_VISIBILITY 2180 constexpr explicit 2181 __compressed_pair_elem(_Up&& __u) 2182 : __value_type(_VSTD::forward<_Up>(__u)){}; 2183 2184 template <class... _Args, size_t... _Indexes> 2185 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 2186 __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, 2187 __tuple_indices<_Indexes...>) 2188 : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} 2189 #else 2190 _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_type() {} 2191 _LIBCPP_INLINE_VISIBILITY 2192 __compressed_pair_elem(_ParamT __p) 2193 : __value_type(std::forward<_ParamT>(__p)) {} 2194 #endif 2195 2196 _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; } 2197 _LIBCPP_INLINE_VISIBILITY 2198 const_reference __get() const _NOEXCEPT { return *this; } 2199 }; 2200 2201 // Tag used to construct the second element of the compressed pair. 2202 struct __second_tag {}; 2203 2204 template <class _T1, class _T2> 2205 class __compressed_pair : private __compressed_pair_elem<_T1, 0>, 2206 private __compressed_pair_elem<_T2, 1> { 2207 typedef __compressed_pair_elem<_T1, 0> _Base1; 2208 typedef __compressed_pair_elem<_T2, 1> _Base2; 2209 2210 // NOTE: This static assert should never fire because __compressed_pair 2211 // is *almost never* used in a scenario where it's possible for T1 == T2. 2212 // (The exception is std::function where it is possible that the function 2213 // object and the allocator have the same type). 2214 static_assert((!is_same<_T1, _T2>::value), 2215 "__compressed_pair cannot be instantated when T1 and T2 are the same type; " 2216 "The current implementation is NOT ABI-compatible with the previous " 2217 "implementation for this configuration"); 2218 2219 public: 2220 #ifndef _LIBCPP_CXX03_LANG 2221 template <bool _Dummy = true, 2222 class = typename enable_if< 2223 __dependent_type<is_default_constructible<_T1>, _Dummy>::value && 2224 __dependent_type<is_default_constructible<_T2>, _Dummy>::value 2225 >::type 2226 > 2227 _LIBCPP_INLINE_VISIBILITY 2228 constexpr __compressed_pair() {} 2229 2230 template <class _Tp, typename enable_if<!is_same<typename decay<_Tp>::type, 2231 __compressed_pair>::value, 2232 bool>::type = true> 2233 _LIBCPP_INLINE_VISIBILITY constexpr explicit 2234 __compressed_pair(_Tp&& __t) 2235 : _Base1(std::forward<_Tp>(__t)), _Base2() {} 2236 2237 template <class _Tp> 2238 _LIBCPP_INLINE_VISIBILITY constexpr 2239 __compressed_pair(__second_tag, _Tp&& __t) 2240 : _Base1(), _Base2(std::forward<_Tp>(__t)) {} 2241 2242 template <class _U1, class _U2> 2243 _LIBCPP_INLINE_VISIBILITY constexpr 2244 __compressed_pair(_U1&& __t1, _U2&& __t2) 2245 : _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {} 2246 2247 template <class... _Args1, class... _Args2> 2248 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 2249 __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, 2250 tuple<_Args2...> __second_args) 2251 : _Base1(__pc, _VSTD::move(__first_args), 2252 typename __make_tuple_indices<sizeof...(_Args1)>::type()), 2253 _Base2(__pc, _VSTD::move(__second_args), 2254 typename __make_tuple_indices<sizeof...(_Args2)>::type()) {} 2255 2256 #else 2257 _LIBCPP_INLINE_VISIBILITY 2258 __compressed_pair() {} 2259 2260 _LIBCPP_INLINE_VISIBILITY explicit 2261 __compressed_pair(_T1 __t1) : _Base1(_VSTD::forward<_T1>(__t1)) {} 2262 2263 _LIBCPP_INLINE_VISIBILITY 2264 __compressed_pair(__second_tag, _T2 __t2) 2265 : _Base1(), _Base2(_VSTD::forward<_T2>(__t2)) {} 2266 2267 _LIBCPP_INLINE_VISIBILITY 2268 __compressed_pair(_T1 __t1, _T2 __t2) 2269 : _Base1(_VSTD::forward<_T1>(__t1)), _Base2(_VSTD::forward<_T2>(__t2)) {} 2270 #endif 2271 2272 _LIBCPP_INLINE_VISIBILITY 2273 typename _Base1::reference first() _NOEXCEPT { 2274 return static_cast<_Base1&>(*this).__get(); 2275 } 2276 2277 _LIBCPP_INLINE_VISIBILITY 2278 typename _Base1::const_reference first() const _NOEXCEPT { 2279 return static_cast<_Base1 const&>(*this).__get(); 2280 } 2281 2282 _LIBCPP_INLINE_VISIBILITY 2283 typename _Base2::reference second() _NOEXCEPT { 2284 return static_cast<_Base2&>(*this).__get(); 2285 } 2286 2287 _LIBCPP_INLINE_VISIBILITY 2288 typename _Base2::const_reference second() const _NOEXCEPT { 2289 return static_cast<_Base2 const&>(*this).__get(); 2290 } 2291 2292 _LIBCPP_INLINE_VISIBILITY 2293 void swap(__compressed_pair& __x) 2294 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2295 __is_nothrow_swappable<_T2>::value) 2296 { 2297 using std::swap; 2298 swap(first(), __x.first()); 2299 swap(second(), __x.second()); 2300 } 2301 }; 2302 2303 template <class _T1, class _T2> 2304 inline _LIBCPP_INLINE_VISIBILITY 2305 void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y) 2306 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2307 __is_nothrow_swappable<_T2>::value) { 2308 __x.swap(__y); 2309 } 2310 2311 // default_delete 2312 2313 template <class _Tp> 2314 struct _LIBCPP_TEMPLATE_VIS default_delete { 2315 static_assert(!is_function<_Tp>::value, 2316 "default_delete cannot be instantiated for function types"); 2317 #ifndef _LIBCPP_CXX03_LANG 2318 _LIBCPP_INLINE_VISIBILITY constexpr default_delete() noexcept = default; 2319 #else 2320 _LIBCPP_INLINE_VISIBILITY default_delete() {} 2321 #endif 2322 template <class _Up> 2323 _LIBCPP_INLINE_VISIBILITY 2324 default_delete(const default_delete<_Up>&, 2325 typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 2326 0) _NOEXCEPT {} 2327 2328 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __ptr) const _NOEXCEPT { 2329 static_assert(sizeof(_Tp) > 0, 2330 "default_delete can not delete incomplete type"); 2331 static_assert(!is_void<_Tp>::value, 2332 "default_delete can not delete incomplete type"); 2333 delete __ptr; 2334 } 2335 }; 2336 2337 template <class _Tp> 2338 struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> { 2339 private: 2340 template <class _Up> 2341 struct _EnableIfConvertible 2342 : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {}; 2343 2344 public: 2345 #ifndef _LIBCPP_CXX03_LANG 2346 _LIBCPP_INLINE_VISIBILITY constexpr default_delete() noexcept = default; 2347 #else 2348 _LIBCPP_INLINE_VISIBILITY default_delete() {} 2349 #endif 2350 2351 template <class _Up> 2352 _LIBCPP_INLINE_VISIBILITY 2353 default_delete(const default_delete<_Up[]>&, 2354 typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {} 2355 2356 template <class _Up> 2357 _LIBCPP_INLINE_VISIBILITY 2358 typename _EnableIfConvertible<_Up>::type 2359 operator()(_Up* __ptr) const _NOEXCEPT { 2360 static_assert(sizeof(_Tp) > 0, 2361 "default_delete can not delete incomplete type"); 2362 static_assert(!is_void<_Tp>::value, 2363 "default_delete can not delete void type"); 2364 delete[] __ptr; 2365 } 2366 }; 2367 2368 2369 2370 #ifndef _LIBCPP_CXX03_LANG 2371 template <class _Deleter> 2372 struct __unique_ptr_deleter_sfinae { 2373 static_assert(!is_reference<_Deleter>::value, "incorrect specialization"); 2374 typedef const _Deleter& __lval_ref_type; 2375 typedef _Deleter&& __good_rval_ref_type; 2376 typedef true_type __enable_rval_overload; 2377 }; 2378 2379 template <class _Deleter> 2380 struct __unique_ptr_deleter_sfinae<_Deleter const&> { 2381 typedef const _Deleter& __lval_ref_type; 2382 typedef const _Deleter&& __bad_rval_ref_type; 2383 typedef false_type __enable_rval_overload; 2384 }; 2385 2386 template <class _Deleter> 2387 struct __unique_ptr_deleter_sfinae<_Deleter&> { 2388 typedef _Deleter& __lval_ref_type; 2389 typedef _Deleter&& __bad_rval_ref_type; 2390 typedef false_type __enable_rval_overload; 2391 }; 2392 #endif // !defined(_LIBCPP_CXX03_LANG) 2393 2394 template <class _Tp, class _Dp = default_delete<_Tp> > 2395 class _LIBCPP_TEMPLATE_VIS unique_ptr { 2396 public: 2397 typedef _Tp element_type; 2398 typedef _Dp deleter_type; 2399 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2400 2401 static_assert(!is_rvalue_reference<deleter_type>::value, 2402 "the specified deleter type cannot be an rvalue reference"); 2403 2404 private: 2405 __compressed_pair<pointer, deleter_type> __ptr_; 2406 2407 struct __nat { int __for_bool_; }; 2408 2409 #ifndef _LIBCPP_CXX03_LANG 2410 typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE; 2411 2412 template <bool _Dummy> 2413 using _LValRefType = 2414 typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type; 2415 2416 template <bool _Dummy> 2417 using _GoodRValRefType = 2418 typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type; 2419 2420 template <bool _Dummy> 2421 using _BadRValRefType = 2422 typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type; 2423 2424 template <bool _Dummy, class _Deleter = typename __dependent_type< 2425 __identity<deleter_type>, _Dummy>::type> 2426 using _EnableIfDeleterDefaultConstructible = 2427 typename enable_if<is_default_constructible<_Deleter>::value && 2428 !is_pointer<_Deleter>::value>::type; 2429 2430 template <class _ArgType> 2431 using _EnableIfDeleterConstructible = 2432 typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type; 2433 2434 template <class _UPtr, class _Up> 2435 using _EnableIfMoveConvertible = typename enable_if< 2436 is_convertible<typename _UPtr::pointer, pointer>::value && 2437 !is_array<_Up>::value 2438 >::type; 2439 2440 template <class _UDel> 2441 using _EnableIfDeleterConvertible = typename enable_if< 2442 (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) || 2443 (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) 2444 >::type; 2445 2446 template <class _UDel> 2447 using _EnableIfDeleterAssignable = typename enable_if< 2448 is_assignable<_Dp&, _UDel&&>::value 2449 >::type; 2450 2451 public: 2452 template <bool _Dummy = true, 2453 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2454 _LIBCPP_INLINE_VISIBILITY 2455 constexpr unique_ptr() noexcept : __ptr_(pointer()) {} 2456 2457 template <bool _Dummy = true, 2458 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2459 _LIBCPP_INLINE_VISIBILITY 2460 constexpr unique_ptr(nullptr_t) noexcept : __ptr_(pointer()) {} 2461 2462 template <bool _Dummy = true, 2463 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2464 _LIBCPP_INLINE_VISIBILITY 2465 explicit unique_ptr(pointer __p) noexcept : __ptr_(__p) {} 2466 2467 template <bool _Dummy = true, 2468 class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>> 2469 _LIBCPP_INLINE_VISIBILITY 2470 unique_ptr(pointer __p, _LValRefType<_Dummy> __d) noexcept 2471 : __ptr_(__p, __d) {} 2472 2473 template <bool _Dummy = true, 2474 class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>> 2475 _LIBCPP_INLINE_VISIBILITY 2476 unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) noexcept 2477 : __ptr_(__p, _VSTD::move(__d)) { 2478 static_assert(!is_reference<deleter_type>::value, 2479 "rvalue deleter bound to reference"); 2480 } 2481 2482 template <bool _Dummy = true, 2483 class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>> 2484 _LIBCPP_INLINE_VISIBILITY 2485 unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete; 2486 2487 _LIBCPP_INLINE_VISIBILITY 2488 unique_ptr(unique_ptr&& __u) noexcept 2489 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) { 2490 } 2491 2492 template <class _Up, class _Ep, 2493 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2494 class = _EnableIfDeleterConvertible<_Ep> 2495 > 2496 _LIBCPP_INLINE_VISIBILITY 2497 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT 2498 : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {} 2499 2500 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 2501 template <class _Up> 2502 _LIBCPP_INLINE_VISIBILITY 2503 unique_ptr(auto_ptr<_Up>&& __p, 2504 typename enable_if<is_convertible<_Up*, _Tp*>::value && 2505 is_same<_Dp, default_delete<_Tp>>::value, 2506 __nat>::type = __nat()) _NOEXCEPT 2507 : __ptr_(__p.release()) {} 2508 #endif 2509 2510 _LIBCPP_INLINE_VISIBILITY 2511 unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT { 2512 reset(__u.release()); 2513 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2514 return *this; 2515 } 2516 2517 template <class _Up, class _Ep, 2518 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2519 class = _EnableIfDeleterAssignable<_Ep> 2520 > 2521 _LIBCPP_INLINE_VISIBILITY 2522 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT { 2523 reset(__u.release()); 2524 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2525 return *this; 2526 } 2527 2528 #else // _LIBCPP_CXX03_LANG 2529 private: 2530 unique_ptr(unique_ptr&); 2531 template <class _Up, class _Ep> unique_ptr(unique_ptr<_Up, _Ep>&); 2532 2533 unique_ptr& operator=(unique_ptr&); 2534 template <class _Up, class _Ep> unique_ptr& operator=(unique_ptr<_Up, _Ep>&); 2535 2536 public: 2537 _LIBCPP_INLINE_VISIBILITY 2538 unique_ptr() : __ptr_(pointer()) 2539 { 2540 static_assert(!is_pointer<deleter_type>::value, 2541 "unique_ptr constructed with null function pointer deleter"); 2542 static_assert(is_default_constructible<deleter_type>::value, 2543 "unique_ptr::deleter_type is not default constructible"); 2544 } 2545 _LIBCPP_INLINE_VISIBILITY 2546 unique_ptr(nullptr_t) : __ptr_(pointer()) 2547 { 2548 static_assert(!is_pointer<deleter_type>::value, 2549 "unique_ptr constructed with null function pointer deleter"); 2550 } 2551 _LIBCPP_INLINE_VISIBILITY 2552 explicit unique_ptr(pointer __p) 2553 : __ptr_(_VSTD::move(__p)) { 2554 static_assert(!is_pointer<deleter_type>::value, 2555 "unique_ptr constructed with null function pointer deleter"); 2556 } 2557 2558 _LIBCPP_INLINE_VISIBILITY 2559 operator __rv<unique_ptr>() { 2560 return __rv<unique_ptr>(*this); 2561 } 2562 2563 _LIBCPP_INLINE_VISIBILITY 2564 unique_ptr(__rv<unique_ptr> __u) 2565 : __ptr_(__u->release(), 2566 _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2567 2568 template <class _Up, class _Ep> 2569 _LIBCPP_INLINE_VISIBILITY 2570 typename enable_if< 2571 !is_array<_Up>::value && 2572 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, 2573 pointer>::value && 2574 is_assignable<deleter_type&, _Ep&>::value, 2575 unique_ptr&>::type 2576 operator=(unique_ptr<_Up, _Ep> __u) { 2577 reset(__u.release()); 2578 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2579 return *this; 2580 } 2581 2582 _LIBCPP_INLINE_VISIBILITY 2583 unique_ptr(pointer __p, deleter_type __d) 2584 : __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {} 2585 #endif // _LIBCPP_CXX03_LANG 2586 2587 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 2588 template <class _Up> 2589 _LIBCPP_INLINE_VISIBILITY 2590 typename enable_if<is_convertible<_Up*, _Tp*>::value && 2591 is_same<_Dp, default_delete<_Tp> >::value, 2592 unique_ptr&>::type 2593 operator=(auto_ptr<_Up> __p) { 2594 reset(__p.release()); 2595 return *this; 2596 } 2597 #endif 2598 2599 _LIBCPP_INLINE_VISIBILITY 2600 ~unique_ptr() { reset(); } 2601 2602 _LIBCPP_INLINE_VISIBILITY 2603 unique_ptr& operator=(nullptr_t) _NOEXCEPT { 2604 reset(); 2605 return *this; 2606 } 2607 2608 _LIBCPP_INLINE_VISIBILITY 2609 typename add_lvalue_reference<_Tp>::type 2610 operator*() const { 2611 return *__ptr_.first(); 2612 } 2613 _LIBCPP_INLINE_VISIBILITY 2614 pointer operator->() const _NOEXCEPT { 2615 return __ptr_.first(); 2616 } 2617 _LIBCPP_INLINE_VISIBILITY 2618 pointer get() const _NOEXCEPT { 2619 return __ptr_.first(); 2620 } 2621 _LIBCPP_INLINE_VISIBILITY 2622 deleter_type& get_deleter() _NOEXCEPT { 2623 return __ptr_.second(); 2624 } 2625 _LIBCPP_INLINE_VISIBILITY 2626 const deleter_type& get_deleter() const _NOEXCEPT { 2627 return __ptr_.second(); 2628 } 2629 _LIBCPP_INLINE_VISIBILITY 2630 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { 2631 return __ptr_.first() != nullptr; 2632 } 2633 2634 _LIBCPP_INLINE_VISIBILITY 2635 pointer release() _NOEXCEPT { 2636 pointer __t = __ptr_.first(); 2637 __ptr_.first() = pointer(); 2638 return __t; 2639 } 2640 2641 _LIBCPP_INLINE_VISIBILITY 2642 void reset(pointer __p = pointer()) _NOEXCEPT { 2643 pointer __tmp = __ptr_.first(); 2644 __ptr_.first() = __p; 2645 if (__tmp) 2646 __ptr_.second()(__tmp); 2647 } 2648 2649 _LIBCPP_INLINE_VISIBILITY 2650 void swap(unique_ptr& __u) _NOEXCEPT { 2651 __ptr_.swap(__u.__ptr_); 2652 } 2653 }; 2654 2655 2656 template <class _Tp, class _Dp> 2657 class _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> { 2658 public: 2659 typedef _Tp element_type; 2660 typedef _Dp deleter_type; 2661 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2662 2663 private: 2664 __compressed_pair<pointer, deleter_type> __ptr_; 2665 2666 template <class _From> 2667 struct _CheckArrayPointerConversion : is_same<_From, pointer> {}; 2668 2669 template <class _FromElem> 2670 struct _CheckArrayPointerConversion<_FromElem*> 2671 : integral_constant<bool, 2672 is_same<_FromElem*, pointer>::value || 2673 (is_same<pointer, element_type*>::value && 2674 is_convertible<_FromElem(*)[], element_type(*)[]>::value) 2675 > 2676 {}; 2677 2678 #ifndef _LIBCPP_CXX03_LANG 2679 typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE; 2680 2681 template <bool _Dummy> 2682 using _LValRefType = 2683 typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type; 2684 2685 template <bool _Dummy> 2686 using _GoodRValRefType = 2687 typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type; 2688 2689 template <bool _Dummy> 2690 using _BadRValRefType = 2691 typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type; 2692 2693 template <bool _Dummy, class _Deleter = typename __dependent_type< 2694 __identity<deleter_type>, _Dummy>::type> 2695 using _EnableIfDeleterDefaultConstructible = 2696 typename enable_if<is_default_constructible<_Deleter>::value && 2697 !is_pointer<_Deleter>::value>::type; 2698 2699 template <class _ArgType> 2700 using _EnableIfDeleterConstructible = 2701 typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type; 2702 2703 template <class _Pp> 2704 using _EnableIfPointerConvertible = typename enable_if< 2705 _CheckArrayPointerConversion<_Pp>::value 2706 >::type; 2707 2708 template <class _UPtr, class _Up, 2709 class _ElemT = typename _UPtr::element_type> 2710 using _EnableIfMoveConvertible = typename enable_if< 2711 is_array<_Up>::value && 2712 is_same<pointer, element_type*>::value && 2713 is_same<typename _UPtr::pointer, _ElemT*>::value && 2714 is_convertible<_ElemT(*)[], element_type(*)[]>::value 2715 >::type; 2716 2717 template <class _UDel> 2718 using _EnableIfDeleterConvertible = typename enable_if< 2719 (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) || 2720 (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) 2721 >::type; 2722 2723 template <class _UDel> 2724 using _EnableIfDeleterAssignable = typename enable_if< 2725 is_assignable<_Dp&, _UDel&&>::value 2726 >::type; 2727 2728 public: 2729 template <bool _Dummy = true, 2730 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2731 _LIBCPP_INLINE_VISIBILITY 2732 constexpr unique_ptr() noexcept : __ptr_(pointer()) {} 2733 2734 template <bool _Dummy = true, 2735 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2736 _LIBCPP_INLINE_VISIBILITY 2737 constexpr unique_ptr(nullptr_t) noexcept : __ptr_(pointer()) {} 2738 2739 template <class _Pp, bool _Dummy = true, 2740 class = _EnableIfDeleterDefaultConstructible<_Dummy>, 2741 class = _EnableIfPointerConvertible<_Pp>> 2742 _LIBCPP_INLINE_VISIBILITY 2743 explicit unique_ptr(_Pp __p) noexcept 2744 : __ptr_(__p) {} 2745 2746 template <class _Pp, bool _Dummy = true, 2747 class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>, 2748 class = _EnableIfPointerConvertible<_Pp>> 2749 _LIBCPP_INLINE_VISIBILITY 2750 unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) noexcept 2751 : __ptr_(__p, __d) {} 2752 2753 template <bool _Dummy = true, 2754 class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>> 2755 _LIBCPP_INLINE_VISIBILITY 2756 unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) noexcept 2757 : __ptr_(nullptr, __d) {} 2758 2759 template <class _Pp, bool _Dummy = true, 2760 class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>, 2761 class = _EnableIfPointerConvertible<_Pp>> 2762 _LIBCPP_INLINE_VISIBILITY 2763 unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) noexcept 2764 : __ptr_(__p, _VSTD::move(__d)) { 2765 static_assert(!is_reference<deleter_type>::value, 2766 "rvalue deleter bound to reference"); 2767 } 2768 2769 template <bool _Dummy = true, 2770 class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>> 2771 _LIBCPP_INLINE_VISIBILITY 2772 unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) noexcept 2773 : __ptr_(nullptr, _VSTD::move(__d)) { 2774 static_assert(!is_reference<deleter_type>::value, 2775 "rvalue deleter bound to reference"); 2776 } 2777 2778 template <class _Pp, bool _Dummy = true, 2779 class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>, 2780 class = _EnableIfPointerConvertible<_Pp>> 2781 _LIBCPP_INLINE_VISIBILITY 2782 unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete; 2783 2784 _LIBCPP_INLINE_VISIBILITY 2785 unique_ptr(unique_ptr&& __u) noexcept 2786 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) { 2787 } 2788 2789 _LIBCPP_INLINE_VISIBILITY 2790 unique_ptr& operator=(unique_ptr&& __u) noexcept { 2791 reset(__u.release()); 2792 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2793 return *this; 2794 } 2795 2796 template <class _Up, class _Ep, 2797 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2798 class = _EnableIfDeleterConvertible<_Ep> 2799 > 2800 _LIBCPP_INLINE_VISIBILITY 2801 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept 2802 : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) { 2803 } 2804 2805 template <class _Up, class _Ep, 2806 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2807 class = _EnableIfDeleterAssignable<_Ep> 2808 > 2809 _LIBCPP_INLINE_VISIBILITY 2810 unique_ptr& 2811 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept { 2812 reset(__u.release()); 2813 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2814 return *this; 2815 } 2816 2817 #else // _LIBCPP_CXX03_LANG 2818 private: 2819 template <class _Up> explicit unique_ptr(_Up); 2820 2821 unique_ptr(unique_ptr&); 2822 template <class _Up> unique_ptr(unique_ptr<_Up>&); 2823 2824 unique_ptr& operator=(unique_ptr&); 2825 template <class _Up> unique_ptr& operator=(unique_ptr<_Up>&); 2826 2827 template <class _Up> 2828 unique_ptr(_Up __u, 2829 typename conditional< 2830 is_reference<deleter_type>::value, deleter_type, 2831 typename add_lvalue_reference<const deleter_type>::type>::type, 2832 typename enable_if<is_convertible<_Up, pointer>::value, 2833 __nat>::type = __nat()); 2834 public: 2835 _LIBCPP_INLINE_VISIBILITY 2836 unique_ptr() : __ptr_(pointer()) { 2837 static_assert(!is_pointer<deleter_type>::value, 2838 "unique_ptr constructed with null function pointer deleter"); 2839 } 2840 _LIBCPP_INLINE_VISIBILITY 2841 unique_ptr(nullptr_t) : __ptr_(pointer()) { 2842 static_assert(!is_pointer<deleter_type>::value, 2843 "unique_ptr constructed with null function pointer deleter"); 2844 } 2845 2846 _LIBCPP_INLINE_VISIBILITY 2847 explicit unique_ptr(pointer __p) : __ptr_(__p) { 2848 static_assert(!is_pointer<deleter_type>::value, 2849 "unique_ptr constructed with null function pointer deleter"); 2850 } 2851 2852 _LIBCPP_INLINE_VISIBILITY 2853 unique_ptr(pointer __p, deleter_type __d) 2854 : __ptr_(__p, _VSTD::forward<deleter_type>(__d)) {} 2855 2856 _LIBCPP_INLINE_VISIBILITY 2857 unique_ptr(nullptr_t, deleter_type __d) 2858 : __ptr_(pointer(), _VSTD::forward<deleter_type>(__d)) {} 2859 2860 _LIBCPP_INLINE_VISIBILITY 2861 operator __rv<unique_ptr>() { 2862 return __rv<unique_ptr>(*this); 2863 } 2864 2865 _LIBCPP_INLINE_VISIBILITY 2866 unique_ptr(__rv<unique_ptr> __u) 2867 : __ptr_(__u->release(), 2868 _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2869 2870 _LIBCPP_INLINE_VISIBILITY 2871 unique_ptr& operator=(__rv<unique_ptr> __u) { 2872 reset(__u->release()); 2873 __ptr_.second() = _VSTD::forward<deleter_type>(__u->get_deleter()); 2874 return *this; 2875 } 2876 2877 #endif // _LIBCPP_CXX03_LANG 2878 2879 public: 2880 _LIBCPP_INLINE_VISIBILITY 2881 ~unique_ptr() { reset(); } 2882 2883 _LIBCPP_INLINE_VISIBILITY 2884 unique_ptr& operator=(nullptr_t) _NOEXCEPT { 2885 reset(); 2886 return *this; 2887 } 2888 2889 _LIBCPP_INLINE_VISIBILITY 2890 typename add_lvalue_reference<_Tp>::type 2891 operator[](size_t __i) const { 2892 return __ptr_.first()[__i]; 2893 } 2894 _LIBCPP_INLINE_VISIBILITY 2895 pointer get() const _NOEXCEPT { 2896 return __ptr_.first(); 2897 } 2898 2899 _LIBCPP_INLINE_VISIBILITY 2900 deleter_type& get_deleter() _NOEXCEPT { 2901 return __ptr_.second(); 2902 } 2903 2904 _LIBCPP_INLINE_VISIBILITY 2905 const deleter_type& get_deleter() const _NOEXCEPT { 2906 return __ptr_.second(); 2907 } 2908 _LIBCPP_INLINE_VISIBILITY 2909 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { 2910 return __ptr_.first() != nullptr; 2911 } 2912 2913 _LIBCPP_INLINE_VISIBILITY 2914 pointer release() _NOEXCEPT { 2915 pointer __t = __ptr_.first(); 2916 __ptr_.first() = pointer(); 2917 return __t; 2918 } 2919 2920 template <class _Pp> 2921 _LIBCPP_INLINE_VISIBILITY 2922 typename enable_if< 2923 _CheckArrayPointerConversion<_Pp>::value 2924 >::type 2925 reset(_Pp __p) _NOEXCEPT { 2926 pointer __tmp = __ptr_.first(); 2927 __ptr_.first() = __p; 2928 if (__tmp) 2929 __ptr_.second()(__tmp); 2930 } 2931 2932 _LIBCPP_INLINE_VISIBILITY 2933 void reset(nullptr_t = nullptr) _NOEXCEPT { 2934 pointer __tmp = __ptr_.first(); 2935 __ptr_.first() = nullptr; 2936 if (__tmp) 2937 __ptr_.second()(__tmp); 2938 } 2939 2940 _LIBCPP_INLINE_VISIBILITY 2941 void swap(unique_ptr& __u) _NOEXCEPT { 2942 __ptr_.swap(__u.__ptr_); 2943 } 2944 2945 }; 2946 2947 template <class _Tp, class _Dp> 2948 inline _LIBCPP_INLINE_VISIBILITY 2949 typename enable_if< 2950 __is_swappable<_Dp>::value, 2951 void 2952 >::type 2953 swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);} 2954 2955 template <class _T1, class _D1, class _T2, class _D2> 2956 inline _LIBCPP_INLINE_VISIBILITY 2957 bool 2958 operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();} 2959 2960 template <class _T1, class _D1, class _T2, class _D2> 2961 inline _LIBCPP_INLINE_VISIBILITY 2962 bool 2963 operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);} 2964 2965 template <class _T1, class _D1, class _T2, class _D2> 2966 inline _LIBCPP_INLINE_VISIBILITY 2967 bool 2968 operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) 2969 { 2970 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 2971 typedef typename unique_ptr<_T2, _D2>::pointer _P2; 2972 typedef typename common_type<_P1, _P2>::type _Vp; 2973 return less<_Vp>()(__x.get(), __y.get()); 2974 } 2975 2976 template <class _T1, class _D1, class _T2, class _D2> 2977 inline _LIBCPP_INLINE_VISIBILITY 2978 bool 2979 operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;} 2980 2981 template <class _T1, class _D1, class _T2, class _D2> 2982 inline _LIBCPP_INLINE_VISIBILITY 2983 bool 2984 operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);} 2985 2986 template <class _T1, class _D1, class _T2, class _D2> 2987 inline _LIBCPP_INLINE_VISIBILITY 2988 bool 2989 operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);} 2990 2991 template <class _T1, class _D1> 2992 inline _LIBCPP_INLINE_VISIBILITY 2993 bool 2994 operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT 2995 { 2996 return !__x; 2997 } 2998 2999 template <class _T1, class _D1> 3000 inline _LIBCPP_INLINE_VISIBILITY 3001 bool 3002 operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT 3003 { 3004 return !__x; 3005 } 3006 3007 template <class _T1, class _D1> 3008 inline _LIBCPP_INLINE_VISIBILITY 3009 bool 3010 operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT 3011 { 3012 return static_cast<bool>(__x); 3013 } 3014 3015 template <class _T1, class _D1> 3016 inline _LIBCPP_INLINE_VISIBILITY 3017 bool 3018 operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT 3019 { 3020 return static_cast<bool>(__x); 3021 } 3022 3023 template <class _T1, class _D1> 3024 inline _LIBCPP_INLINE_VISIBILITY 3025 bool 3026 operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3027 { 3028 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 3029 return less<_P1>()(__x.get(), nullptr); 3030 } 3031 3032 template <class _T1, class _D1> 3033 inline _LIBCPP_INLINE_VISIBILITY 3034 bool 3035 operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3036 { 3037 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 3038 return less<_P1>()(nullptr, __x.get()); 3039 } 3040 3041 template <class _T1, class _D1> 3042 inline _LIBCPP_INLINE_VISIBILITY 3043 bool 3044 operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3045 { 3046 return nullptr < __x; 3047 } 3048 3049 template <class _T1, class _D1> 3050 inline _LIBCPP_INLINE_VISIBILITY 3051 bool 3052 operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3053 { 3054 return __x < nullptr; 3055 } 3056 3057 template <class _T1, class _D1> 3058 inline _LIBCPP_INLINE_VISIBILITY 3059 bool 3060 operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3061 { 3062 return !(nullptr < __x); 3063 } 3064 3065 template <class _T1, class _D1> 3066 inline _LIBCPP_INLINE_VISIBILITY 3067 bool 3068 operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3069 { 3070 return !(__x < nullptr); 3071 } 3072 3073 template <class _T1, class _D1> 3074 inline _LIBCPP_INLINE_VISIBILITY 3075 bool 3076 operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3077 { 3078 return !(__x < nullptr); 3079 } 3080 3081 template <class _T1, class _D1> 3082 inline _LIBCPP_INLINE_VISIBILITY 3083 bool 3084 operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3085 { 3086 return !(nullptr < __x); 3087 } 3088 3089 #ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3090 3091 template <class _Tp, class _Dp> 3092 inline _LIBCPP_INLINE_VISIBILITY 3093 unique_ptr<_Tp, _Dp> 3094 move(unique_ptr<_Tp, _Dp>& __t) 3095 { 3096 return unique_ptr<_Tp, _Dp>(__rv<unique_ptr<_Tp, _Dp> >(__t)); 3097 } 3098 3099 #endif 3100 3101 #if _LIBCPP_STD_VER > 11 3102 3103 template<class _Tp> 3104 struct __unique_if 3105 { 3106 typedef unique_ptr<_Tp> __unique_single; 3107 }; 3108 3109 template<class _Tp> 3110 struct __unique_if<_Tp[]> 3111 { 3112 typedef unique_ptr<_Tp[]> __unique_array_unknown_bound; 3113 }; 3114 3115 template<class _Tp, size_t _Np> 3116 struct __unique_if<_Tp[_Np]> 3117 { 3118 typedef void __unique_array_known_bound; 3119 }; 3120 3121 template<class _Tp, class... _Args> 3122 inline _LIBCPP_INLINE_VISIBILITY 3123 typename __unique_if<_Tp>::__unique_single 3124 make_unique(_Args&&... __args) 3125 { 3126 return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...)); 3127 } 3128 3129 template<class _Tp> 3130 inline _LIBCPP_INLINE_VISIBILITY 3131 typename __unique_if<_Tp>::__unique_array_unknown_bound 3132 make_unique(size_t __n) 3133 { 3134 typedef typename remove_extent<_Tp>::type _Up; 3135 return unique_ptr<_Tp>(new _Up[__n]()); 3136 } 3137 3138 template<class _Tp, class... _Args> 3139 typename __unique_if<_Tp>::__unique_array_known_bound 3140 make_unique(_Args&&...) = delete; 3141 3142 #endif // _LIBCPP_STD_VER > 11 3143 3144 template <class _Tp, class _Dp> 3145 #ifdef _LIBCPP_CXX03_LANG 3146 struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> > 3147 #else 3148 struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper< 3149 unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer>> 3150 #endif 3151 { 3152 typedef unique_ptr<_Tp, _Dp> argument_type; 3153 typedef size_t result_type; 3154 _LIBCPP_INLINE_VISIBILITY 3155 result_type operator()(const argument_type& __ptr) const 3156 { 3157 typedef typename argument_type::pointer pointer; 3158 return hash<pointer>()(__ptr.get()); 3159 } 3160 }; 3161 3162 struct __destruct_n 3163 { 3164 private: 3165 size_t __size_; 3166 3167 template <class _Tp> 3168 _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT 3169 {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();} 3170 3171 template <class _Tp> 3172 _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT 3173 {} 3174 3175 _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT 3176 {++__size_;} 3177 _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT 3178 {} 3179 3180 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT 3181 {__size_ = __s;} 3182 _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT 3183 {} 3184 public: 3185 _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT 3186 : __size_(__s) {} 3187 3188 template <class _Tp> 3189 _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*) _NOEXCEPT 3190 {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3191 3192 template <class _Tp> 3193 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT 3194 {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3195 3196 template <class _Tp> 3197 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT 3198 {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3199 }; 3200 3201 template <class _Alloc> 3202 class __allocator_destructor 3203 { 3204 typedef allocator_traits<_Alloc> __alloc_traits; 3205 public: 3206 typedef typename __alloc_traits::pointer pointer; 3207 typedef typename __alloc_traits::size_type size_type; 3208 private: 3209 _Alloc& __alloc_; 3210 size_type __s_; 3211 public: 3212 _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s) 3213 _NOEXCEPT 3214 : __alloc_(__a), __s_(__s) {} 3215 _LIBCPP_INLINE_VISIBILITY 3216 void operator()(pointer __p) _NOEXCEPT 3217 {__alloc_traits::deallocate(__alloc_, __p, __s_);} 3218 }; 3219 3220 template <class _InputIterator, class _ForwardIterator> 3221 _ForwardIterator 3222 uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r) 3223 { 3224 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3225 #ifndef _LIBCPP_NO_EXCEPTIONS 3226 _ForwardIterator __s = __r; 3227 try 3228 { 3229 #endif 3230 for (; __f != __l; ++__f, (void) ++__r) 3231 ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f); 3232 #ifndef _LIBCPP_NO_EXCEPTIONS 3233 } 3234 catch (...) 3235 { 3236 for (; __s != __r; ++__s) 3237 __s->~value_type(); 3238 throw; 3239 } 3240 #endif 3241 return __r; 3242 } 3243 3244 template <class _InputIterator, class _Size, class _ForwardIterator> 3245 _ForwardIterator 3246 uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r) 3247 { 3248 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3249 #ifndef _LIBCPP_NO_EXCEPTIONS 3250 _ForwardIterator __s = __r; 3251 try 3252 { 3253 #endif 3254 for (; __n > 0; ++__f, (void) ++__r, (void) --__n) 3255 ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f); 3256 #ifndef _LIBCPP_NO_EXCEPTIONS 3257 } 3258 catch (...) 3259 { 3260 for (; __s != __r; ++__s) 3261 __s->~value_type(); 3262 throw; 3263 } 3264 #endif 3265 return __r; 3266 } 3267 3268 template <class _ForwardIterator, class _Tp> 3269 void 3270 uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x) 3271 { 3272 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3273 #ifndef _LIBCPP_NO_EXCEPTIONS 3274 _ForwardIterator __s = __f; 3275 try 3276 { 3277 #endif 3278 for (; __f != __l; ++__f) 3279 ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x); 3280 #ifndef _LIBCPP_NO_EXCEPTIONS 3281 } 3282 catch (...) 3283 { 3284 for (; __s != __f; ++__s) 3285 __s->~value_type(); 3286 throw; 3287 } 3288 #endif 3289 } 3290 3291 template <class _ForwardIterator, class _Size, class _Tp> 3292 _ForwardIterator 3293 uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x) 3294 { 3295 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3296 #ifndef _LIBCPP_NO_EXCEPTIONS 3297 _ForwardIterator __s = __f; 3298 try 3299 { 3300 #endif 3301 for (; __n > 0; ++__f, (void) --__n) 3302 ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x); 3303 #ifndef _LIBCPP_NO_EXCEPTIONS 3304 } 3305 catch (...) 3306 { 3307 for (; __s != __f; ++__s) 3308 __s->~value_type(); 3309 throw; 3310 } 3311 #endif 3312 return __f; 3313 } 3314 3315 #if _LIBCPP_STD_VER > 14 3316 3317 template <class _Tp> 3318 inline _LIBCPP_INLINE_VISIBILITY 3319 void destroy_at(_Tp* __loc) { 3320 _LIBCPP_ASSERT(__loc, "null pointer given to destroy_at"); 3321 __loc->~_Tp(); 3322 } 3323 3324 template <class _ForwardIterator> 3325 inline _LIBCPP_INLINE_VISIBILITY 3326 void destroy(_ForwardIterator __first, _ForwardIterator __last) { 3327 for (; __first != __last; ++__first) 3328 _VSTD::destroy_at(_VSTD::addressof(*__first)); 3329 } 3330 3331 template <class _ForwardIterator, class _Size> 3332 inline _LIBCPP_INLINE_VISIBILITY 3333 _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) { 3334 for (; __n > 0; (void)++__first, --__n) 3335 _VSTD::destroy_at(_VSTD::addressof(*__first)); 3336 return __first; 3337 } 3338 3339 template <class _ForwardIterator> 3340 inline _LIBCPP_INLINE_VISIBILITY 3341 void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) { 3342 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3343 auto __idx = __first; 3344 #ifndef _LIBCPP_NO_EXCEPTIONS 3345 try { 3346 #endif 3347 for (; __idx != __last; ++__idx) 3348 ::new((void*)_VSTD::addressof(*__idx)) _Vt; 3349 #ifndef _LIBCPP_NO_EXCEPTIONS 3350 } catch (...) { 3351 _VSTD::destroy(__first, __idx); 3352 throw; 3353 } 3354 #endif 3355 } 3356 3357 template <class _ForwardIterator, class _Size> 3358 inline _LIBCPP_INLINE_VISIBILITY 3359 _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) { 3360 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3361 auto __idx = __first; 3362 #ifndef _LIBCPP_NO_EXCEPTIONS 3363 try { 3364 #endif 3365 for (; __n > 0; (void)++__idx, --__n) 3366 ::new((void*)_VSTD::addressof(*__idx)) _Vt; 3367 return __idx; 3368 #ifndef _LIBCPP_NO_EXCEPTIONS 3369 } catch (...) { 3370 _VSTD::destroy(__first, __idx); 3371 throw; 3372 } 3373 #endif 3374 } 3375 3376 3377 template <class _ForwardIterator> 3378 inline _LIBCPP_INLINE_VISIBILITY 3379 void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) { 3380 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3381 auto __idx = __first; 3382 #ifndef _LIBCPP_NO_EXCEPTIONS 3383 try { 3384 #endif 3385 for (; __idx != __last; ++__idx) 3386 ::new((void*)_VSTD::addressof(*__idx)) _Vt(); 3387 #ifndef _LIBCPP_NO_EXCEPTIONS 3388 } catch (...) { 3389 _VSTD::destroy(__first, __idx); 3390 throw; 3391 } 3392 #endif 3393 } 3394 3395 template <class _ForwardIterator, class _Size> 3396 inline _LIBCPP_INLINE_VISIBILITY 3397 _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) { 3398 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3399 auto __idx = __first; 3400 #ifndef _LIBCPP_NO_EXCEPTIONS 3401 try { 3402 #endif 3403 for (; __n > 0; (void)++__idx, --__n) 3404 ::new((void*)_VSTD::addressof(*__idx)) _Vt(); 3405 return __idx; 3406 #ifndef _LIBCPP_NO_EXCEPTIONS 3407 } catch (...) { 3408 _VSTD::destroy(__first, __idx); 3409 throw; 3410 } 3411 #endif 3412 } 3413 3414 3415 template <class _InputIt, class _ForwardIt> 3416 inline _LIBCPP_INLINE_VISIBILITY 3417 _ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) { 3418 using _Vt = typename iterator_traits<_ForwardIt>::value_type; 3419 auto __idx = __first_res; 3420 #ifndef _LIBCPP_NO_EXCEPTIONS 3421 try { 3422 #endif 3423 for (; __first != __last; (void)++__idx, ++__first) 3424 ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first)); 3425 return __idx; 3426 #ifndef _LIBCPP_NO_EXCEPTIONS 3427 } catch (...) { 3428 _VSTD::destroy(__first_res, __idx); 3429 throw; 3430 } 3431 #endif 3432 } 3433 3434 template <class _InputIt, class _Size, class _ForwardIt> 3435 inline _LIBCPP_INLINE_VISIBILITY 3436 pair<_InputIt, _ForwardIt> 3437 uninitialized_move_n(_InputIt __first, _Size __n, _ForwardIt __first_res) { 3438 using _Vt = typename iterator_traits<_ForwardIt>::value_type; 3439 auto __idx = __first_res; 3440 #ifndef _LIBCPP_NO_EXCEPTIONS 3441 try { 3442 #endif 3443 for (; __n > 0; ++__idx, (void)++__first, --__n) 3444 ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first)); 3445 return {__first, __idx}; 3446 #ifndef _LIBCPP_NO_EXCEPTIONS 3447 } catch (...) { 3448 _VSTD::destroy(__first_res, __idx); 3449 throw; 3450 } 3451 #endif 3452 } 3453 3454 3455 #endif // _LIBCPP_STD_VER > 14 3456 3457 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively) 3458 // should be sufficient for thread safety. 3459 // See https://bugs.llvm.org/show_bug.cgi?id=22803 3460 #if defined(__clang__) && __has_builtin(__atomic_add_fetch) \ 3461 && defined(__ATOMIC_RELAXED) \ 3462 && defined(__ATOMIC_ACQ_REL) 3463 # define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT 3464 #elif !defined(__clang__) && defined(_GNUC_VER) && _GNUC_VER >= 407 3465 # define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT 3466 #endif 3467 3468 template <class _Tp> 3469 inline _LIBCPP_INLINE_VISIBILITY _Tp 3470 __libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT 3471 { 3472 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS) 3473 return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED); 3474 #else 3475 return __t += 1; 3476 #endif 3477 } 3478 3479 template <class _Tp> 3480 inline _LIBCPP_INLINE_VISIBILITY _Tp 3481 __libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT 3482 { 3483 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS) 3484 return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL); 3485 #else 3486 return __t -= 1; 3487 #endif 3488 } 3489 3490 class _LIBCPP_EXCEPTION_ABI bad_weak_ptr 3491 : public std::exception 3492 { 3493 public: 3494 virtual ~bad_weak_ptr() _NOEXCEPT; 3495 virtual const char* what() const _NOEXCEPT; 3496 }; 3497 3498 _LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE 3499 void __throw_bad_weak_ptr() 3500 { 3501 #ifndef _LIBCPP_NO_EXCEPTIONS 3502 throw bad_weak_ptr(); 3503 #else 3504 _VSTD::abort(); 3505 #endif 3506 } 3507 3508 template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr; 3509 3510 class _LIBCPP_TYPE_VIS __shared_count 3511 { 3512 __shared_count(const __shared_count&); 3513 __shared_count& operator=(const __shared_count&); 3514 3515 protected: 3516 long __shared_owners_; 3517 virtual ~__shared_count(); 3518 private: 3519 virtual void __on_zero_shared() _NOEXCEPT = 0; 3520 3521 public: 3522 _LIBCPP_INLINE_VISIBILITY 3523 explicit __shared_count(long __refs = 0) _NOEXCEPT 3524 : __shared_owners_(__refs) {} 3525 3526 #if defined(_LIBCPP_BUILDING_MEMORY) && \ 3527 defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) 3528 void __add_shared() _NOEXCEPT; 3529 bool __release_shared() _NOEXCEPT; 3530 #else 3531 _LIBCPP_INLINE_VISIBILITY 3532 void __add_shared() _NOEXCEPT { 3533 __libcpp_atomic_refcount_increment(__shared_owners_); 3534 } 3535 _LIBCPP_INLINE_VISIBILITY 3536 bool __release_shared() _NOEXCEPT { 3537 if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) { 3538 __on_zero_shared(); 3539 return true; 3540 } 3541 return false; 3542 } 3543 #endif 3544 _LIBCPP_INLINE_VISIBILITY 3545 long use_count() const _NOEXCEPT { 3546 return __libcpp_relaxed_load(&__shared_owners_) + 1; 3547 } 3548 }; 3549 3550 class _LIBCPP_TYPE_VIS __shared_weak_count 3551 : private __shared_count 3552 { 3553 long __shared_weak_owners_; 3554 3555 public: 3556 _LIBCPP_INLINE_VISIBILITY 3557 explicit __shared_weak_count(long __refs = 0) _NOEXCEPT 3558 : __shared_count(__refs), 3559 __shared_weak_owners_(__refs) {} 3560 protected: 3561 virtual ~__shared_weak_count(); 3562 3563 public: 3564 #if defined(_LIBCPP_BUILDING_MEMORY) && \ 3565 defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) 3566 void __add_shared() _NOEXCEPT; 3567 void __add_weak() _NOEXCEPT; 3568 void __release_shared() _NOEXCEPT; 3569 #else 3570 _LIBCPP_INLINE_VISIBILITY 3571 void __add_shared() _NOEXCEPT { 3572 __shared_count::__add_shared(); 3573 } 3574 _LIBCPP_INLINE_VISIBILITY 3575 void __add_weak() _NOEXCEPT { 3576 __libcpp_atomic_refcount_increment(__shared_weak_owners_); 3577 } 3578 _LIBCPP_INLINE_VISIBILITY 3579 void __release_shared() _NOEXCEPT { 3580 if (__shared_count::__release_shared()) 3581 __release_weak(); 3582 } 3583 #endif 3584 void __release_weak() _NOEXCEPT; 3585 _LIBCPP_INLINE_VISIBILITY 3586 long use_count() const _NOEXCEPT {return __shared_count::use_count();} 3587 __shared_weak_count* lock() _NOEXCEPT; 3588 3589 // Define the function out only if we build static libc++ without RTTI. 3590 // Otherwise we may break clients who need to compile their projects with 3591 // -fno-rtti and yet link against a libc++.dylib compiled 3592 // without -fno-rtti. 3593 #if !defined(_LIBCPP_NO_RTTI) || !defined(_LIBCPP_BUILD_STATIC) 3594 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3595 #endif 3596 private: 3597 virtual void __on_zero_shared_weak() _NOEXCEPT = 0; 3598 }; 3599 3600 template <class _Tp, class _Dp, class _Alloc> 3601 class __shared_ptr_pointer 3602 : public __shared_weak_count 3603 { 3604 __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_; 3605 public: 3606 _LIBCPP_INLINE_VISIBILITY 3607 __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a) 3608 : __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {} 3609 3610 #ifndef _LIBCPP_NO_RTTI 3611 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3612 #endif 3613 3614 private: 3615 virtual void __on_zero_shared() _NOEXCEPT; 3616 virtual void __on_zero_shared_weak() _NOEXCEPT; 3617 }; 3618 3619 #ifndef _LIBCPP_NO_RTTI 3620 3621 template <class _Tp, class _Dp, class _Alloc> 3622 const void* 3623 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT 3624 { 3625 return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr; 3626 } 3627 3628 #endif // _LIBCPP_NO_RTTI 3629 3630 template <class _Tp, class _Dp, class _Alloc> 3631 void 3632 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT 3633 { 3634 __data_.first().second()(__data_.first().first()); 3635 __data_.first().second().~_Dp(); 3636 } 3637 3638 template <class _Tp, class _Dp, class _Alloc> 3639 void 3640 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3641 { 3642 typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al; 3643 typedef allocator_traits<_Al> _ATraits; 3644 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 3645 3646 _Al __a(__data_.second()); 3647 __data_.second().~_Alloc(); 3648 __a.deallocate(_PTraits::pointer_to(*this), 1); 3649 } 3650 3651 template <class _Tp, class _Alloc> 3652 class __shared_ptr_emplace 3653 : public __shared_weak_count 3654 { 3655 __compressed_pair<_Alloc, _Tp> __data_; 3656 public: 3657 #ifndef _LIBCPP_HAS_NO_VARIADICS 3658 3659 _LIBCPP_INLINE_VISIBILITY 3660 __shared_ptr_emplace(_Alloc __a) 3661 : __data_(_VSTD::move(__a)) {} 3662 3663 template <class ..._Args> 3664 _LIBCPP_INLINE_VISIBILITY 3665 __shared_ptr_emplace(_Alloc __a, _Args&& ...__args) 3666 : __data_(piecewise_construct, _VSTD::forward_as_tuple(__a), 3667 _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {} 3668 3669 #else // _LIBCPP_HAS_NO_VARIADICS 3670 3671 _LIBCPP_INLINE_VISIBILITY 3672 __shared_ptr_emplace(_Alloc __a) 3673 : __data_(__a) {} 3674 3675 template <class _A0> 3676 _LIBCPP_INLINE_VISIBILITY 3677 __shared_ptr_emplace(_Alloc __a, _A0& __a0) 3678 : __data_(__a, _Tp(__a0)) {} 3679 3680 template <class _A0, class _A1> 3681 _LIBCPP_INLINE_VISIBILITY 3682 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1) 3683 : __data_(__a, _Tp(__a0, __a1)) {} 3684 3685 template <class _A0, class _A1, class _A2> 3686 _LIBCPP_INLINE_VISIBILITY 3687 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1, _A2& __a2) 3688 : __data_(__a, _Tp(__a0, __a1, __a2)) {} 3689 3690 #endif // _LIBCPP_HAS_NO_VARIADICS 3691 3692 private: 3693 virtual void __on_zero_shared() _NOEXCEPT; 3694 virtual void __on_zero_shared_weak() _NOEXCEPT; 3695 public: 3696 _LIBCPP_INLINE_VISIBILITY 3697 _Tp* get() _NOEXCEPT {return &__data_.second();} 3698 }; 3699 3700 template <class _Tp, class _Alloc> 3701 void 3702 __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT 3703 { 3704 __data_.second().~_Tp(); 3705 } 3706 3707 template <class _Tp, class _Alloc> 3708 void 3709 __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3710 { 3711 typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type _Al; 3712 typedef allocator_traits<_Al> _ATraits; 3713 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 3714 _Al __a(__data_.first()); 3715 __data_.first().~_Alloc(); 3716 __a.deallocate(_PTraits::pointer_to(*this), 1); 3717 } 3718 3719 struct __shared_ptr_dummy_rebind_allocator_type; 3720 template <> 3721 class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type> 3722 { 3723 public: 3724 template <class _Other> 3725 struct rebind 3726 { 3727 typedef allocator<_Other> other; 3728 }; 3729 }; 3730 3731 template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this; 3732 3733 template<class _Tp> 3734 class _LIBCPP_TEMPLATE_VIS shared_ptr 3735 { 3736 public: 3737 typedef _Tp element_type; 3738 3739 #if _LIBCPP_STD_VER > 14 3740 typedef weak_ptr<_Tp> weak_type; 3741 #endif 3742 private: 3743 element_type* __ptr_; 3744 __shared_weak_count* __cntrl_; 3745 3746 struct __nat {int __for_bool_;}; 3747 public: 3748 _LIBCPP_INLINE_VISIBILITY 3749 _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT; 3750 _LIBCPP_INLINE_VISIBILITY 3751 _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT; 3752 template<class _Yp> 3753 explicit shared_ptr(_Yp* __p, 3754 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3755 template<class _Yp, class _Dp> 3756 shared_ptr(_Yp* __p, _Dp __d, 3757 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3758 template<class _Yp, class _Dp, class _Alloc> 3759 shared_ptr(_Yp* __p, _Dp __d, _Alloc __a, 3760 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3761 template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d); 3762 template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a); 3763 template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT; 3764 _LIBCPP_INLINE_VISIBILITY 3765 shared_ptr(const shared_ptr& __r) _NOEXCEPT; 3766 template<class _Yp> 3767 _LIBCPP_INLINE_VISIBILITY 3768 shared_ptr(const shared_ptr<_Yp>& __r, 3769 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()) 3770 _NOEXCEPT; 3771 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3772 _LIBCPP_INLINE_VISIBILITY 3773 shared_ptr(shared_ptr&& __r) _NOEXCEPT; 3774 template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(shared_ptr<_Yp>&& __r, 3775 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()) 3776 _NOEXCEPT; 3777 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3778 template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r, 3779 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type= __nat()); 3780 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 3781 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3782 template<class _Yp> 3783 shared_ptr(auto_ptr<_Yp>&& __r, 3784 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3785 #else 3786 template<class _Yp> 3787 shared_ptr(auto_ptr<_Yp> __r, 3788 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3789 #endif 3790 #endif 3791 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3792 template <class _Yp, class _Dp> 3793 shared_ptr(unique_ptr<_Yp, _Dp>&&, 3794 typename enable_if 3795 < 3796 !is_lvalue_reference<_Dp>::value && 3797 !is_array<_Yp>::value && 3798 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3799 __nat 3800 >::type = __nat()); 3801 template <class _Yp, class _Dp> 3802 shared_ptr(unique_ptr<_Yp, _Dp>&&, 3803 typename enable_if 3804 < 3805 is_lvalue_reference<_Dp>::value && 3806 !is_array<_Yp>::value && 3807 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3808 __nat 3809 >::type = __nat()); 3810 #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3811 template <class _Yp, class _Dp> 3812 shared_ptr(unique_ptr<_Yp, _Dp>, 3813 typename enable_if 3814 < 3815 !is_lvalue_reference<_Dp>::value && 3816 !is_array<_Yp>::value && 3817 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3818 __nat 3819 >::type = __nat()); 3820 template <class _Yp, class _Dp> 3821 shared_ptr(unique_ptr<_Yp, _Dp>, 3822 typename enable_if 3823 < 3824 is_lvalue_reference<_Dp>::value && 3825 !is_array<_Yp>::value && 3826 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3827 __nat 3828 >::type = __nat()); 3829 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3830 3831 ~shared_ptr(); 3832 3833 _LIBCPP_INLINE_VISIBILITY 3834 shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT; 3835 template<class _Yp> 3836 typename enable_if 3837 < 3838 is_convertible<_Yp*, element_type*>::value, 3839 shared_ptr& 3840 >::type 3841 _LIBCPP_INLINE_VISIBILITY 3842 operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT; 3843 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3844 _LIBCPP_INLINE_VISIBILITY 3845 shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT; 3846 template<class _Yp> 3847 typename enable_if 3848 < 3849 is_convertible<_Yp*, element_type*>::value, 3850 shared_ptr<_Tp>& 3851 >::type 3852 _LIBCPP_INLINE_VISIBILITY 3853 operator=(shared_ptr<_Yp>&& __r); 3854 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 3855 template<class _Yp> 3856 _LIBCPP_INLINE_VISIBILITY 3857 typename enable_if 3858 < 3859 !is_array<_Yp>::value && 3860 is_convertible<_Yp*, element_type*>::value, 3861 shared_ptr 3862 >::type& 3863 operator=(auto_ptr<_Yp>&& __r); 3864 #endif 3865 #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3866 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 3867 template<class _Yp> 3868 _LIBCPP_INLINE_VISIBILITY 3869 typename enable_if 3870 < 3871 !is_array<_Yp>::value && 3872 is_convertible<_Yp*, element_type*>::value, 3873 shared_ptr& 3874 >::type 3875 operator=(auto_ptr<_Yp> __r); 3876 #endif 3877 #endif 3878 template <class _Yp, class _Dp> 3879 typename enable_if 3880 < 3881 !is_array<_Yp>::value && 3882 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3883 shared_ptr& 3884 >::type 3885 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3886 _LIBCPP_INLINE_VISIBILITY 3887 operator=(unique_ptr<_Yp, _Dp>&& __r); 3888 #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3889 _LIBCPP_INLINE_VISIBILITY 3890 operator=(unique_ptr<_Yp, _Dp> __r); 3891 #endif 3892 3893 _LIBCPP_INLINE_VISIBILITY 3894 void swap(shared_ptr& __r) _NOEXCEPT; 3895 _LIBCPP_INLINE_VISIBILITY 3896 void reset() _NOEXCEPT; 3897 template<class _Yp> 3898 typename enable_if 3899 < 3900 is_convertible<_Yp*, element_type*>::value, 3901 void 3902 >::type 3903 _LIBCPP_INLINE_VISIBILITY 3904 reset(_Yp* __p); 3905 template<class _Yp, class _Dp> 3906 typename enable_if 3907 < 3908 is_convertible<_Yp*, element_type*>::value, 3909 void 3910 >::type 3911 _LIBCPP_INLINE_VISIBILITY 3912 reset(_Yp* __p, _Dp __d); 3913 template<class _Yp, class _Dp, class _Alloc> 3914 typename enable_if 3915 < 3916 is_convertible<_Yp*, element_type*>::value, 3917 void 3918 >::type 3919 _LIBCPP_INLINE_VISIBILITY 3920 reset(_Yp* __p, _Dp __d, _Alloc __a); 3921 3922 _LIBCPP_INLINE_VISIBILITY 3923 element_type* get() const _NOEXCEPT {return __ptr_;} 3924 _LIBCPP_INLINE_VISIBILITY 3925 typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT 3926 {return *__ptr_;} 3927 _LIBCPP_INLINE_VISIBILITY 3928 element_type* operator->() const _NOEXCEPT {return __ptr_;} 3929 _LIBCPP_INLINE_VISIBILITY 3930 long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;} 3931 _LIBCPP_INLINE_VISIBILITY 3932 bool unique() const _NOEXCEPT {return use_count() == 1;} 3933 _LIBCPP_INLINE_VISIBILITY 3934 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != 0;} 3935 template <class _Up> 3936 _LIBCPP_INLINE_VISIBILITY 3937 bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT 3938 {return __cntrl_ < __p.__cntrl_;} 3939 template <class _Up> 3940 _LIBCPP_INLINE_VISIBILITY 3941 bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT 3942 {return __cntrl_ < __p.__cntrl_;} 3943 _LIBCPP_INLINE_VISIBILITY 3944 bool 3945 __owner_equivalent(const shared_ptr& __p) const 3946 {return __cntrl_ == __p.__cntrl_;} 3947 3948 #ifndef _LIBCPP_NO_RTTI 3949 template <class _Dp> 3950 _LIBCPP_INLINE_VISIBILITY 3951 _Dp* __get_deleter() const _NOEXCEPT 3952 {return static_cast<_Dp*>(__cntrl_ 3953 ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp))) 3954 : nullptr);} 3955 #endif // _LIBCPP_NO_RTTI 3956 3957 #ifndef _LIBCPP_HAS_NO_VARIADICS 3958 3959 template<class ..._Args> 3960 static 3961 shared_ptr<_Tp> 3962 make_shared(_Args&& ...__args); 3963 3964 template<class _Alloc, class ..._Args> 3965 static 3966 shared_ptr<_Tp> 3967 allocate_shared(const _Alloc& __a, _Args&& ...__args); 3968 3969 #else // _LIBCPP_HAS_NO_VARIADICS 3970 3971 static shared_ptr<_Tp> make_shared(); 3972 3973 template<class _A0> 3974 static shared_ptr<_Tp> make_shared(_A0&); 3975 3976 template<class _A0, class _A1> 3977 static shared_ptr<_Tp> make_shared(_A0&, _A1&); 3978 3979 template<class _A0, class _A1, class _A2> 3980 static shared_ptr<_Tp> make_shared(_A0&, _A1&, _A2&); 3981 3982 template<class _Alloc> 3983 static shared_ptr<_Tp> 3984 allocate_shared(const _Alloc& __a); 3985 3986 template<class _Alloc, class _A0> 3987 static shared_ptr<_Tp> 3988 allocate_shared(const _Alloc& __a, _A0& __a0); 3989 3990 template<class _Alloc, class _A0, class _A1> 3991 static shared_ptr<_Tp> 3992 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1); 3993 3994 template<class _Alloc, class _A0, class _A1, class _A2> 3995 static shared_ptr<_Tp> 3996 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2); 3997 3998 #endif // _LIBCPP_HAS_NO_VARIADICS 3999 4000 private: 4001 template <class _Yp, bool = is_function<_Yp>::value> 4002 struct __shared_ptr_default_allocator 4003 { 4004 typedef allocator<_Yp> type; 4005 }; 4006 4007 template <class _Yp> 4008 struct __shared_ptr_default_allocator<_Yp, true> 4009 { 4010 typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type; 4011 }; 4012 4013 template <class _Yp, class _OrigPtr> 4014 _LIBCPP_INLINE_VISIBILITY 4015 typename enable_if<is_convertible<_OrigPtr*, 4016 const enable_shared_from_this<_Yp>* 4017 >::value, 4018 void>::type 4019 __enable_weak_this(const enable_shared_from_this<_Yp>* __e, 4020 _OrigPtr* __ptr) _NOEXCEPT 4021 { 4022 typedef typename remove_cv<_Yp>::type _RawYp; 4023 if (__e && __e->__weak_this_.expired()) 4024 { 4025 __e->__weak_this_ = shared_ptr<_RawYp>(*this, 4026 const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr))); 4027 } 4028 } 4029 4030 _LIBCPP_INLINE_VISIBILITY void __enable_weak_this(...) _NOEXCEPT {} 4031 4032 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; 4033 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; 4034 }; 4035 4036 4037 template<class _Tp> 4038 inline 4039 _LIBCPP_CONSTEXPR 4040 shared_ptr<_Tp>::shared_ptr() _NOEXCEPT 4041 : __ptr_(0), 4042 __cntrl_(0) 4043 { 4044 } 4045 4046 template<class _Tp> 4047 inline 4048 _LIBCPP_CONSTEXPR 4049 shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT 4050 : __ptr_(0), 4051 __cntrl_(0) 4052 { 4053 } 4054 4055 template<class _Tp> 4056 template<class _Yp> 4057 shared_ptr<_Tp>::shared_ptr(_Yp* __p, 4058 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4059 : __ptr_(__p) 4060 { 4061 unique_ptr<_Yp> __hold(__p); 4062 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4063 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, _AllocT > _CntrlBlk; 4064 __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), _AllocT()); 4065 __hold.release(); 4066 __enable_weak_this(__p, __p); 4067 } 4068 4069 template<class _Tp> 4070 template<class _Yp, class _Dp> 4071 shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, 4072 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4073 : __ptr_(__p) 4074 { 4075 #ifndef _LIBCPP_NO_EXCEPTIONS 4076 try 4077 { 4078 #endif // _LIBCPP_NO_EXCEPTIONS 4079 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4080 typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk; 4081 __cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); 4082 __enable_weak_this(__p, __p); 4083 #ifndef _LIBCPP_NO_EXCEPTIONS 4084 } 4085 catch (...) 4086 { 4087 __d(__p); 4088 throw; 4089 } 4090 #endif // _LIBCPP_NO_EXCEPTIONS 4091 } 4092 4093 template<class _Tp> 4094 template<class _Dp> 4095 shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d) 4096 : __ptr_(0) 4097 { 4098 #ifndef _LIBCPP_NO_EXCEPTIONS 4099 try 4100 { 4101 #endif // _LIBCPP_NO_EXCEPTIONS 4102 typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT; 4103 typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk; 4104 __cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); 4105 #ifndef _LIBCPP_NO_EXCEPTIONS 4106 } 4107 catch (...) 4108 { 4109 __d(__p); 4110 throw; 4111 } 4112 #endif // _LIBCPP_NO_EXCEPTIONS 4113 } 4114 4115 template<class _Tp> 4116 template<class _Yp, class _Dp, class _Alloc> 4117 shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a, 4118 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4119 : __ptr_(__p) 4120 { 4121 #ifndef _LIBCPP_NO_EXCEPTIONS 4122 try 4123 { 4124 #endif // _LIBCPP_NO_EXCEPTIONS 4125 typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk; 4126 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; 4127 typedef __allocator_destructor<_A2> _D2; 4128 _A2 __a2(__a); 4129 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4130 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4131 _CntrlBlk(__p, __d, __a); 4132 __cntrl_ = _VSTD::addressof(*__hold2.release()); 4133 __enable_weak_this(__p, __p); 4134 #ifndef _LIBCPP_NO_EXCEPTIONS 4135 } 4136 catch (...) 4137 { 4138 __d(__p); 4139 throw; 4140 } 4141 #endif // _LIBCPP_NO_EXCEPTIONS 4142 } 4143 4144 template<class _Tp> 4145 template<class _Dp, class _Alloc> 4146 shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a) 4147 : __ptr_(0) 4148 { 4149 #ifndef _LIBCPP_NO_EXCEPTIONS 4150 try 4151 { 4152 #endif // _LIBCPP_NO_EXCEPTIONS 4153 typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk; 4154 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; 4155 typedef __allocator_destructor<_A2> _D2; 4156 _A2 __a2(__a); 4157 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4158 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4159 _CntrlBlk(__p, __d, __a); 4160 __cntrl_ = _VSTD::addressof(*__hold2.release()); 4161 #ifndef _LIBCPP_NO_EXCEPTIONS 4162 } 4163 catch (...) 4164 { 4165 __d(__p); 4166 throw; 4167 } 4168 #endif // _LIBCPP_NO_EXCEPTIONS 4169 } 4170 4171 template<class _Tp> 4172 template<class _Yp> 4173 inline 4174 shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT 4175 : __ptr_(__p), 4176 __cntrl_(__r.__cntrl_) 4177 { 4178 if (__cntrl_) 4179 __cntrl_->__add_shared(); 4180 } 4181 4182 template<class _Tp> 4183 inline 4184 shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT 4185 : __ptr_(__r.__ptr_), 4186 __cntrl_(__r.__cntrl_) 4187 { 4188 if (__cntrl_) 4189 __cntrl_->__add_shared(); 4190 } 4191 4192 template<class _Tp> 4193 template<class _Yp> 4194 inline 4195 shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, 4196 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4197 _NOEXCEPT 4198 : __ptr_(__r.__ptr_), 4199 __cntrl_(__r.__cntrl_) 4200 { 4201 if (__cntrl_) 4202 __cntrl_->__add_shared(); 4203 } 4204 4205 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4206 4207 template<class _Tp> 4208 inline 4209 shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT 4210 : __ptr_(__r.__ptr_), 4211 __cntrl_(__r.__cntrl_) 4212 { 4213 __r.__ptr_ = 0; 4214 __r.__cntrl_ = 0; 4215 } 4216 4217 template<class _Tp> 4218 template<class _Yp> 4219 inline 4220 shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r, 4221 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4222 _NOEXCEPT 4223 : __ptr_(__r.__ptr_), 4224 __cntrl_(__r.__cntrl_) 4225 { 4226 __r.__ptr_ = 0; 4227 __r.__cntrl_ = 0; 4228 } 4229 4230 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4231 4232 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 4233 template<class _Tp> 4234 template<class _Yp> 4235 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4236 shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r, 4237 #else 4238 shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r, 4239 #endif 4240 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4241 : __ptr_(__r.get()) 4242 { 4243 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk; 4244 __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>()); 4245 __enable_weak_this(__r.get(), __r.get()); 4246 __r.release(); 4247 } 4248 #endif 4249 4250 template<class _Tp> 4251 template <class _Yp, class _Dp> 4252 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4253 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 4254 #else 4255 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 4256 #endif 4257 typename enable_if 4258 < 4259 !is_lvalue_reference<_Dp>::value && 4260 !is_array<_Yp>::value && 4261 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 4262 __nat 4263 >::type) 4264 : __ptr_(__r.get()) 4265 { 4266 #if _LIBCPP_STD_VER > 11 4267 if (__ptr_ == nullptr) 4268 __cntrl_ = nullptr; 4269 else 4270 #endif 4271 { 4272 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4273 typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk; 4274 __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), _AllocT()); 4275 __enable_weak_this(__r.get(), __r.get()); 4276 } 4277 __r.release(); 4278 } 4279 4280 template<class _Tp> 4281 template <class _Yp, class _Dp> 4282 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4283 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 4284 #else 4285 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 4286 #endif 4287 typename enable_if 4288 < 4289 is_lvalue_reference<_Dp>::value && 4290 !is_array<_Yp>::value && 4291 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 4292 __nat 4293 >::type) 4294 : __ptr_(__r.get()) 4295 { 4296 #if _LIBCPP_STD_VER > 11 4297 if (__ptr_ == nullptr) 4298 __cntrl_ = nullptr; 4299 else 4300 #endif 4301 { 4302 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4303 typedef __shared_ptr_pointer<_Yp*, 4304 reference_wrapper<typename remove_reference<_Dp>::type>, 4305 _AllocT > _CntrlBlk; 4306 __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), _AllocT()); 4307 __enable_weak_this(__r.get(), __r.get()); 4308 } 4309 __r.release(); 4310 } 4311 4312 #ifndef _LIBCPP_HAS_NO_VARIADICS 4313 4314 template<class _Tp> 4315 template<class ..._Args> 4316 shared_ptr<_Tp> 4317 shared_ptr<_Tp>::make_shared(_Args&& ...__args) 4318 { 4319 static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in make_shared" ); 4320 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4321 typedef allocator<_CntrlBlk> _A2; 4322 typedef __allocator_destructor<_A2> _D2; 4323 _A2 __a2; 4324 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4325 ::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...); 4326 shared_ptr<_Tp> __r; 4327 __r.__ptr_ = __hold2.get()->get(); 4328 __r.__cntrl_ = __hold2.release(); 4329 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4330 return __r; 4331 } 4332 4333 template<class _Tp> 4334 template<class _Alloc, class ..._Args> 4335 shared_ptr<_Tp> 4336 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args) 4337 { 4338 static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in allocate_shared" ); 4339 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4340 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; 4341 typedef __allocator_destructor<_A2> _D2; 4342 _A2 __a2(__a); 4343 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4344 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4345 _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...); 4346 shared_ptr<_Tp> __r; 4347 __r.__ptr_ = __hold2.get()->get(); 4348 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4349 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4350 return __r; 4351 } 4352 4353 #else // _LIBCPP_HAS_NO_VARIADICS 4354 4355 template<class _Tp> 4356 shared_ptr<_Tp> 4357 shared_ptr<_Tp>::make_shared() 4358 { 4359 static_assert((is_constructible<_Tp>::value), "Can't construct object in make_shared" ); 4360 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4361 typedef allocator<_CntrlBlk> _Alloc2; 4362 typedef __allocator_destructor<_Alloc2> _D2; 4363 _Alloc2 __alloc2; 4364 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4365 ::new(__hold2.get()) _CntrlBlk(__alloc2); 4366 shared_ptr<_Tp> __r; 4367 __r.__ptr_ = __hold2.get()->get(); 4368 __r.__cntrl_ = __hold2.release(); 4369 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4370 return __r; 4371 } 4372 4373 template<class _Tp> 4374 template<class _A0> 4375 shared_ptr<_Tp> 4376 shared_ptr<_Tp>::make_shared(_A0& __a0) 4377 { 4378 static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in make_shared" ); 4379 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4380 typedef allocator<_CntrlBlk> _Alloc2; 4381 typedef __allocator_destructor<_Alloc2> _D2; 4382 _Alloc2 __alloc2; 4383 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4384 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0); 4385 shared_ptr<_Tp> __r; 4386 __r.__ptr_ = __hold2.get()->get(); 4387 __r.__cntrl_ = __hold2.release(); 4388 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4389 return __r; 4390 } 4391 4392 template<class _Tp> 4393 template<class _A0, class _A1> 4394 shared_ptr<_Tp> 4395 shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1) 4396 { 4397 static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in make_shared" ); 4398 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4399 typedef allocator<_CntrlBlk> _Alloc2; 4400 typedef __allocator_destructor<_Alloc2> _D2; 4401 _Alloc2 __alloc2; 4402 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4403 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1); 4404 shared_ptr<_Tp> __r; 4405 __r.__ptr_ = __hold2.get()->get(); 4406 __r.__cntrl_ = __hold2.release(); 4407 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4408 return __r; 4409 } 4410 4411 template<class _Tp> 4412 template<class _A0, class _A1, class _A2> 4413 shared_ptr<_Tp> 4414 shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 4415 { 4416 static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in make_shared" ); 4417 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4418 typedef allocator<_CntrlBlk> _Alloc2; 4419 typedef __allocator_destructor<_Alloc2> _D2; 4420 _Alloc2 __alloc2; 4421 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4422 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1, __a2); 4423 shared_ptr<_Tp> __r; 4424 __r.__ptr_ = __hold2.get()->get(); 4425 __r.__cntrl_ = __hold2.release(); 4426 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4427 return __r; 4428 } 4429 4430 template<class _Tp> 4431 template<class _Alloc> 4432 shared_ptr<_Tp> 4433 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a) 4434 { 4435 static_assert((is_constructible<_Tp>::value), "Can't construct object in allocate_shared" ); 4436 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4437 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4438 typedef __allocator_destructor<_Alloc2> _D2; 4439 _Alloc2 __alloc2(__a); 4440 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4441 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4442 _CntrlBlk(__a); 4443 shared_ptr<_Tp> __r; 4444 __r.__ptr_ = __hold2.get()->get(); 4445 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4446 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4447 return __r; 4448 } 4449 4450 template<class _Tp> 4451 template<class _Alloc, class _A0> 4452 shared_ptr<_Tp> 4453 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0) 4454 { 4455 static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in allocate_shared" ); 4456 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4457 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4458 typedef __allocator_destructor<_Alloc2> _D2; 4459 _Alloc2 __alloc2(__a); 4460 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4461 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4462 _CntrlBlk(__a, __a0); 4463 shared_ptr<_Tp> __r; 4464 __r.__ptr_ = __hold2.get()->get(); 4465 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4466 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4467 return __r; 4468 } 4469 4470 template<class _Tp> 4471 template<class _Alloc, class _A0, class _A1> 4472 shared_ptr<_Tp> 4473 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 4474 { 4475 static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in allocate_shared" ); 4476 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4477 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4478 typedef __allocator_destructor<_Alloc2> _D2; 4479 _Alloc2 __alloc2(__a); 4480 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4481 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4482 _CntrlBlk(__a, __a0, __a1); 4483 shared_ptr<_Tp> __r; 4484 __r.__ptr_ = __hold2.get()->get(); 4485 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4486 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4487 return __r; 4488 } 4489 4490 template<class _Tp> 4491 template<class _Alloc, class _A0, class _A1, class _A2> 4492 shared_ptr<_Tp> 4493 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 4494 { 4495 static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in allocate_shared" ); 4496 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4497 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4498 typedef __allocator_destructor<_Alloc2> _D2; 4499 _Alloc2 __alloc2(__a); 4500 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4501 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4502 _CntrlBlk(__a, __a0, __a1, __a2); 4503 shared_ptr<_Tp> __r; 4504 __r.__ptr_ = __hold2.get()->get(); 4505 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4506 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4507 return __r; 4508 } 4509 4510 #endif // _LIBCPP_HAS_NO_VARIADICS 4511 4512 template<class _Tp> 4513 shared_ptr<_Tp>::~shared_ptr() 4514 { 4515 if (__cntrl_) 4516 __cntrl_->__release_shared(); 4517 } 4518 4519 template<class _Tp> 4520 inline 4521 shared_ptr<_Tp>& 4522 shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT 4523 { 4524 shared_ptr(__r).swap(*this); 4525 return *this; 4526 } 4527 4528 template<class _Tp> 4529 template<class _Yp> 4530 inline 4531 typename enable_if 4532 < 4533 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4534 shared_ptr<_Tp>& 4535 >::type 4536 shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT 4537 { 4538 shared_ptr(__r).swap(*this); 4539 return *this; 4540 } 4541 4542 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4543 4544 template<class _Tp> 4545 inline 4546 shared_ptr<_Tp>& 4547 shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT 4548 { 4549 shared_ptr(_VSTD::move(__r)).swap(*this); 4550 return *this; 4551 } 4552 4553 template<class _Tp> 4554 template<class _Yp> 4555 inline 4556 typename enable_if 4557 < 4558 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4559 shared_ptr<_Tp>& 4560 >::type 4561 shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r) 4562 { 4563 shared_ptr(_VSTD::move(__r)).swap(*this); 4564 return *this; 4565 } 4566 4567 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 4568 template<class _Tp> 4569 template<class _Yp> 4570 inline 4571 typename enable_if 4572 < 4573 !is_array<_Yp>::value && 4574 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4575 shared_ptr<_Tp> 4576 >::type& 4577 shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r) 4578 { 4579 shared_ptr(_VSTD::move(__r)).swap(*this); 4580 return *this; 4581 } 4582 #endif 4583 4584 template<class _Tp> 4585 template <class _Yp, class _Dp> 4586 inline 4587 typename enable_if 4588 < 4589 !is_array<_Yp>::value && 4590 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 4591 typename shared_ptr<_Tp>::element_type*>::value, 4592 shared_ptr<_Tp>& 4593 >::type 4594 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r) 4595 { 4596 shared_ptr(_VSTD::move(__r)).swap(*this); 4597 return *this; 4598 } 4599 4600 #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4601 4602 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 4603 template<class _Tp> 4604 template<class _Yp> 4605 inline _LIBCPP_INLINE_VISIBILITY 4606 typename enable_if 4607 < 4608 !is_array<_Yp>::value && 4609 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4610 shared_ptr<_Tp>& 4611 >::type 4612 shared_ptr<_Tp>::operator=(auto_ptr<_Yp> __r) 4613 { 4614 shared_ptr(__r).swap(*this); 4615 return *this; 4616 } 4617 #endif 4618 4619 template<class _Tp> 4620 template <class _Yp, class _Dp> 4621 inline _LIBCPP_INLINE_VISIBILITY 4622 typename enable_if 4623 < 4624 !is_array<_Yp>::value && 4625 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 4626 typename shared_ptr<_Tp>::element_type*>::value, 4627 shared_ptr<_Tp>& 4628 >::type 4629 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r) 4630 { 4631 shared_ptr(_VSTD::move(__r)).swap(*this); 4632 return *this; 4633 } 4634 4635 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4636 4637 template<class _Tp> 4638 inline 4639 void 4640 shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT 4641 { 4642 _VSTD::swap(__ptr_, __r.__ptr_); 4643 _VSTD::swap(__cntrl_, __r.__cntrl_); 4644 } 4645 4646 template<class _Tp> 4647 inline 4648 void 4649 shared_ptr<_Tp>::reset() _NOEXCEPT 4650 { 4651 shared_ptr().swap(*this); 4652 } 4653 4654 template<class _Tp> 4655 template<class _Yp> 4656 inline 4657 typename enable_if 4658 < 4659 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4660 void 4661 >::type 4662 shared_ptr<_Tp>::reset(_Yp* __p) 4663 { 4664 shared_ptr(__p).swap(*this); 4665 } 4666 4667 template<class _Tp> 4668 template<class _Yp, class _Dp> 4669 inline 4670 typename enable_if 4671 < 4672 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4673 void 4674 >::type 4675 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d) 4676 { 4677 shared_ptr(__p, __d).swap(*this); 4678 } 4679 4680 template<class _Tp> 4681 template<class _Yp, class _Dp, class _Alloc> 4682 inline 4683 typename enable_if 4684 < 4685 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4686 void 4687 >::type 4688 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a) 4689 { 4690 shared_ptr(__p, __d, __a).swap(*this); 4691 } 4692 4693 #ifndef _LIBCPP_HAS_NO_VARIADICS 4694 4695 template<class _Tp, class ..._Args> 4696 inline _LIBCPP_INLINE_VISIBILITY 4697 typename enable_if 4698 < 4699 !is_array<_Tp>::value, 4700 shared_ptr<_Tp> 4701 >::type 4702 make_shared(_Args&& ...__args) 4703 { 4704 return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...); 4705 } 4706 4707 template<class _Tp, class _Alloc, class ..._Args> 4708 inline _LIBCPP_INLINE_VISIBILITY 4709 typename enable_if 4710 < 4711 !is_array<_Tp>::value, 4712 shared_ptr<_Tp> 4713 >::type 4714 allocate_shared(const _Alloc& __a, _Args&& ...__args) 4715 { 4716 return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...); 4717 } 4718 4719 #else // _LIBCPP_HAS_NO_VARIADICS 4720 4721 template<class _Tp> 4722 inline _LIBCPP_INLINE_VISIBILITY 4723 shared_ptr<_Tp> 4724 make_shared() 4725 { 4726 return shared_ptr<_Tp>::make_shared(); 4727 } 4728 4729 template<class _Tp, class _A0> 4730 inline _LIBCPP_INLINE_VISIBILITY 4731 shared_ptr<_Tp> 4732 make_shared(_A0& __a0) 4733 { 4734 return shared_ptr<_Tp>::make_shared(__a0); 4735 } 4736 4737 template<class _Tp, class _A0, class _A1> 4738 inline _LIBCPP_INLINE_VISIBILITY 4739 shared_ptr<_Tp> 4740 make_shared(_A0& __a0, _A1& __a1) 4741 { 4742 return shared_ptr<_Tp>::make_shared(__a0, __a1); 4743 } 4744 4745 template<class _Tp, class _A0, class _A1, class _A2> 4746 inline _LIBCPP_INLINE_VISIBILITY 4747 shared_ptr<_Tp> 4748 make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 4749 { 4750 return shared_ptr<_Tp>::make_shared(__a0, __a1, __a2); 4751 } 4752 4753 template<class _Tp, class _Alloc> 4754 inline _LIBCPP_INLINE_VISIBILITY 4755 shared_ptr<_Tp> 4756 allocate_shared(const _Alloc& __a) 4757 { 4758 return shared_ptr<_Tp>::allocate_shared(__a); 4759 } 4760 4761 template<class _Tp, class _Alloc, class _A0> 4762 inline _LIBCPP_INLINE_VISIBILITY 4763 shared_ptr<_Tp> 4764 allocate_shared(const _Alloc& __a, _A0& __a0) 4765 { 4766 return shared_ptr<_Tp>::allocate_shared(__a, __a0); 4767 } 4768 4769 template<class _Tp, class _Alloc, class _A0, class _A1> 4770 inline _LIBCPP_INLINE_VISIBILITY 4771 shared_ptr<_Tp> 4772 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 4773 { 4774 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1); 4775 } 4776 4777 template<class _Tp, class _Alloc, class _A0, class _A1, class _A2> 4778 inline _LIBCPP_INLINE_VISIBILITY 4779 shared_ptr<_Tp> 4780 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 4781 { 4782 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1, __a2); 4783 } 4784 4785 #endif // _LIBCPP_HAS_NO_VARIADICS 4786 4787 template<class _Tp, class _Up> 4788 inline _LIBCPP_INLINE_VISIBILITY 4789 bool 4790 operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4791 { 4792 return __x.get() == __y.get(); 4793 } 4794 4795 template<class _Tp, class _Up> 4796 inline _LIBCPP_INLINE_VISIBILITY 4797 bool 4798 operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4799 { 4800 return !(__x == __y); 4801 } 4802 4803 template<class _Tp, class _Up> 4804 inline _LIBCPP_INLINE_VISIBILITY 4805 bool 4806 operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4807 { 4808 typedef typename common_type<_Tp*, _Up*>::type _Vp; 4809 return less<_Vp>()(__x.get(), __y.get()); 4810 } 4811 4812 template<class _Tp, class _Up> 4813 inline _LIBCPP_INLINE_VISIBILITY 4814 bool 4815 operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4816 { 4817 return __y < __x; 4818 } 4819 4820 template<class _Tp, class _Up> 4821 inline _LIBCPP_INLINE_VISIBILITY 4822 bool 4823 operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4824 { 4825 return !(__y < __x); 4826 } 4827 4828 template<class _Tp, class _Up> 4829 inline _LIBCPP_INLINE_VISIBILITY 4830 bool 4831 operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4832 { 4833 return !(__x < __y); 4834 } 4835 4836 template<class _Tp> 4837 inline _LIBCPP_INLINE_VISIBILITY 4838 bool 4839 operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4840 { 4841 return !__x; 4842 } 4843 4844 template<class _Tp> 4845 inline _LIBCPP_INLINE_VISIBILITY 4846 bool 4847 operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4848 { 4849 return !__x; 4850 } 4851 4852 template<class _Tp> 4853 inline _LIBCPP_INLINE_VISIBILITY 4854 bool 4855 operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4856 { 4857 return static_cast<bool>(__x); 4858 } 4859 4860 template<class _Tp> 4861 inline _LIBCPP_INLINE_VISIBILITY 4862 bool 4863 operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4864 { 4865 return static_cast<bool>(__x); 4866 } 4867 4868 template<class _Tp> 4869 inline _LIBCPP_INLINE_VISIBILITY 4870 bool 4871 operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4872 { 4873 return less<_Tp*>()(__x.get(), nullptr); 4874 } 4875 4876 template<class _Tp> 4877 inline _LIBCPP_INLINE_VISIBILITY 4878 bool 4879 operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4880 { 4881 return less<_Tp*>()(nullptr, __x.get()); 4882 } 4883 4884 template<class _Tp> 4885 inline _LIBCPP_INLINE_VISIBILITY 4886 bool 4887 operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4888 { 4889 return nullptr < __x; 4890 } 4891 4892 template<class _Tp> 4893 inline _LIBCPP_INLINE_VISIBILITY 4894 bool 4895 operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4896 { 4897 return __x < nullptr; 4898 } 4899 4900 template<class _Tp> 4901 inline _LIBCPP_INLINE_VISIBILITY 4902 bool 4903 operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4904 { 4905 return !(nullptr < __x); 4906 } 4907 4908 template<class _Tp> 4909 inline _LIBCPP_INLINE_VISIBILITY 4910 bool 4911 operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4912 { 4913 return !(__x < nullptr); 4914 } 4915 4916 template<class _Tp> 4917 inline _LIBCPP_INLINE_VISIBILITY 4918 bool 4919 operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4920 { 4921 return !(__x < nullptr); 4922 } 4923 4924 template<class _Tp> 4925 inline _LIBCPP_INLINE_VISIBILITY 4926 bool 4927 operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4928 { 4929 return !(nullptr < __x); 4930 } 4931 4932 template<class _Tp> 4933 inline _LIBCPP_INLINE_VISIBILITY 4934 void 4935 swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT 4936 { 4937 __x.swap(__y); 4938 } 4939 4940 template<class _Tp, class _Up> 4941 inline _LIBCPP_INLINE_VISIBILITY 4942 typename enable_if 4943 < 4944 !is_array<_Tp>::value && !is_array<_Up>::value, 4945 shared_ptr<_Tp> 4946 >::type 4947 static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4948 { 4949 return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); 4950 } 4951 4952 template<class _Tp, class _Up> 4953 inline _LIBCPP_INLINE_VISIBILITY 4954 typename enable_if 4955 < 4956 !is_array<_Tp>::value && !is_array<_Up>::value, 4957 shared_ptr<_Tp> 4958 >::type 4959 dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4960 { 4961 _Tp* __p = dynamic_cast<_Tp*>(__r.get()); 4962 return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>(); 4963 } 4964 4965 template<class _Tp, class _Up> 4966 typename enable_if 4967 < 4968 is_array<_Tp>::value == is_array<_Up>::value, 4969 shared_ptr<_Tp> 4970 >::type 4971 const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4972 { 4973 typedef typename remove_extent<_Tp>::type _RTp; 4974 return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get())); 4975 } 4976 4977 #ifndef _LIBCPP_NO_RTTI 4978 4979 template<class _Dp, class _Tp> 4980 inline _LIBCPP_INLINE_VISIBILITY 4981 _Dp* 4982 get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT 4983 { 4984 return __p.template __get_deleter<_Dp>(); 4985 } 4986 4987 #endif // _LIBCPP_NO_RTTI 4988 4989 template<class _Tp> 4990 class _LIBCPP_TEMPLATE_VIS weak_ptr 4991 { 4992 public: 4993 typedef _Tp element_type; 4994 private: 4995 element_type* __ptr_; 4996 __shared_weak_count* __cntrl_; 4997 4998 public: 4999 _LIBCPP_INLINE_VISIBILITY 5000 _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT; 5001 template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r, 5002 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 5003 _NOEXCEPT; 5004 _LIBCPP_INLINE_VISIBILITY 5005 weak_ptr(weak_ptr const& __r) _NOEXCEPT; 5006 template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r, 5007 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 5008 _NOEXCEPT; 5009 5010 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5011 _LIBCPP_INLINE_VISIBILITY 5012 weak_ptr(weak_ptr&& __r) _NOEXCEPT; 5013 template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r, 5014 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 5015 _NOEXCEPT; 5016 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5017 ~weak_ptr(); 5018 5019 _LIBCPP_INLINE_VISIBILITY 5020 weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT; 5021 template<class _Yp> 5022 typename enable_if 5023 < 5024 is_convertible<_Yp*, element_type*>::value, 5025 weak_ptr& 5026 >::type 5027 _LIBCPP_INLINE_VISIBILITY 5028 operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT; 5029 5030 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5031 5032 _LIBCPP_INLINE_VISIBILITY 5033 weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT; 5034 template<class _Yp> 5035 typename enable_if 5036 < 5037 is_convertible<_Yp*, element_type*>::value, 5038 weak_ptr& 5039 >::type 5040 _LIBCPP_INLINE_VISIBILITY 5041 operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT; 5042 5043 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5044 5045 template<class _Yp> 5046 typename enable_if 5047 < 5048 is_convertible<_Yp*, element_type*>::value, 5049 weak_ptr& 5050 >::type 5051 _LIBCPP_INLINE_VISIBILITY 5052 operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT; 5053 5054 _LIBCPP_INLINE_VISIBILITY 5055 void swap(weak_ptr& __r) _NOEXCEPT; 5056 _LIBCPP_INLINE_VISIBILITY 5057 void reset() _NOEXCEPT; 5058 5059 _LIBCPP_INLINE_VISIBILITY 5060 long use_count() const _NOEXCEPT 5061 {return __cntrl_ ? __cntrl_->use_count() : 0;} 5062 _LIBCPP_INLINE_VISIBILITY 5063 bool expired() const _NOEXCEPT 5064 {return __cntrl_ == 0 || __cntrl_->use_count() == 0;} 5065 shared_ptr<_Tp> lock() const _NOEXCEPT; 5066 template<class _Up> 5067 _LIBCPP_INLINE_VISIBILITY 5068 bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT 5069 {return __cntrl_ < __r.__cntrl_;} 5070 template<class _Up> 5071 _LIBCPP_INLINE_VISIBILITY 5072 bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT 5073 {return __cntrl_ < __r.__cntrl_;} 5074 5075 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; 5076 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; 5077 }; 5078 5079 template<class _Tp> 5080 inline 5081 _LIBCPP_CONSTEXPR 5082 weak_ptr<_Tp>::weak_ptr() _NOEXCEPT 5083 : __ptr_(0), 5084 __cntrl_(0) 5085 { 5086 } 5087 5088 template<class _Tp> 5089 inline 5090 weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT 5091 : __ptr_(__r.__ptr_), 5092 __cntrl_(__r.__cntrl_) 5093 { 5094 if (__cntrl_) 5095 __cntrl_->__add_weak(); 5096 } 5097 5098 template<class _Tp> 5099 template<class _Yp> 5100 inline 5101 weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r, 5102 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5103 _NOEXCEPT 5104 : __ptr_(__r.__ptr_), 5105 __cntrl_(__r.__cntrl_) 5106 { 5107 if (__cntrl_) 5108 __cntrl_->__add_weak(); 5109 } 5110 5111 template<class _Tp> 5112 template<class _Yp> 5113 inline 5114 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r, 5115 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5116 _NOEXCEPT 5117 : __ptr_(__r.__ptr_), 5118 __cntrl_(__r.__cntrl_) 5119 { 5120 if (__cntrl_) 5121 __cntrl_->__add_weak(); 5122 } 5123 5124 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5125 5126 template<class _Tp> 5127 inline 5128 weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT 5129 : __ptr_(__r.__ptr_), 5130 __cntrl_(__r.__cntrl_) 5131 { 5132 __r.__ptr_ = 0; 5133 __r.__cntrl_ = 0; 5134 } 5135 5136 template<class _Tp> 5137 template<class _Yp> 5138 inline 5139 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r, 5140 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5141 _NOEXCEPT 5142 : __ptr_(__r.__ptr_), 5143 __cntrl_(__r.__cntrl_) 5144 { 5145 __r.__ptr_ = 0; 5146 __r.__cntrl_ = 0; 5147 } 5148 5149 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5150 5151 template<class _Tp> 5152 weak_ptr<_Tp>::~weak_ptr() 5153 { 5154 if (__cntrl_) 5155 __cntrl_->__release_weak(); 5156 } 5157 5158 template<class _Tp> 5159 inline 5160 weak_ptr<_Tp>& 5161 weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT 5162 { 5163 weak_ptr(__r).swap(*this); 5164 return *this; 5165 } 5166 5167 template<class _Tp> 5168 template<class _Yp> 5169 inline 5170 typename enable_if 5171 < 5172 is_convertible<_Yp*, _Tp*>::value, 5173 weak_ptr<_Tp>& 5174 >::type 5175 weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT 5176 { 5177 weak_ptr(__r).swap(*this); 5178 return *this; 5179 } 5180 5181 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5182 5183 template<class _Tp> 5184 inline 5185 weak_ptr<_Tp>& 5186 weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT 5187 { 5188 weak_ptr(_VSTD::move(__r)).swap(*this); 5189 return *this; 5190 } 5191 5192 template<class _Tp> 5193 template<class _Yp> 5194 inline 5195 typename enable_if 5196 < 5197 is_convertible<_Yp*, _Tp*>::value, 5198 weak_ptr<_Tp>& 5199 >::type 5200 weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT 5201 { 5202 weak_ptr(_VSTD::move(__r)).swap(*this); 5203 return *this; 5204 } 5205 5206 #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5207 5208 template<class _Tp> 5209 template<class _Yp> 5210 inline 5211 typename enable_if 5212 < 5213 is_convertible<_Yp*, _Tp*>::value, 5214 weak_ptr<_Tp>& 5215 >::type 5216 weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT 5217 { 5218 weak_ptr(__r).swap(*this); 5219 return *this; 5220 } 5221 5222 template<class _Tp> 5223 inline 5224 void 5225 weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT 5226 { 5227 _VSTD::swap(__ptr_, __r.__ptr_); 5228 _VSTD::swap(__cntrl_, __r.__cntrl_); 5229 } 5230 5231 template<class _Tp> 5232 inline _LIBCPP_INLINE_VISIBILITY 5233 void 5234 swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT 5235 { 5236 __x.swap(__y); 5237 } 5238 5239 template<class _Tp> 5240 inline 5241 void 5242 weak_ptr<_Tp>::reset() _NOEXCEPT 5243 { 5244 weak_ptr().swap(*this); 5245 } 5246 5247 template<class _Tp> 5248 template<class _Yp> 5249 shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r, 5250 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 5251 : __ptr_(__r.__ptr_), 5252 __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) 5253 { 5254 if (__cntrl_ == 0) 5255 __throw_bad_weak_ptr(); 5256 } 5257 5258 template<class _Tp> 5259 shared_ptr<_Tp> 5260 weak_ptr<_Tp>::lock() const _NOEXCEPT 5261 { 5262 shared_ptr<_Tp> __r; 5263 __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_; 5264 if (__r.__cntrl_) 5265 __r.__ptr_ = __ptr_; 5266 return __r; 5267 } 5268 5269 #if _LIBCPP_STD_VER > 14 5270 template <class _Tp = void> struct owner_less; 5271 #else 5272 template <class _Tp> struct owner_less; 5273 #endif 5274 5275 template <class _Tp> 5276 struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> > 5277 : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> 5278 { 5279 typedef bool result_type; 5280 _LIBCPP_INLINE_VISIBILITY 5281 bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT 5282 {return __x.owner_before(__y);} 5283 _LIBCPP_INLINE_VISIBILITY 5284 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT 5285 {return __x.owner_before(__y);} 5286 _LIBCPP_INLINE_VISIBILITY 5287 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT 5288 {return __x.owner_before(__y);} 5289 }; 5290 5291 template <class _Tp> 5292 struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> > 5293 : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> 5294 { 5295 typedef bool result_type; 5296 _LIBCPP_INLINE_VISIBILITY 5297 bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT 5298 {return __x.owner_before(__y);} 5299 _LIBCPP_INLINE_VISIBILITY 5300 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT 5301 {return __x.owner_before(__y);} 5302 _LIBCPP_INLINE_VISIBILITY 5303 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT 5304 {return __x.owner_before(__y);} 5305 }; 5306 5307 #if _LIBCPP_STD_VER > 14 5308 template <> 5309 struct _LIBCPP_TEMPLATE_VIS owner_less<void> 5310 { 5311 template <class _Tp, class _Up> 5312 _LIBCPP_INLINE_VISIBILITY 5313 bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT 5314 {return __x.owner_before(__y);} 5315 template <class _Tp, class _Up> 5316 _LIBCPP_INLINE_VISIBILITY 5317 bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT 5318 {return __x.owner_before(__y);} 5319 template <class _Tp, class _Up> 5320 _LIBCPP_INLINE_VISIBILITY 5321 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT 5322 {return __x.owner_before(__y);} 5323 template <class _Tp, class _Up> 5324 _LIBCPP_INLINE_VISIBILITY 5325 bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT 5326 {return __x.owner_before(__y);} 5327 typedef void is_transparent; 5328 }; 5329 #endif 5330 5331 template<class _Tp> 5332 class _LIBCPP_TEMPLATE_VIS enable_shared_from_this 5333 { 5334 mutable weak_ptr<_Tp> __weak_this_; 5335 protected: 5336 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 5337 enable_shared_from_this() _NOEXCEPT {} 5338 _LIBCPP_INLINE_VISIBILITY 5339 enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {} 5340 _LIBCPP_INLINE_VISIBILITY 5341 enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT 5342 {return *this;} 5343 _LIBCPP_INLINE_VISIBILITY 5344 ~enable_shared_from_this() {} 5345 public: 5346 _LIBCPP_INLINE_VISIBILITY 5347 shared_ptr<_Tp> shared_from_this() 5348 {return shared_ptr<_Tp>(__weak_this_);} 5349 _LIBCPP_INLINE_VISIBILITY 5350 shared_ptr<_Tp const> shared_from_this() const 5351 {return shared_ptr<const _Tp>(__weak_this_);} 5352 5353 #if _LIBCPP_STD_VER > 14 5354 _LIBCPP_INLINE_VISIBILITY 5355 weak_ptr<_Tp> weak_from_this() _NOEXCEPT 5356 { return __weak_this_; } 5357 5358 _LIBCPP_INLINE_VISIBILITY 5359 weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT 5360 { return __weak_this_; } 5361 #endif // _LIBCPP_STD_VER > 14 5362 5363 template <class _Up> friend class shared_ptr; 5364 }; 5365 5366 template <class _Tp> 5367 struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> > 5368 { 5369 typedef shared_ptr<_Tp> argument_type; 5370 typedef size_t result_type; 5371 5372 _LIBCPP_INLINE_VISIBILITY 5373 result_type operator()(const argument_type& __ptr) const _NOEXCEPT 5374 { 5375 return hash<_Tp*>()(__ptr.get()); 5376 } 5377 }; 5378 5379 template<class _CharT, class _Traits, class _Yp> 5380 inline _LIBCPP_INLINE_VISIBILITY 5381 basic_ostream<_CharT, _Traits>& 5382 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p); 5383 5384 5385 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) 5386 5387 class _LIBCPP_TYPE_VIS __sp_mut 5388 { 5389 void* __lx; 5390 public: 5391 void lock() _NOEXCEPT; 5392 void unlock() _NOEXCEPT; 5393 5394 private: 5395 _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT; 5396 __sp_mut(const __sp_mut&); 5397 __sp_mut& operator=(const __sp_mut&); 5398 5399 friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*); 5400 }; 5401 5402 _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5403 __sp_mut& __get_sp_mut(const void*); 5404 5405 template <class _Tp> 5406 inline _LIBCPP_INLINE_VISIBILITY 5407 bool 5408 atomic_is_lock_free(const shared_ptr<_Tp>*) 5409 { 5410 return false; 5411 } 5412 5413 template <class _Tp> 5414 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5415 shared_ptr<_Tp> 5416 atomic_load(const shared_ptr<_Tp>* __p) 5417 { 5418 __sp_mut& __m = __get_sp_mut(__p); 5419 __m.lock(); 5420 shared_ptr<_Tp> __q = *__p; 5421 __m.unlock(); 5422 return __q; 5423 } 5424 5425 template <class _Tp> 5426 inline _LIBCPP_INLINE_VISIBILITY 5427 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5428 shared_ptr<_Tp> 5429 atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) 5430 { 5431 return atomic_load(__p); 5432 } 5433 5434 template <class _Tp> 5435 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5436 void 5437 atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) 5438 { 5439 __sp_mut& __m = __get_sp_mut(__p); 5440 __m.lock(); 5441 __p->swap(__r); 5442 __m.unlock(); 5443 } 5444 5445 template <class _Tp> 5446 inline _LIBCPP_INLINE_VISIBILITY 5447 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5448 void 5449 atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) 5450 { 5451 atomic_store(__p, __r); 5452 } 5453 5454 template <class _Tp> 5455 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5456 shared_ptr<_Tp> 5457 atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) 5458 { 5459 __sp_mut& __m = __get_sp_mut(__p); 5460 __m.lock(); 5461 __p->swap(__r); 5462 __m.unlock(); 5463 return __r; 5464 } 5465 5466 template <class _Tp> 5467 inline _LIBCPP_INLINE_VISIBILITY 5468 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5469 shared_ptr<_Tp> 5470 atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) 5471 { 5472 return atomic_exchange(__p, __r); 5473 } 5474 5475 template <class _Tp> 5476 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5477 bool 5478 atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) 5479 { 5480 shared_ptr<_Tp> __temp; 5481 __sp_mut& __m = __get_sp_mut(__p); 5482 __m.lock(); 5483 if (__p->__owner_equivalent(*__v)) 5484 { 5485 _VSTD::swap(__temp, *__p); 5486 *__p = __w; 5487 __m.unlock(); 5488 return true; 5489 } 5490 _VSTD::swap(__temp, *__v); 5491 *__v = *__p; 5492 __m.unlock(); 5493 return false; 5494 } 5495 5496 template <class _Tp> 5497 inline _LIBCPP_INLINE_VISIBILITY 5498 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5499 bool 5500 atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) 5501 { 5502 return atomic_compare_exchange_strong(__p, __v, __w); 5503 } 5504 5505 template <class _Tp> 5506 inline _LIBCPP_INLINE_VISIBILITY 5507 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5508 bool 5509 atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, 5510 shared_ptr<_Tp> __w, memory_order, memory_order) 5511 { 5512 return atomic_compare_exchange_strong(__p, __v, __w); 5513 } 5514 5515 template <class _Tp> 5516 inline _LIBCPP_INLINE_VISIBILITY 5517 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5518 bool 5519 atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, 5520 shared_ptr<_Tp> __w, memory_order, memory_order) 5521 { 5522 return atomic_compare_exchange_weak(__p, __v, __w); 5523 } 5524 5525 #endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) 5526 5527 //enum class 5528 #if defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) 5529 # ifndef _LIBCPP_CXX03_LANG 5530 enum class pointer_safety : unsigned char { 5531 relaxed, 5532 preferred, 5533 strict 5534 }; 5535 # endif 5536 #else 5537 struct _LIBCPP_TYPE_VIS pointer_safety 5538 { 5539 enum __lx 5540 { 5541 relaxed, 5542 preferred, 5543 strict 5544 }; 5545 5546 __lx __v_; 5547 5548 _LIBCPP_INLINE_VISIBILITY 5549 pointer_safety() : __v_() {} 5550 5551 _LIBCPP_INLINE_VISIBILITY 5552 pointer_safety(__lx __v) : __v_(__v) {} 5553 _LIBCPP_INLINE_VISIBILITY 5554 operator int() const {return __v_;} 5555 }; 5556 #endif 5557 5558 #if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) && \ 5559 defined(_LIBCPP_BUILDING_MEMORY) 5560 _LIBCPP_FUNC_VIS pointer_safety get_pointer_safety() _NOEXCEPT; 5561 #else 5562 // This function is only offered in C++03 under ABI v1. 5563 # if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) || !defined(_LIBCPP_CXX03_LANG) 5564 inline _LIBCPP_INLINE_VISIBILITY 5565 pointer_safety get_pointer_safety() _NOEXCEPT { 5566 return pointer_safety::relaxed; 5567 } 5568 # endif 5569 #endif 5570 5571 5572 _LIBCPP_FUNC_VIS void declare_reachable(void* __p); 5573 _LIBCPP_FUNC_VIS void declare_no_pointers(char* __p, size_t __n); 5574 _LIBCPP_FUNC_VIS void undeclare_no_pointers(char* __p, size_t __n); 5575 _LIBCPP_FUNC_VIS void* __undeclare_reachable(void* __p); 5576 5577 template <class _Tp> 5578 inline _LIBCPP_INLINE_VISIBILITY 5579 _Tp* 5580 undeclare_reachable(_Tp* __p) 5581 { 5582 return static_cast<_Tp*>(__undeclare_reachable(__p)); 5583 } 5584 5585 _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space); 5586 5587 // --- Helper for container swap -- 5588 template <typename _Alloc> 5589 inline _LIBCPP_INLINE_VISIBILITY 5590 void __swap_allocator(_Alloc & __a1, _Alloc & __a2) 5591 #if _LIBCPP_STD_VER >= 14 5592 _NOEXCEPT 5593 #else 5594 _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) 5595 #endif 5596 { 5597 __swap_allocator(__a1, __a2, 5598 integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>()); 5599 } 5600 5601 template <typename _Alloc> 5602 _LIBCPP_INLINE_VISIBILITY 5603 void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type) 5604 #if _LIBCPP_STD_VER >= 14 5605 _NOEXCEPT 5606 #else 5607 _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) 5608 #endif 5609 { 5610 using _VSTD::swap; 5611 swap(__a1, __a2); 5612 } 5613 5614 template <typename _Alloc> 5615 inline _LIBCPP_INLINE_VISIBILITY 5616 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {} 5617 5618 template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> > 5619 struct __noexcept_move_assign_container : public integral_constant<bool, 5620 _Traits::propagate_on_container_move_assignment::value 5621 #if _LIBCPP_STD_VER > 14 5622 || _Traits::is_always_equal::value 5623 #else 5624 && is_nothrow_move_assignable<_Alloc>::value 5625 #endif 5626 > {}; 5627 5628 5629 #ifndef _LIBCPP_HAS_NO_VARIADICS 5630 template <class _Tp, class _Alloc> 5631 struct __temp_value { 5632 typedef allocator_traits<_Alloc> _Traits; 5633 5634 typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __v; 5635 _Alloc &__a; 5636 5637 _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); } 5638 _Tp & get() { return *__addr(); } 5639 5640 template<class... _Args> 5641 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) 5642 { _Traits::construct(__a, __addr(), _VSTD::forward<_Args>(__args)...); } 5643 5644 ~__temp_value() { _Traits::destroy(__a, __addr()); } 5645 }; 5646 #endif 5647 5648 #if _LIBCPP_STD_VER > 14 5649 template<typename _Alloc, typename = void> 5650 struct __is_allocator : false_type {}; 5651 5652 template<typename _Alloc> 5653 struct __is_allocator<_Alloc, 5654 void_t<typename _Alloc::value_type, decltype(_VSTD::declval<_Alloc&>().allocate(size_t{}))>> 5655 : true_type {}; 5656 #endif 5657 5658 _LIBCPP_END_NAMESPACE_STD 5659 5660 _LIBCPP_POP_MACROS 5661 5662 #endif // _LIBCPP_MEMORY 5663
