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