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