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