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