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