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