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 __n) _NOEXCEPT 1803 {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), __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 __n) _NOEXCEPT 1904 {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), __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_unsized((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 } 2137 2138 template <class... _Args, size_t... _Indexes> 2139 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 2140 __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, 2141 __tuple_indices<_Indexes...>) 2142 : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} 2143#else 2144 _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_() {} 2145 _LIBCPP_INLINE_VISIBILITY 2146 __compressed_pair_elem(_ParamT __p) : __value_(std::forward<_ParamT>(__p)) {} 2147#endif 2148 2149 _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; } 2150 _LIBCPP_INLINE_VISIBILITY 2151 const_reference __get() const _NOEXCEPT { return __value_; } 2152 2153private: 2154 _Tp __value_; 2155}; 2156 2157template <class _Tp, int _Idx> 2158struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp { 2159 typedef _Tp _ParamT; 2160 typedef _Tp& reference; 2161 typedef const _Tp& const_reference; 2162 typedef _Tp __value_type; 2163 2164#ifndef _LIBCPP_CXX03_LANG 2165 _LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() = default; 2166 2167 template <class _Up, class = typename enable_if< 2168 !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value 2169 >::type> 2170 _LIBCPP_INLINE_VISIBILITY 2171 constexpr explicit 2172 __compressed_pair_elem(_Up&& __u) 2173 : __value_type(_VSTD::forward<_Up>(__u)) 2174 {} 2175 2176 template <class... _Args, size_t... _Indexes> 2177 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 2178 __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, 2179 __tuple_indices<_Indexes...>) 2180 : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} 2181#else 2182 _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_type() {} 2183 _LIBCPP_INLINE_VISIBILITY 2184 __compressed_pair_elem(_ParamT __p) 2185 : __value_type(std::forward<_ParamT>(__p)) {} 2186#endif 2187 2188 _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; } 2189 _LIBCPP_INLINE_VISIBILITY 2190 const_reference __get() const _NOEXCEPT { return *this; } 2191}; 2192 2193// Tag used to construct the second element of the compressed pair. 2194struct __second_tag {}; 2195 2196template <class _T1, class _T2> 2197class __compressed_pair : private __compressed_pair_elem<_T1, 0>, 2198 private __compressed_pair_elem<_T2, 1> { 2199 typedef __compressed_pair_elem<_T1, 0> _Base1; 2200 typedef __compressed_pair_elem<_T2, 1> _Base2; 2201 2202 // NOTE: This static assert should never fire because __compressed_pair 2203 // is *almost never* used in a scenario where it's possible for T1 == T2. 2204 // (The exception is std::function where it is possible that the function 2205 // object and the allocator have the same type). 2206 static_assert((!is_same<_T1, _T2>::value), 2207 "__compressed_pair cannot be instantated when T1 and T2 are the same type; " 2208 "The current implementation is NOT ABI-compatible with the previous " 2209 "implementation for this configuration"); 2210 2211public: 2212#ifndef _LIBCPP_CXX03_LANG 2213 template <bool _Dummy = true, 2214 class = typename enable_if< 2215 __dependent_type<is_default_constructible<_T1>, _Dummy>::value && 2216 __dependent_type<is_default_constructible<_T2>, _Dummy>::value 2217 >::type 2218 > 2219 _LIBCPP_INLINE_VISIBILITY 2220 constexpr __compressed_pair() {} 2221 2222 template <class _Tp, typename enable_if<!is_same<typename decay<_Tp>::type, 2223 __compressed_pair>::value, 2224 bool>::type = true> 2225 _LIBCPP_INLINE_VISIBILITY constexpr explicit 2226 __compressed_pair(_Tp&& __t) 2227 : _Base1(std::forward<_Tp>(__t)), _Base2() {} 2228 2229 template <class _Tp> 2230 _LIBCPP_INLINE_VISIBILITY constexpr 2231 __compressed_pair(__second_tag, _Tp&& __t) 2232 : _Base1(), _Base2(std::forward<_Tp>(__t)) {} 2233 2234 template <class _U1, class _U2> 2235 _LIBCPP_INLINE_VISIBILITY constexpr 2236 __compressed_pair(_U1&& __t1, _U2&& __t2) 2237 : _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {} 2238 2239 template <class... _Args1, class... _Args2> 2240 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 2241 __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, 2242 tuple<_Args2...> __second_args) 2243 : _Base1(__pc, _VSTD::move(__first_args), 2244 typename __make_tuple_indices<sizeof...(_Args1)>::type()), 2245 _Base2(__pc, _VSTD::move(__second_args), 2246 typename __make_tuple_indices<sizeof...(_Args2)>::type()) {} 2247 2248#else 2249 _LIBCPP_INLINE_VISIBILITY 2250 __compressed_pair() {} 2251 2252 _LIBCPP_INLINE_VISIBILITY explicit 2253 __compressed_pair(_T1 __t1) : _Base1(_VSTD::forward<_T1>(__t1)) {} 2254 2255 _LIBCPP_INLINE_VISIBILITY 2256 __compressed_pair(__second_tag, _T2 __t2) 2257 : _Base1(), _Base2(_VSTD::forward<_T2>(__t2)) {} 2258 2259 _LIBCPP_INLINE_VISIBILITY 2260 __compressed_pair(_T1 __t1, _T2 __t2) 2261 : _Base1(_VSTD::forward<_T1>(__t1)), _Base2(_VSTD::forward<_T2>(__t2)) {} 2262#endif 2263 2264 _LIBCPP_INLINE_VISIBILITY 2265 typename _Base1::reference first() _NOEXCEPT { 2266 return static_cast<_Base1&>(*this).__get(); 2267 } 2268 2269 _LIBCPP_INLINE_VISIBILITY 2270 typename _Base1::const_reference first() const _NOEXCEPT { 2271 return static_cast<_Base1 const&>(*this).__get(); 2272 } 2273 2274 _LIBCPP_INLINE_VISIBILITY 2275 typename _Base2::reference second() _NOEXCEPT { 2276 return static_cast<_Base2&>(*this).__get(); 2277 } 2278 2279 _LIBCPP_INLINE_VISIBILITY 2280 typename _Base2::const_reference second() const _NOEXCEPT { 2281 return static_cast<_Base2 const&>(*this).__get(); 2282 } 2283 2284 _LIBCPP_INLINE_VISIBILITY 2285 void swap(__compressed_pair& __x) 2286 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2287 __is_nothrow_swappable<_T2>::value) 2288 { 2289 using std::swap; 2290 swap(first(), __x.first()); 2291 swap(second(), __x.second()); 2292 } 2293}; 2294 2295template <class _T1, class _T2> 2296inline _LIBCPP_INLINE_VISIBILITY 2297void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y) 2298 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2299 __is_nothrow_swappable<_T2>::value) { 2300 __x.swap(__y); 2301} 2302 2303// default_delete 2304 2305template <class _Tp> 2306struct _LIBCPP_TEMPLATE_VIS default_delete { 2307 static_assert(!is_function<_Tp>::value, 2308 "default_delete cannot be instantiated for function types"); 2309#ifndef _LIBCPP_CXX03_LANG 2310 _LIBCPP_INLINE_VISIBILITY constexpr default_delete() noexcept = default; 2311#else 2312 _LIBCPP_INLINE_VISIBILITY default_delete() {} 2313#endif 2314 template <class _Up> 2315 _LIBCPP_INLINE_VISIBILITY 2316 default_delete(const default_delete<_Up>&, 2317 typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 2318 0) _NOEXCEPT {} 2319 2320 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __ptr) const _NOEXCEPT { 2321 static_assert(sizeof(_Tp) > 0, 2322 "default_delete can not delete incomplete type"); 2323 static_assert(!is_void<_Tp>::value, 2324 "default_delete can not delete incomplete type"); 2325 delete __ptr; 2326 } 2327}; 2328 2329template <class _Tp> 2330struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> { 2331private: 2332 template <class _Up> 2333 struct _EnableIfConvertible 2334 : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {}; 2335 2336public: 2337#ifndef _LIBCPP_CXX03_LANG 2338 _LIBCPP_INLINE_VISIBILITY constexpr default_delete() noexcept = default; 2339#else 2340 _LIBCPP_INLINE_VISIBILITY default_delete() {} 2341#endif 2342 2343 template <class _Up> 2344 _LIBCPP_INLINE_VISIBILITY 2345 default_delete(const default_delete<_Up[]>&, 2346 typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {} 2347 2348 template <class _Up> 2349 _LIBCPP_INLINE_VISIBILITY 2350 typename _EnableIfConvertible<_Up>::type 2351 operator()(_Up* __ptr) const _NOEXCEPT { 2352 static_assert(sizeof(_Tp) > 0, 2353 "default_delete can not delete incomplete type"); 2354 static_assert(!is_void<_Tp>::value, 2355 "default_delete can not delete void type"); 2356 delete[] __ptr; 2357 } 2358}; 2359 2360 2361 2362#ifndef _LIBCPP_CXX03_LANG 2363template <class _Deleter> 2364struct __unique_ptr_deleter_sfinae { 2365 static_assert(!is_reference<_Deleter>::value, "incorrect specialization"); 2366 typedef const _Deleter& __lval_ref_type; 2367 typedef _Deleter&& __good_rval_ref_type; 2368 typedef true_type __enable_rval_overload; 2369}; 2370 2371template <class _Deleter> 2372struct __unique_ptr_deleter_sfinae<_Deleter const&> { 2373 typedef const _Deleter& __lval_ref_type; 2374 typedef const _Deleter&& __bad_rval_ref_type; 2375 typedef false_type __enable_rval_overload; 2376}; 2377 2378template <class _Deleter> 2379struct __unique_ptr_deleter_sfinae<_Deleter&> { 2380 typedef _Deleter& __lval_ref_type; 2381 typedef _Deleter&& __bad_rval_ref_type; 2382 typedef false_type __enable_rval_overload; 2383}; 2384#endif // !defined(_LIBCPP_CXX03_LANG) 2385 2386template <class _Tp, class _Dp = default_delete<_Tp> > 2387class _LIBCPP_TEMPLATE_VIS unique_ptr { 2388public: 2389 typedef _Tp element_type; 2390 typedef _Dp deleter_type; 2391 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2392 2393 static_assert(!is_rvalue_reference<deleter_type>::value, 2394 "the specified deleter type cannot be an rvalue reference"); 2395 2396private: 2397 __compressed_pair<pointer, deleter_type> __ptr_; 2398 2399 struct __nat { int __for_bool_; }; 2400 2401#ifndef _LIBCPP_CXX03_LANG 2402 typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE; 2403 2404 template <bool _Dummy> 2405 using _LValRefType = 2406 typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type; 2407 2408 template <bool _Dummy> 2409 using _GoodRValRefType = 2410 typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type; 2411 2412 template <bool _Dummy> 2413 using _BadRValRefType = 2414 typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type; 2415 2416 template <bool _Dummy, class _Deleter = typename __dependent_type< 2417 __identity<deleter_type>, _Dummy>::type> 2418 using _EnableIfDeleterDefaultConstructible = 2419 typename enable_if<is_default_constructible<_Deleter>::value && 2420 !is_pointer<_Deleter>::value>::type; 2421 2422 template <class _ArgType> 2423 using _EnableIfDeleterConstructible = 2424 typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type; 2425 2426 template <class _UPtr, class _Up> 2427 using _EnableIfMoveConvertible = typename enable_if< 2428 is_convertible<typename _UPtr::pointer, pointer>::value && 2429 !is_array<_Up>::value 2430 >::type; 2431 2432 template <class _UDel> 2433 using _EnableIfDeleterConvertible = typename enable_if< 2434 (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) || 2435 (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) 2436 >::type; 2437 2438 template <class _UDel> 2439 using _EnableIfDeleterAssignable = typename enable_if< 2440 is_assignable<_Dp&, _UDel&&>::value 2441 >::type; 2442 2443public: 2444 template <bool _Dummy = true, 2445 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2446 _LIBCPP_INLINE_VISIBILITY 2447 constexpr unique_ptr() noexcept : __ptr_(pointer()) {} 2448 2449 template <bool _Dummy = true, 2450 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2451 _LIBCPP_INLINE_VISIBILITY 2452 constexpr unique_ptr(nullptr_t) noexcept : __ptr_(pointer()) {} 2453 2454 template <bool _Dummy = true, 2455 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2456 _LIBCPP_INLINE_VISIBILITY 2457 explicit unique_ptr(pointer __p) noexcept : __ptr_(__p) {} 2458 2459 template <bool _Dummy = true, 2460 class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>> 2461 _LIBCPP_INLINE_VISIBILITY 2462 unique_ptr(pointer __p, _LValRefType<_Dummy> __d) noexcept 2463 : __ptr_(__p, __d) {} 2464 2465 template <bool _Dummy = true, 2466 class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>> 2467 _LIBCPP_INLINE_VISIBILITY 2468 unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) noexcept 2469 : __ptr_(__p, _VSTD::move(__d)) { 2470 static_assert(!is_reference<deleter_type>::value, 2471 "rvalue deleter bound to reference"); 2472 } 2473 2474 template <bool _Dummy = true, 2475 class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>> 2476 _LIBCPP_INLINE_VISIBILITY 2477 unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete; 2478 2479 _LIBCPP_INLINE_VISIBILITY 2480 unique_ptr(unique_ptr&& __u) noexcept 2481 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) { 2482 } 2483 2484 template <class _Up, class _Ep, 2485 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2486 class = _EnableIfDeleterConvertible<_Ep> 2487 > 2488 _LIBCPP_INLINE_VISIBILITY 2489 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT 2490 : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {} 2491 2492#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 2493 template <class _Up> 2494 _LIBCPP_INLINE_VISIBILITY 2495 unique_ptr(auto_ptr<_Up>&& __p, 2496 typename enable_if<is_convertible<_Up*, _Tp*>::value && 2497 is_same<_Dp, default_delete<_Tp>>::value, 2498 __nat>::type = __nat()) _NOEXCEPT 2499 : __ptr_(__p.release()) {} 2500#endif 2501 2502 _LIBCPP_INLINE_VISIBILITY 2503 unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT { 2504 reset(__u.release()); 2505 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2506 return *this; 2507 } 2508 2509 template <class _Up, class _Ep, 2510 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2511 class = _EnableIfDeleterAssignable<_Ep> 2512 > 2513 _LIBCPP_INLINE_VISIBILITY 2514 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT { 2515 reset(__u.release()); 2516 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2517 return *this; 2518 } 2519 2520#else // _LIBCPP_CXX03_LANG 2521private: 2522 unique_ptr(unique_ptr&); 2523 template <class _Up, class _Ep> unique_ptr(unique_ptr<_Up, _Ep>&); 2524 2525 unique_ptr& operator=(unique_ptr&); 2526 template <class _Up, class _Ep> unique_ptr& operator=(unique_ptr<_Up, _Ep>&); 2527 2528public: 2529 _LIBCPP_INLINE_VISIBILITY 2530 unique_ptr() : __ptr_(pointer()) 2531 { 2532 static_assert(!is_pointer<deleter_type>::value, 2533 "unique_ptr constructed with null function pointer deleter"); 2534 static_assert(is_default_constructible<deleter_type>::value, 2535 "unique_ptr::deleter_type is not default constructible"); 2536 } 2537 _LIBCPP_INLINE_VISIBILITY 2538 unique_ptr(nullptr_t) : __ptr_(pointer()) 2539 { 2540 static_assert(!is_pointer<deleter_type>::value, 2541 "unique_ptr constructed with null function pointer deleter"); 2542 } 2543 _LIBCPP_INLINE_VISIBILITY 2544 explicit unique_ptr(pointer __p) 2545 : __ptr_(_VSTD::move(__p)) { 2546 static_assert(!is_pointer<deleter_type>::value, 2547 "unique_ptr constructed with null function pointer deleter"); 2548 } 2549 2550 _LIBCPP_INLINE_VISIBILITY 2551 operator __rv<unique_ptr>() { 2552 return __rv<unique_ptr>(*this); 2553 } 2554 2555 _LIBCPP_INLINE_VISIBILITY 2556 unique_ptr(__rv<unique_ptr> __u) 2557 : __ptr_(__u->release(), 2558 _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2559 2560 template <class _Up, class _Ep> 2561 _LIBCPP_INLINE_VISIBILITY 2562 typename enable_if< 2563 !is_array<_Up>::value && 2564 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, 2565 pointer>::value && 2566 is_assignable<deleter_type&, _Ep&>::value, 2567 unique_ptr&>::type 2568 operator=(unique_ptr<_Up, _Ep> __u) { 2569 reset(__u.release()); 2570 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2571 return *this; 2572 } 2573 2574 _LIBCPP_INLINE_VISIBILITY 2575 unique_ptr(pointer __p, deleter_type __d) 2576 : __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {} 2577#endif // _LIBCPP_CXX03_LANG 2578 2579#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 2580 template <class _Up> 2581 _LIBCPP_INLINE_VISIBILITY 2582 typename enable_if<is_convertible<_Up*, _Tp*>::value && 2583 is_same<_Dp, default_delete<_Tp> >::value, 2584 unique_ptr&>::type 2585 operator=(auto_ptr<_Up> __p) { 2586 reset(__p.release()); 2587 return *this; 2588 } 2589#endif 2590 2591 _LIBCPP_INLINE_VISIBILITY 2592 ~unique_ptr() { reset(); } 2593 2594 _LIBCPP_INLINE_VISIBILITY 2595 unique_ptr& operator=(nullptr_t) _NOEXCEPT { 2596 reset(); 2597 return *this; 2598 } 2599 2600 _LIBCPP_INLINE_VISIBILITY 2601 typename add_lvalue_reference<_Tp>::type 2602 operator*() const { 2603 return *__ptr_.first(); 2604 } 2605 _LIBCPP_INLINE_VISIBILITY 2606 pointer operator->() const _NOEXCEPT { 2607 return __ptr_.first(); 2608 } 2609 _LIBCPP_INLINE_VISIBILITY 2610 pointer get() const _NOEXCEPT { 2611 return __ptr_.first(); 2612 } 2613 _LIBCPP_INLINE_VISIBILITY 2614 deleter_type& get_deleter() _NOEXCEPT { 2615 return __ptr_.second(); 2616 } 2617 _LIBCPP_INLINE_VISIBILITY 2618 const deleter_type& get_deleter() const _NOEXCEPT { 2619 return __ptr_.second(); 2620 } 2621 _LIBCPP_INLINE_VISIBILITY 2622 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { 2623 return __ptr_.first() != nullptr; 2624 } 2625 2626 _LIBCPP_INLINE_VISIBILITY 2627 pointer release() _NOEXCEPT { 2628 pointer __t = __ptr_.first(); 2629 __ptr_.first() = pointer(); 2630 return __t; 2631 } 2632 2633 _LIBCPP_INLINE_VISIBILITY 2634 void reset(pointer __p = pointer()) _NOEXCEPT { 2635 pointer __tmp = __ptr_.first(); 2636 __ptr_.first() = __p; 2637 if (__tmp) 2638 __ptr_.second()(__tmp); 2639 } 2640 2641 _LIBCPP_INLINE_VISIBILITY 2642 void swap(unique_ptr& __u) _NOEXCEPT { 2643 __ptr_.swap(__u.__ptr_); 2644 } 2645}; 2646 2647 2648template <class _Tp, class _Dp> 2649class _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> { 2650public: 2651 typedef _Tp element_type; 2652 typedef _Dp deleter_type; 2653 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2654 2655private: 2656 __compressed_pair<pointer, deleter_type> __ptr_; 2657 2658 template <class _From> 2659 struct _CheckArrayPointerConversion : is_same<_From, pointer> {}; 2660 2661 template <class _FromElem> 2662 struct _CheckArrayPointerConversion<_FromElem*> 2663 : integral_constant<bool, 2664 is_same<_FromElem*, pointer>::value || 2665 (is_same<pointer, element_type*>::value && 2666 is_convertible<_FromElem(*)[], element_type(*)[]>::value) 2667 > 2668 {}; 2669 2670#ifndef _LIBCPP_CXX03_LANG 2671 typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE; 2672 2673 template <bool _Dummy> 2674 using _LValRefType = 2675 typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type; 2676 2677 template <bool _Dummy> 2678 using _GoodRValRefType = 2679 typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type; 2680 2681 template <bool _Dummy> 2682 using _BadRValRefType = 2683 typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type; 2684 2685 template <bool _Dummy, class _Deleter = typename __dependent_type< 2686 __identity<deleter_type>, _Dummy>::type> 2687 using _EnableIfDeleterDefaultConstructible = 2688 typename enable_if<is_default_constructible<_Deleter>::value && 2689 !is_pointer<_Deleter>::value>::type; 2690 2691 template <class _ArgType> 2692 using _EnableIfDeleterConstructible = 2693 typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type; 2694 2695 template <class _Pp> 2696 using _EnableIfPointerConvertible = typename enable_if< 2697 _CheckArrayPointerConversion<_Pp>::value 2698 >::type; 2699 2700 template <class _UPtr, class _Up, 2701 class _ElemT = typename _UPtr::element_type> 2702 using _EnableIfMoveConvertible = typename enable_if< 2703 is_array<_Up>::value && 2704 is_same<pointer, element_type*>::value && 2705 is_same<typename _UPtr::pointer, _ElemT*>::value && 2706 is_convertible<_ElemT(*)[], element_type(*)[]>::value 2707 >::type; 2708 2709 template <class _UDel> 2710 using _EnableIfDeleterConvertible = typename enable_if< 2711 (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) || 2712 (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) 2713 >::type; 2714 2715 template <class _UDel> 2716 using _EnableIfDeleterAssignable = typename enable_if< 2717 is_assignable<_Dp&, _UDel&&>::value 2718 >::type; 2719 2720public: 2721 template <bool _Dummy = true, 2722 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2723 _LIBCPP_INLINE_VISIBILITY 2724 constexpr unique_ptr() noexcept : __ptr_(pointer()) {} 2725 2726 template <bool _Dummy = true, 2727 class = _EnableIfDeleterDefaultConstructible<_Dummy>> 2728 _LIBCPP_INLINE_VISIBILITY 2729 constexpr unique_ptr(nullptr_t) noexcept : __ptr_(pointer()) {} 2730 2731 template <class _Pp, bool _Dummy = true, 2732 class = _EnableIfDeleterDefaultConstructible<_Dummy>, 2733 class = _EnableIfPointerConvertible<_Pp>> 2734 _LIBCPP_INLINE_VISIBILITY 2735 explicit unique_ptr(_Pp __p) noexcept 2736 : __ptr_(__p) {} 2737 2738 template <class _Pp, bool _Dummy = true, 2739 class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>, 2740 class = _EnableIfPointerConvertible<_Pp>> 2741 _LIBCPP_INLINE_VISIBILITY 2742 unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) noexcept 2743 : __ptr_(__p, __d) {} 2744 2745 template <bool _Dummy = true, 2746 class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>> 2747 _LIBCPP_INLINE_VISIBILITY 2748 unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) noexcept 2749 : __ptr_(nullptr, __d) {} 2750 2751 template <class _Pp, bool _Dummy = true, 2752 class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>, 2753 class = _EnableIfPointerConvertible<_Pp>> 2754 _LIBCPP_INLINE_VISIBILITY 2755 unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) noexcept 2756 : __ptr_(__p, _VSTD::move(__d)) { 2757 static_assert(!is_reference<deleter_type>::value, 2758 "rvalue deleter bound to reference"); 2759 } 2760 2761 template <bool _Dummy = true, 2762 class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>> 2763 _LIBCPP_INLINE_VISIBILITY 2764 unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) noexcept 2765 : __ptr_(nullptr, _VSTD::move(__d)) { 2766 static_assert(!is_reference<deleter_type>::value, 2767 "rvalue deleter bound to reference"); 2768 } 2769 2770 template <class _Pp, bool _Dummy = true, 2771 class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>, 2772 class = _EnableIfPointerConvertible<_Pp>> 2773 _LIBCPP_INLINE_VISIBILITY 2774 unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete; 2775 2776 _LIBCPP_INLINE_VISIBILITY 2777 unique_ptr(unique_ptr&& __u) noexcept 2778 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) { 2779 } 2780 2781 _LIBCPP_INLINE_VISIBILITY 2782 unique_ptr& operator=(unique_ptr&& __u) noexcept { 2783 reset(__u.release()); 2784 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2785 return *this; 2786 } 2787 2788 template <class _Up, class _Ep, 2789 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2790 class = _EnableIfDeleterConvertible<_Ep> 2791 > 2792 _LIBCPP_INLINE_VISIBILITY 2793 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept 2794 : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) { 2795 } 2796 2797 template <class _Up, class _Ep, 2798 class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, 2799 class = _EnableIfDeleterAssignable<_Ep> 2800 > 2801 _LIBCPP_INLINE_VISIBILITY 2802 unique_ptr& 2803 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept { 2804 reset(__u.release()); 2805 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2806 return *this; 2807 } 2808 2809#else // _LIBCPP_CXX03_LANG 2810private: 2811 template <class _Up> explicit unique_ptr(_Up); 2812 2813 unique_ptr(unique_ptr&); 2814 template <class _Up> unique_ptr(unique_ptr<_Up>&); 2815 2816 unique_ptr& operator=(unique_ptr&); 2817 template <class _Up> unique_ptr& operator=(unique_ptr<_Up>&); 2818 2819 template <class _Up> 2820 unique_ptr(_Up __u, 2821 typename conditional< 2822 is_reference<deleter_type>::value, deleter_type, 2823 typename add_lvalue_reference<const deleter_type>::type>::type, 2824 typename enable_if<is_convertible<_Up, pointer>::value, 2825 __nat>::type = __nat()); 2826public: 2827 _LIBCPP_INLINE_VISIBILITY 2828 unique_ptr() : __ptr_(pointer()) { 2829 static_assert(!is_pointer<deleter_type>::value, 2830 "unique_ptr constructed with null function pointer deleter"); 2831 } 2832 _LIBCPP_INLINE_VISIBILITY 2833 unique_ptr(nullptr_t) : __ptr_(pointer()) { 2834 static_assert(!is_pointer<deleter_type>::value, 2835 "unique_ptr constructed with null function pointer deleter"); 2836 } 2837 2838 _LIBCPP_INLINE_VISIBILITY 2839 explicit unique_ptr(pointer __p) : __ptr_(__p) { 2840 static_assert(!is_pointer<deleter_type>::value, 2841 "unique_ptr constructed with null function pointer deleter"); 2842 } 2843 2844 _LIBCPP_INLINE_VISIBILITY 2845 unique_ptr(pointer __p, deleter_type __d) 2846 : __ptr_(__p, _VSTD::forward<deleter_type>(__d)) {} 2847 2848 _LIBCPP_INLINE_VISIBILITY 2849 unique_ptr(nullptr_t, deleter_type __d) 2850 : __ptr_(pointer(), _VSTD::forward<deleter_type>(__d)) {} 2851 2852 _LIBCPP_INLINE_VISIBILITY 2853 operator __rv<unique_ptr>() { 2854 return __rv<unique_ptr>(*this); 2855 } 2856 2857 _LIBCPP_INLINE_VISIBILITY 2858 unique_ptr(__rv<unique_ptr> __u) 2859 : __ptr_(__u->release(), 2860 _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2861 2862 _LIBCPP_INLINE_VISIBILITY 2863 unique_ptr& operator=(__rv<unique_ptr> __u) { 2864 reset(__u->release()); 2865 __ptr_.second() = _VSTD::forward<deleter_type>(__u->get_deleter()); 2866 return *this; 2867 } 2868 2869#endif // _LIBCPP_CXX03_LANG 2870 2871public: 2872 _LIBCPP_INLINE_VISIBILITY 2873 ~unique_ptr() { reset(); } 2874 2875 _LIBCPP_INLINE_VISIBILITY 2876 unique_ptr& operator=(nullptr_t) _NOEXCEPT { 2877 reset(); 2878 return *this; 2879 } 2880 2881 _LIBCPP_INLINE_VISIBILITY 2882 typename add_lvalue_reference<_Tp>::type 2883 operator[](size_t __i) const { 2884 return __ptr_.first()[__i]; 2885 } 2886 _LIBCPP_INLINE_VISIBILITY 2887 pointer get() const _NOEXCEPT { 2888 return __ptr_.first(); 2889 } 2890 2891 _LIBCPP_INLINE_VISIBILITY 2892 deleter_type& get_deleter() _NOEXCEPT { 2893 return __ptr_.second(); 2894 } 2895 2896 _LIBCPP_INLINE_VISIBILITY 2897 const deleter_type& get_deleter() const _NOEXCEPT { 2898 return __ptr_.second(); 2899 } 2900 _LIBCPP_INLINE_VISIBILITY 2901 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { 2902 return __ptr_.first() != nullptr; 2903 } 2904 2905 _LIBCPP_INLINE_VISIBILITY 2906 pointer release() _NOEXCEPT { 2907 pointer __t = __ptr_.first(); 2908 __ptr_.first() = pointer(); 2909 return __t; 2910 } 2911 2912 template <class _Pp> 2913 _LIBCPP_INLINE_VISIBILITY 2914 typename enable_if< 2915 _CheckArrayPointerConversion<_Pp>::value 2916 >::type 2917 reset(_Pp __p) _NOEXCEPT { 2918 pointer __tmp = __ptr_.first(); 2919 __ptr_.first() = __p; 2920 if (__tmp) 2921 __ptr_.second()(__tmp); 2922 } 2923 2924 _LIBCPP_INLINE_VISIBILITY 2925 void reset(nullptr_t = nullptr) _NOEXCEPT { 2926 pointer __tmp = __ptr_.first(); 2927 __ptr_.first() = nullptr; 2928 if (__tmp) 2929 __ptr_.second()(__tmp); 2930 } 2931 2932 _LIBCPP_INLINE_VISIBILITY 2933 void swap(unique_ptr& __u) _NOEXCEPT { 2934 __ptr_.swap(__u.__ptr_); 2935 } 2936 2937}; 2938 2939template <class _Tp, class _Dp> 2940inline _LIBCPP_INLINE_VISIBILITY 2941typename enable_if< 2942 __is_swappable<_Dp>::value, 2943 void 2944>::type 2945swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);} 2946 2947template <class _T1, class _D1, class _T2, class _D2> 2948inline _LIBCPP_INLINE_VISIBILITY 2949bool 2950operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();} 2951 2952template <class _T1, class _D1, class _T2, class _D2> 2953inline _LIBCPP_INLINE_VISIBILITY 2954bool 2955operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);} 2956 2957template <class _T1, class _D1, class _T2, class _D2> 2958inline _LIBCPP_INLINE_VISIBILITY 2959bool 2960operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) 2961{ 2962 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 2963 typedef typename unique_ptr<_T2, _D2>::pointer _P2; 2964 typedef typename common_type<_P1, _P2>::type _Vp; 2965 return less<_Vp>()(__x.get(), __y.get()); 2966} 2967 2968template <class _T1, class _D1, class _T2, class _D2> 2969inline _LIBCPP_INLINE_VISIBILITY 2970bool 2971operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;} 2972 2973template <class _T1, class _D1, class _T2, class _D2> 2974inline _LIBCPP_INLINE_VISIBILITY 2975bool 2976operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);} 2977 2978template <class _T1, class _D1, class _T2, class _D2> 2979inline _LIBCPP_INLINE_VISIBILITY 2980bool 2981operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);} 2982 2983template <class _T1, class _D1> 2984inline _LIBCPP_INLINE_VISIBILITY 2985bool 2986operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT 2987{ 2988 return !__x; 2989} 2990 2991template <class _T1, class _D1> 2992inline _LIBCPP_INLINE_VISIBILITY 2993bool 2994operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT 2995{ 2996 return !__x; 2997} 2998 2999template <class _T1, class _D1> 3000inline _LIBCPP_INLINE_VISIBILITY 3001bool 3002operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT 3003{ 3004 return static_cast<bool>(__x); 3005} 3006 3007template <class _T1, class _D1> 3008inline _LIBCPP_INLINE_VISIBILITY 3009bool 3010operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT 3011{ 3012 return static_cast<bool>(__x); 3013} 3014 3015template <class _T1, class _D1> 3016inline _LIBCPP_INLINE_VISIBILITY 3017bool 3018operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3019{ 3020 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 3021 return less<_P1>()(__x.get(), nullptr); 3022} 3023 3024template <class _T1, class _D1> 3025inline _LIBCPP_INLINE_VISIBILITY 3026bool 3027operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3028{ 3029 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 3030 return less<_P1>()(nullptr, __x.get()); 3031} 3032 3033template <class _T1, class _D1> 3034inline _LIBCPP_INLINE_VISIBILITY 3035bool 3036operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3037{ 3038 return nullptr < __x; 3039} 3040 3041template <class _T1, class _D1> 3042inline _LIBCPP_INLINE_VISIBILITY 3043bool 3044operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3045{ 3046 return __x < nullptr; 3047} 3048 3049template <class _T1, class _D1> 3050inline _LIBCPP_INLINE_VISIBILITY 3051bool 3052operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3053{ 3054 return !(nullptr < __x); 3055} 3056 3057template <class _T1, class _D1> 3058inline _LIBCPP_INLINE_VISIBILITY 3059bool 3060operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3061{ 3062 return !(__x < nullptr); 3063} 3064 3065template <class _T1, class _D1> 3066inline _LIBCPP_INLINE_VISIBILITY 3067bool 3068operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3069{ 3070 return !(__x < nullptr); 3071} 3072 3073template <class _T1, class _D1> 3074inline _LIBCPP_INLINE_VISIBILITY 3075bool 3076operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3077{ 3078 return !(nullptr < __x); 3079} 3080 3081#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3082 3083template <class _Tp, class _Dp> 3084inline _LIBCPP_INLINE_VISIBILITY 3085unique_ptr<_Tp, _Dp> 3086move(unique_ptr<_Tp, _Dp>& __t) 3087{ 3088 return unique_ptr<_Tp, _Dp>(__rv<unique_ptr<_Tp, _Dp> >(__t)); 3089} 3090 3091#endif 3092 3093#if _LIBCPP_STD_VER > 11 3094 3095template<class _Tp> 3096struct __unique_if 3097{ 3098 typedef unique_ptr<_Tp> __unique_single; 3099}; 3100 3101template<class _Tp> 3102struct __unique_if<_Tp[]> 3103{ 3104 typedef unique_ptr<_Tp[]> __unique_array_unknown_bound; 3105}; 3106 3107template<class _Tp, size_t _Np> 3108struct __unique_if<_Tp[_Np]> 3109{ 3110 typedef void __unique_array_known_bound; 3111}; 3112 3113template<class _Tp, class... _Args> 3114inline _LIBCPP_INLINE_VISIBILITY 3115typename __unique_if<_Tp>::__unique_single 3116make_unique(_Args&&... __args) 3117{ 3118 return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...)); 3119} 3120 3121template<class _Tp> 3122inline _LIBCPP_INLINE_VISIBILITY 3123typename __unique_if<_Tp>::__unique_array_unknown_bound 3124make_unique(size_t __n) 3125{ 3126 typedef typename remove_extent<_Tp>::type _Up; 3127 return unique_ptr<_Tp>(new _Up[__n]()); 3128} 3129 3130template<class _Tp, class... _Args> 3131 typename __unique_if<_Tp>::__unique_array_known_bound 3132 make_unique(_Args&&...) = delete; 3133 3134#endif // _LIBCPP_STD_VER > 11 3135 3136template <class _Tp, class _Dp> 3137#ifdef _LIBCPP_CXX03_LANG 3138struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> > 3139#else 3140struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper< 3141 unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer>> 3142#endif 3143{ 3144 typedef unique_ptr<_Tp, _Dp> argument_type; 3145 typedef size_t result_type; 3146 _LIBCPP_INLINE_VISIBILITY 3147 result_type operator()(const argument_type& __ptr) const 3148 { 3149 typedef typename argument_type::pointer pointer; 3150 return hash<pointer>()(__ptr.get()); 3151 } 3152}; 3153 3154struct __destruct_n 3155{ 3156private: 3157 size_t __size_; 3158 3159 template <class _Tp> 3160 _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT 3161 {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();} 3162 3163 template <class _Tp> 3164 _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT 3165 {} 3166 3167 _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT 3168 {++__size_;} 3169 _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT 3170 {} 3171 3172 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT 3173 {__size_ = __s;} 3174 _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT 3175 {} 3176public: 3177 _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT 3178 : __size_(__s) {} 3179 3180 template <class _Tp> 3181 _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*) _NOEXCEPT 3182 {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3183 3184 template <class _Tp> 3185 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT 3186 {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3187 3188 template <class _Tp> 3189 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT 3190 {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3191}; 3192 3193template <class _Alloc> 3194class __allocator_destructor 3195{ 3196 typedef allocator_traits<_Alloc> __alloc_traits; 3197public: 3198 typedef typename __alloc_traits::pointer pointer; 3199 typedef typename __alloc_traits::size_type size_type; 3200private: 3201 _Alloc& __alloc_; 3202 size_type __s_; 3203public: 3204 _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s) 3205 _NOEXCEPT 3206 : __alloc_(__a), __s_(__s) {} 3207 _LIBCPP_INLINE_VISIBILITY 3208 void operator()(pointer __p) _NOEXCEPT 3209 {__alloc_traits::deallocate(__alloc_, __p, __s_);} 3210}; 3211 3212template <class _InputIterator, class _ForwardIterator> 3213_ForwardIterator 3214uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r) 3215{ 3216 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3217#ifndef _LIBCPP_NO_EXCEPTIONS 3218 _ForwardIterator __s = __r; 3219 try 3220 { 3221#endif 3222 for (; __f != __l; ++__f, (void) ++__r) 3223 ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f); 3224#ifndef _LIBCPP_NO_EXCEPTIONS 3225 } 3226 catch (...) 3227 { 3228 for (; __s != __r; ++__s) 3229 __s->~value_type(); 3230 throw; 3231 } 3232#endif 3233 return __r; 3234} 3235 3236template <class _InputIterator, class _Size, class _ForwardIterator> 3237_ForwardIterator 3238uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r) 3239{ 3240 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3241#ifndef _LIBCPP_NO_EXCEPTIONS 3242 _ForwardIterator __s = __r; 3243 try 3244 { 3245#endif 3246 for (; __n > 0; ++__f, (void) ++__r, (void) --__n) 3247 ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f); 3248#ifndef _LIBCPP_NO_EXCEPTIONS 3249 } 3250 catch (...) 3251 { 3252 for (; __s != __r; ++__s) 3253 __s->~value_type(); 3254 throw; 3255 } 3256#endif 3257 return __r; 3258} 3259 3260template <class _ForwardIterator, class _Tp> 3261void 3262uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x) 3263{ 3264 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3265#ifndef _LIBCPP_NO_EXCEPTIONS 3266 _ForwardIterator __s = __f; 3267 try 3268 { 3269#endif 3270 for (; __f != __l; ++__f) 3271 ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x); 3272#ifndef _LIBCPP_NO_EXCEPTIONS 3273 } 3274 catch (...) 3275 { 3276 for (; __s != __f; ++__s) 3277 __s->~value_type(); 3278 throw; 3279 } 3280#endif 3281} 3282 3283template <class _ForwardIterator, class _Size, class _Tp> 3284_ForwardIterator 3285uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x) 3286{ 3287 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3288#ifndef _LIBCPP_NO_EXCEPTIONS 3289 _ForwardIterator __s = __f; 3290 try 3291 { 3292#endif 3293 for (; __n > 0; ++__f, (void) --__n) 3294 ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x); 3295#ifndef _LIBCPP_NO_EXCEPTIONS 3296 } 3297 catch (...) 3298 { 3299 for (; __s != __f; ++__s) 3300 __s->~value_type(); 3301 throw; 3302 } 3303#endif 3304 return __f; 3305} 3306 3307#if _LIBCPP_STD_VER > 14 3308 3309template <class _Tp> 3310inline _LIBCPP_INLINE_VISIBILITY 3311void destroy_at(_Tp* __loc) { 3312 _LIBCPP_ASSERT(__loc, "null pointer given to destroy_at"); 3313 __loc->~_Tp(); 3314} 3315 3316template <class _ForwardIterator> 3317inline _LIBCPP_INLINE_VISIBILITY 3318void destroy(_ForwardIterator __first, _ForwardIterator __last) { 3319 for (; __first != __last; ++__first) 3320 _VSTD::destroy_at(_VSTD::addressof(*__first)); 3321} 3322 3323template <class _ForwardIterator, class _Size> 3324inline _LIBCPP_INLINE_VISIBILITY 3325_ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) { 3326 for (; __n > 0; (void)++__first, --__n) 3327 _VSTD::destroy_at(_VSTD::addressof(*__first)); 3328 return __first; 3329} 3330 3331template <class _ForwardIterator> 3332inline _LIBCPP_INLINE_VISIBILITY 3333void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) { 3334 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3335 auto __idx = __first; 3336#ifndef _LIBCPP_NO_EXCEPTIONS 3337 try { 3338#endif 3339 for (; __idx != __last; ++__idx) 3340 ::new((void*)_VSTD::addressof(*__idx)) _Vt; 3341#ifndef _LIBCPP_NO_EXCEPTIONS 3342 } catch (...) { 3343 _VSTD::destroy(__first, __idx); 3344 throw; 3345 } 3346#endif 3347} 3348 3349template <class _ForwardIterator, class _Size> 3350inline _LIBCPP_INLINE_VISIBILITY 3351_ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) { 3352 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3353 auto __idx = __first; 3354#ifndef _LIBCPP_NO_EXCEPTIONS 3355 try { 3356#endif 3357 for (; __n > 0; (void)++__idx, --__n) 3358 ::new((void*)_VSTD::addressof(*__idx)) _Vt; 3359 return __idx; 3360#ifndef _LIBCPP_NO_EXCEPTIONS 3361 } catch (...) { 3362 _VSTD::destroy(__first, __idx); 3363 throw; 3364 } 3365#endif 3366} 3367 3368 3369template <class _ForwardIterator> 3370inline _LIBCPP_INLINE_VISIBILITY 3371void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) { 3372 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3373 auto __idx = __first; 3374#ifndef _LIBCPP_NO_EXCEPTIONS 3375 try { 3376#endif 3377 for (; __idx != __last; ++__idx) 3378 ::new((void*)_VSTD::addressof(*__idx)) _Vt(); 3379#ifndef _LIBCPP_NO_EXCEPTIONS 3380 } catch (...) { 3381 _VSTD::destroy(__first, __idx); 3382 throw; 3383 } 3384#endif 3385} 3386 3387template <class _ForwardIterator, class _Size> 3388inline _LIBCPP_INLINE_VISIBILITY 3389_ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) { 3390 using _Vt = typename iterator_traits<_ForwardIterator>::value_type; 3391 auto __idx = __first; 3392#ifndef _LIBCPP_NO_EXCEPTIONS 3393 try { 3394#endif 3395 for (; __n > 0; (void)++__idx, --__n) 3396 ::new((void*)_VSTD::addressof(*__idx)) _Vt(); 3397 return __idx; 3398#ifndef _LIBCPP_NO_EXCEPTIONS 3399 } catch (...) { 3400 _VSTD::destroy(__first, __idx); 3401 throw; 3402 } 3403#endif 3404} 3405 3406 3407template <class _InputIt, class _ForwardIt> 3408inline _LIBCPP_INLINE_VISIBILITY 3409_ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) { 3410 using _Vt = typename iterator_traits<_ForwardIt>::value_type; 3411 auto __idx = __first_res; 3412#ifndef _LIBCPP_NO_EXCEPTIONS 3413 try { 3414#endif 3415 for (; __first != __last; (void)++__idx, ++__first) 3416 ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first)); 3417 return __idx; 3418#ifndef _LIBCPP_NO_EXCEPTIONS 3419 } catch (...) { 3420 _VSTD::destroy(__first_res, __idx); 3421 throw; 3422 } 3423#endif 3424} 3425 3426template <class _InputIt, class _Size, class _ForwardIt> 3427inline _LIBCPP_INLINE_VISIBILITY 3428pair<_InputIt, _ForwardIt> 3429uninitialized_move_n(_InputIt __first, _Size __n, _ForwardIt __first_res) { 3430 using _Vt = typename iterator_traits<_ForwardIt>::value_type; 3431 auto __idx = __first_res; 3432#ifndef _LIBCPP_NO_EXCEPTIONS 3433 try { 3434#endif 3435 for (; __n > 0; ++__idx, (void)++__first, --__n) 3436 ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first)); 3437 return {__first, __idx}; 3438#ifndef _LIBCPP_NO_EXCEPTIONS 3439 } catch (...) { 3440 _VSTD::destroy(__first_res, __idx); 3441 throw; 3442 } 3443#endif 3444} 3445 3446 3447#endif // _LIBCPP_STD_VER > 14 3448 3449// NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively) 3450// should be sufficient for thread safety. 3451// See https://bugs.llvm.org/show_bug.cgi?id=22803 3452#if defined(__clang__) && __has_builtin(__atomic_add_fetch) \ 3453 && defined(__ATOMIC_RELAXED) \ 3454 && defined(__ATOMIC_ACQ_REL) 3455# define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT 3456#elif !defined(__clang__) && defined(_GNUC_VER) && _GNUC_VER >= 407 3457# define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT 3458#endif 3459 3460template <class _Tp> 3461inline _LIBCPP_INLINE_VISIBILITY _Tp 3462__libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT 3463{ 3464#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS) 3465 return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED); 3466#else 3467 return __t += 1; 3468#endif 3469} 3470 3471template <class _Tp> 3472inline _LIBCPP_INLINE_VISIBILITY _Tp 3473__libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT 3474{ 3475#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS) 3476 return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL); 3477#else 3478 return __t -= 1; 3479#endif 3480} 3481 3482class _LIBCPP_EXCEPTION_ABI bad_weak_ptr 3483 : public std::exception 3484{ 3485public: 3486 virtual ~bad_weak_ptr() _NOEXCEPT; 3487 virtual const char* what() const _NOEXCEPT; 3488}; 3489 3490_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY 3491void __throw_bad_weak_ptr() 3492{ 3493#ifndef _LIBCPP_NO_EXCEPTIONS 3494 throw bad_weak_ptr(); 3495#else 3496 _VSTD::abort(); 3497#endif 3498} 3499 3500template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr; 3501 3502class _LIBCPP_TYPE_VIS __shared_count 3503{ 3504 __shared_count(const __shared_count&); 3505 __shared_count& operator=(const __shared_count&); 3506 3507protected: 3508 long __shared_owners_; 3509 virtual ~__shared_count(); 3510private: 3511 virtual void __on_zero_shared() _NOEXCEPT = 0; 3512 3513public: 3514 _LIBCPP_INLINE_VISIBILITY 3515 explicit __shared_count(long __refs = 0) _NOEXCEPT 3516 : __shared_owners_(__refs) {} 3517 3518#if defined(_LIBCPP_BUILDING_LIBRARY) && \ 3519 defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) 3520 void __add_shared() _NOEXCEPT; 3521 bool __release_shared() _NOEXCEPT; 3522#else 3523 _LIBCPP_INLINE_VISIBILITY 3524 void __add_shared() _NOEXCEPT { 3525 __libcpp_atomic_refcount_increment(__shared_owners_); 3526 } 3527 _LIBCPP_INLINE_VISIBILITY 3528 bool __release_shared() _NOEXCEPT { 3529 if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) { 3530 __on_zero_shared(); 3531 return true; 3532 } 3533 return false; 3534 } 3535#endif 3536 _LIBCPP_INLINE_VISIBILITY 3537 long use_count() const _NOEXCEPT { 3538 return __libcpp_relaxed_load(&__shared_owners_) + 1; 3539 } 3540}; 3541 3542class _LIBCPP_TYPE_VIS __shared_weak_count 3543 : private __shared_count 3544{ 3545 long __shared_weak_owners_; 3546 3547public: 3548 _LIBCPP_INLINE_VISIBILITY 3549 explicit __shared_weak_count(long __refs = 0) _NOEXCEPT 3550 : __shared_count(__refs), 3551 __shared_weak_owners_(__refs) {} 3552protected: 3553 virtual ~__shared_weak_count(); 3554 3555public: 3556#if defined(_LIBCPP_BUILDING_LIBRARY) && \ 3557 defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) 3558 void __add_shared() _NOEXCEPT; 3559 void __add_weak() _NOEXCEPT; 3560 void __release_shared() _NOEXCEPT; 3561#else 3562 _LIBCPP_INLINE_VISIBILITY 3563 void __add_shared() _NOEXCEPT { 3564 __shared_count::__add_shared(); 3565 } 3566 _LIBCPP_INLINE_VISIBILITY 3567 void __add_weak() _NOEXCEPT { 3568 __libcpp_atomic_refcount_increment(__shared_weak_owners_); 3569 } 3570 _LIBCPP_INLINE_VISIBILITY 3571 void __release_shared() _NOEXCEPT { 3572 if (__shared_count::__release_shared()) 3573 __release_weak(); 3574 } 3575#endif 3576 void __release_weak() _NOEXCEPT; 3577 _LIBCPP_INLINE_VISIBILITY 3578 long use_count() const _NOEXCEPT {return __shared_count::use_count();} 3579 __shared_weak_count* lock() _NOEXCEPT; 3580 3581 // Define the function out only if we build static libc++ without RTTI. 3582 // Otherwise we may break clients who need to compile their projects with 3583 // -fno-rtti and yet link against a libc++.dylib compiled 3584 // without -fno-rtti. 3585#if !defined(_LIBCPP_NO_RTTI) || !defined(_LIBCPP_BUILD_STATIC) 3586 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3587#endif 3588private: 3589 virtual void __on_zero_shared_weak() _NOEXCEPT = 0; 3590}; 3591 3592template <class _Tp, class _Dp, class _Alloc> 3593class __shared_ptr_pointer 3594 : public __shared_weak_count 3595{ 3596 __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_; 3597public: 3598 _LIBCPP_INLINE_VISIBILITY 3599 __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a) 3600 : __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {} 3601 3602#ifndef _LIBCPP_NO_RTTI 3603 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3604#endif 3605 3606private: 3607 virtual void __on_zero_shared() _NOEXCEPT; 3608 virtual void __on_zero_shared_weak() _NOEXCEPT; 3609}; 3610 3611#ifndef _LIBCPP_NO_RTTI 3612 3613template <class _Tp, class _Dp, class _Alloc> 3614const void* 3615__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT 3616{ 3617 return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr; 3618} 3619 3620#endif // _LIBCPP_NO_RTTI 3621 3622template <class _Tp, class _Dp, class _Alloc> 3623void 3624__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT 3625{ 3626 __data_.first().second()(__data_.first().first()); 3627 __data_.first().second().~_Dp(); 3628} 3629 3630template <class _Tp, class _Dp, class _Alloc> 3631void 3632__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3633{ 3634 typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al; 3635 typedef allocator_traits<_Al> _ATraits; 3636 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 3637 3638 _Al __a(__data_.second()); 3639 __data_.second().~_Alloc(); 3640 __a.deallocate(_PTraits::pointer_to(*this), 1); 3641} 3642 3643template <class _Tp, class _Alloc> 3644class __shared_ptr_emplace 3645 : public __shared_weak_count 3646{ 3647 __compressed_pair<_Alloc, _Tp> __data_; 3648public: 3649#ifndef _LIBCPP_HAS_NO_VARIADICS 3650 3651 _LIBCPP_INLINE_VISIBILITY 3652 __shared_ptr_emplace(_Alloc __a) 3653 : __data_(_VSTD::move(__a)) {} 3654 3655 template <class ..._Args> 3656 _LIBCPP_INLINE_VISIBILITY 3657 __shared_ptr_emplace(_Alloc __a, _Args&& ...__args) 3658 : __data_(piecewise_construct, _VSTD::forward_as_tuple(__a), 3659 _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {} 3660 3661#else // _LIBCPP_HAS_NO_VARIADICS 3662 3663 _LIBCPP_INLINE_VISIBILITY 3664 __shared_ptr_emplace(_Alloc __a) 3665 : __data_(__a) {} 3666 3667 template <class _A0> 3668 _LIBCPP_INLINE_VISIBILITY 3669 __shared_ptr_emplace(_Alloc __a, _A0& __a0) 3670 : __data_(__a, _Tp(__a0)) {} 3671 3672 template <class _A0, class _A1> 3673 _LIBCPP_INLINE_VISIBILITY 3674 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1) 3675 : __data_(__a, _Tp(__a0, __a1)) {} 3676 3677 template <class _A0, class _A1, class _A2> 3678 _LIBCPP_INLINE_VISIBILITY 3679 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1, _A2& __a2) 3680 : __data_(__a, _Tp(__a0, __a1, __a2)) {} 3681 3682#endif // _LIBCPP_HAS_NO_VARIADICS 3683 3684private: 3685 virtual void __on_zero_shared() _NOEXCEPT; 3686 virtual void __on_zero_shared_weak() _NOEXCEPT; 3687public: 3688 _LIBCPP_INLINE_VISIBILITY 3689 _Tp* get() _NOEXCEPT {return _VSTD::addressof(__data_.second());} 3690}; 3691 3692template <class _Tp, class _Alloc> 3693void 3694__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT 3695{ 3696 __data_.second().~_Tp(); 3697} 3698 3699template <class _Tp, class _Alloc> 3700void 3701__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3702{ 3703 typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type _Al; 3704 typedef allocator_traits<_Al> _ATraits; 3705 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 3706 _Al __a(__data_.first()); 3707 __data_.first().~_Alloc(); 3708 __a.deallocate(_PTraits::pointer_to(*this), 1); 3709} 3710 3711struct __shared_ptr_dummy_rebind_allocator_type; 3712template <> 3713class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type> 3714{ 3715public: 3716 template <class _Other> 3717 struct rebind 3718 { 3719 typedef allocator<_Other> other; 3720 }; 3721}; 3722 3723template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this; 3724 3725template<class _Tp> 3726class _LIBCPP_TEMPLATE_VIS shared_ptr 3727{ 3728public: 3729 typedef _Tp element_type; 3730 3731#if _LIBCPP_STD_VER > 14 3732 typedef weak_ptr<_Tp> weak_type; 3733#endif 3734private: 3735 element_type* __ptr_; 3736 __shared_weak_count* __cntrl_; 3737 3738 struct __nat {int __for_bool_;}; 3739public: 3740 _LIBCPP_INLINE_VISIBILITY 3741 _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT; 3742 _LIBCPP_INLINE_VISIBILITY 3743 _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT; 3744 template<class _Yp> 3745 explicit shared_ptr(_Yp* __p, 3746 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3747 template<class _Yp, class _Dp> 3748 shared_ptr(_Yp* __p, _Dp __d, 3749 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3750 template<class _Yp, class _Dp, class _Alloc> 3751 shared_ptr(_Yp* __p, _Dp __d, _Alloc __a, 3752 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3753 template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d); 3754 template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a); 3755 template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT; 3756 _LIBCPP_INLINE_VISIBILITY 3757 shared_ptr(const shared_ptr& __r) _NOEXCEPT; 3758 template<class _Yp> 3759 _LIBCPP_INLINE_VISIBILITY 3760 shared_ptr(const shared_ptr<_Yp>& __r, 3761 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()) 3762 _NOEXCEPT; 3763#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3764 _LIBCPP_INLINE_VISIBILITY 3765 shared_ptr(shared_ptr&& __r) _NOEXCEPT; 3766 template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(shared_ptr<_Yp>&& __r, 3767 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()) 3768 _NOEXCEPT; 3769#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3770 template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r, 3771 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type= __nat()); 3772#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 3773#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3774 template<class _Yp> 3775 shared_ptr(auto_ptr<_Yp>&& __r, 3776 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3777#else 3778 template<class _Yp> 3779 shared_ptr(auto_ptr<_Yp> __r, 3780 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); 3781#endif 3782#endif 3783#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3784 template <class _Yp, class _Dp> 3785 shared_ptr(unique_ptr<_Yp, _Dp>&&, 3786 typename enable_if 3787 < 3788 !is_lvalue_reference<_Dp>::value && 3789 !is_array<_Yp>::value && 3790 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3791 __nat 3792 >::type = __nat()); 3793 template <class _Yp, class _Dp> 3794 shared_ptr(unique_ptr<_Yp, _Dp>&&, 3795 typename enable_if 3796 < 3797 is_lvalue_reference<_Dp>::value && 3798 !is_array<_Yp>::value && 3799 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3800 __nat 3801 >::type = __nat()); 3802#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3803 template <class _Yp, class _Dp> 3804 shared_ptr(unique_ptr<_Yp, _Dp>, 3805 typename enable_if 3806 < 3807 !is_lvalue_reference<_Dp>::value && 3808 !is_array<_Yp>::value && 3809 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3810 __nat 3811 >::type = __nat()); 3812 template <class _Yp, class _Dp> 3813 shared_ptr(unique_ptr<_Yp, _Dp>, 3814 typename enable_if 3815 < 3816 is_lvalue_reference<_Dp>::value && 3817 !is_array<_Yp>::value && 3818 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3819 __nat 3820 >::type = __nat()); 3821#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3822 3823 ~shared_ptr(); 3824 3825 _LIBCPP_INLINE_VISIBILITY 3826 shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT; 3827 template<class _Yp> 3828 typename enable_if 3829 < 3830 is_convertible<_Yp*, element_type*>::value, 3831 shared_ptr& 3832 >::type 3833 _LIBCPP_INLINE_VISIBILITY 3834 operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT; 3835#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3836 _LIBCPP_INLINE_VISIBILITY 3837 shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT; 3838 template<class _Yp> 3839 typename enable_if 3840 < 3841 is_convertible<_Yp*, element_type*>::value, 3842 shared_ptr<_Tp>& 3843 >::type 3844 _LIBCPP_INLINE_VISIBILITY 3845 operator=(shared_ptr<_Yp>&& __r); 3846#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 3847 template<class _Yp> 3848 _LIBCPP_INLINE_VISIBILITY 3849 typename enable_if 3850 < 3851 !is_array<_Yp>::value && 3852 is_convertible<_Yp*, element_type*>::value, 3853 shared_ptr 3854 >::type& 3855 operator=(auto_ptr<_Yp>&& __r); 3856#endif 3857#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3858#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 3859 template<class _Yp> 3860 _LIBCPP_INLINE_VISIBILITY 3861 typename enable_if 3862 < 3863 !is_array<_Yp>::value && 3864 is_convertible<_Yp*, element_type*>::value, 3865 shared_ptr& 3866 >::type 3867 operator=(auto_ptr<_Yp> __r); 3868#endif 3869#endif 3870 template <class _Yp, class _Dp> 3871 typename enable_if 3872 < 3873 !is_array<_Yp>::value && 3874 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3875 shared_ptr& 3876 >::type 3877#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3878 _LIBCPP_INLINE_VISIBILITY 3879 operator=(unique_ptr<_Yp, _Dp>&& __r); 3880#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3881 _LIBCPP_INLINE_VISIBILITY 3882 operator=(unique_ptr<_Yp, _Dp> __r); 3883#endif 3884 3885 _LIBCPP_INLINE_VISIBILITY 3886 void swap(shared_ptr& __r) _NOEXCEPT; 3887 _LIBCPP_INLINE_VISIBILITY 3888 void reset() _NOEXCEPT; 3889 template<class _Yp> 3890 typename enable_if 3891 < 3892 is_convertible<_Yp*, element_type*>::value, 3893 void 3894 >::type 3895 _LIBCPP_INLINE_VISIBILITY 3896 reset(_Yp* __p); 3897 template<class _Yp, class _Dp> 3898 typename enable_if 3899 < 3900 is_convertible<_Yp*, element_type*>::value, 3901 void 3902 >::type 3903 _LIBCPP_INLINE_VISIBILITY 3904 reset(_Yp* __p, _Dp __d); 3905 template<class _Yp, class _Dp, class _Alloc> 3906 typename enable_if 3907 < 3908 is_convertible<_Yp*, element_type*>::value, 3909 void 3910 >::type 3911 _LIBCPP_INLINE_VISIBILITY 3912 reset(_Yp* __p, _Dp __d, _Alloc __a); 3913 3914 _LIBCPP_INLINE_VISIBILITY 3915 element_type* get() const _NOEXCEPT {return __ptr_;} 3916 _LIBCPP_INLINE_VISIBILITY 3917 typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT 3918 {return *__ptr_;} 3919 _LIBCPP_INLINE_VISIBILITY 3920 element_type* operator->() const _NOEXCEPT {return __ptr_;} 3921 _LIBCPP_INLINE_VISIBILITY 3922 long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;} 3923 _LIBCPP_INLINE_VISIBILITY 3924 bool unique() const _NOEXCEPT {return use_count() == 1;} 3925 _LIBCPP_INLINE_VISIBILITY 3926 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != 0;} 3927 template <class _Up> 3928 _LIBCPP_INLINE_VISIBILITY 3929 bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT 3930 {return __cntrl_ < __p.__cntrl_;} 3931 template <class _Up> 3932 _LIBCPP_INLINE_VISIBILITY 3933 bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT 3934 {return __cntrl_ < __p.__cntrl_;} 3935 _LIBCPP_INLINE_VISIBILITY 3936 bool 3937 __owner_equivalent(const shared_ptr& __p) const 3938 {return __cntrl_ == __p.__cntrl_;} 3939 3940#ifndef _LIBCPP_NO_RTTI 3941 template <class _Dp> 3942 _LIBCPP_INLINE_VISIBILITY 3943 _Dp* __get_deleter() const _NOEXCEPT 3944 {return static_cast<_Dp*>(__cntrl_ 3945 ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp))) 3946 : nullptr);} 3947#endif // _LIBCPP_NO_RTTI 3948 3949#ifndef _LIBCPP_HAS_NO_VARIADICS 3950 3951 template<class ..._Args> 3952 static 3953 shared_ptr<_Tp> 3954 make_shared(_Args&& ...__args); 3955 3956 template<class _Alloc, class ..._Args> 3957 static 3958 shared_ptr<_Tp> 3959 allocate_shared(const _Alloc& __a, _Args&& ...__args); 3960 3961#else // _LIBCPP_HAS_NO_VARIADICS 3962 3963 static shared_ptr<_Tp> make_shared(); 3964 3965 template<class _A0> 3966 static shared_ptr<_Tp> make_shared(_A0&); 3967 3968 template<class _A0, class _A1> 3969 static shared_ptr<_Tp> make_shared(_A0&, _A1&); 3970 3971 template<class _A0, class _A1, class _A2> 3972 static shared_ptr<_Tp> make_shared(_A0&, _A1&, _A2&); 3973 3974 template<class _Alloc> 3975 static shared_ptr<_Tp> 3976 allocate_shared(const _Alloc& __a); 3977 3978 template<class _Alloc, class _A0> 3979 static shared_ptr<_Tp> 3980 allocate_shared(const _Alloc& __a, _A0& __a0); 3981 3982 template<class _Alloc, class _A0, class _A1> 3983 static shared_ptr<_Tp> 3984 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1); 3985 3986 template<class _Alloc, class _A0, class _A1, class _A2> 3987 static shared_ptr<_Tp> 3988 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2); 3989 3990#endif // _LIBCPP_HAS_NO_VARIADICS 3991 3992private: 3993 template <class _Yp, bool = is_function<_Yp>::value> 3994 struct __shared_ptr_default_allocator 3995 { 3996 typedef allocator<_Yp> type; 3997 }; 3998 3999 template <class _Yp> 4000 struct __shared_ptr_default_allocator<_Yp, true> 4001 { 4002 typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type; 4003 }; 4004 4005 template <class _Yp, class _OrigPtr> 4006 _LIBCPP_INLINE_VISIBILITY 4007 typename enable_if<is_convertible<_OrigPtr*, 4008 const enable_shared_from_this<_Yp>* 4009 >::value, 4010 void>::type 4011 __enable_weak_this(const enable_shared_from_this<_Yp>* __e, 4012 _OrigPtr* __ptr) _NOEXCEPT 4013 { 4014 typedef typename remove_cv<_Yp>::type _RawYp; 4015 if (__e && __e->__weak_this_.expired()) 4016 { 4017 __e->__weak_this_ = shared_ptr<_RawYp>(*this, 4018 const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr))); 4019 } 4020 } 4021 4022 _LIBCPP_INLINE_VISIBILITY void __enable_weak_this(...) _NOEXCEPT {} 4023 4024 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; 4025 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; 4026}; 4027 4028 4029template<class _Tp> 4030inline 4031_LIBCPP_CONSTEXPR 4032shared_ptr<_Tp>::shared_ptr() _NOEXCEPT 4033 : __ptr_(0), 4034 __cntrl_(0) 4035{ 4036} 4037 4038template<class _Tp> 4039inline 4040_LIBCPP_CONSTEXPR 4041shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT 4042 : __ptr_(0), 4043 __cntrl_(0) 4044{ 4045} 4046 4047template<class _Tp> 4048template<class _Yp> 4049shared_ptr<_Tp>::shared_ptr(_Yp* __p, 4050 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4051 : __ptr_(__p) 4052{ 4053 unique_ptr<_Yp> __hold(__p); 4054 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4055 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, _AllocT > _CntrlBlk; 4056 __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), _AllocT()); 4057 __hold.release(); 4058 __enable_weak_this(__p, __p); 4059} 4060 4061template<class _Tp> 4062template<class _Yp, class _Dp> 4063shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, 4064 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4065 : __ptr_(__p) 4066{ 4067#ifndef _LIBCPP_NO_EXCEPTIONS 4068 try 4069 { 4070#endif // _LIBCPP_NO_EXCEPTIONS 4071 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4072 typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk; 4073 __cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); 4074 __enable_weak_this(__p, __p); 4075#ifndef _LIBCPP_NO_EXCEPTIONS 4076 } 4077 catch (...) 4078 { 4079 __d(__p); 4080 throw; 4081 } 4082#endif // _LIBCPP_NO_EXCEPTIONS 4083} 4084 4085template<class _Tp> 4086template<class _Dp> 4087shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d) 4088 : __ptr_(0) 4089{ 4090#ifndef _LIBCPP_NO_EXCEPTIONS 4091 try 4092 { 4093#endif // _LIBCPP_NO_EXCEPTIONS 4094 typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT; 4095 typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk; 4096 __cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); 4097#ifndef _LIBCPP_NO_EXCEPTIONS 4098 } 4099 catch (...) 4100 { 4101 __d(__p); 4102 throw; 4103 } 4104#endif // _LIBCPP_NO_EXCEPTIONS 4105} 4106 4107template<class _Tp> 4108template<class _Yp, class _Dp, class _Alloc> 4109shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a, 4110 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4111 : __ptr_(__p) 4112{ 4113#ifndef _LIBCPP_NO_EXCEPTIONS 4114 try 4115 { 4116#endif // _LIBCPP_NO_EXCEPTIONS 4117 typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk; 4118 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; 4119 typedef __allocator_destructor<_A2> _D2; 4120 _A2 __a2(__a); 4121 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4122 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4123 _CntrlBlk(__p, __d, __a); 4124 __cntrl_ = _VSTD::addressof(*__hold2.release()); 4125 __enable_weak_this(__p, __p); 4126#ifndef _LIBCPP_NO_EXCEPTIONS 4127 } 4128 catch (...) 4129 { 4130 __d(__p); 4131 throw; 4132 } 4133#endif // _LIBCPP_NO_EXCEPTIONS 4134} 4135 4136template<class _Tp> 4137template<class _Dp, class _Alloc> 4138shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a) 4139 : __ptr_(0) 4140{ 4141#ifndef _LIBCPP_NO_EXCEPTIONS 4142 try 4143 { 4144#endif // _LIBCPP_NO_EXCEPTIONS 4145 typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk; 4146 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; 4147 typedef __allocator_destructor<_A2> _D2; 4148 _A2 __a2(__a); 4149 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4150 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4151 _CntrlBlk(__p, __d, __a); 4152 __cntrl_ = _VSTD::addressof(*__hold2.release()); 4153#ifndef _LIBCPP_NO_EXCEPTIONS 4154 } 4155 catch (...) 4156 { 4157 __d(__p); 4158 throw; 4159 } 4160#endif // _LIBCPP_NO_EXCEPTIONS 4161} 4162 4163template<class _Tp> 4164template<class _Yp> 4165inline 4166shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT 4167 : __ptr_(__p), 4168 __cntrl_(__r.__cntrl_) 4169{ 4170 if (__cntrl_) 4171 __cntrl_->__add_shared(); 4172} 4173 4174template<class _Tp> 4175inline 4176shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT 4177 : __ptr_(__r.__ptr_), 4178 __cntrl_(__r.__cntrl_) 4179{ 4180 if (__cntrl_) 4181 __cntrl_->__add_shared(); 4182} 4183 4184template<class _Tp> 4185template<class _Yp> 4186inline 4187shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, 4188 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4189 _NOEXCEPT 4190 : __ptr_(__r.__ptr_), 4191 __cntrl_(__r.__cntrl_) 4192{ 4193 if (__cntrl_) 4194 __cntrl_->__add_shared(); 4195} 4196 4197#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4198 4199template<class _Tp> 4200inline 4201shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT 4202 : __ptr_(__r.__ptr_), 4203 __cntrl_(__r.__cntrl_) 4204{ 4205 __r.__ptr_ = 0; 4206 __r.__cntrl_ = 0; 4207} 4208 4209template<class _Tp> 4210template<class _Yp> 4211inline 4212shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r, 4213 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4214 _NOEXCEPT 4215 : __ptr_(__r.__ptr_), 4216 __cntrl_(__r.__cntrl_) 4217{ 4218 __r.__ptr_ = 0; 4219 __r.__cntrl_ = 0; 4220} 4221 4222#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4223 4224#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 4225template<class _Tp> 4226template<class _Yp> 4227#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4228shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r, 4229#else 4230shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r, 4231#endif 4232 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 4233 : __ptr_(__r.get()) 4234{ 4235 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk; 4236 __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>()); 4237 __enable_weak_this(__r.get(), __r.get()); 4238 __r.release(); 4239} 4240#endif 4241 4242template<class _Tp> 4243template <class _Yp, class _Dp> 4244#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4245shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 4246#else 4247shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 4248#endif 4249 typename enable_if 4250 < 4251 !is_lvalue_reference<_Dp>::value && 4252 !is_array<_Yp>::value && 4253 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 4254 __nat 4255 >::type) 4256 : __ptr_(__r.get()) 4257{ 4258#if _LIBCPP_STD_VER > 11 4259 if (__ptr_ == nullptr) 4260 __cntrl_ = nullptr; 4261 else 4262#endif 4263 { 4264 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4265 typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk; 4266 __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), _AllocT()); 4267 __enable_weak_this(__r.get(), __r.get()); 4268 } 4269 __r.release(); 4270} 4271 4272template<class _Tp> 4273template <class _Yp, class _Dp> 4274#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4275shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 4276#else 4277shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 4278#endif 4279 typename enable_if 4280 < 4281 is_lvalue_reference<_Dp>::value && 4282 !is_array<_Yp>::value && 4283 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 4284 __nat 4285 >::type) 4286 : __ptr_(__r.get()) 4287{ 4288#if _LIBCPP_STD_VER > 11 4289 if (__ptr_ == nullptr) 4290 __cntrl_ = nullptr; 4291 else 4292#endif 4293 { 4294 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; 4295 typedef __shared_ptr_pointer<_Yp*, 4296 reference_wrapper<typename remove_reference<_Dp>::type>, 4297 _AllocT > _CntrlBlk; 4298 __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), _AllocT()); 4299 __enable_weak_this(__r.get(), __r.get()); 4300 } 4301 __r.release(); 4302} 4303 4304#ifndef _LIBCPP_HAS_NO_VARIADICS 4305 4306template<class _Tp> 4307template<class ..._Args> 4308shared_ptr<_Tp> 4309shared_ptr<_Tp>::make_shared(_Args&& ...__args) 4310{ 4311 static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in make_shared" ); 4312 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4313 typedef allocator<_CntrlBlk> _A2; 4314 typedef __allocator_destructor<_A2> _D2; 4315 _A2 __a2; 4316 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4317 ::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...); 4318 shared_ptr<_Tp> __r; 4319 __r.__ptr_ = __hold2.get()->get(); 4320 __r.__cntrl_ = __hold2.release(); 4321 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4322 return __r; 4323} 4324 4325template<class _Tp> 4326template<class _Alloc, class ..._Args> 4327shared_ptr<_Tp> 4328shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args) 4329{ 4330 static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in allocate_shared" ); 4331 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4332 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; 4333 typedef __allocator_destructor<_A2> _D2; 4334 _A2 __a2(__a); 4335 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4336 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4337 _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...); 4338 shared_ptr<_Tp> __r; 4339 __r.__ptr_ = __hold2.get()->get(); 4340 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4341 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4342 return __r; 4343} 4344 4345#else // _LIBCPP_HAS_NO_VARIADICS 4346 4347template<class _Tp> 4348shared_ptr<_Tp> 4349shared_ptr<_Tp>::make_shared() 4350{ 4351 static_assert((is_constructible<_Tp>::value), "Can't construct object in make_shared" ); 4352 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4353 typedef allocator<_CntrlBlk> _Alloc2; 4354 typedef __allocator_destructor<_Alloc2> _D2; 4355 _Alloc2 __alloc2; 4356 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4357 ::new(__hold2.get()) _CntrlBlk(__alloc2); 4358 shared_ptr<_Tp> __r; 4359 __r.__ptr_ = __hold2.get()->get(); 4360 __r.__cntrl_ = __hold2.release(); 4361 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4362 return __r; 4363} 4364 4365template<class _Tp> 4366template<class _A0> 4367shared_ptr<_Tp> 4368shared_ptr<_Tp>::make_shared(_A0& __a0) 4369{ 4370 static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in make_shared" ); 4371 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4372 typedef allocator<_CntrlBlk> _Alloc2; 4373 typedef __allocator_destructor<_Alloc2> _D2; 4374 _Alloc2 __alloc2; 4375 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4376 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0); 4377 shared_ptr<_Tp> __r; 4378 __r.__ptr_ = __hold2.get()->get(); 4379 __r.__cntrl_ = __hold2.release(); 4380 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4381 return __r; 4382} 4383 4384template<class _Tp> 4385template<class _A0, class _A1> 4386shared_ptr<_Tp> 4387shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1) 4388{ 4389 static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in make_shared" ); 4390 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4391 typedef allocator<_CntrlBlk> _Alloc2; 4392 typedef __allocator_destructor<_Alloc2> _D2; 4393 _Alloc2 __alloc2; 4394 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4395 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1); 4396 shared_ptr<_Tp> __r; 4397 __r.__ptr_ = __hold2.get()->get(); 4398 __r.__cntrl_ = __hold2.release(); 4399 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4400 return __r; 4401} 4402 4403template<class _Tp> 4404template<class _A0, class _A1, class _A2> 4405shared_ptr<_Tp> 4406shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 4407{ 4408 static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in make_shared" ); 4409 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4410 typedef allocator<_CntrlBlk> _Alloc2; 4411 typedef __allocator_destructor<_Alloc2> _D2; 4412 _Alloc2 __alloc2; 4413 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4414 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1, __a2); 4415 shared_ptr<_Tp> __r; 4416 __r.__ptr_ = __hold2.get()->get(); 4417 __r.__cntrl_ = __hold2.release(); 4418 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4419 return __r; 4420} 4421 4422template<class _Tp> 4423template<class _Alloc> 4424shared_ptr<_Tp> 4425shared_ptr<_Tp>::allocate_shared(const _Alloc& __a) 4426{ 4427 static_assert((is_constructible<_Tp>::value), "Can't construct object in allocate_shared" ); 4428 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4429 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4430 typedef __allocator_destructor<_Alloc2> _D2; 4431 _Alloc2 __alloc2(__a); 4432 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4433 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4434 _CntrlBlk(__a); 4435 shared_ptr<_Tp> __r; 4436 __r.__ptr_ = __hold2.get()->get(); 4437 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4438 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4439 return __r; 4440} 4441 4442template<class _Tp> 4443template<class _Alloc, class _A0> 4444shared_ptr<_Tp> 4445shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0) 4446{ 4447 static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in allocate_shared" ); 4448 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4449 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4450 typedef __allocator_destructor<_Alloc2> _D2; 4451 _Alloc2 __alloc2(__a); 4452 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4453 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4454 _CntrlBlk(__a, __a0); 4455 shared_ptr<_Tp> __r; 4456 __r.__ptr_ = __hold2.get()->get(); 4457 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4458 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4459 return __r; 4460} 4461 4462template<class _Tp> 4463template<class _Alloc, class _A0, class _A1> 4464shared_ptr<_Tp> 4465shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 4466{ 4467 static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in allocate_shared" ); 4468 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4469 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4470 typedef __allocator_destructor<_Alloc2> _D2; 4471 _Alloc2 __alloc2(__a); 4472 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4473 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4474 _CntrlBlk(__a, __a0, __a1); 4475 shared_ptr<_Tp> __r; 4476 __r.__ptr_ = __hold2.get()->get(); 4477 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4478 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4479 return __r; 4480} 4481 4482template<class _Tp> 4483template<class _Alloc, class _A0, class _A1, class _A2> 4484shared_ptr<_Tp> 4485shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 4486{ 4487 static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in allocate_shared" ); 4488 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4489 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2; 4490 typedef __allocator_destructor<_Alloc2> _D2; 4491 _Alloc2 __alloc2(__a); 4492 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4493 ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get()))) 4494 _CntrlBlk(__a, __a0, __a1, __a2); 4495 shared_ptr<_Tp> __r; 4496 __r.__ptr_ = __hold2.get()->get(); 4497 __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); 4498 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); 4499 return __r; 4500} 4501 4502#endif // _LIBCPP_HAS_NO_VARIADICS 4503 4504template<class _Tp> 4505shared_ptr<_Tp>::~shared_ptr() 4506{ 4507 if (__cntrl_) 4508 __cntrl_->__release_shared(); 4509} 4510 4511template<class _Tp> 4512inline 4513shared_ptr<_Tp>& 4514shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT 4515{ 4516 shared_ptr(__r).swap(*this); 4517 return *this; 4518} 4519 4520template<class _Tp> 4521template<class _Yp> 4522inline 4523typename enable_if 4524< 4525 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4526 shared_ptr<_Tp>& 4527>::type 4528shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT 4529{ 4530 shared_ptr(__r).swap(*this); 4531 return *this; 4532} 4533 4534#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4535 4536template<class _Tp> 4537inline 4538shared_ptr<_Tp>& 4539shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT 4540{ 4541 shared_ptr(_VSTD::move(__r)).swap(*this); 4542 return *this; 4543} 4544 4545template<class _Tp> 4546template<class _Yp> 4547inline 4548typename enable_if 4549< 4550 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4551 shared_ptr<_Tp>& 4552>::type 4553shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r) 4554{ 4555 shared_ptr(_VSTD::move(__r)).swap(*this); 4556 return *this; 4557} 4558 4559#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 4560template<class _Tp> 4561template<class _Yp> 4562inline 4563typename enable_if 4564< 4565 !is_array<_Yp>::value && 4566 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4567 shared_ptr<_Tp> 4568>::type& 4569shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r) 4570{ 4571 shared_ptr(_VSTD::move(__r)).swap(*this); 4572 return *this; 4573} 4574#endif 4575 4576template<class _Tp> 4577template <class _Yp, class _Dp> 4578inline 4579typename enable_if 4580< 4581 !is_array<_Yp>::value && 4582 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 4583 typename shared_ptr<_Tp>::element_type*>::value, 4584 shared_ptr<_Tp>& 4585>::type 4586shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r) 4587{ 4588 shared_ptr(_VSTD::move(__r)).swap(*this); 4589 return *this; 4590} 4591 4592#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4593 4594#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) 4595template<class _Tp> 4596template<class _Yp> 4597inline _LIBCPP_INLINE_VISIBILITY 4598typename enable_if 4599< 4600 !is_array<_Yp>::value && 4601 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4602 shared_ptr<_Tp>& 4603>::type 4604shared_ptr<_Tp>::operator=(auto_ptr<_Yp> __r) 4605{ 4606 shared_ptr(__r).swap(*this); 4607 return *this; 4608} 4609#endif 4610 4611template<class _Tp> 4612template <class _Yp, class _Dp> 4613inline _LIBCPP_INLINE_VISIBILITY 4614typename enable_if 4615< 4616 !is_array<_Yp>::value && 4617 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 4618 typename shared_ptr<_Tp>::element_type*>::value, 4619 shared_ptr<_Tp>& 4620>::type 4621shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r) 4622{ 4623 shared_ptr(_VSTD::move(__r)).swap(*this); 4624 return *this; 4625} 4626 4627#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4628 4629template<class _Tp> 4630inline 4631void 4632shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT 4633{ 4634 _VSTD::swap(__ptr_, __r.__ptr_); 4635 _VSTD::swap(__cntrl_, __r.__cntrl_); 4636} 4637 4638template<class _Tp> 4639inline 4640void 4641shared_ptr<_Tp>::reset() _NOEXCEPT 4642{ 4643 shared_ptr().swap(*this); 4644} 4645 4646template<class _Tp> 4647template<class _Yp> 4648inline 4649typename enable_if 4650< 4651 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4652 void 4653>::type 4654shared_ptr<_Tp>::reset(_Yp* __p) 4655{ 4656 shared_ptr(__p).swap(*this); 4657} 4658 4659template<class _Tp> 4660template<class _Yp, class _Dp> 4661inline 4662typename enable_if 4663< 4664 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4665 void 4666>::type 4667shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d) 4668{ 4669 shared_ptr(__p, __d).swap(*this); 4670} 4671 4672template<class _Tp> 4673template<class _Yp, class _Dp, class _Alloc> 4674inline 4675typename enable_if 4676< 4677 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, 4678 void 4679>::type 4680shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a) 4681{ 4682 shared_ptr(__p, __d, __a).swap(*this); 4683} 4684 4685#ifndef _LIBCPP_HAS_NO_VARIADICS 4686 4687template<class _Tp, class ..._Args> 4688inline _LIBCPP_INLINE_VISIBILITY 4689typename enable_if 4690< 4691 !is_array<_Tp>::value, 4692 shared_ptr<_Tp> 4693>::type 4694make_shared(_Args&& ...__args) 4695{ 4696 return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...); 4697} 4698 4699template<class _Tp, class _Alloc, class ..._Args> 4700inline _LIBCPP_INLINE_VISIBILITY 4701typename enable_if 4702< 4703 !is_array<_Tp>::value, 4704 shared_ptr<_Tp> 4705>::type 4706allocate_shared(const _Alloc& __a, _Args&& ...__args) 4707{ 4708 return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...); 4709} 4710 4711#else // _LIBCPP_HAS_NO_VARIADICS 4712 4713template<class _Tp> 4714inline _LIBCPP_INLINE_VISIBILITY 4715shared_ptr<_Tp> 4716make_shared() 4717{ 4718 return shared_ptr<_Tp>::make_shared(); 4719} 4720 4721template<class _Tp, class _A0> 4722inline _LIBCPP_INLINE_VISIBILITY 4723shared_ptr<_Tp> 4724make_shared(_A0& __a0) 4725{ 4726 return shared_ptr<_Tp>::make_shared(__a0); 4727} 4728 4729template<class _Tp, class _A0, class _A1> 4730inline _LIBCPP_INLINE_VISIBILITY 4731shared_ptr<_Tp> 4732make_shared(_A0& __a0, _A1& __a1) 4733{ 4734 return shared_ptr<_Tp>::make_shared(__a0, __a1); 4735} 4736 4737template<class _Tp, class _A0, class _A1, class _A2> 4738inline _LIBCPP_INLINE_VISIBILITY 4739shared_ptr<_Tp> 4740make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 4741{ 4742 return shared_ptr<_Tp>::make_shared(__a0, __a1, __a2); 4743} 4744 4745template<class _Tp, class _Alloc> 4746inline _LIBCPP_INLINE_VISIBILITY 4747shared_ptr<_Tp> 4748allocate_shared(const _Alloc& __a) 4749{ 4750 return shared_ptr<_Tp>::allocate_shared(__a); 4751} 4752 4753template<class _Tp, class _Alloc, class _A0> 4754inline _LIBCPP_INLINE_VISIBILITY 4755shared_ptr<_Tp> 4756allocate_shared(const _Alloc& __a, _A0& __a0) 4757{ 4758 return shared_ptr<_Tp>::allocate_shared(__a, __a0); 4759} 4760 4761template<class _Tp, class _Alloc, class _A0, class _A1> 4762inline _LIBCPP_INLINE_VISIBILITY 4763shared_ptr<_Tp> 4764allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 4765{ 4766 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1); 4767} 4768 4769template<class _Tp, class _Alloc, class _A0, class _A1, class _A2> 4770inline _LIBCPP_INLINE_VISIBILITY 4771shared_ptr<_Tp> 4772allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 4773{ 4774 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1, __a2); 4775} 4776 4777#endif // _LIBCPP_HAS_NO_VARIADICS 4778 4779template<class _Tp, class _Up> 4780inline _LIBCPP_INLINE_VISIBILITY 4781bool 4782operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4783{ 4784 return __x.get() == __y.get(); 4785} 4786 4787template<class _Tp, class _Up> 4788inline _LIBCPP_INLINE_VISIBILITY 4789bool 4790operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4791{ 4792 return !(__x == __y); 4793} 4794 4795template<class _Tp, class _Up> 4796inline _LIBCPP_INLINE_VISIBILITY 4797bool 4798operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4799{ 4800#if _LIBCPP_STD_VER <= 11 4801 typedef typename common_type<_Tp*, _Up*>::type _Vp; 4802 return less<_Vp>()(__x.get(), __y.get()); 4803#else 4804 return less<>()(__x.get(), __y.get()); 4805#endif 4806 4807} 4808 4809template<class _Tp, class _Up> 4810inline _LIBCPP_INLINE_VISIBILITY 4811bool 4812operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4813{ 4814 return __y < __x; 4815} 4816 4817template<class _Tp, class _Up> 4818inline _LIBCPP_INLINE_VISIBILITY 4819bool 4820operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4821{ 4822 return !(__y < __x); 4823} 4824 4825template<class _Tp, class _Up> 4826inline _LIBCPP_INLINE_VISIBILITY 4827bool 4828operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4829{ 4830 return !(__x < __y); 4831} 4832 4833template<class _Tp> 4834inline _LIBCPP_INLINE_VISIBILITY 4835bool 4836operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4837{ 4838 return !__x; 4839} 4840 4841template<class _Tp> 4842inline _LIBCPP_INLINE_VISIBILITY 4843bool 4844operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4845{ 4846 return !__x; 4847} 4848 4849template<class _Tp> 4850inline _LIBCPP_INLINE_VISIBILITY 4851bool 4852operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4853{ 4854 return static_cast<bool>(__x); 4855} 4856 4857template<class _Tp> 4858inline _LIBCPP_INLINE_VISIBILITY 4859bool 4860operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4861{ 4862 return static_cast<bool>(__x); 4863} 4864 4865template<class _Tp> 4866inline _LIBCPP_INLINE_VISIBILITY 4867bool 4868operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4869{ 4870 return less<_Tp*>()(__x.get(), nullptr); 4871} 4872 4873template<class _Tp> 4874inline _LIBCPP_INLINE_VISIBILITY 4875bool 4876operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4877{ 4878 return less<_Tp*>()(nullptr, __x.get()); 4879} 4880 4881template<class _Tp> 4882inline _LIBCPP_INLINE_VISIBILITY 4883bool 4884operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4885{ 4886 return nullptr < __x; 4887} 4888 4889template<class _Tp> 4890inline _LIBCPP_INLINE_VISIBILITY 4891bool 4892operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4893{ 4894 return __x < nullptr; 4895} 4896 4897template<class _Tp> 4898inline _LIBCPP_INLINE_VISIBILITY 4899bool 4900operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4901{ 4902 return !(nullptr < __x); 4903} 4904 4905template<class _Tp> 4906inline _LIBCPP_INLINE_VISIBILITY 4907bool 4908operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4909{ 4910 return !(__x < nullptr); 4911} 4912 4913template<class _Tp> 4914inline _LIBCPP_INLINE_VISIBILITY 4915bool 4916operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4917{ 4918 return !(__x < nullptr); 4919} 4920 4921template<class _Tp> 4922inline _LIBCPP_INLINE_VISIBILITY 4923bool 4924operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4925{ 4926 return !(nullptr < __x); 4927} 4928 4929template<class _Tp> 4930inline _LIBCPP_INLINE_VISIBILITY 4931void 4932swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT 4933{ 4934 __x.swap(__y); 4935} 4936 4937template<class _Tp, class _Up> 4938inline _LIBCPP_INLINE_VISIBILITY 4939typename enable_if 4940< 4941 !is_array<_Tp>::value && !is_array<_Up>::value, 4942 shared_ptr<_Tp> 4943>::type 4944static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4945{ 4946 return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); 4947} 4948 4949template<class _Tp, class _Up> 4950inline _LIBCPP_INLINE_VISIBILITY 4951typename enable_if 4952< 4953 !is_array<_Tp>::value && !is_array<_Up>::value, 4954 shared_ptr<_Tp> 4955>::type 4956dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4957{ 4958 _Tp* __p = dynamic_cast<_Tp*>(__r.get()); 4959 return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>(); 4960} 4961 4962template<class _Tp, class _Up> 4963typename enable_if 4964< 4965 is_array<_Tp>::value == is_array<_Up>::value, 4966 shared_ptr<_Tp> 4967>::type 4968const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4969{ 4970 typedef typename remove_extent<_Tp>::type _RTp; 4971 return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get())); 4972} 4973 4974#ifndef _LIBCPP_NO_RTTI 4975 4976template<class _Dp, class _Tp> 4977inline _LIBCPP_INLINE_VISIBILITY 4978_Dp* 4979get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT 4980{ 4981 return __p.template __get_deleter<_Dp>(); 4982} 4983 4984#endif // _LIBCPP_NO_RTTI 4985 4986template<class _Tp> 4987class _LIBCPP_TEMPLATE_VIS weak_ptr 4988{ 4989public: 4990 typedef _Tp element_type; 4991private: 4992 element_type* __ptr_; 4993 __shared_weak_count* __cntrl_; 4994 4995public: 4996 _LIBCPP_INLINE_VISIBILITY 4997 _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT; 4998 template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r, 4999 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 5000 _NOEXCEPT; 5001 _LIBCPP_INLINE_VISIBILITY 5002 weak_ptr(weak_ptr const& __r) _NOEXCEPT; 5003 template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r, 5004 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 5005 _NOEXCEPT; 5006 5007#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5008 _LIBCPP_INLINE_VISIBILITY 5009 weak_ptr(weak_ptr&& __r) _NOEXCEPT; 5010 template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r, 5011 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 5012 _NOEXCEPT; 5013#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5014 ~weak_ptr(); 5015 5016 _LIBCPP_INLINE_VISIBILITY 5017 weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT; 5018 template<class _Yp> 5019 typename enable_if 5020 < 5021 is_convertible<_Yp*, element_type*>::value, 5022 weak_ptr& 5023 >::type 5024 _LIBCPP_INLINE_VISIBILITY 5025 operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT; 5026 5027#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5028 5029 _LIBCPP_INLINE_VISIBILITY 5030 weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT; 5031 template<class _Yp> 5032 typename enable_if 5033 < 5034 is_convertible<_Yp*, element_type*>::value, 5035 weak_ptr& 5036 >::type 5037 _LIBCPP_INLINE_VISIBILITY 5038 operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT; 5039 5040#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5041 5042 template<class _Yp> 5043 typename enable_if 5044 < 5045 is_convertible<_Yp*, element_type*>::value, 5046 weak_ptr& 5047 >::type 5048 _LIBCPP_INLINE_VISIBILITY 5049 operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT; 5050 5051 _LIBCPP_INLINE_VISIBILITY 5052 void swap(weak_ptr& __r) _NOEXCEPT; 5053 _LIBCPP_INLINE_VISIBILITY 5054 void reset() _NOEXCEPT; 5055 5056 _LIBCPP_INLINE_VISIBILITY 5057 long use_count() const _NOEXCEPT 5058 {return __cntrl_ ? __cntrl_->use_count() : 0;} 5059 _LIBCPP_INLINE_VISIBILITY 5060 bool expired() const _NOEXCEPT 5061 {return __cntrl_ == 0 || __cntrl_->use_count() == 0;} 5062 shared_ptr<_Tp> lock() const _NOEXCEPT; 5063 template<class _Up> 5064 _LIBCPP_INLINE_VISIBILITY 5065 bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT 5066 {return __cntrl_ < __r.__cntrl_;} 5067 template<class _Up> 5068 _LIBCPP_INLINE_VISIBILITY 5069 bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT 5070 {return __cntrl_ < __r.__cntrl_;} 5071 5072 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; 5073 template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; 5074}; 5075 5076template<class _Tp> 5077inline 5078_LIBCPP_CONSTEXPR 5079weak_ptr<_Tp>::weak_ptr() _NOEXCEPT 5080 : __ptr_(0), 5081 __cntrl_(0) 5082{ 5083} 5084 5085template<class _Tp> 5086inline 5087weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT 5088 : __ptr_(__r.__ptr_), 5089 __cntrl_(__r.__cntrl_) 5090{ 5091 if (__cntrl_) 5092 __cntrl_->__add_weak(); 5093} 5094 5095template<class _Tp> 5096template<class _Yp> 5097inline 5098weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r, 5099 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5100 _NOEXCEPT 5101 : __ptr_(__r.__ptr_), 5102 __cntrl_(__r.__cntrl_) 5103{ 5104 if (__cntrl_) 5105 __cntrl_->__add_weak(); 5106} 5107 5108template<class _Tp> 5109template<class _Yp> 5110inline 5111weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r, 5112 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5113 _NOEXCEPT 5114 : __ptr_(__r.__ptr_), 5115 __cntrl_(__r.__cntrl_) 5116{ 5117 if (__cntrl_) 5118 __cntrl_->__add_weak(); 5119} 5120 5121#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5122 5123template<class _Tp> 5124inline 5125weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT 5126 : __ptr_(__r.__ptr_), 5127 __cntrl_(__r.__cntrl_) 5128{ 5129 __r.__ptr_ = 0; 5130 __r.__cntrl_ = 0; 5131} 5132 5133template<class _Tp> 5134template<class _Yp> 5135inline 5136weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r, 5137 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5138 _NOEXCEPT 5139 : __ptr_(__r.__ptr_), 5140 __cntrl_(__r.__cntrl_) 5141{ 5142 __r.__ptr_ = 0; 5143 __r.__cntrl_ = 0; 5144} 5145 5146#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5147 5148template<class _Tp> 5149weak_ptr<_Tp>::~weak_ptr() 5150{ 5151 if (__cntrl_) 5152 __cntrl_->__release_weak(); 5153} 5154 5155template<class _Tp> 5156inline 5157weak_ptr<_Tp>& 5158weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT 5159{ 5160 weak_ptr(__r).swap(*this); 5161 return *this; 5162} 5163 5164template<class _Tp> 5165template<class _Yp> 5166inline 5167typename enable_if 5168< 5169 is_convertible<_Yp*, _Tp*>::value, 5170 weak_ptr<_Tp>& 5171>::type 5172weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT 5173{ 5174 weak_ptr(__r).swap(*this); 5175 return *this; 5176} 5177 5178#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5179 5180template<class _Tp> 5181inline 5182weak_ptr<_Tp>& 5183weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT 5184{ 5185 weak_ptr(_VSTD::move(__r)).swap(*this); 5186 return *this; 5187} 5188 5189template<class _Tp> 5190template<class _Yp> 5191inline 5192typename enable_if 5193< 5194 is_convertible<_Yp*, _Tp*>::value, 5195 weak_ptr<_Tp>& 5196>::type 5197weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT 5198{ 5199 weak_ptr(_VSTD::move(__r)).swap(*this); 5200 return *this; 5201} 5202 5203#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5204 5205template<class _Tp> 5206template<class _Yp> 5207inline 5208typename enable_if 5209< 5210 is_convertible<_Yp*, _Tp*>::value, 5211 weak_ptr<_Tp>& 5212>::type 5213weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT 5214{ 5215 weak_ptr(__r).swap(*this); 5216 return *this; 5217} 5218 5219template<class _Tp> 5220inline 5221void 5222weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT 5223{ 5224 _VSTD::swap(__ptr_, __r.__ptr_); 5225 _VSTD::swap(__cntrl_, __r.__cntrl_); 5226} 5227 5228template<class _Tp> 5229inline _LIBCPP_INLINE_VISIBILITY 5230void 5231swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT 5232{ 5233 __x.swap(__y); 5234} 5235 5236template<class _Tp> 5237inline 5238void 5239weak_ptr<_Tp>::reset() _NOEXCEPT 5240{ 5241 weak_ptr().swap(*this); 5242} 5243 5244template<class _Tp> 5245template<class _Yp> 5246shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r, 5247 typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) 5248 : __ptr_(__r.__ptr_), 5249 __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) 5250{ 5251 if (__cntrl_ == 0) 5252 __throw_bad_weak_ptr(); 5253} 5254 5255template<class _Tp> 5256shared_ptr<_Tp> 5257weak_ptr<_Tp>::lock() const _NOEXCEPT 5258{ 5259 shared_ptr<_Tp> __r; 5260 __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_; 5261 if (__r.__cntrl_) 5262 __r.__ptr_ = __ptr_; 5263 return __r; 5264} 5265 5266#if _LIBCPP_STD_VER > 14 5267template <class _Tp = void> struct owner_less; 5268#else 5269template <class _Tp> struct owner_less; 5270#endif 5271 5272template <class _Tp> 5273struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> > 5274 : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> 5275{ 5276 typedef bool result_type; 5277 _LIBCPP_INLINE_VISIBILITY 5278 bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT 5279 {return __x.owner_before(__y);} 5280 _LIBCPP_INLINE_VISIBILITY 5281 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT 5282 {return __x.owner_before(__y);} 5283 _LIBCPP_INLINE_VISIBILITY 5284 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT 5285 {return __x.owner_before(__y);} 5286}; 5287 5288template <class _Tp> 5289struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> > 5290 : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> 5291{ 5292 typedef bool result_type; 5293 _LIBCPP_INLINE_VISIBILITY 5294 bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT 5295 {return __x.owner_before(__y);} 5296 _LIBCPP_INLINE_VISIBILITY 5297 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT 5298 {return __x.owner_before(__y);} 5299 _LIBCPP_INLINE_VISIBILITY 5300 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT 5301 {return __x.owner_before(__y);} 5302}; 5303 5304#if _LIBCPP_STD_VER > 14 5305template <> 5306struct _LIBCPP_TEMPLATE_VIS owner_less<void> 5307{ 5308 template <class _Tp, class _Up> 5309 _LIBCPP_INLINE_VISIBILITY 5310 bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT 5311 {return __x.owner_before(__y);} 5312 template <class _Tp, class _Up> 5313 _LIBCPP_INLINE_VISIBILITY 5314 bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT 5315 {return __x.owner_before(__y);} 5316 template <class _Tp, class _Up> 5317 _LIBCPP_INLINE_VISIBILITY 5318 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT 5319 {return __x.owner_before(__y);} 5320 template <class _Tp, class _Up> 5321 _LIBCPP_INLINE_VISIBILITY 5322 bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT 5323 {return __x.owner_before(__y);} 5324 typedef void is_transparent; 5325}; 5326#endif 5327 5328template<class _Tp> 5329class _LIBCPP_TEMPLATE_VIS enable_shared_from_this 5330{ 5331 mutable weak_ptr<_Tp> __weak_this_; 5332protected: 5333 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 5334 enable_shared_from_this() _NOEXCEPT {} 5335 _LIBCPP_INLINE_VISIBILITY 5336 enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {} 5337 _LIBCPP_INLINE_VISIBILITY 5338 enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT 5339 {return *this;} 5340 _LIBCPP_INLINE_VISIBILITY 5341 ~enable_shared_from_this() {} 5342public: 5343 _LIBCPP_INLINE_VISIBILITY 5344 shared_ptr<_Tp> shared_from_this() 5345 {return shared_ptr<_Tp>(__weak_this_);} 5346 _LIBCPP_INLINE_VISIBILITY 5347 shared_ptr<_Tp const> shared_from_this() const 5348 {return shared_ptr<const _Tp>(__weak_this_);} 5349 5350#if _LIBCPP_STD_VER > 14 5351 _LIBCPP_INLINE_VISIBILITY 5352 weak_ptr<_Tp> weak_from_this() _NOEXCEPT 5353 { return __weak_this_; } 5354 5355 _LIBCPP_INLINE_VISIBILITY 5356 weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT 5357 { return __weak_this_; } 5358#endif // _LIBCPP_STD_VER > 14 5359 5360 template <class _Up> friend class shared_ptr; 5361}; 5362 5363template <class _Tp> 5364struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> > 5365{ 5366 typedef shared_ptr<_Tp> argument_type; 5367 typedef size_t result_type; 5368 5369 _LIBCPP_INLINE_VISIBILITY 5370 result_type operator()(const argument_type& __ptr) const _NOEXCEPT 5371 { 5372 return hash<_Tp*>()(__ptr.get()); 5373 } 5374}; 5375 5376template<class _CharT, class _Traits, class _Yp> 5377inline _LIBCPP_INLINE_VISIBILITY 5378basic_ostream<_CharT, _Traits>& 5379operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p); 5380 5381 5382#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) 5383 5384class _LIBCPP_TYPE_VIS __sp_mut 5385{ 5386 void* __lx; 5387public: 5388 void lock() _NOEXCEPT; 5389 void unlock() _NOEXCEPT; 5390 5391private: 5392 _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT; 5393 __sp_mut(const __sp_mut&); 5394 __sp_mut& operator=(const __sp_mut&); 5395 5396 friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*); 5397}; 5398 5399_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5400__sp_mut& __get_sp_mut(const void*); 5401 5402template <class _Tp> 5403inline _LIBCPP_INLINE_VISIBILITY 5404bool 5405atomic_is_lock_free(const shared_ptr<_Tp>*) 5406{ 5407 return false; 5408} 5409 5410template <class _Tp> 5411_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5412shared_ptr<_Tp> 5413atomic_load(const shared_ptr<_Tp>* __p) 5414{ 5415 __sp_mut& __m = __get_sp_mut(__p); 5416 __m.lock(); 5417 shared_ptr<_Tp> __q = *__p; 5418 __m.unlock(); 5419 return __q; 5420} 5421 5422template <class _Tp> 5423inline _LIBCPP_INLINE_VISIBILITY 5424_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5425shared_ptr<_Tp> 5426atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) 5427{ 5428 return atomic_load(__p); 5429} 5430 5431template <class _Tp> 5432_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5433void 5434atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) 5435{ 5436 __sp_mut& __m = __get_sp_mut(__p); 5437 __m.lock(); 5438 __p->swap(__r); 5439 __m.unlock(); 5440} 5441 5442template <class _Tp> 5443inline _LIBCPP_INLINE_VISIBILITY 5444_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5445void 5446atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) 5447{ 5448 atomic_store(__p, __r); 5449} 5450 5451template <class _Tp> 5452_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5453shared_ptr<_Tp> 5454atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) 5455{ 5456 __sp_mut& __m = __get_sp_mut(__p); 5457 __m.lock(); 5458 __p->swap(__r); 5459 __m.unlock(); 5460 return __r; 5461} 5462 5463template <class _Tp> 5464inline _LIBCPP_INLINE_VISIBILITY 5465_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5466shared_ptr<_Tp> 5467atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) 5468{ 5469 return atomic_exchange(__p, __r); 5470} 5471 5472template <class _Tp> 5473_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5474bool 5475atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) 5476{ 5477 shared_ptr<_Tp> __temp; 5478 __sp_mut& __m = __get_sp_mut(__p); 5479 __m.lock(); 5480 if (__p->__owner_equivalent(*__v)) 5481 { 5482 _VSTD::swap(__temp, *__p); 5483 *__p = __w; 5484 __m.unlock(); 5485 return true; 5486 } 5487 _VSTD::swap(__temp, *__v); 5488 *__v = *__p; 5489 __m.unlock(); 5490 return false; 5491} 5492 5493template <class _Tp> 5494inline _LIBCPP_INLINE_VISIBILITY 5495_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5496bool 5497atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) 5498{ 5499 return atomic_compare_exchange_strong(__p, __v, __w); 5500} 5501 5502template <class _Tp> 5503inline _LIBCPP_INLINE_VISIBILITY 5504_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5505bool 5506atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, 5507 shared_ptr<_Tp> __w, memory_order, memory_order) 5508{ 5509 return atomic_compare_exchange_strong(__p, __v, __w); 5510} 5511 5512template <class _Tp> 5513inline _LIBCPP_INLINE_VISIBILITY 5514_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR 5515bool 5516atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, 5517 shared_ptr<_Tp> __w, memory_order, memory_order) 5518{ 5519 return atomic_compare_exchange_weak(__p, __v, __w); 5520} 5521 5522#endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) 5523 5524//enum class 5525#if defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) 5526# ifndef _LIBCPP_CXX03_LANG 5527enum class pointer_safety : unsigned char { 5528 relaxed, 5529 preferred, 5530 strict 5531}; 5532# endif 5533#else 5534struct _LIBCPP_TYPE_VIS pointer_safety 5535{ 5536 enum __lx 5537 { 5538 relaxed, 5539 preferred, 5540 strict 5541 }; 5542 5543 __lx __v_; 5544 5545 _LIBCPP_INLINE_VISIBILITY 5546 pointer_safety() : __v_() {} 5547 5548 _LIBCPP_INLINE_VISIBILITY 5549 pointer_safety(__lx __v) : __v_(__v) {} 5550 _LIBCPP_INLINE_VISIBILITY 5551 operator int() const {return __v_;} 5552}; 5553#endif 5554 5555#if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) && \ 5556 defined(_LIBCPP_BUILDING_LIBRARY) 5557_LIBCPP_FUNC_VIS pointer_safety get_pointer_safety() _NOEXCEPT; 5558#else 5559// This function is only offered in C++03 under ABI v1. 5560# if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) || !defined(_LIBCPP_CXX03_LANG) 5561inline _LIBCPP_INLINE_VISIBILITY 5562pointer_safety get_pointer_safety() _NOEXCEPT { 5563 return pointer_safety::relaxed; 5564} 5565# endif 5566#endif 5567 5568 5569_LIBCPP_FUNC_VIS void declare_reachable(void* __p); 5570_LIBCPP_FUNC_VIS void declare_no_pointers(char* __p, size_t __n); 5571_LIBCPP_FUNC_VIS void undeclare_no_pointers(char* __p, size_t __n); 5572_LIBCPP_FUNC_VIS void* __undeclare_reachable(void* __p); 5573 5574template <class _Tp> 5575inline _LIBCPP_INLINE_VISIBILITY 5576_Tp* 5577undeclare_reachable(_Tp* __p) 5578{ 5579 return static_cast<_Tp*>(__undeclare_reachable(__p)); 5580} 5581 5582_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space); 5583 5584// --- Helper for container swap -- 5585template <typename _Alloc> 5586inline _LIBCPP_INLINE_VISIBILITY 5587void __swap_allocator(_Alloc & __a1, _Alloc & __a2) 5588#if _LIBCPP_STD_VER >= 14 5589 _NOEXCEPT 5590#else 5591 _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) 5592#endif 5593{ 5594 __swap_allocator(__a1, __a2, 5595 integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>()); 5596} 5597 5598template <typename _Alloc> 5599_LIBCPP_INLINE_VISIBILITY 5600void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type) 5601#if _LIBCPP_STD_VER >= 14 5602 _NOEXCEPT 5603#else 5604 _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) 5605#endif 5606{ 5607 using _VSTD::swap; 5608 swap(__a1, __a2); 5609} 5610 5611template <typename _Alloc> 5612inline _LIBCPP_INLINE_VISIBILITY 5613void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {} 5614 5615template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> > 5616struct __noexcept_move_assign_container : public integral_constant<bool, 5617 _Traits::propagate_on_container_move_assignment::value 5618#if _LIBCPP_STD_VER > 14 5619 || _Traits::is_always_equal::value 5620#else 5621 && is_nothrow_move_assignable<_Alloc>::value 5622#endif 5623 > {}; 5624 5625 5626#ifndef _LIBCPP_HAS_NO_VARIADICS 5627template <class _Tp, class _Alloc> 5628struct __temp_value { 5629 typedef allocator_traits<_Alloc> _Traits; 5630 5631 typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __v; 5632 _Alloc &__a; 5633 5634 _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); } 5635 _Tp & get() { return *__addr(); } 5636 5637 template<class... _Args> 5638 _LIBCPP_NO_CFI 5639 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) { 5640 _Traits::construct(__a, reinterpret_cast<_Tp*>(addressof(__v)), 5641 _VSTD::forward<_Args>(__args)...); 5642 } 5643 5644 ~__temp_value() { _Traits::destroy(__a, __addr()); } 5645 }; 5646#endif 5647 5648template<typename _Alloc, typename = void, typename = void> 5649struct __is_allocator : false_type {}; 5650 5651template<typename _Alloc> 5652struct __is_allocator<_Alloc, 5653 typename __void_t<typename _Alloc::value_type>::type, 5654 typename __void_t<decltype(_VSTD::declval<_Alloc&>().allocate(size_t(0)))>::type 5655 > 5656 : true_type {}; 5657 5658_LIBCPP_END_NAMESPACE_STD 5659 5660_LIBCPP_POP_MACROS 5661 5662#endif // _LIBCPP_MEMORY 5663