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