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 79 template <class T> using rebind_alloc = Alloc::rebind<U>::other | Alloc<T, Args...>; 80 template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>; 81 82 static pointer allocate(allocator_type& a, size_type n); 83 static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); 84 85 static void deallocate(allocator_type& a, pointer p, size_type n) noexcept; 86 87 template <class T, class... Args> 88 static void construct(allocator_type& a, T* p, Args&&... args); 89 90 template <class T> 91 static void destroy(allocator_type& a, T* p); 92 93 static size_type max_size(const allocator_type& a); 94 95 static allocator_type 96 select_on_container_copy_construction(const allocator_type& a); 97}; 98 99template <> 100class allocator<void> 101{ 102public: 103 typedef void* pointer; 104 typedef const void* const_pointer; 105 typedef void value_type; 106 107 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 108}; 109 110template <class T> 111class allocator 112{ 113public: 114 typedef size_t size_type; 115 typedef ptrdiff_t difference_type; 116 typedef T* pointer; 117 typedef const T* const_pointer; 118 typedef typename add_lvalue_reference<T>::type reference; 119 typedef typename add_lvalue_reference<const T>::type const_reference; 120 typedef T value_type; 121 122 template <class U> struct rebind {typedef allocator<U> other;}; 123 124 allocator() noexcept; 125 allocator(const allocator&) noexcept; 126 template <class U> allocator(const allocator<U>&) noexcept; 127 ~allocator(); 128 pointer address(reference x) const noexcept; 129 const_pointer address(const_reference x) const noexcept; 130 pointer allocate(size_type, allocator<void>::const_pointer hint = 0); 131 void deallocate(pointer p, size_type n) noexcept; 132 size_type max_size() const noexcept; 133 template<class U, class... Args> 134 void construct(U* p, Args&&... args); 135 template <class U> 136 void destroy(U* p); 137}; 138 139template <class T, class U> 140bool operator==(const allocator<T>&, const allocator<U>&) noexcept; 141 142template <class T, class U> 143bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; 144 145template <class OutputIterator, class T> 146class raw_storage_iterator 147 : public iterator<output_iterator_tag, 148 T, // purposefully not C++03 149 ptrdiff_t, // purposefully not C++03 150 T*, // purposefully not C++03 151 raw_storage_iterator&> // purposefully not C++03 152{ 153public: 154 explicit raw_storage_iterator(OutputIterator x); 155 raw_storage_iterator& operator*(); 156 raw_storage_iterator& operator=(const T& element); 157 raw_storage_iterator& operator++(); 158 raw_storage_iterator operator++(int); 159}; 160 161template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept; 162template <class T> void return_temporary_buffer(T* p) noexcept; 163 164template <class T> T* addressof(T& r) noexcept; 165 166template <class InputIterator, class ForwardIterator> 167ForwardIterator 168uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); 169 170template <class InputIterator, class Size, class ForwardIterator> 171ForwardIterator 172uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result); 173 174template <class ForwardIterator, class T> 175void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); 176 177template <class ForwardIterator, class Size, class T> 178ForwardIterator 179uninitialized_fill_n(ForwardIterator first, Size n, const T& x); 180 181template <class Y> struct auto_ptr_ref {}; 182 183template<class X> 184class auto_ptr 185{ 186public: 187 typedef X element_type; 188 189 explicit auto_ptr(X* p =0) throw(); 190 auto_ptr(auto_ptr&) throw(); 191 template<class Y> auto_ptr(auto_ptr<Y>&) throw(); 192 auto_ptr& operator=(auto_ptr&) throw(); 193 template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw(); 194 auto_ptr& operator=(auto_ptr_ref<X> r) throw(); 195 ~auto_ptr() throw(); 196 197 typename add_lvalue_reference<X>::type operator*() const throw(); 198 X* operator->() const throw(); 199 X* get() const throw(); 200 X* release() throw(); 201 void reset(X* p =0) throw(); 202 203 auto_ptr(auto_ptr_ref<X>) throw(); 204 template<class Y> operator auto_ptr_ref<Y>() throw(); 205 template<class Y> operator auto_ptr<Y>() throw(); 206}; 207 208template <class T> 209struct default_delete 210{ 211 constexpr default_delete() noexcept = default; 212 template <class U> default_delete(const default_delete<U>&) noexcept; 213 214 void operator()(T*) const noexcept; 215}; 216 217template <class T> 218struct default_delete<T[]> 219{ 220 constexpr default_delete() noexcept = default; 221 void operator()(T*) const noexcept; 222 template <class U> void operator()(U*) const = delete; 223}; 224 225template <class T, class D = default_delete<T>> 226class unique_ptr 227{ 228public: 229 typedef see below pointer; 230 typedef T element_type; 231 typedef D deleter_type; 232 233 // constructors 234 constexpr unique_ptr() noexcept; 235 explicit unique_ptr(pointer p) noexcept; 236 unique_ptr(pointer p, see below d1) noexcept; 237 unique_ptr(pointer p, see below d2) noexcept; 238 unique_ptr(unique_ptr&& u) noexcept; 239 unique_ptr(nullptr_t) noexcept : unique_ptr() { } 240 template <class U, class E> 241 unique_ptr(unique_ptr<U, E>&& u) noexcept; 242 template <class U> 243 unique_ptr(auto_ptr<U>&& u) noexcept; 244 245 // destructor 246 ~unique_ptr(); 247 248 // assignment 249 unique_ptr& operator=(unique_ptr&& u) noexcept; 250 template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept; 251 unique_ptr& operator=(nullptr_t) noexcept; 252 253 // observers 254 typename add_lvalue_reference<T>::type operator*() const; 255 pointer operator->() const noexcept; 256 pointer get() const noexcept; 257 deleter_type& get_deleter() noexcept; 258 const deleter_type& get_deleter() const noexcept; 259 explicit operator bool() const noexcept; 260 261 // modifiers 262 pointer release() noexcept; 263 void reset(pointer p = pointer()) noexcept; 264 void swap(unique_ptr& u) noexcept; 265}; 266 267template <class T, class D> 268class unique_ptr<T[], D> 269{ 270public: 271 typedef implementation-defined pointer; 272 typedef T element_type; 273 typedef D deleter_type; 274 275 // constructors 276 constexpr unique_ptr() noexcept; 277 explicit unique_ptr(pointer p) noexcept; 278 unique_ptr(pointer p, see below d) noexcept; 279 unique_ptr(pointer p, see below d) noexcept; 280 unique_ptr(unique_ptr&& u) noexcept; 281 unique_ptr(nullptr_t) noexcept : unique_ptr() { } 282 283 // destructor 284 ~unique_ptr(); 285 286 // assignment 287 unique_ptr& operator=(unique_ptr&& u) noexcept; 288 unique_ptr& operator=(nullptr_t) noexcept; 289 290 // observers 291 T& operator[](size_t i) const; 292 pointer get() const noexcept; 293 deleter_type& get_deleter() noexcept; 294 const deleter_type& get_deleter() const noexcept; 295 explicit operator bool() const noexcept; 296 297 // modifiers 298 pointer release() noexcept; 299 void reset(pointer p = pointer()) noexcept; 300 void reset(nullptr_t) noexcept; 301 template <class U> void reset(U) = delete; 302 void swap(unique_ptr& u) noexcept; 303}; 304 305template <class T, class D> 306 void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; 307 308template <class T1, class D1, class T2, class D2> 309 bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 310template <class T1, class D1, class T2, class D2> 311 bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 312template <class T1, class D1, class T2, class D2> 313 bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 314template <class T1, class D1, class T2, class D2> 315 bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 316template <class T1, class D1, class T2, class D2> 317 bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 318template <class T1, class D1, class T2, class D2> 319 bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 320 321template <class T, class D> 322 bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; 323template <class T, class D> 324 bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept; 325template <class T, class D> 326 bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept; 327template <class T, class D> 328 bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept; 329 330template <class T, class D> 331 bool operator<(const unique_ptr<T, D>& x, nullptr_t); 332template <class T, class D> 333 bool operator<(nullptr_t, const unique_ptr<T, D>& y); 334template <class T, class D> 335 bool operator<=(const unique_ptr<T, D>& x, nullptr_t); 336template <class T, class D> 337 bool operator<=(nullptr_t, const unique_ptr<T, D>& y); 338template <class T, class D> 339 bool operator>(const unique_ptr<T, D>& x, nullptr_t); 340template <class T, class D> 341 bool operator>(nullptr_t, const unique_ptr<T, D>& y); 342template <class T, class D> 343 bool operator>=(const unique_ptr<T, D>& x, nullptr_t); 344template <class T, class D> 345 bool operator>=(nullptr_t, const unique_ptr<T, D>& y); 346 347class bad_weak_ptr 348 : public std::exception 349{ 350 bad_weak_ptr() noexcept; 351}; 352 353template<class T> 354class shared_ptr 355{ 356public: 357 typedef T element_type; 358 359 // constructors: 360 constexpr shared_ptr() noexcept; 361 template<class Y> explicit shared_ptr(Y* p); 362 template<class Y, class D> shared_ptr(Y* p, D d); 363 template<class Y, class D, class A> shared_ptr(Y* p, D d, A a); 364 template <class D> shared_ptr(nullptr_t p, D d); 365 template <class D, class A> shared_ptr(nullptr_t p, D d, A a); 366 template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept; 367 shared_ptr(const shared_ptr& r) noexcept; 368 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept; 369 shared_ptr(shared_ptr&& r) noexcept; 370 template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept; 371 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r); 372 template<class Y> shared_ptr(auto_ptr<Y>&& r); 373 template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r); 374 shared_ptr(nullptr_t) : shared_ptr() { } 375 376 // destructor: 377 ~shared_ptr(); 378 379 // assignment: 380 shared_ptr& operator=(const shared_ptr& r) noexcept; 381 template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept; 382 shared_ptr& operator=(shared_ptr&& r) noexcept; 383 template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r); 384 template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); 385 template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r); 386 387 // modifiers: 388 void swap(shared_ptr& r) noexcept; 389 void reset() noexcept; 390 template<class Y> void reset(Y* p); 391 template<class Y, class D> void reset(Y* p, D d); 392 template<class Y, class D, class A> void reset(Y* p, D d, A a); 393 394 // observers: 395 T* get() const noexcept; 396 T& operator*() const noexcept; 397 T* operator->() const noexcept; 398 long use_count() const noexcept; 399 bool unique() const noexcept; 400 explicit operator bool() const noexcept; 401 template<class U> bool owner_before(shared_ptr<U> const& b) const; 402 template<class U> bool owner_before(weak_ptr<U> const& b) const; 403}; 404 405// shared_ptr comparisons: 406template<class T, class U> 407 bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 408template<class T, class U> 409 bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 410template<class T, class U> 411 bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 412template<class T, class U> 413 bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 414template<class T, class U> 415 bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 416template<class T, class U> 417 bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 418 419template <class T> 420 bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept; 421template <class T> 422 bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept; 423template <class T> 424 bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept; 425template <class T> 426 bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept; 427template <class T> 428 bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept; 429template <class T> 430bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept; 431template <class T> 432 bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept; 433template <class T> 434 bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept; 435template <class T> 436 bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept; 437template <class T> 438 bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept; 439template <class T> 440 bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept; 441template <class T> 442 bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept; 443 444// shared_ptr specialized algorithms: 445template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept; 446 447// shared_ptr casts: 448template<class T, class U> 449 shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept; 450template<class T, class U> 451 shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept; 452template<class T, class U> 453 shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept; 454 455// shared_ptr I/O: 456template<class E, class T, class Y> 457 basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p); 458 459// shared_ptr get_deleter: 460template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept; 461 462template<class T, class... Args> 463 shared_ptr<T> make_shared(Args&&... args); 464template<class T, class A, class... Args> 465 shared_ptr<T> allocate_shared(const A& a, Args&&... args); 466 467template<class T> 468class weak_ptr 469{ 470public: 471 typedef T element_type; 472 473 // constructors 474 constexpr weak_ptr() noexcept; 475 template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept; 476 weak_ptr(weak_ptr const& r) noexcept; 477 template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept; 478 479 // destructor 480 ~weak_ptr(); 481 482 // assignment 483 weak_ptr& operator=(weak_ptr const& r) noexcept; 484 template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept; 485 template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept; 486 487 // modifiers 488 void swap(weak_ptr& r) noexcept; 489 void reset() noexcept; 490 491 // observers 492 long use_count() const noexcept; 493 bool expired() const noexcept; 494 shared_ptr<T> lock() const noexcept; 495 template<class U> bool owner_before(shared_ptr<U> const& b); 496 template<class U> bool owner_before(weak_ptr<U> const& b); 497}; 498 499// weak_ptr specialized algorithms: 500template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept; 501 502// class owner_less: 503template<class T> struct owner_less; 504 505template<class T> 506struct owner_less<shared_ptr<T>> 507 : binary_function<shared_ptr<T>, shared_ptr<T>, bool> 508{ 509 typedef bool result_type; 510 bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const; 511 bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const; 512 bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const; 513}; 514 515template<class T> 516struct owner_less<weak_ptr<T>> 517 : binary_function<weak_ptr<T>, weak_ptr<T>, bool> 518{ 519 typedef bool result_type; 520 bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const; 521 bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const; 522 bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const; 523}; 524 525template<class T> 526class enable_shared_from_this 527{ 528protected: 529 constexpr enable_shared_from_this() noexcept; 530 enable_shared_from_this(enable_shared_from_this const&) noexcept; 531 enable_shared_from_this& operator=(enable_shared_from_this const&) noexcept; 532 ~enable_shared_from_this(); 533public: 534 shared_ptr<T> shared_from_this(); 535 shared_ptr<T const> shared_from_this() const; 536}; 537 538template<class T> 539 bool atomic_is_lock_free(const shared_ptr<T>* p); 540template<class T> 541 shared_ptr<T> atomic_load(const shared_ptr<T>* p); 542template<class T> 543 shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo); 544template<class T> 545 void atomic_store(shared_ptr<T>* p, shared_ptr<T> r); 546template<class T> 547 void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 548template<class T> 549 shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r); 550template<class T> 551 shared_ptr<T> 552 atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 553template<class T> 554 bool 555 atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 556template<class T> 557 bool 558 atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 559template<class T> 560 bool 561 atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 562 shared_ptr<T> w, memory_order success, 563 memory_order failure); 564template<class T> 565 bool 566 atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 567 shared_ptr<T> w, memory_order success, 568 memory_order failure); 569// Hash support 570template <class T> struct hash; 571template <class T, class D> struct hash<unique_ptr<T, D> >; 572template <class T> struct hash<shared_ptr<T> >; 573 574// Pointer safety 575enum class pointer_safety { relaxed, preferred, strict }; 576void declare_reachable(void *p); 577template <class T> T *undeclare_reachable(T *p); 578void declare_no_pointers(char *p, size_t n); 579void undeclare_no_pointers(char *p, size_t n); 580pointer_safety get_pointer_safety() noexcept; 581 582void* align(size_t alignment, size_t size, void*& ptr, size_t& space); 583 584} // std 585 586*/ 587 588#include <__config> 589#include <type_traits> 590#include <typeinfo> 591#include <cstddef> 592#include <cstdint> 593#include <new> 594#include <utility> 595#include <limits> 596#include <iterator> 597#include <__functional_base> 598#include <iosfwd> 599#if defined(_LIBCPP_NO_EXCEPTIONS) 600 #include <cassert> 601#endif 602 603#include <__undef_min_max> 604 605#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 606#pragma GCC system_header 607#endif 608 609_LIBCPP_BEGIN_NAMESPACE_STD 610 611// allocator_arg_t 612 613struct _LIBCPP_VISIBLE allocator_arg_t { }; 614 615extern const allocator_arg_t allocator_arg; 616 617// addressof 618 619template <class _Tp> 620inline _LIBCPP_INLINE_VISIBILITY 621_Tp* 622addressof(_Tp& __x) _NOEXCEPT 623{ 624 return (_Tp*)&(char&)__x; 625} 626 627#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) 628// Objective-C++ Automatic Reference Counting uses qualified pointers 629// that require special addressof() signatures. When 630// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler 631// itself is providing these definitions. Otherwise, we provide them. 632template <class _Tp> 633inline _LIBCPP_INLINE_VISIBILITY 634__strong _Tp* 635addressof(__strong _Tp& __x) _NOEXCEPT 636{ 637 return &__x; 638} 639 640#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK 641template <class _Tp> 642inline _LIBCPP_INLINE_VISIBILITY 643__weak _Tp* 644addressof(__weak _Tp& __x) _NOEXCEPT 645{ 646 return &__x; 647} 648#endif 649 650template <class _Tp> 651inline _LIBCPP_INLINE_VISIBILITY 652__autoreleasing _Tp* 653addressof(__autoreleasing _Tp& __x) _NOEXCEPT 654{ 655 return &__x; 656} 657 658template <class _Tp> 659inline _LIBCPP_INLINE_VISIBILITY 660__unsafe_unretained _Tp* 661addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT 662{ 663 return &__x; 664} 665#endif 666 667template <class _Tp> class allocator; 668 669template <> 670class _LIBCPP_VISIBLE allocator<void> 671{ 672public: 673 typedef void* pointer; 674 typedef const void* const_pointer; 675 typedef void value_type; 676 677 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 678}; 679 680// pointer_traits 681 682template <class _Tp> 683struct __has_element_type 684{ 685private: 686 struct __two {char _; char __;}; 687 template <class _Up> static __two __test(...); 688 template <class _Up> static char __test(typename _Up::element_type* = 0); 689public: 690 static const bool value = sizeof(__test<_Tp>(0)) == 1; 691}; 692 693template <class _Ptr, bool = __has_element_type<_Ptr>::value> 694struct __pointer_traits_element_type; 695 696template <class _Ptr> 697struct __pointer_traits_element_type<_Ptr, true> 698{ 699 typedef typename _Ptr::element_type type; 700}; 701 702#ifndef _LIBCPP_HAS_NO_VARIADICS 703 704template <template <class, class...> class _Sp, class _Tp, class ..._Args> 705struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true> 706{ 707 typedef typename _Sp<_Tp, _Args...>::element_type type; 708}; 709 710template <template <class, class...> class _Sp, class _Tp, class ..._Args> 711struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false> 712{ 713 typedef _Tp type; 714}; 715 716#else // _LIBCPP_HAS_NO_VARIADICS 717 718template <template <class> class _Sp, class _Tp> 719struct __pointer_traits_element_type<_Sp<_Tp>, true> 720{ 721 typedef typename _Sp<_Tp>::element_type type; 722}; 723 724template <template <class> class _Sp, class _Tp> 725struct __pointer_traits_element_type<_Sp<_Tp>, false> 726{ 727 typedef _Tp type; 728}; 729 730template <template <class, class> class _Sp, class _Tp, class _A0> 731struct __pointer_traits_element_type<_Sp<_Tp, _A0>, true> 732{ 733 typedef typename _Sp<_Tp, _A0>::element_type type; 734}; 735 736template <template <class, class> class _Sp, class _Tp, class _A0> 737struct __pointer_traits_element_type<_Sp<_Tp, _A0>, false> 738{ 739 typedef _Tp type; 740}; 741 742template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1> 743struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, true> 744{ 745 typedef typename _Sp<_Tp, _A0, _A1>::element_type type; 746}; 747 748template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1> 749struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, false> 750{ 751 typedef _Tp type; 752}; 753 754template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 755 class _A1, class _A2> 756struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, true> 757{ 758 typedef typename _Sp<_Tp, _A0, _A1, _A2>::element_type type; 759}; 760 761template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 762 class _A1, class _A2> 763struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, false> 764{ 765 typedef _Tp type; 766}; 767 768#endif // _LIBCPP_HAS_NO_VARIADICS 769 770template <class _Tp> 771struct __has_difference_type 772{ 773private: 774 struct __two {char _; char __;}; 775 template <class _Up> static __two __test(...); 776 template <class _Up> static char __test(typename _Up::difference_type* = 0); 777public: 778 static const bool value = sizeof(__test<_Tp>(0)) == 1; 779}; 780 781template <class _Ptr, bool = __has_difference_type<_Ptr>::value> 782struct __pointer_traits_difference_type 783{ 784 typedef ptrdiff_t type; 785}; 786 787template <class _Ptr> 788struct __pointer_traits_difference_type<_Ptr, true> 789{ 790 typedef typename _Ptr::difference_type type; 791}; 792 793template <class _Tp, class _Up> 794struct __has_rebind 795{ 796private: 797 struct __two {char _; char __;}; 798 template <class _Xp> static __two __test(...); 799 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0); 800public: 801 static const bool value = sizeof(__test<_Tp>(0)) == 1; 802}; 803 804template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> 805struct __pointer_traits_rebind 806{ 807#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 808 typedef typename _Tp::template rebind<_Up> type; 809#else 810 typedef typename _Tp::template rebind<_Up>::other type; 811#endif 812}; 813 814#ifndef _LIBCPP_HAS_NO_VARIADICS 815 816template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 817struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true> 818{ 819#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 820 typedef typename _Sp<_Tp, _Args...>::template rebind<_Up> type; 821#else 822 typedef typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type; 823#endif 824}; 825 826template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 827struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false> 828{ 829 typedef _Sp<_Up, _Args...> type; 830}; 831 832#else // _LIBCPP_HAS_NO_VARIADICS 833 834template <template <class> class _Sp, class _Tp, class _Up> 835struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true> 836{ 837#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 838 typedef typename _Sp<_Tp>::template rebind<_Up> type; 839#else 840 typedef typename _Sp<_Tp>::template rebind<_Up>::other type; 841#endif 842}; 843 844template <template <class> class _Sp, class _Tp, class _Up> 845struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false> 846{ 847 typedef _Sp<_Up> type; 848}; 849 850template <template <class, class> class _Sp, class _Tp, class _A0, class _Up> 851struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true> 852{ 853#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 854 typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type; 855#else 856 typedef typename _Sp<_Tp, _A0>::template rebind<_Up>::other type; 857#endif 858}; 859 860template <template <class, class> class _Sp, class _Tp, class _A0, class _Up> 861struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false> 862{ 863 typedef _Sp<_Up, _A0> type; 864}; 865 866template <template <class, class, class> class _Sp, class _Tp, class _A0, 867 class _A1, class _Up> 868struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true> 869{ 870#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 871 typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type; 872#else 873 typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up>::other type; 874#endif 875}; 876 877template <template <class, class, class> class _Sp, class _Tp, class _A0, 878 class _A1, class _Up> 879struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false> 880{ 881 typedef _Sp<_Up, _A0, _A1> type; 882}; 883 884template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 885 class _A1, class _A2, class _Up> 886struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true> 887{ 888#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 889 typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type; 890#else 891 typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type; 892#endif 893}; 894 895template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 896 class _A1, class _A2, class _Up> 897struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false> 898{ 899 typedef _Sp<_Up, _A0, _A1, _A2> type; 900}; 901 902#endif // _LIBCPP_HAS_NO_VARIADICS 903 904template <class _Ptr> 905struct _LIBCPP_VISIBLE pointer_traits 906{ 907 typedef _Ptr pointer; 908 typedef typename __pointer_traits_element_type<pointer>::type element_type; 909 typedef typename __pointer_traits_difference_type<pointer>::type difference_type; 910 911#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 912 template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type; 913#else 914 template <class _Up> struct rebind 915 {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;}; 916#endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES 917 918private: 919 struct __nat {}; 920public: 921 _LIBCPP_INLINE_VISIBILITY 922 static pointer pointer_to(typename conditional<is_void<element_type>::value, 923 __nat, element_type>::type& __r) 924 {return pointer::pointer_to(__r);} 925}; 926 927template <class _Tp> 928struct _LIBCPP_VISIBLE pointer_traits<_Tp*> 929{ 930 typedef _Tp* pointer; 931 typedef _Tp element_type; 932 typedef ptrdiff_t difference_type; 933 934#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 935 template <class _Up> using rebind = _Up*; 936#else 937 template <class _Up> struct rebind {typedef _Up* other;}; 938#endif 939 940private: 941 struct __nat {}; 942public: 943 _LIBCPP_INLINE_VISIBILITY 944 static pointer pointer_to(typename conditional<is_void<element_type>::value, 945 __nat, element_type>::type& __r) _NOEXCEPT 946 {return _VSTD::addressof(__r);} 947}; 948 949// allocator_traits 950 951namespace __has_pointer_type_imp 952{ 953 template <class _Up> static __two test(...); 954 template <class _Up> static char test(typename _Up::pointer* = 0); 955} 956 957template <class _Tp> 958struct __has_pointer_type 959 : public integral_constant<bool, sizeof(__has_pointer_type_imp::test<_Tp>(0)) == 1> 960{ 961}; 962 963namespace __pointer_type_imp 964{ 965 966template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value> 967struct __pointer_type 968{ 969 typedef typename _Dp::pointer type; 970}; 971 972template <class _Tp, class _Dp> 973struct __pointer_type<_Tp, _Dp, false> 974{ 975 typedef _Tp* type; 976}; 977 978} // __pointer_type_imp 979 980template <class _Tp, class _Dp> 981struct __pointer_type 982{ 983 typedef typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type; 984}; 985 986template <class _Tp> 987struct __has_const_pointer 988{ 989private: 990 struct __two {char _; char __;}; 991 template <class _Up> static __two __test(...); 992 template <class _Up> static char __test(typename _Up::const_pointer* = 0); 993public: 994 static const bool value = sizeof(__test<_Tp>(0)) == 1; 995}; 996 997template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value> 998struct __const_pointer 999{ 1000 typedef typename _Alloc::const_pointer type; 1001}; 1002 1003template <class _Tp, class _Ptr, class _Alloc> 1004struct __const_pointer<_Tp, _Ptr, _Alloc, false> 1005{ 1006#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1007 typedef typename pointer_traits<_Ptr>::template rebind<const _Tp> type; 1008#else 1009 typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type; 1010#endif 1011}; 1012 1013template <class _Tp> 1014struct __has_void_pointer 1015{ 1016private: 1017 struct __two {char _; char __;}; 1018 template <class _Up> static __two __test(...); 1019 template <class _Up> static char __test(typename _Up::void_pointer* = 0); 1020public: 1021 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1022}; 1023 1024template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value> 1025struct __void_pointer 1026{ 1027 typedef typename _Alloc::void_pointer type; 1028}; 1029 1030template <class _Ptr, class _Alloc> 1031struct __void_pointer<_Ptr, _Alloc, false> 1032{ 1033#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1034 typedef typename pointer_traits<_Ptr>::template rebind<void> type; 1035#else 1036 typedef typename pointer_traits<_Ptr>::template rebind<void>::other type; 1037#endif 1038}; 1039 1040template <class _Tp> 1041struct __has_const_void_pointer 1042{ 1043private: 1044 struct __two {char _; char __;}; 1045 template <class _Up> static __two __test(...); 1046 template <class _Up> static char __test(typename _Up::const_void_pointer* = 0); 1047public: 1048 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1049}; 1050 1051template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value> 1052struct __const_void_pointer 1053{ 1054 typedef typename _Alloc::const_void_pointer type; 1055}; 1056 1057template <class _Ptr, class _Alloc> 1058struct __const_void_pointer<_Ptr, _Alloc, false> 1059{ 1060#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1061 typedef typename pointer_traits<_Ptr>::template rebind<const void> type; 1062#else 1063 typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type; 1064#endif 1065}; 1066 1067template <class _Tp> 1068inline _LIBCPP_INLINE_VISIBILITY 1069_Tp* 1070__to_raw_pointer(_Tp* __p) _NOEXCEPT 1071{ 1072 return __p; 1073} 1074 1075template <class _Pointer> 1076inline _LIBCPP_INLINE_VISIBILITY 1077typename pointer_traits<_Pointer>::element_type* 1078__to_raw_pointer(_Pointer __p) _NOEXCEPT 1079{ 1080 return _VSTD::__to_raw_pointer(__p.operator->()); 1081} 1082 1083template <class _Tp> 1084struct __has_size_type 1085{ 1086private: 1087 struct __two {char _; char __;}; 1088 template <class _Up> static __two __test(...); 1089 template <class _Up> static char __test(typename _Up::size_type* = 0); 1090public: 1091 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1092}; 1093 1094template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value> 1095struct __size_type 1096{ 1097 typedef typename make_unsigned<_DiffType>::type type; 1098}; 1099 1100template <class _Alloc, class _DiffType> 1101struct __size_type<_Alloc, _DiffType, true> 1102{ 1103 typedef typename _Alloc::size_type type; 1104}; 1105 1106template <class _Tp> 1107struct __has_propagate_on_container_copy_assignment 1108{ 1109private: 1110 struct __two {char _; char __;}; 1111 template <class _Up> static __two __test(...); 1112 template <class _Up> static char __test(typename _Up::propagate_on_container_copy_assignment* = 0); 1113public: 1114 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1115}; 1116 1117template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value> 1118struct __propagate_on_container_copy_assignment 1119{ 1120 typedef false_type type; 1121}; 1122 1123template <class _Alloc> 1124struct __propagate_on_container_copy_assignment<_Alloc, true> 1125{ 1126 typedef typename _Alloc::propagate_on_container_copy_assignment type; 1127}; 1128 1129template <class _Tp> 1130struct __has_propagate_on_container_move_assignment 1131{ 1132private: 1133 struct __two {char _; char __;}; 1134 template <class _Up> static __two __test(...); 1135 template <class _Up> static char __test(typename _Up::propagate_on_container_move_assignment* = 0); 1136public: 1137 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1138}; 1139 1140template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value> 1141struct __propagate_on_container_move_assignment 1142{ 1143 typedef false_type type; 1144}; 1145 1146template <class _Alloc> 1147struct __propagate_on_container_move_assignment<_Alloc, true> 1148{ 1149 typedef typename _Alloc::propagate_on_container_move_assignment type; 1150}; 1151 1152template <class _Tp> 1153struct __has_propagate_on_container_swap 1154{ 1155private: 1156 struct __two {char _; char __;}; 1157 template <class _Up> static __two __test(...); 1158 template <class _Up> static char __test(typename _Up::propagate_on_container_swap* = 0); 1159public: 1160 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1161}; 1162 1163template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value> 1164struct __propagate_on_container_swap 1165{ 1166 typedef false_type type; 1167}; 1168 1169template <class _Alloc> 1170struct __propagate_on_container_swap<_Alloc, true> 1171{ 1172 typedef typename _Alloc::propagate_on_container_swap type; 1173}; 1174 1175template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> 1176struct __has_rebind_other 1177{ 1178private: 1179 struct __two {char _; char __;}; 1180 template <class _Xp> static __two __test(...); 1181 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0); 1182public: 1183 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1184}; 1185 1186template <class _Tp, class _Up> 1187struct __has_rebind_other<_Tp, _Up, false> 1188{ 1189 static const bool value = false; 1190}; 1191 1192template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value> 1193struct __allocator_traits_rebind 1194{ 1195 typedef typename _Tp::template rebind<_Up>::other type; 1196}; 1197 1198#ifndef _LIBCPP_HAS_NO_VARIADICS 1199 1200template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> 1201struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> 1202{ 1203 typedef typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type; 1204}; 1205 1206template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> 1207struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> 1208{ 1209 typedef _Alloc<_Up, _Args...> type; 1210}; 1211 1212#else // _LIBCPP_HAS_NO_VARIADICS 1213 1214template <template <class> class _Alloc, class _Tp, class _Up> 1215struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, true> 1216{ 1217 typedef typename _Alloc<_Tp>::template rebind<_Up>::other type; 1218}; 1219 1220template <template <class> class _Alloc, class _Tp, class _Up> 1221struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, false> 1222{ 1223 typedef _Alloc<_Up> type; 1224}; 1225 1226template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up> 1227struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, true> 1228{ 1229 typedef typename _Alloc<_Tp, _A0>::template rebind<_Up>::other type; 1230}; 1231 1232template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up> 1233struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, false> 1234{ 1235 typedef _Alloc<_Up, _A0> type; 1236}; 1237 1238template <template <class, class, class> class _Alloc, class _Tp, class _A0, 1239 class _A1, class _Up> 1240struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, true> 1241{ 1242 typedef typename _Alloc<_Tp, _A0, _A1>::template rebind<_Up>::other type; 1243}; 1244 1245template <template <class, class, class> class _Alloc, class _Tp, class _A0, 1246 class _A1, class _Up> 1247struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, false> 1248{ 1249 typedef _Alloc<_Up, _A0, _A1> type; 1250}; 1251 1252template <template <class, class, class, class> class _Alloc, class _Tp, class _A0, 1253 class _A1, class _A2, class _Up> 1254struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, true> 1255{ 1256 typedef typename _Alloc<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type; 1257}; 1258 1259template <template <class, class, class, class> class _Alloc, class _Tp, class _A0, 1260 class _A1, class _A2, class _Up> 1261struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false> 1262{ 1263 typedef _Alloc<_Up, _A0, _A1, _A2> type; 1264}; 1265 1266#endif // _LIBCPP_HAS_NO_VARIADICS 1267 1268#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE 1269 1270template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1271auto 1272__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) 1273 -> decltype(__a.allocate(__sz, __p), true_type()); 1274 1275template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1276auto 1277__has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) 1278 -> false_type; 1279 1280template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1281struct __has_allocate_hint 1282 : integral_constant<bool, 1283 is_same< 1284 decltype(__has_allocate_hint_test(declval<_Alloc>(), 1285 declval<_SizeType>(), 1286 declval<_ConstVoidPtr>())), 1287 true_type>::value> 1288{ 1289}; 1290 1291#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1292 1293template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1294struct __has_allocate_hint 1295 : true_type 1296{ 1297}; 1298 1299#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1300 1301#if !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1302 1303template <class _Alloc, class _Tp, class ..._Args> 1304decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(), 1305 _VSTD::declval<_Args>()...), 1306 true_type()) 1307__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args); 1308 1309template <class _Alloc, class _Pointer, class ..._Args> 1310false_type 1311__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args); 1312 1313template <class _Alloc, class _Pointer, class ..._Args> 1314struct __has_construct 1315 : integral_constant<bool, 1316 is_same< 1317 decltype(__has_construct_test(declval<_Alloc>(), 1318 declval<_Pointer>(), 1319 declval<_Args>()...)), 1320 true_type>::value> 1321{ 1322}; 1323 1324template <class _Alloc, class _Pointer> 1325auto 1326__has_destroy_test(_Alloc&& __a, _Pointer&& __p) 1327 -> decltype(__a.destroy(__p), true_type()); 1328 1329template <class _Alloc, class _Pointer> 1330auto 1331__has_destroy_test(const _Alloc& __a, _Pointer&& __p) 1332 -> false_type; 1333 1334template <class _Alloc, class _Pointer> 1335struct __has_destroy 1336 : integral_constant<bool, 1337 is_same< 1338 decltype(__has_destroy_test(declval<_Alloc>(), 1339 declval<_Pointer>())), 1340 true_type>::value> 1341{ 1342}; 1343 1344template <class _Alloc> 1345auto 1346__has_max_size_test(_Alloc&& __a) 1347 -> decltype(__a.max_size(), true_type()); 1348 1349template <class _Alloc> 1350auto 1351__has_max_size_test(const volatile _Alloc& __a) 1352 -> false_type; 1353 1354template <class _Alloc> 1355struct __has_max_size 1356 : integral_constant<bool, 1357 is_same< 1358 decltype(__has_max_size_test(declval<_Alloc&>())), 1359 true_type>::value> 1360{ 1361}; 1362 1363template <class _Alloc> 1364auto 1365__has_select_on_container_copy_construction_test(_Alloc&& __a) 1366 -> decltype(__a.select_on_container_copy_construction(), true_type()); 1367 1368template <class _Alloc> 1369auto 1370__has_select_on_container_copy_construction_test(const volatile _Alloc& __a) 1371 -> false_type; 1372 1373template <class _Alloc> 1374struct __has_select_on_container_copy_construction 1375 : integral_constant<bool, 1376 is_same< 1377 decltype(__has_select_on_container_copy_construction_test(declval<_Alloc&>())), 1378 true_type>::value> 1379{ 1380}; 1381 1382#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1383 1384#ifndef _LIBCPP_HAS_NO_VARIADICS 1385 1386template <class _Alloc, class _Pointer, class ..._Args> 1387struct __has_construct 1388 : false_type 1389{ 1390}; 1391 1392#endif // _LIBCPP_HAS_NO_VARIADICS 1393 1394template <class _Alloc, class _Pointer> 1395struct __has_destroy 1396 : false_type 1397{ 1398}; 1399 1400template <class _Alloc> 1401struct __has_max_size 1402 : true_type 1403{ 1404}; 1405 1406template <class _Alloc> 1407struct __has_select_on_container_copy_construction 1408 : false_type 1409{ 1410}; 1411 1412#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1413 1414template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value> 1415struct __alloc_traits_difference_type 1416{ 1417 typedef typename pointer_traits<_Ptr>::difference_type type; 1418}; 1419 1420template <class _Alloc, class _Ptr> 1421struct __alloc_traits_difference_type<_Alloc, _Ptr, true> 1422{ 1423 typedef typename _Alloc::difference_type type; 1424}; 1425 1426template <class _Alloc> 1427struct _LIBCPP_VISIBLE allocator_traits 1428{ 1429 typedef _Alloc allocator_type; 1430 typedef typename allocator_type::value_type value_type; 1431 1432 typedef typename __pointer_type<value_type, allocator_type>::type pointer; 1433 typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer; 1434 typedef typename __void_pointer<pointer, allocator_type>::type void_pointer; 1435 typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer; 1436 1437 typedef typename __alloc_traits_difference_type<allocator_type, pointer>::type difference_type; 1438 typedef typename __size_type<allocator_type, difference_type>::type size_type; 1439 1440 typedef typename __propagate_on_container_copy_assignment<allocator_type>::type 1441 propagate_on_container_copy_assignment; 1442 typedef typename __propagate_on_container_move_assignment<allocator_type>::type 1443 propagate_on_container_move_assignment; 1444 typedef typename __propagate_on_container_swap<allocator_type>::type 1445 propagate_on_container_swap; 1446 1447#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1448 template <class _Tp> using rebind_alloc = 1449 typename __allocator_traits_rebind<allocator_type, _Tp>::type; 1450 template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>; 1451#else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1452 template <class _Tp> struct rebind_alloc 1453 {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;}; 1454 template <class _Tp> struct rebind_traits 1455 {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;}; 1456#endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1457 1458 _LIBCPP_INLINE_VISIBILITY 1459 static pointer allocate(allocator_type& __a, size_type __n) 1460 {return __a.allocate(__n);} 1461 _LIBCPP_INLINE_VISIBILITY 1462 static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) 1463 {return allocate(__a, __n, __hint, 1464 __has_allocate_hint<allocator_type, size_type, const_void_pointer>());} 1465 1466 _LIBCPP_INLINE_VISIBILITY 1467 static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT 1468 {__a.deallocate(__p, __n);} 1469 1470#ifndef _LIBCPP_HAS_NO_VARIADICS 1471 template <class _Tp, class... _Args> 1472 _LIBCPP_INLINE_VISIBILITY 1473 static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) 1474 {__construct(__has_construct<allocator_type, pointer, _Args...>(), 1475 __a, __p, _VSTD::forward<_Args>(__args)...);} 1476#else // _LIBCPP_HAS_NO_VARIADICS 1477 template <class _Tp> 1478 _LIBCPP_INLINE_VISIBILITY 1479 static void construct(allocator_type& __a, _Tp* __p) 1480 { 1481 ::new ((void*)__p) _Tp(); 1482 } 1483 template <class _Tp, class _A0> 1484 _LIBCPP_INLINE_VISIBILITY 1485 static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0) 1486 { 1487 ::new ((void*)__p) _Tp(__a0); 1488 } 1489 template <class _Tp, class _A0, class _A1> 1490 _LIBCPP_INLINE_VISIBILITY 1491 static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0, 1492 const _A1& __a1) 1493 { 1494 ::new ((void*)__p) _Tp(__a0, __a1); 1495 } 1496 template <class _Tp, class _A0, class _A1, class _A2> 1497 _LIBCPP_INLINE_VISIBILITY 1498 static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0, 1499 const _A1& __a1, const _A2& __a2) 1500 { 1501 ::new ((void*)__p) _Tp(__a0, __a1, __a2); 1502 } 1503#endif // _LIBCPP_HAS_NO_VARIADICS 1504 1505 template <class _Tp> 1506 _LIBCPP_INLINE_VISIBILITY 1507 static void destroy(allocator_type& __a, _Tp* __p) 1508 {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);} 1509 1510 _LIBCPP_INLINE_VISIBILITY 1511 static size_type max_size(const allocator_type& __a) 1512 {return __max_size(__has_max_size<const allocator_type>(), __a);} 1513 1514 _LIBCPP_INLINE_VISIBILITY 1515 static allocator_type 1516 select_on_container_copy_construction(const allocator_type& __a) 1517 {return select_on_container_copy_construction( 1518 __has_select_on_container_copy_construction<const allocator_type>(), 1519 __a);} 1520 1521private: 1522 1523 _LIBCPP_INLINE_VISIBILITY 1524 static pointer allocate(allocator_type& __a, size_type __n, 1525 const_void_pointer __hint, true_type) 1526 {return __a.allocate(__n, __hint);} 1527 _LIBCPP_INLINE_VISIBILITY 1528 static pointer allocate(allocator_type& __a, size_type __n, 1529 const_void_pointer, false_type) 1530 {return __a.allocate(__n);} 1531 1532#ifndef _LIBCPP_HAS_NO_VARIADICS 1533 template <class _Tp, class... _Args> 1534 _LIBCPP_INLINE_VISIBILITY 1535 static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args) 1536 {__a.construct(__p, _VSTD::forward<_Args>(__args)...);} 1537 template <class _Tp, class... _Args> 1538 _LIBCPP_INLINE_VISIBILITY 1539 static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args) 1540 { 1541 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); 1542 } 1543#endif // _LIBCPP_HAS_NO_VARIADICS 1544 1545 template <class _Tp> 1546 _LIBCPP_INLINE_VISIBILITY 1547 static void __destroy(true_type, allocator_type& __a, _Tp* __p) 1548 {__a.destroy(__p);} 1549 template <class _Tp> 1550 _LIBCPP_INLINE_VISIBILITY 1551 static void __destroy(false_type, allocator_type&, _Tp* __p) 1552 { 1553 __p->~_Tp(); 1554 } 1555 1556 _LIBCPP_INLINE_VISIBILITY 1557 static size_type __max_size(true_type, const allocator_type& __a) 1558 {return __a.max_size();} 1559 _LIBCPP_INLINE_VISIBILITY 1560 static size_type __max_size(false_type, const allocator_type&) 1561 {return numeric_limits<size_type>::max();} 1562 1563 _LIBCPP_INLINE_VISIBILITY 1564 static allocator_type 1565 select_on_container_copy_construction(true_type, const allocator_type& __a) 1566 {return __a.select_on_container_copy_construction();} 1567 _LIBCPP_INLINE_VISIBILITY 1568 static allocator_type 1569 select_on_container_copy_construction(false_type, const allocator_type& __a) 1570 {return __a;} 1571}; 1572 1573// uses_allocator 1574 1575template <class _Tp> 1576struct __has_allocator_type 1577{ 1578private: 1579 struct __two {char _; char __;}; 1580 template <class _Up> static __two __test(...); 1581 template <class _Up> static char __test(typename _Up::allocator_type* = 0); 1582public: 1583 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1584}; 1585 1586template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value> 1587struct __uses_allocator 1588 : public integral_constant<bool, 1589 is_convertible<_Alloc, typename _Tp::allocator_type>::value> 1590{ 1591}; 1592 1593template <class _Tp, class _Alloc> 1594struct __uses_allocator<_Tp, _Alloc, false> 1595 : public false_type 1596{ 1597}; 1598 1599template <class _Tp, class _Alloc> 1600struct _LIBCPP_VISIBLE uses_allocator 1601 : public __uses_allocator<_Tp, _Alloc> 1602{ 1603}; 1604 1605#ifndef _LIBCPP_HAS_NO_VARIADICS 1606 1607// uses-allocator construction 1608 1609template <class _Tp, class _Alloc, class ..._Args> 1610struct __uses_alloc_ctor_imp 1611{ 1612 static const bool __ua = uses_allocator<_Tp, _Alloc>::value; 1613 static const bool __ic = 1614 is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; 1615 static const int value = __ua ? 2 - __ic : 0; 1616}; 1617 1618template <class _Tp, class _Alloc, class ..._Args> 1619struct __uses_alloc_ctor 1620 : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value> 1621 {}; 1622 1623#endif // _LIBCPP_HAS_NO_VARIADICS 1624 1625// allocator 1626 1627template <class _Tp> 1628class _LIBCPP_VISIBLE allocator 1629{ 1630public: 1631 typedef size_t size_type; 1632 typedef ptrdiff_t difference_type; 1633 typedef _Tp* pointer; 1634 typedef const _Tp* const_pointer; 1635 typedef _Tp& reference; 1636 typedef const _Tp& const_reference; 1637 typedef _Tp value_type; 1638 1639 typedef true_type propagate_on_container_move_assignment; 1640 1641 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 1642 1643 _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {} 1644 template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {} 1645 _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT 1646 {return _VSTD::addressof(__x);} 1647 _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT 1648 {return _VSTD::addressof(__x);} 1649 _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0) 1650 {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));} 1651 _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT 1652 {::operator delete((void*)__p);} 1653 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT 1654 {return size_type(~0) / sizeof(_Tp);} 1655#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1656 template <class _Up, class... _Args> 1657 _LIBCPP_INLINE_VISIBILITY 1658 void 1659 construct(_Up* __p, _Args&&... __args) 1660 { 1661 ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); 1662 } 1663#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1664 _LIBCPP_INLINE_VISIBILITY 1665 void 1666 construct(pointer __p) 1667 { 1668 ::new((void*)__p) _Tp(); 1669 } 1670# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1671 template <class _A0> 1672 _LIBCPP_INLINE_VISIBILITY 1673 typename enable_if 1674 < 1675 !is_convertible<_A0, __rv<_A0> >::value, 1676 void 1677 >::type 1678 construct(pointer __p, _A0& __a0) 1679 { 1680 ::new((void*)__p) _Tp(__a0); 1681 } 1682 template <class _A0> 1683 _LIBCPP_INLINE_VISIBILITY 1684 typename enable_if 1685 < 1686 !is_convertible<_A0, __rv<_A0> >::value, 1687 void 1688 >::type 1689 construct(pointer __p, const _A0& __a0) 1690 { 1691 ::new((void*)__p) _Tp(__a0); 1692 } 1693 template <class _A0> 1694 _LIBCPP_INLINE_VISIBILITY 1695 typename enable_if 1696 < 1697 is_convertible<_A0, __rv<_A0> >::value, 1698 void 1699 >::type 1700 construct(pointer __p, _A0 __a0) 1701 { 1702 ::new((void*)__p) _Tp(_VSTD::move(__a0)); 1703 } 1704# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1705 template <class _A0, class _A1> 1706 _LIBCPP_INLINE_VISIBILITY 1707 void 1708 construct(pointer __p, _A0& __a0, _A1& __a1) 1709 { 1710 ::new((void*)__p) _Tp(__a0, __a1); 1711 } 1712 template <class _A0, class _A1> 1713 _LIBCPP_INLINE_VISIBILITY 1714 void 1715 construct(pointer __p, const _A0& __a0, _A1& __a1) 1716 { 1717 ::new((void*)__p) _Tp(__a0, __a1); 1718 } 1719 template <class _A0, class _A1> 1720 _LIBCPP_INLINE_VISIBILITY 1721 void 1722 construct(pointer __p, _A0& __a0, const _A1& __a1) 1723 { 1724 ::new((void*)__p) _Tp(__a0, __a1); 1725 } 1726 template <class _A0, class _A1> 1727 _LIBCPP_INLINE_VISIBILITY 1728 void 1729 construct(pointer __p, const _A0& __a0, const _A1& __a1) 1730 { 1731 ::new((void*)__p) _Tp(__a0, __a1); 1732 } 1733#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1734 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} 1735}; 1736 1737template <class _Tp, class _Up> 1738inline _LIBCPP_INLINE_VISIBILITY 1739bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;} 1740 1741template <class _Tp, class _Up> 1742inline _LIBCPP_INLINE_VISIBILITY 1743bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;} 1744 1745template <class _OutputIterator, class _Tp> 1746class _LIBCPP_VISIBLE raw_storage_iterator 1747 : public iterator<output_iterator_tag, 1748 _Tp, // purposefully not C++03 1749 ptrdiff_t, // purposefully not C++03 1750 _Tp*, // purposefully not C++03 1751 raw_storage_iterator<_OutputIterator, _Tp>&> // purposefully not C++03 1752{ 1753private: 1754 _OutputIterator __x_; 1755public: 1756 _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {} 1757 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;} 1758 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element) 1759 {::new(&*__x_) _Tp(__element); return *this;} 1760 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;} 1761 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator operator++(int) 1762 {raw_storage_iterator __t(*this); ++__x_; return __t;} 1763}; 1764 1765template <class _Tp> 1766pair<_Tp*, ptrdiff_t> 1767get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT 1768{ 1769 pair<_Tp*, ptrdiff_t> __r(0, 0); 1770 const ptrdiff_t __m = (~ptrdiff_t(0) ^ 1771 ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1))) 1772 / sizeof(_Tp); 1773 if (__n > __m) 1774 __n = __m; 1775 while (__n > 0) 1776 { 1777 __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow)); 1778 if (__r.first) 1779 { 1780 __r.second = __n; 1781 break; 1782 } 1783 __n /= 2; 1784 } 1785 return __r; 1786} 1787 1788template <class _Tp> 1789inline _LIBCPP_INLINE_VISIBILITY 1790void return_temporary_buffer(_Tp* __p) _NOEXCEPT {::operator delete(__p);} 1791 1792template <class _Tp> 1793struct auto_ptr_ref 1794{ 1795 _Tp* __ptr_; 1796}; 1797 1798template<class _Tp> 1799class _LIBCPP_VISIBLE auto_ptr 1800{ 1801private: 1802 _Tp* __ptr_; 1803public: 1804 typedef _Tp element_type; 1805 1806 _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {} 1807 _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {} 1808 template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) throw() 1809 : __ptr_(__p.release()) {} 1810 _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) throw() 1811 {reset(__p.release()); return *this;} 1812 template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) throw() 1813 {reset(__p.release()); return *this;} 1814 _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) throw() 1815 {reset(__p.__ptr_); return *this;} 1816 _LIBCPP_INLINE_VISIBILITY ~auto_ptr() throw() {delete __ptr_;} 1817 1818 _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const throw() 1819 {return *__ptr_;} 1820 _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const throw() {return __ptr_;} 1821 _LIBCPP_INLINE_VISIBILITY _Tp* get() const throw() {return __ptr_;} 1822 _LIBCPP_INLINE_VISIBILITY _Tp* release() throw() 1823 { 1824 _Tp* __t = __ptr_; 1825 __ptr_ = 0; 1826 return __t; 1827 } 1828 _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) throw() 1829 { 1830 if (__ptr_ != __p) 1831 delete __ptr_; 1832 __ptr_ = __p; 1833 } 1834 1835 _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {} 1836 template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() throw() 1837 {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;} 1838 template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() throw() 1839 {return auto_ptr<_Up>(release());} 1840}; 1841 1842template <> 1843class _LIBCPP_VISIBLE auto_ptr<void> 1844{ 1845public: 1846 typedef void element_type; 1847}; 1848 1849template <class _T1, class _T2, bool = is_same<typename remove_cv<_T1>::type, 1850 typename remove_cv<_T2>::type>::value, 1851 bool = is_empty<_T1>::value 1852#if __has_feature(is_final) 1853 && !__is_final(_T1) 1854#endif 1855 , 1856 bool = is_empty<_T2>::value 1857#if __has_feature(is_final) 1858 && !__is_final(_T2) 1859#endif 1860 > 1861struct __libcpp_compressed_pair_switch; 1862 1863template <class _T1, class _T2, bool IsSame> 1864struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, false, false> {enum {value = 0};}; 1865 1866template <class _T1, class _T2, bool IsSame> 1867struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, true, false> {enum {value = 1};}; 1868 1869template <class _T1, class _T2, bool IsSame> 1870struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, false, true> {enum {value = 2};}; 1871 1872template <class _T1, class _T2> 1873struct __libcpp_compressed_pair_switch<_T1, _T2, false, true, true> {enum {value = 3};}; 1874 1875template <class _T1, class _T2> 1876struct __libcpp_compressed_pair_switch<_T1, _T2, true, true, true> {enum {value = 1};}; 1877 1878template <class _T1, class _T2, unsigned = __libcpp_compressed_pair_switch<_T1, _T2>::value> 1879class __libcpp_compressed_pair_imp; 1880 1881template <class _T1, class _T2> 1882class __libcpp_compressed_pair_imp<_T1, _T2, 0> 1883{ 1884private: 1885 _T1 __first_; 1886 _T2 __second_; 1887public: 1888 typedef _T1 _T1_param; 1889 typedef _T2 _T2_param; 1890 1891 typedef typename remove_reference<_T1>::type& _T1_reference; 1892 typedef typename remove_reference<_T2>::type& _T2_reference; 1893 1894 typedef const typename remove_reference<_T1>::type& _T1_const_reference; 1895 typedef const typename remove_reference<_T2>::type& _T2_const_reference; 1896 1897 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 1898 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0) 1899 : __first_(_VSTD::forward<_T1_param>(__t1)) {} 1900 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0) 1901 : __second_(_VSTD::forward<_T2_param>(__t2)) {} 1902 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 1903 : __first_(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {} 1904 1905#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 1906 1907 _LIBCPP_INLINE_VISIBILITY 1908 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 1909 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 1910 is_nothrow_copy_constructible<_T2>::value) 1911 : __first_(__p.first()), 1912 __second_(__p.second()) {} 1913 1914 _LIBCPP_INLINE_VISIBILITY 1915 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 1916 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 1917 is_nothrow_copy_assignable<_T2>::value) 1918 { 1919 __first_ = __p.first(); 1920 __second_ = __p.second(); 1921 return *this; 1922 } 1923 1924#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1925 1926 _LIBCPP_INLINE_VISIBILITY 1927 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 1928 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 1929 is_nothrow_move_constructible<_T2>::value) 1930 : __first_(_VSTD::forward<_T1>(__p.first())), 1931 __second_(_VSTD::forward<_T2>(__p.second())) {} 1932 1933 _LIBCPP_INLINE_VISIBILITY 1934 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 1935 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 1936 is_nothrow_move_assignable<_T2>::value) 1937 { 1938 __first_ = _VSTD::forward<_T1>(__p.first()); 1939 __second_ = _VSTD::forward<_T2>(__p.second()); 1940 return *this; 1941 } 1942 1943#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1944 1945#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 1946 1947 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return __first_;} 1948 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;} 1949 1950 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return __second_;} 1951 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return __second_;} 1952 1953 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x) 1954 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 1955 __is_nothrow_swappable<_T1>::value) 1956 { 1957 using _VSTD::swap; 1958 swap(__first_, __x.__first_); 1959 swap(__second_, __x.__second_); 1960 } 1961}; 1962 1963template <class _T1, class _T2> 1964class __libcpp_compressed_pair_imp<_T1, _T2, 1> 1965 : private _T1 1966{ 1967private: 1968 _T2 __second_; 1969public: 1970 typedef _T1 _T1_param; 1971 typedef _T2 _T2_param; 1972 1973 typedef _T1& _T1_reference; 1974 typedef typename remove_reference<_T2>::type& _T2_reference; 1975 1976 typedef const _T1& _T1_const_reference; 1977 typedef const typename remove_reference<_T2>::type& _T2_const_reference; 1978 1979 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 1980 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0) 1981 : _T1(_VSTD::forward<_T1_param>(__t1)) {} 1982 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0) 1983 : __second_(_VSTD::forward<_T2_param>(__t2)) {} 1984 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 1985 : _T1(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {} 1986 1987#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 1988 1989 _LIBCPP_INLINE_VISIBILITY 1990 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 1991 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 1992 is_nothrow_copy_constructible<_T2>::value) 1993 : _T1(__p.first()), __second_(__p.second()) {} 1994 1995 _LIBCPP_INLINE_VISIBILITY 1996 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 1997 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 1998 is_nothrow_copy_assignable<_T2>::value) 1999 { 2000 _T1::operator=(__p.first()); 2001 __second_ = __p.second(); 2002 return *this; 2003 } 2004 2005#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2006 2007 _LIBCPP_INLINE_VISIBILITY 2008 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 2009 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2010 is_nothrow_move_constructible<_T2>::value) 2011 : _T1(_VSTD::move(__p.first())), __second_(_VSTD::forward<_T2>(__p.second())) {} 2012 2013 _LIBCPP_INLINE_VISIBILITY 2014 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 2015 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2016 is_nothrow_move_assignable<_T2>::value) 2017 { 2018 _T1::operator=(_VSTD::move(__p.first())); 2019 __second_ = _VSTD::forward<_T2>(__p.second()); 2020 return *this; 2021 } 2022 2023#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2024 2025#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2026 2027 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return *this;} 2028 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;} 2029 2030 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return __second_;} 2031 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return __second_;} 2032 2033 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x) 2034 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2035 __is_nothrow_swappable<_T1>::value) 2036 { 2037 using _VSTD::swap; 2038 swap(__second_, __x.__second_); 2039 } 2040}; 2041 2042template <class _T1, class _T2> 2043class __libcpp_compressed_pair_imp<_T1, _T2, 2> 2044 : private _T2 2045{ 2046private: 2047 _T1 __first_; 2048public: 2049 typedef _T1 _T1_param; 2050 typedef _T2 _T2_param; 2051 2052 typedef typename remove_reference<_T1>::type& _T1_reference; 2053 typedef _T2& _T2_reference; 2054 2055 typedef const typename remove_reference<_T1>::type& _T1_const_reference; 2056 typedef const _T2& _T2_const_reference; 2057 2058 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 2059 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) 2060 : __first_(_VSTD::forward<_T1_param>(__t1)) {} 2061 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) 2062 : _T2(_VSTD::forward<_T2_param>(__t2)) {} 2063 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 2064 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2065 is_nothrow_move_constructible<_T2>::value) 2066 : _T2(_VSTD::forward<_T2_param>(__t2)), __first_(_VSTD::forward<_T1_param>(__t1)) {} 2067 2068#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2069 2070 _LIBCPP_INLINE_VISIBILITY 2071 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 2072 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2073 is_nothrow_copy_constructible<_T2>::value) 2074 : _T2(__p.second()), __first_(__p.first()) {} 2075 2076 _LIBCPP_INLINE_VISIBILITY 2077 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 2078 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2079 is_nothrow_copy_assignable<_T2>::value) 2080 { 2081 _T2::operator=(__p.second()); 2082 __first_ = __p.first(); 2083 return *this; 2084 } 2085 2086#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2087 2088 _LIBCPP_INLINE_VISIBILITY 2089 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 2090 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2091 is_nothrow_move_constructible<_T2>::value) 2092 : _T2(_VSTD::forward<_T2>(__p.second())), __first_(_VSTD::move(__p.first())) {} 2093 2094 _LIBCPP_INLINE_VISIBILITY 2095 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 2096 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2097 is_nothrow_move_assignable<_T2>::value) 2098 { 2099 _T2::operator=(_VSTD::forward<_T2>(__p.second())); 2100 __first_ = _VSTD::move(__p.first()); 2101 return *this; 2102 } 2103 2104#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2105 2106#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2107 2108 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return __first_;} 2109 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;} 2110 2111 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return *this;} 2112 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return *this;} 2113 2114 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x) 2115 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2116 __is_nothrow_swappable<_T1>::value) 2117 { 2118 using _VSTD::swap; 2119 swap(__first_, __x.__first_); 2120 } 2121}; 2122 2123template <class _T1, class _T2> 2124class __libcpp_compressed_pair_imp<_T1, _T2, 3> 2125 : private _T1, 2126 private _T2 2127{ 2128public: 2129 typedef _T1 _T1_param; 2130 typedef _T2 _T2_param; 2131 2132 typedef _T1& _T1_reference; 2133 typedef _T2& _T2_reference; 2134 2135 typedef const _T1& _T1_const_reference; 2136 typedef const _T2& _T2_const_reference; 2137 2138 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 2139 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) 2140 : _T1(_VSTD::forward<_T1_param>(__t1)) {} 2141 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) 2142 : _T2(_VSTD::forward<_T2_param>(__t2)) {} 2143 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 2144 : _T1(_VSTD::forward<_T1_param>(__t1)), _T2(_VSTD::forward<_T2_param>(__t2)) {} 2145 2146#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2147 2148 _LIBCPP_INLINE_VISIBILITY 2149 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 2150 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2151 is_nothrow_copy_constructible<_T2>::value) 2152 : _T1(__p.first()), _T2(__p.second()) {} 2153 2154 _LIBCPP_INLINE_VISIBILITY 2155 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 2156 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2157 is_nothrow_copy_assignable<_T2>::value) 2158 { 2159 _T1::operator=(__p.first()); 2160 _T2::operator=(__p.second()); 2161 return *this; 2162 } 2163 2164#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2165 2166 _LIBCPP_INLINE_VISIBILITY 2167 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 2168 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2169 is_nothrow_move_constructible<_T2>::value) 2170 : _T1(_VSTD::move(__p.first())), _T2(_VSTD::move(__p.second())) {} 2171 2172 _LIBCPP_INLINE_VISIBILITY 2173 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 2174 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2175 is_nothrow_move_assignable<_T2>::value) 2176 { 2177 _T1::operator=(_VSTD::move(__p.first())); 2178 _T2::operator=(_VSTD::move(__p.second())); 2179 return *this; 2180 } 2181 2182#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2183 2184#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2185 2186 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return *this;} 2187 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;} 2188 2189 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return *this;} 2190 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return *this;} 2191 2192 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp&) 2193 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2194 __is_nothrow_swappable<_T1>::value) 2195 { 2196 } 2197}; 2198 2199template <class _T1, class _T2> 2200class __compressed_pair 2201 : private __libcpp_compressed_pair_imp<_T1, _T2> 2202{ 2203 typedef __libcpp_compressed_pair_imp<_T1, _T2> base; 2204public: 2205 typedef typename base::_T1_param _T1_param; 2206 typedef typename base::_T2_param _T2_param; 2207 2208 typedef typename base::_T1_reference _T1_reference; 2209 typedef typename base::_T2_reference _T2_reference; 2210 2211 typedef typename base::_T1_const_reference _T1_const_reference; 2212 typedef typename base::_T2_const_reference _T2_const_reference; 2213 2214 _LIBCPP_INLINE_VISIBILITY __compressed_pair() {} 2215 _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T1_param __t1, int = 0) 2216 : base(_VSTD::forward<_T1_param>(__t1)) {} 2217 _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T2_param __t2, int* = 0) 2218 : base(_VSTD::forward<_T2_param>(__t2)) {} 2219 _LIBCPP_INLINE_VISIBILITY __compressed_pair(_T1_param __t1, _T2_param __t2) 2220 : base(_VSTD::forward<_T1_param>(__t1), _VSTD::forward<_T2_param>(__t2)) {} 2221 2222#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2223 2224 _LIBCPP_INLINE_VISIBILITY 2225 __compressed_pair(const __compressed_pair& __p) 2226 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2227 is_nothrow_copy_constructible<_T2>::value) 2228 : base(__p) {} 2229 2230 _LIBCPP_INLINE_VISIBILITY 2231 __compressed_pair& operator=(const __compressed_pair& __p) 2232 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2233 is_nothrow_copy_assignable<_T2>::value) 2234 { 2235 base::operator=(__p); 2236 return *this; 2237 } 2238 2239#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2240 _LIBCPP_INLINE_VISIBILITY 2241 __compressed_pair(__compressed_pair&& __p) 2242 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2243 is_nothrow_move_constructible<_T2>::value) 2244 : base(_VSTD::move(__p)) {} 2245 2246 _LIBCPP_INLINE_VISIBILITY 2247 __compressed_pair& operator=(__compressed_pair&& __p) 2248 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2249 is_nothrow_move_assignable<_T2>::value) 2250 { 2251 base::operator=(_VSTD::move(__p)); 2252 return *this; 2253 } 2254#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2255 2256#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2257 2258 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return base::first();} 2259 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return base::first();} 2260 2261 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return base::second();} 2262 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return base::second();} 2263 2264 _LIBCPP_INLINE_VISIBILITY void swap(__compressed_pair& __x) 2265 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2266 __is_nothrow_swappable<_T1>::value) 2267 {base::swap(__x);} 2268}; 2269 2270template <class _T1, class _T2> 2271inline _LIBCPP_INLINE_VISIBILITY 2272void 2273swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y) 2274 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2275 __is_nothrow_swappable<_T1>::value) 2276 {__x.swap(__y);} 2277 2278template <class _Tp> 2279struct _LIBCPP_VISIBLE default_delete 2280{ 2281 _LIBCPP_INLINE_VISIBILITY default_delete() _NOEXCEPT {} 2282 template <class _Up> 2283 _LIBCPP_INLINE_VISIBILITY default_delete(const default_delete<_Up>&, 2284 typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {} 2285 _LIBCPP_INLINE_VISIBILITY void operator() (_Tp* __ptr) const _NOEXCEPT 2286 { 2287 static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type"); 2288 delete __ptr; 2289 } 2290}; 2291 2292template <class _Tp> 2293struct _LIBCPP_VISIBLE default_delete<_Tp[]> 2294{ 2295 _LIBCPP_INLINE_VISIBILITY void operator() (_Tp* __ptr) const _NOEXCEPT 2296 { 2297 static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type"); 2298 delete [] __ptr; 2299 } 2300private: 2301 template <class _Up> void operator() (_Up*) const; 2302}; 2303 2304template <class _Tp, class _Dp = default_delete<_Tp> > 2305class _LIBCPP_VISIBLE unique_ptr 2306{ 2307public: 2308 typedef _Tp element_type; 2309 typedef _Dp deleter_type; 2310 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2311private: 2312 __compressed_pair<pointer, deleter_type> __ptr_; 2313 2314#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2315 unique_ptr(const unique_ptr&); 2316 unique_ptr& operator=(const unique_ptr&); 2317 template <class _Up, class _Ep> 2318 unique_ptr(const unique_ptr<_Up, _Ep>&); 2319 template <class _Up, class _Ep> 2320 unique_ptr& operator=(const unique_ptr<_Up, _Ep>&); 2321#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2322 unique_ptr(unique_ptr&); 2323 template <class _Up, class _Ep> 2324 unique_ptr(unique_ptr<_Up, _Ep>&); 2325 unique_ptr& operator=(unique_ptr&); 2326 template <class _Up, class _Ep> 2327 unique_ptr& operator=(unique_ptr<_Up, _Ep>&); 2328#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2329 2330 struct __nat {int __for_bool_;}; 2331 2332 typedef typename remove_reference<deleter_type>::type& _Dp_reference; 2333 typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference; 2334public: 2335 _LIBCPP_INLINE_VISIBILITY unique_ptr() _NOEXCEPT 2336 : __ptr_(pointer()) 2337 { 2338 static_assert(!is_pointer<deleter_type>::value, 2339 "unique_ptr constructed with null function pointer deleter"); 2340 } 2341 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t) _NOEXCEPT 2342 : __ptr_(pointer()) 2343 { 2344 static_assert(!is_pointer<deleter_type>::value, 2345 "unique_ptr constructed with null function pointer deleter"); 2346 } 2347 _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) _NOEXCEPT 2348 : __ptr_(_VSTD::move(__p)) 2349 { 2350 static_assert(!is_pointer<deleter_type>::value, 2351 "unique_ptr constructed with null function pointer deleter"); 2352 } 2353 2354#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2355 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, typename conditional< 2356 is_reference<deleter_type>::value, 2357 deleter_type, 2358 typename add_lvalue_reference<const deleter_type>::type>::type __d) 2359 _NOEXCEPT 2360 : __ptr_(__p, __d) {} 2361 2362 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, typename remove_reference<deleter_type>::type&& __d) 2363 _NOEXCEPT 2364 : __ptr_(__p, _VSTD::move(__d)) 2365 { 2366 static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference"); 2367 } 2368 _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT 2369 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {} 2370 template <class _Up, class _Ep> 2371 _LIBCPP_INLINE_VISIBILITY 2372 unique_ptr(unique_ptr<_Up, _Ep>&& __u, 2373 typename enable_if 2374 < 2375 !is_array<_Up>::value && 2376 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value && 2377 is_convertible<_Ep, deleter_type>::value && 2378 ( 2379 !is_reference<deleter_type>::value || 2380 is_same<deleter_type, _Ep>::value 2381 ), 2382 __nat 2383 >::type = __nat()) _NOEXCEPT 2384 : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {} 2385 2386 template <class _Up> 2387 _LIBCPP_INLINE_VISIBILITY unique_ptr(auto_ptr<_Up>&& __p, 2388 typename enable_if< 2389 is_convertible<_Up*, _Tp*>::value && 2390 is_same<_Dp, default_delete<_Tp> >::value, 2391 __nat 2392 >::type = __nat()) _NOEXCEPT 2393 : __ptr_(__p.release()) 2394 { 2395 } 2396 2397 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT 2398 { 2399 reset(__u.release()); 2400 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2401 return *this; 2402 } 2403 2404 template <class _Up, class _Ep> 2405 _LIBCPP_INLINE_VISIBILITY 2406 typename enable_if 2407 < 2408 !is_array<_Up>::value, 2409 unique_ptr& 2410 >::type 2411 operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT 2412 { 2413 reset(__u.release()); 2414 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2415 return *this; 2416 } 2417#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2418 2419 _LIBCPP_INLINE_VISIBILITY operator __rv<unique_ptr>() 2420 { 2421 return __rv<unique_ptr>(*this); 2422 } 2423 2424 _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u) 2425 : __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2426 2427 template <class _Up, class _Ep> 2428 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr<_Up, _Ep> __u) 2429 { 2430 reset(__u.release()); 2431 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2432 return *this; 2433 } 2434 2435 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d) 2436 : __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {} 2437 2438 template <class _Up> 2439 _LIBCPP_INLINE_VISIBILITY 2440 typename enable_if< 2441 is_convertible<_Up*, _Tp*>::value && 2442 is_same<_Dp, default_delete<_Tp> >::value, 2443 unique_ptr& 2444 >::type 2445 operator=(auto_ptr<_Up> __p) 2446 {reset(__p.release()); return *this;} 2447 2448#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2449 _LIBCPP_INLINE_VISIBILITY ~unique_ptr() {reset();} 2450 2451 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(nullptr_t) _NOEXCEPT 2452 { 2453 reset(); 2454 return *this; 2455 } 2456 2457 _LIBCPP_INLINE_VISIBILITY typename add_lvalue_reference<_Tp>::type operator*() const 2458 {return *__ptr_.first();} 2459 _LIBCPP_INLINE_VISIBILITY pointer operator->() const _NOEXCEPT {return __ptr_.first();} 2460 _LIBCPP_INLINE_VISIBILITY pointer get() const _NOEXCEPT {return __ptr_.first();} 2461 _LIBCPP_INLINE_VISIBILITY _Dp_reference get_deleter() _NOEXCEPT 2462 {return __ptr_.second();} 2463 _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT 2464 {return __ptr_.second();} 2465 _LIBCPP_INLINE_VISIBILITY operator int __nat::*() const 2466 _NOEXCEPT 2467 {return __ptr_.first() ? &__nat::__for_bool_ : 0;} 2468 2469 _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT 2470 { 2471 pointer __t = __ptr_.first(); 2472 __ptr_.first() = pointer(); 2473 return __t; 2474 } 2475 2476 _LIBCPP_INLINE_VISIBILITY void reset(pointer __p = pointer()) _NOEXCEPT 2477 { 2478 pointer __tmp = __ptr_.first(); 2479 __ptr_.first() = __p; 2480 if (__tmp) 2481 __ptr_.second()(__tmp); 2482 } 2483 2484 _LIBCPP_INLINE_VISIBILITY void swap(unique_ptr& __u) _NOEXCEPT 2485 {__ptr_.swap(__u.__ptr_);} 2486}; 2487 2488template <class _Tp, class _Dp> 2489class _LIBCPP_VISIBLE unique_ptr<_Tp[], _Dp> 2490{ 2491public: 2492 typedef _Tp element_type; 2493 typedef _Dp deleter_type; 2494 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2495private: 2496 __compressed_pair<pointer, deleter_type> __ptr_; 2497 2498#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2499 unique_ptr(const unique_ptr&); 2500 unique_ptr& operator=(const unique_ptr&); 2501#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2502 unique_ptr(unique_ptr&); 2503 template <class _Up> 2504 unique_ptr(unique_ptr<_Up>&); 2505 unique_ptr& operator=(unique_ptr&); 2506 template <class _Up> 2507 unique_ptr& operator=(unique_ptr<_Up>&); 2508#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2509 2510 struct __nat {int __for_bool_;}; 2511 2512 typedef typename remove_reference<deleter_type>::type& _Dp_reference; 2513 typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference; 2514public: 2515 _LIBCPP_INLINE_VISIBILITY unique_ptr() _NOEXCEPT 2516 : __ptr_(pointer()) 2517 { 2518 static_assert(!is_pointer<deleter_type>::value, 2519 "unique_ptr constructed with null function pointer deleter"); 2520 } 2521 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t) _NOEXCEPT 2522 : __ptr_(pointer()) 2523 { 2524 static_assert(!is_pointer<deleter_type>::value, 2525 "unique_ptr constructed with null function pointer deleter"); 2526 } 2527#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2528 template <class _Pp, 2529 class = typename enable_if<is_same<_Pp, pointer>::value>::type 2530 > 2531 _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(_Pp __p) _NOEXCEPT 2532 : __ptr_(__p) 2533 { 2534 static_assert(!is_pointer<deleter_type>::value, 2535 "unique_ptr constructed with null function pointer deleter"); 2536 } 2537 2538 template <class _Pp, 2539 class = typename enable_if<is_same<_Pp, pointer>::value>::type 2540 > 2541 _LIBCPP_INLINE_VISIBILITY unique_ptr(_Pp __p, typename conditional< 2542 is_reference<deleter_type>::value, 2543 deleter_type, 2544 typename add_lvalue_reference<const deleter_type>::type>::type __d) 2545 _NOEXCEPT 2546 : __ptr_(__p, __d) {} 2547 2548 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, typename conditional< 2549 is_reference<deleter_type>::value, 2550 deleter_type, 2551 typename add_lvalue_reference<const deleter_type>::type>::type __d) 2552 _NOEXCEPT 2553 : __ptr_(pointer(), __d) {} 2554 2555 template <class _Pp, 2556 class = typename enable_if<is_same<_Pp, pointer>::value || 2557 is_same<_Pp, nullptr_t>::value>::type 2558 > 2559 _LIBCPP_INLINE_VISIBILITY unique_ptr(_Pp __p, typename remove_reference<deleter_type>::type&& __d) 2560 _NOEXCEPT 2561 : __ptr_(__p, _VSTD::move(__d)) 2562 { 2563 static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference"); 2564 } 2565 2566 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, typename remove_reference<deleter_type>::type&& __d) 2567 _NOEXCEPT 2568 : __ptr_(pointer(), _VSTD::move(__d)) 2569 { 2570 static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference"); 2571 } 2572 2573 _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT 2574 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {} 2575 2576 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT 2577 { 2578 reset(__u.release()); 2579 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2580 return *this; 2581 } 2582#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2583 2584 _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) 2585 : __ptr_(__p) 2586 { 2587 static_assert(!is_pointer<deleter_type>::value, 2588 "unique_ptr constructed with null function pointer deleter"); 2589 } 2590 2591 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d) 2592 : __ptr_(__p, _VSTD::forward<deleter_type>(__d)) {} 2593 2594 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, deleter_type __d) 2595 : __ptr_(pointer(), _VSTD::forward<deleter_type>(__d)) {} 2596 2597 _LIBCPP_INLINE_VISIBILITY operator __rv<unique_ptr>() 2598 { 2599 return __rv<unique_ptr>(*this); 2600 } 2601 2602 _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u) 2603 : __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2604 2605 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(__rv<unique_ptr> __u) 2606 { 2607 reset(__u->release()); 2608 __ptr_.second() = _VSTD::forward<deleter_type>(__u->get_deleter()); 2609 return *this; 2610 } 2611 2612#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2613 _LIBCPP_INLINE_VISIBILITY ~unique_ptr() {reset();} 2614 2615 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(nullptr_t) _NOEXCEPT 2616 { 2617 reset(); 2618 return *this; 2619 } 2620 2621 _LIBCPP_INLINE_VISIBILITY typename add_lvalue_reference<_Tp>::type operator[](size_t __i) const 2622 {return __ptr_.first()[__i];} 2623 _LIBCPP_INLINE_VISIBILITY pointer get() const _NOEXCEPT {return __ptr_.first();} 2624 _LIBCPP_INLINE_VISIBILITY _Dp_reference get_deleter() _NOEXCEPT 2625 {return __ptr_.second();} 2626 _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT 2627 {return __ptr_.second();} 2628 _LIBCPP_INLINE_VISIBILITY operator int __nat::*() const _NOEXCEPT 2629 {return __ptr_.first() ? &__nat::__for_bool_ : 0;} 2630 2631 _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT 2632 { 2633 pointer __t = __ptr_.first(); 2634 __ptr_.first() = pointer(); 2635 return __t; 2636 } 2637 2638#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2639 template <class _Pp, 2640 class = typename enable_if<is_same<_Pp, pointer>::value>::type 2641 > 2642 _LIBCPP_INLINE_VISIBILITY void reset(_Pp __p) _NOEXCEPT 2643 { 2644 pointer __tmp = __ptr_.first(); 2645 __ptr_.first() = __p; 2646 if (__tmp) 2647 __ptr_.second()(__tmp); 2648 } 2649 _LIBCPP_INLINE_VISIBILITY void reset(nullptr_t) _NOEXCEPT 2650 { 2651 pointer __tmp = __ptr_.first(); 2652 __ptr_.first() = nullptr; 2653 if (__tmp) 2654 __ptr_.second()(__tmp); 2655 } 2656 _LIBCPP_INLINE_VISIBILITY void reset() _NOEXCEPT 2657 { 2658 pointer __tmp = __ptr_.first(); 2659 __ptr_.first() = nullptr; 2660 if (__tmp) 2661 __ptr_.second()(__tmp); 2662 } 2663#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2664 _LIBCPP_INLINE_VISIBILITY void reset(pointer __p = pointer()) 2665 { 2666 pointer __tmp = __ptr_.first(); 2667 __ptr_.first() = __p; 2668 if (__tmp) 2669 __ptr_.second()(__tmp); 2670 } 2671#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2672 2673 _LIBCPP_INLINE_VISIBILITY void swap(unique_ptr& __u) {__ptr_.swap(__u.__ptr_);} 2674private: 2675 2676#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2677 template <class _Up> 2678 explicit unique_ptr(_Up); 2679 template <class _Up> 2680 unique_ptr(_Up __u, 2681 typename conditional< 2682 is_reference<deleter_type>::value, 2683 deleter_type, 2684 typename add_lvalue_reference<const deleter_type>::type>::type, 2685 typename enable_if 2686 < 2687 is_convertible<_Up, pointer>::value, 2688 __nat 2689 >::type = __nat()); 2690#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2691}; 2692 2693template <class _Tp, class _Dp> 2694inline _LIBCPP_INLINE_VISIBILITY 2695void 2696swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);} 2697 2698template <class _T1, class _D1, class _T2, class _D2> 2699inline _LIBCPP_INLINE_VISIBILITY 2700bool 2701operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();} 2702 2703template <class _T1, class _D1, class _T2, class _D2> 2704inline _LIBCPP_INLINE_VISIBILITY 2705bool 2706operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);} 2707 2708template <class _T1, class _D1, class _T2, class _D2> 2709inline _LIBCPP_INLINE_VISIBILITY 2710bool 2711operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() < __y.get();} 2712 2713template <class _T1, class _D1, class _T2, class _D2> 2714inline _LIBCPP_INLINE_VISIBILITY 2715bool 2716operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;} 2717 2718template <class _T1, class _D1, class _T2, class _D2> 2719inline _LIBCPP_INLINE_VISIBILITY 2720bool 2721operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);} 2722 2723template <class _T1, class _D1, class _T2, class _D2> 2724inline _LIBCPP_INLINE_VISIBILITY 2725bool 2726operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);} 2727 2728template <class _Tp> struct hash; 2729 2730// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t 2731// is 64 bits. This is because cityhash64 uses 64bit x 64bit 2732// multiplication, which can be very slow on 32-bit systems. 2733template <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__> 2734struct __murmur2_or_cityhash; 2735 2736template <class _Size> 2737struct __murmur2_or_cityhash<_Size, 32> 2738{ 2739 _Size operator()(const void* __key, _Size __len); 2740}; 2741 2742// murmur2 2743template <class _Size> 2744_Size 2745__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len) 2746{ 2747 const _Size __m = 0x5bd1e995; 2748 const _Size __r = 24; 2749 _Size __h = __len; 2750 const unsigned char* __data = static_cast<const unsigned char*>(__key); 2751 for (; __len >= 4; __data += 4, __len -= 4) 2752 { 2753 _Size __k = *(const _Size*)__data; 2754 __k *= __m; 2755 __k ^= __k >> __r; 2756 __k *= __m; 2757 __h *= __m; 2758 __h ^= __k; 2759 } 2760 switch (__len) 2761 { 2762 case 3: 2763 __h ^= __data[2] << 16; 2764 case 2: 2765 __h ^= __data[1] << 8; 2766 case 1: 2767 __h ^= __data[0]; 2768 __h *= __m; 2769 } 2770 __h ^= __h >> 13; 2771 __h *= __m; 2772 __h ^= __h >> 15; 2773 return __h; 2774} 2775 2776template <class _Size> 2777struct __murmur2_or_cityhash<_Size, 64> 2778{ 2779 _Size operator()(const void* __key, _Size __len); 2780 2781 private: 2782 // Some primes between 2^63 and 2^64. 2783 static const _Size __k0 = 0xc3a5c85c97cb3127ULL; 2784 static const _Size __k1 = 0xb492b66fbe98f273ULL; 2785 static const _Size __k2 = 0x9ae16a3b2f90404fULL; 2786 static const _Size __k3 = 0xc949d7c7509e6557ULL; 2787 2788 static _Size __rotate(_Size __val, int __shift) { 2789 return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift))); 2790 } 2791 2792 static _Size __rotate_by_at_least_1(_Size __val, int __shift) { 2793 return (__val >> __shift) | (__val << (64 - __shift)); 2794 } 2795 2796 static _Size __shift_mix(_Size __val) { 2797 return __val ^ (__val >> 47); 2798 } 2799 2800 static _Size __hash_len_16(_Size __u, _Size __v) { 2801 const _Size __mul = 0x9ddfea08eb382d69ULL; 2802 _Size __a = (__u ^ __v) * __mul; 2803 __a ^= (__a >> 47); 2804 _Size __b = (__v ^ __a) * __mul; 2805 __b ^= (__b >> 47); 2806 __b *= __mul; 2807 return __b; 2808 } 2809 2810 static _Size __hash_len_0_to_16(const char* __s, _Size __len) { 2811 if (__len > 8) { 2812 const _Size __a = *(const _Size*)__s; 2813 const _Size __b = *(const _Size*)(__s + __len - 8); 2814 return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b; 2815 } 2816 if (__len >= 4) { 2817 const uint32_t __a = *(const uint32_t*)(__s); 2818 const uint32_t __b = *(const uint32_t*)(__s + __len - 4); 2819 return __hash_len_16(__len + (__a << 3), __b); 2820 } 2821 if (__len > 0) { 2822 const unsigned char __a = __s[0]; 2823 const unsigned char __b = __s[__len >> 1]; 2824 const unsigned char __c = __s[__len - 1]; 2825 const uint32_t __y = static_cast<uint32_t>(__a) + 2826 (static_cast<uint32_t>(__b) << 8); 2827 const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2); 2828 return __shift_mix(__y * __k2 ^ __z * __k3) * __k2; 2829 } 2830 return __k2; 2831 } 2832 2833 static _Size __hash_len_17_to_32(const char *__s, _Size __len) { 2834 const _Size __a = *(const _Size*)(__s) * __k1; 2835 const _Size __b = *(const _Size*)(__s + 8); 2836 const _Size __c = *(const _Size*)(__s + __len - 8) * __k2; 2837 const _Size __d = *(const _Size*)(__s + __len - 16) * __k0; 2838 return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d, 2839 __a + __rotate(__b ^ __k3, 20) - __c + __len); 2840 } 2841 2842 // Return a 16-byte hash for 48 bytes. Quick and dirty. 2843 // Callers do best to use "random-looking" values for a and b. 2844 static pair<_Size, _Size> __weak_hash_len_32_with_seeds( 2845 _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b) { 2846 __a += __w; 2847 __b = __rotate(__b + __a + __z, 21); 2848 const _Size __c = __a; 2849 __a += __x; 2850 __a += __y; 2851 __b += __rotate(__a, 44); 2852 return pair<_Size, _Size>(__a + __z, __b + __c); 2853 } 2854 2855 // Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. 2856 static pair<_Size, _Size> __weak_hash_len_32_with_seeds( 2857 const char* __s, _Size __a, _Size __b) { 2858 return __weak_hash_len_32_with_seeds(*(const _Size*)(__s), 2859 *(const _Size*)(__s + 8), 2860 *(const _Size*)(__s + 16), 2861 *(const _Size*)(__s + 24), 2862 __a, 2863 __b); 2864 } 2865 2866 // Return an 8-byte hash for 33 to 64 bytes. 2867 static _Size __hash_len_33_to_64(const char *__s, size_t __len) { 2868 _Size __z = *(const _Size*)(__s + 24); 2869 _Size __a = *(const _Size*)(__s) + 2870 (__len + *(const _Size*)(__s + __len - 16)) * __k0; 2871 _Size __b = __rotate(__a + __z, 52); 2872 _Size __c = __rotate(__a, 37); 2873 __a += *(const _Size*)(__s + 8); 2874 __c += __rotate(__a, 7); 2875 __a += *(const _Size*)(__s + 16); 2876 _Size __vf = __a + __z; 2877 _Size __vs = __b + __rotate(__a, 31) + __c; 2878 __a = *(const _Size*)(__s + 16) + *(const _Size*)(__s + __len - 32); 2879 __z += *(const _Size*)(__s + __len - 8); 2880 __b = __rotate(__a + __z, 52); 2881 __c = __rotate(__a, 37); 2882 __a += *(const _Size*)(__s + __len - 24); 2883 __c += __rotate(__a, 7); 2884 __a += *(const _Size*)(__s + __len - 16); 2885 _Size __wf = __a + __z; 2886 _Size __ws = __b + __rotate(__a, 31) + __c; 2887 _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0); 2888 return __shift_mix(__r * __k0 + __vs) * __k2; 2889 } 2890}; 2891 2892// cityhash64 2893template <class _Size> 2894_Size 2895__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len) 2896{ 2897 const char* __s = static_cast<const char*>(__key); 2898 if (__len <= 32) { 2899 if (__len <= 16) { 2900 return __hash_len_0_to_16(__s, __len); 2901 } else { 2902 return __hash_len_17_to_32(__s, __len); 2903 } 2904 } else if (__len <= 64) { 2905 return __hash_len_33_to_64(__s, __len); 2906 } 2907 2908 // For strings over 64 bytes we hash the end first, and then as we 2909 // loop we keep 56 bytes of state: v, w, x, y, and z. 2910 _Size __x = *(const _Size*)(__s + __len - 40); 2911 _Size __y = *(const _Size*)(__s + __len - 16) + 2912 *(const _Size*)(__s + __len - 56); 2913 _Size __z = __hash_len_16(*(const _Size*)(__s + __len - 48) + __len, 2914 *(const _Size*)(__s + __len - 24)); 2915 pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z); 2916 pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x); 2917 __x = __x * __k1 + *(const _Size*)(__s); 2918 2919 // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. 2920 __len = (__len - 1) & ~static_cast<_Size>(63); 2921 do { 2922 __x = __rotate(__x + __y + __v.first + *(const _Size*)(__s + 8), 37) * __k1; 2923 __y = __rotate(__y + __v.second + *(const _Size*)(__s + 48), 42) * __k1; 2924 __x ^= __w.second; 2925 __y += __v.first + *(const _Size*)(__s + 40); 2926 __z = __rotate(__z + __w.first, 33) * __k1; 2927 __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first); 2928 __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second, 2929 __y + *(const _Size*)(__s + 16)); 2930 std::swap(__z, __x); 2931 __s += 64; 2932 __len -= 64; 2933 } while (__len != 0); 2934 return __hash_len_16( 2935 __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z, 2936 __hash_len_16(__v.second, __w.second) + __x); 2937} 2938 2939template <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)> 2940struct __scalar_hash; 2941 2942template <class _Tp> 2943struct __scalar_hash<_Tp, 0> 2944 : public unary_function<_Tp, size_t> 2945{ 2946 _LIBCPP_INLINE_VISIBILITY 2947 size_t operator()(_Tp __v) const _NOEXCEPT 2948 { 2949 union 2950 { 2951 _Tp __t; 2952 size_t __a; 2953 } __u; 2954 __u.__a = 0; 2955 __u.__t = __v; 2956 return __u.__a; 2957 } 2958}; 2959 2960template <class _Tp> 2961struct __scalar_hash<_Tp, 1> 2962 : public unary_function<_Tp, size_t> 2963{ 2964 _LIBCPP_INLINE_VISIBILITY 2965 size_t operator()(_Tp __v) const _NOEXCEPT 2966 { 2967 union 2968 { 2969 _Tp __t; 2970 size_t __a; 2971 } __u; 2972 __u.__t = __v; 2973 return __u.__a; 2974 } 2975}; 2976 2977template <class _Tp> 2978struct __scalar_hash<_Tp, 2> 2979 : public unary_function<_Tp, size_t> 2980{ 2981 _LIBCPP_INLINE_VISIBILITY 2982 size_t operator()(_Tp __v) const _NOEXCEPT 2983 { 2984 union 2985 { 2986 _Tp __t; 2987 struct 2988 { 2989 size_t __a; 2990 size_t __b; 2991 }; 2992 } __u; 2993 __u.__t = __v; 2994 return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 2995 } 2996}; 2997 2998template <class _Tp> 2999struct __scalar_hash<_Tp, 3> 3000 : public unary_function<_Tp, size_t> 3001{ 3002 _LIBCPP_INLINE_VISIBILITY 3003 size_t operator()(_Tp __v) const _NOEXCEPT 3004 { 3005 union 3006 { 3007 _Tp __t; 3008 struct 3009 { 3010 size_t __a; 3011 size_t __b; 3012 size_t __c; 3013 }; 3014 } __u; 3015 __u.__t = __v; 3016 return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 3017 } 3018}; 3019 3020template <class _Tp> 3021struct __scalar_hash<_Tp, 4> 3022 : public unary_function<_Tp, size_t> 3023{ 3024 _LIBCPP_INLINE_VISIBILITY 3025 size_t operator()(_Tp __v) const _NOEXCEPT 3026 { 3027 union 3028 { 3029 _Tp __t; 3030 struct 3031 { 3032 size_t __a; 3033 size_t __b; 3034 size_t __c; 3035 size_t __d; 3036 }; 3037 } __u; 3038 __u.__t = __v; 3039 return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 3040 } 3041}; 3042 3043template<class _Tp> 3044struct _LIBCPP_VISIBLE hash<_Tp*> 3045 : public __scalar_hash<_Tp*> 3046{ 3047}; 3048 3049template <class _Tp, class _Dp> 3050struct _LIBCPP_VISIBLE hash<unique_ptr<_Tp, _Dp> > 3051{ 3052 typedef unique_ptr<_Tp, _Dp> argument_type; 3053 typedef size_t result_type; 3054 _LIBCPP_INLINE_VISIBILITY 3055 result_type operator()(const argument_type& __ptr) const _NOEXCEPT 3056 { 3057 typedef typename argument_type::pointer pointer; 3058 return hash<pointer>()(__ptr.get()); 3059 } 3060}; 3061 3062struct __destruct_n 3063{ 3064private: 3065 size_t size; 3066 3067 template <class _Tp> 3068 _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT 3069 {for (size_t __i = 0; __i < size; ++__i, ++__p) __p->~_Tp();} 3070 3071 template <class _Tp> 3072 _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT 3073 {} 3074 3075 _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT 3076 {++size;} 3077 _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT 3078 {} 3079 3080 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT 3081 {size = __s;} 3082 _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT 3083 {} 3084public: 3085 _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT 3086 : size(__s) {} 3087 3088 template <class _Tp> 3089 _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*) _NOEXCEPT 3090 {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3091 3092 template <class _Tp> 3093 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT 3094 {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3095 3096 template <class _Tp> 3097 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT 3098 {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3099}; 3100 3101template <class _Alloc> 3102class __allocator_destructor 3103{ 3104 typedef allocator_traits<_Alloc> __alloc_traits; 3105public: 3106 typedef typename __alloc_traits::pointer pointer; 3107 typedef typename __alloc_traits::size_type size_type; 3108private: 3109 _Alloc& __alloc_; 3110 size_type __s_; 3111public: 3112 _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s) 3113 _NOEXCEPT 3114 : __alloc_(__a), __s_(__s) {} 3115 _LIBCPP_INLINE_VISIBILITY 3116 void operator()(pointer __p) _NOEXCEPT 3117 {__alloc_traits::deallocate(__alloc_, __p, __s_);} 3118}; 3119 3120template <class _InputIterator, class _ForwardIterator> 3121_ForwardIterator 3122uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r) 3123{ 3124 __destruct_n __d(0); 3125 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3126 unique_ptr<value_type, __destruct_n&> __h(&*__r, __d); 3127 for (; __f != __l; ++__f, ++__r, __d.__incr((value_type*)0)) 3128 ::new(&*__r) value_type(*__f); 3129 __h.release(); 3130 return __r; 3131} 3132 3133template <class _InputIterator, class _Size, class _ForwardIterator> 3134_ForwardIterator 3135uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r) 3136{ 3137 __destruct_n __d(0); 3138 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3139 unique_ptr<value_type, __destruct_n&> __h(&*__r, __d); 3140 for (; __n > 0; ++__f, ++__r, __d.__incr((value_type*)0), --__n) 3141 ::new(&*__r) value_type(*__f); 3142 __h.release(); 3143 return __r; 3144} 3145 3146template <class _ForwardIterator, class _Tp> 3147void 3148uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x) 3149{ 3150 __destruct_n __d(0); 3151 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3152 unique_ptr<value_type, __destruct_n&> __h(&*__f, __d); 3153 for (; __f != __l; ++__f, __d.__incr((value_type*)0)) 3154 ::new(&*__f) value_type(__x); 3155 __h.release(); 3156} 3157 3158template <class _ForwardIterator, class _Size, class _Tp> 3159_ForwardIterator 3160uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x) 3161{ 3162 __destruct_n __d(0); 3163 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3164 unique_ptr<value_type, __destruct_n&> __h(&*__f, __d); 3165 for (; __n > 0; ++__f, --__n, __d.__incr((value_type*)0)) 3166 ::new(&*__f) value_type(__x); 3167 __h.release(); 3168 return __f; 3169} 3170 3171class _LIBCPP_EXCEPTION_ABI bad_weak_ptr 3172 : public std::exception 3173{ 3174public: 3175 virtual ~bad_weak_ptr() _NOEXCEPT; 3176 virtual const char* what() const _NOEXCEPT; 3177}; 3178 3179template<class _Tp> class weak_ptr; 3180 3181class __shared_count 3182{ 3183 __shared_count(const __shared_count&); 3184 __shared_count& operator=(const __shared_count&); 3185 3186protected: 3187 long __shared_owners_; 3188 virtual ~__shared_count(); 3189private: 3190 virtual void __on_zero_shared() _NOEXCEPT = 0; 3191 3192public: 3193 _LIBCPP_INLINE_VISIBILITY 3194 explicit __shared_count(long __refs = 0) _NOEXCEPT 3195 : __shared_owners_(__refs) {} 3196 3197 void __add_shared() _NOEXCEPT; 3198 bool __release_shared() _NOEXCEPT; 3199 _LIBCPP_INLINE_VISIBILITY 3200 long use_count() const _NOEXCEPT {return __shared_owners_ + 1;} 3201}; 3202 3203class __shared_weak_count 3204 : private __shared_count 3205{ 3206 long __shared_weak_owners_; 3207 3208public: 3209 _LIBCPP_INLINE_VISIBILITY 3210 explicit __shared_weak_count(long __refs = 0) _NOEXCEPT 3211 : __shared_count(__refs), 3212 __shared_weak_owners_(__refs) {} 3213protected: 3214 virtual ~__shared_weak_count(); 3215 3216public: 3217 void __add_shared() _NOEXCEPT; 3218 void __add_weak() _NOEXCEPT; 3219 void __release_shared() _NOEXCEPT; 3220 void __release_weak() _NOEXCEPT; 3221 _LIBCPP_INLINE_VISIBILITY 3222 long use_count() const _NOEXCEPT {return __shared_count::use_count();} 3223 __shared_weak_count* lock() _NOEXCEPT; 3224 3225 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3226private: 3227 virtual void __on_zero_shared_weak() _NOEXCEPT = 0; 3228}; 3229 3230template <class _Tp, class _Dp, class _Alloc> 3231class __shared_ptr_pointer 3232 : public __shared_weak_count 3233{ 3234 __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_; 3235public: 3236 _LIBCPP_INLINE_VISIBILITY 3237 __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a) 3238 : __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {} 3239 3240#ifndef _LIBCPP_NO_RTTI 3241 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3242#endif 3243 3244private: 3245 virtual void __on_zero_shared() _NOEXCEPT; 3246 virtual void __on_zero_shared_weak() _NOEXCEPT; 3247}; 3248 3249#ifndef _LIBCPP_NO_RTTI 3250 3251template <class _Tp, class _Dp, class _Alloc> 3252const void* 3253__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT 3254{ 3255 return __t == typeid(_Dp) ? &__data_.first().second() : 0; 3256} 3257 3258#endif // _LIBCPP_NO_RTTI 3259 3260template <class _Tp, class _Dp, class _Alloc> 3261void 3262__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT 3263{ 3264 __data_.first().second()(__data_.first().first()); 3265 __data_.first().second().~_Dp(); 3266} 3267 3268template <class _Tp, class _Dp, class _Alloc> 3269void 3270__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3271{ 3272 typename _Alloc::template rebind<__shared_ptr_pointer>::other __a(__data_.second()); 3273 __data_.second().~_Alloc(); 3274 __a.deallocate(this, 1); 3275} 3276 3277template <class _Tp, class _Alloc> 3278class __shared_ptr_emplace 3279 : public __shared_weak_count 3280{ 3281 __compressed_pair<_Alloc, _Tp> __data_; 3282public: 3283#ifndef _LIBCPP_HAS_NO_VARIADICS 3284 3285 _LIBCPP_INLINE_VISIBILITY 3286 __shared_ptr_emplace(_Alloc __a) 3287 : __data_(_VSTD::move(__a)) {} 3288 3289 template <class ..._Args> 3290 _LIBCPP_INLINE_VISIBILITY 3291 __shared_ptr_emplace(_Alloc __a, _Args&& ...__args) 3292 : __data_(_VSTD::move(__a), _Tp(_VSTD::forward<_Args>(__args)...)) {} 3293 3294#else // _LIBCPP_HAS_NO_VARIADICS 3295 3296 _LIBCPP_INLINE_VISIBILITY 3297 __shared_ptr_emplace(_Alloc __a) 3298 : __data_(__a) {} 3299 3300 template <class _A0> 3301 _LIBCPP_INLINE_VISIBILITY 3302 __shared_ptr_emplace(_Alloc __a, _A0& __a0) 3303 : __data_(__a, _Tp(__a0)) {} 3304 3305 template <class _A0, class _A1> 3306 _LIBCPP_INLINE_VISIBILITY 3307 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1) 3308 : __data_(__a, _Tp(__a0, __a1)) {} 3309 3310 template <class _A0, class _A1, class _A2> 3311 _LIBCPP_INLINE_VISIBILITY 3312 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1, _A2& __a2) 3313 : __data_(__a, _Tp(__a0, __a1, __a2)) {} 3314 3315#endif // _LIBCPP_HAS_NO_VARIADICS 3316 3317private: 3318 virtual void __on_zero_shared() _NOEXCEPT; 3319 virtual void __on_zero_shared_weak() _NOEXCEPT; 3320public: 3321 _LIBCPP_INLINE_VISIBILITY 3322 _Tp* get() _NOEXCEPT {return &__data_.second();} 3323}; 3324 3325template <class _Tp, class _Alloc> 3326void 3327__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT 3328{ 3329 __data_.second().~_Tp(); 3330} 3331 3332template <class _Tp, class _Alloc> 3333void 3334__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3335{ 3336 typename _Alloc::template rebind<__shared_ptr_emplace>::other __a(__data_.first()); 3337 __data_.first().~_Alloc(); 3338 __a.deallocate(this, 1); 3339} 3340 3341template<class _Tp> class enable_shared_from_this; 3342 3343template<class _Tp> 3344class _LIBCPP_VISIBLE shared_ptr 3345{ 3346public: 3347 typedef _Tp element_type; 3348private: 3349 element_type* __ptr_; 3350 __shared_weak_count* __cntrl_; 3351 3352 struct __nat {int __for_bool_;}; 3353public: 3354 shared_ptr() _NOEXCEPT; 3355 shared_ptr(nullptr_t) _NOEXCEPT; 3356 template<class _Yp> explicit shared_ptr(_Yp* __p); 3357 template<class _Yp, class _Dp> shared_ptr(_Yp* __p, _Dp __d); 3358 template<class _Yp, class _Dp, class _Alloc> shared_ptr(_Yp* __p, _Dp __d, _Alloc __a); 3359 template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d); 3360 template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a); 3361 template<class _Yp> shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT; 3362 shared_ptr(const shared_ptr& __r) _NOEXCEPT; 3363 template<class _Yp> 3364 shared_ptr(const shared_ptr<_Yp>& __r, 3365 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat()) 3366 _NOEXCEPT; 3367#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3368 shared_ptr(shared_ptr&& __r) _NOEXCEPT; 3369 template<class _Yp> shared_ptr(shared_ptr<_Yp>&& __r, 3370 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat()) 3371 _NOEXCEPT; 3372#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3373 template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r, 3374 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type= __nat()); 3375#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3376 template<class _Yp> shared_ptr(auto_ptr<_Yp>&& __r); 3377#else 3378 template<class _Yp> shared_ptr(auto_ptr<_Yp> __r); 3379#endif 3380#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3381private: 3382 template <class _Yp, class _Dp> shared_ptr(const unique_ptr<_Yp, _Dp>& __r);// = delete; 3383public: 3384 template <class _Yp, class _Dp> shared_ptr(unique_ptr<_Yp, _Dp>&&, 3385 typename enable_if<!is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3386 template <class _Yp, class _Dp> shared_ptr(unique_ptr<_Yp, _Dp>&&, 3387 typename enable_if<is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3388#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3389 template <class _Yp, class _Dp> shared_ptr(unique_ptr<_Yp, _Dp>, 3390 typename enable_if<!is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3391 template <class _Yp, class _Dp> shared_ptr(unique_ptr<_Yp, _Dp>, 3392 typename enable_if<is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3393#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3394 3395 ~shared_ptr(); 3396 3397 shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT; 3398 template<class _Yp> shared_ptr& operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT; 3399#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3400 shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT; 3401 template<class _Yp> shared_ptr& operator=(shared_ptr<_Yp>&& __r); 3402 template<class _Yp> shared_ptr& operator=(auto_ptr<_Yp>&& __r); 3403#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3404 template<class _Yp> shared_ptr& operator=(auto_ptr<_Yp> __r); 3405#endif 3406#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3407private: 3408 template <class _Yp, class _Dp> shared_ptr& operator=(const unique_ptr<_Yp, _Dp>& __r);// = delete; 3409public: 3410 template <class _Yp, class _Dp> shared_ptr& operator=(unique_ptr<_Yp, _Dp>&& __r); 3411#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3412 template <class _Yp, class _Dp> shared_ptr& operator=(unique_ptr<_Yp, _Dp> __r); 3413#endif 3414 3415 void swap(shared_ptr& __r) _NOEXCEPT; 3416 void reset() _NOEXCEPT; 3417 template<class _Yp> void reset(_Yp* __p); 3418 template<class _Yp, class _Dp> void reset(_Yp* __p, _Dp __d); 3419 template<class _Yp, class _Dp, class _Alloc> void reset(_Yp* __p, _Dp __d, _Alloc __a); 3420 3421 _LIBCPP_INLINE_VISIBILITY 3422 element_type* get() const _NOEXCEPT {return __ptr_;} 3423 _LIBCPP_INLINE_VISIBILITY 3424 typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT 3425 {return *__ptr_;} 3426 _LIBCPP_INLINE_VISIBILITY 3427 element_type* operator->() const _NOEXCEPT {return __ptr_;} 3428 _LIBCPP_INLINE_VISIBILITY 3429 long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;} 3430 _LIBCPP_INLINE_VISIBILITY 3431 bool unique() const _NOEXCEPT {return use_count() == 1;} 3432 _LIBCPP_INLINE_VISIBILITY 3433 /*explicit*/ operator bool() const _NOEXCEPT {return get() != 0;} 3434 template <class _Up> 3435 _LIBCPP_INLINE_VISIBILITY 3436 bool owner_before(shared_ptr<_Up> const& __p) const 3437 {return __cntrl_ < __p.__cntrl_;} 3438 template <class _Up> 3439 _LIBCPP_INLINE_VISIBILITY 3440 bool owner_before(weak_ptr<_Up> const& __p) const 3441 {return __cntrl_ < __p.__cntrl_;} 3442 3443#ifndef _LIBCPP_NO_RTTI 3444 template <class _Dp> 3445 _LIBCPP_INLINE_VISIBILITY 3446 _Dp* __get_deleter() const _NOEXCEPT 3447 {return (_Dp*)(__cntrl_ ? __cntrl_->__get_deleter(typeid(_Dp)) : 0);} 3448#endif // _LIBCPP_NO_RTTI 3449 3450#ifndef _LIBCPP_HAS_NO_VARIADICS 3451 3452 template<class ..._Args> 3453 static 3454 shared_ptr<_Tp> 3455 make_shared(_Args&& ...__args); 3456 3457 template<class _Alloc, class ..._Args> 3458 static 3459 shared_ptr<_Tp> 3460 allocate_shared(const _Alloc& __a, _Args&& ...__args); 3461 3462#else // _LIBCPP_HAS_NO_VARIADICS 3463 3464 static shared_ptr<_Tp> make_shared(); 3465 3466 template<class _A0> 3467 static shared_ptr<_Tp> make_shared(_A0&); 3468 3469 template<class _A0, class _A1> 3470 static shared_ptr<_Tp> make_shared(_A0&, _A1&); 3471 3472 template<class _A0, class _A1, class _A2> 3473 static shared_ptr<_Tp> make_shared(_A0&, _A1&, _A2&); 3474 3475 template<class _Alloc> 3476 static shared_ptr<_Tp> 3477 allocate_shared(const _Alloc& __a); 3478 3479 template<class _Alloc, class _A0> 3480 static shared_ptr<_Tp> 3481 allocate_shared(const _Alloc& __a, _A0& __a0); 3482 3483 template<class _Alloc, class _A0, class _A1> 3484 static shared_ptr<_Tp> 3485 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1); 3486 3487 template<class _Alloc, class _A0, class _A1, class _A2> 3488 static shared_ptr<_Tp> 3489 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2); 3490 3491#endif // _LIBCPP_HAS_NO_VARIADICS 3492 3493private: 3494 3495 template <class _Yp> 3496 _LIBCPP_INLINE_VISIBILITY 3497 void 3498 __enable_weak_this(const enable_shared_from_this<_Yp>* __e) _NOEXCEPT 3499 { 3500 if (__e) 3501 __e->__weak_this_ = *this; 3502 } 3503 3504 _LIBCPP_INLINE_VISIBILITY 3505 void __enable_weak_this(const void*) _NOEXCEPT {} 3506 3507 template <class _Up> friend class _LIBCPP_VISIBLE shared_ptr; 3508 template <class _Up> friend class _LIBCPP_VISIBLE weak_ptr; 3509}; 3510 3511template<class _Tp> 3512inline _LIBCPP_INLINE_VISIBILITY 3513shared_ptr<_Tp>::shared_ptr() _NOEXCEPT 3514 : __ptr_(0), 3515 __cntrl_(0) 3516{ 3517} 3518 3519template<class _Tp> 3520inline _LIBCPP_INLINE_VISIBILITY 3521shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT 3522 : __ptr_(0), 3523 __cntrl_(0) 3524{ 3525} 3526 3527template<class _Tp> 3528template<class _Yp> 3529shared_ptr<_Tp>::shared_ptr(_Yp* __p) 3530 : __ptr_(__p) 3531{ 3532 unique_ptr<_Yp> __hold(__p); 3533 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk; 3534 __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), allocator<_Yp>()); 3535 __hold.release(); 3536 __enable_weak_this(__p); 3537} 3538 3539template<class _Tp> 3540template<class _Yp, class _Dp> 3541shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d) 3542 : __ptr_(__p) 3543{ 3544#ifndef _LIBCPP_NO_EXCEPTIONS 3545 try 3546 { 3547#endif // _LIBCPP_NO_EXCEPTIONS 3548 typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk; 3549 __cntrl_ = new _CntrlBlk(__p, __d, allocator<_Yp>()); 3550 __enable_weak_this(__p); 3551#ifndef _LIBCPP_NO_EXCEPTIONS 3552 } 3553 catch (...) 3554 { 3555 __d(__p); 3556 throw; 3557 } 3558#endif // _LIBCPP_NO_EXCEPTIONS 3559} 3560 3561template<class _Tp> 3562template<class _Dp> 3563shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d) 3564 : __ptr_(0) 3565{ 3566#ifndef _LIBCPP_NO_EXCEPTIONS 3567 try 3568 { 3569#endif // _LIBCPP_NO_EXCEPTIONS 3570 typedef __shared_ptr_pointer<nullptr_t, _Dp, allocator<_Tp> > _CntrlBlk; 3571 __cntrl_ = new _CntrlBlk(__p, __d, allocator<_Tp>()); 3572#ifndef _LIBCPP_NO_EXCEPTIONS 3573 } 3574 catch (...) 3575 { 3576 __d(__p); 3577 throw; 3578 } 3579#endif // _LIBCPP_NO_EXCEPTIONS 3580} 3581 3582template<class _Tp> 3583template<class _Yp, class _Dp, class _Alloc> 3584shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a) 3585 : __ptr_(__p) 3586{ 3587#ifndef _LIBCPP_NO_EXCEPTIONS 3588 try 3589 { 3590#endif // _LIBCPP_NO_EXCEPTIONS 3591 typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk; 3592 typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2; 3593 typedef __allocator_destructor<_A2> _D2; 3594 _A2 __a2(__a); 3595 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 3596 ::new(__hold2.get()) _CntrlBlk(__p, __d, __a); 3597 __cntrl_ = __hold2.release(); 3598 __enable_weak_this(__p); 3599#ifndef _LIBCPP_NO_EXCEPTIONS 3600 } 3601 catch (...) 3602 { 3603 __d(__p); 3604 throw; 3605 } 3606#endif // _LIBCPP_NO_EXCEPTIONS 3607} 3608 3609template<class _Tp> 3610template<class _Dp, class _Alloc> 3611shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a) 3612 : __ptr_(0) 3613{ 3614#ifndef _LIBCPP_NO_EXCEPTIONS 3615 try 3616 { 3617#endif // _LIBCPP_NO_EXCEPTIONS 3618 typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk; 3619 typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2; 3620 typedef __allocator_destructor<_A2> _D2; 3621 _A2 __a2(__a); 3622 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 3623 ::new(__hold2.get()) _CntrlBlk(__p, __d, __a); 3624 __cntrl_ = __hold2.release(); 3625#ifndef _LIBCPP_NO_EXCEPTIONS 3626 } 3627 catch (...) 3628 { 3629 __d(__p); 3630 throw; 3631 } 3632#endif // _LIBCPP_NO_EXCEPTIONS 3633} 3634 3635template<class _Tp> 3636template<class _Yp> 3637inline _LIBCPP_INLINE_VISIBILITY 3638shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT 3639 : __ptr_(__p), 3640 __cntrl_(__r.__cntrl_) 3641{ 3642 if (__cntrl_) 3643 __cntrl_->__add_shared(); 3644} 3645 3646template<class _Tp> 3647inline _LIBCPP_INLINE_VISIBILITY 3648shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT 3649 : __ptr_(__r.__ptr_), 3650 __cntrl_(__r.__cntrl_) 3651{ 3652 if (__cntrl_) 3653 __cntrl_->__add_shared(); 3654} 3655 3656template<class _Tp> 3657template<class _Yp> 3658inline _LIBCPP_INLINE_VISIBILITY 3659shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, 3660 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type) 3661 _NOEXCEPT 3662 : __ptr_(__r.__ptr_), 3663 __cntrl_(__r.__cntrl_) 3664{ 3665 if (__cntrl_) 3666 __cntrl_->__add_shared(); 3667} 3668 3669#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3670 3671template<class _Tp> 3672inline _LIBCPP_INLINE_VISIBILITY 3673shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT 3674 : __ptr_(__r.__ptr_), 3675 __cntrl_(__r.__cntrl_) 3676{ 3677 __r.__ptr_ = 0; 3678 __r.__cntrl_ = 0; 3679} 3680 3681template<class _Tp> 3682template<class _Yp> 3683inline _LIBCPP_INLINE_VISIBILITY 3684shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r, 3685 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type) 3686 _NOEXCEPT 3687 : __ptr_(__r.__ptr_), 3688 __cntrl_(__r.__cntrl_) 3689{ 3690 __r.__ptr_ = 0; 3691 __r.__cntrl_ = 0; 3692} 3693 3694#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3695 3696template<class _Tp> 3697template<class _Yp> 3698#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3699shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r) 3700#else 3701shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r) 3702#endif 3703 : __ptr_(__r.get()) 3704{ 3705 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk; 3706 __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>()); 3707 __enable_weak_this(__r.get()); 3708 __r.release(); 3709} 3710 3711template<class _Tp> 3712template <class _Yp, class _Dp> 3713#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3714shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 3715#else 3716shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 3717#endif 3718 typename enable_if<!is_lvalue_reference<_Dp>::value, __nat>::type) 3719 : __ptr_(__r.get()) 3720{ 3721 typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk; 3722 __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), allocator<_Yp>()); 3723 __enable_weak_this(__r.get()); 3724 __r.release(); 3725} 3726 3727template<class _Tp> 3728template <class _Yp, class _Dp> 3729#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3730shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 3731#else 3732shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 3733#endif 3734 typename enable_if<is_lvalue_reference<_Dp>::value, __nat>::type) 3735 : __ptr_(__r.get()) 3736{ 3737 typedef __shared_ptr_pointer<_Yp*, 3738 reference_wrapper<typename remove_reference<_Dp>::type>, 3739 allocator<_Yp> > _CntrlBlk; 3740 __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), allocator<_Yp>()); 3741 __enable_weak_this(__r.get()); 3742 __r.release(); 3743} 3744 3745#ifndef _LIBCPP_HAS_NO_VARIADICS 3746 3747template<class _Tp> 3748template<class ..._Args> 3749shared_ptr<_Tp> 3750shared_ptr<_Tp>::make_shared(_Args&& ...__args) 3751{ 3752 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 3753 typedef allocator<_CntrlBlk> _A2; 3754 typedef __allocator_destructor<_A2> _D2; 3755 _A2 __a2; 3756 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 3757 ::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...); 3758 shared_ptr<_Tp> __r; 3759 __r.__ptr_ = __hold2.get()->get(); 3760 __r.__cntrl_ = __hold2.release(); 3761 __r.__enable_weak_this(__r.__ptr_); 3762 return __r; 3763} 3764 3765template<class _Tp> 3766template<class _Alloc, class ..._Args> 3767shared_ptr<_Tp> 3768shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args) 3769{ 3770 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 3771 typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2; 3772 typedef __allocator_destructor<_A2> _D2; 3773 _A2 __a2(__a); 3774 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 3775 ::new(__hold2.get()) _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...); 3776 shared_ptr<_Tp> __r; 3777 __r.__ptr_ = __hold2.get()->get(); 3778 __r.__cntrl_ = __hold2.release(); 3779 __r.__enable_weak_this(__r.__ptr_); 3780 return __r; 3781} 3782 3783#else // _LIBCPP_HAS_NO_VARIADICS 3784 3785template<class _Tp> 3786shared_ptr<_Tp> 3787shared_ptr<_Tp>::make_shared() 3788{ 3789 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 3790 typedef allocator<_CntrlBlk> _Alloc2; 3791 typedef __allocator_destructor<_Alloc2> _D2; 3792 _Alloc2 __alloc2; 3793 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3794 ::new(__hold2.get()) _CntrlBlk(__alloc2); 3795 shared_ptr<_Tp> __r; 3796 __r.__ptr_ = __hold2.get()->get(); 3797 __r.__cntrl_ = __hold2.release(); 3798 __r.__enable_weak_this(__r.__ptr_); 3799 return __r; 3800} 3801 3802template<class _Tp> 3803template<class _A0> 3804shared_ptr<_Tp> 3805shared_ptr<_Tp>::make_shared(_A0& __a0) 3806{ 3807 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 3808 typedef allocator<_CntrlBlk> _Alloc2; 3809 typedef __allocator_destructor<_Alloc2> _D2; 3810 _Alloc2 __alloc2; 3811 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3812 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0); 3813 shared_ptr<_Tp> __r; 3814 __r.__ptr_ = __hold2.get()->get(); 3815 __r.__cntrl_ = __hold2.release(); 3816 __r.__enable_weak_this(__r.__ptr_); 3817 return __r; 3818} 3819 3820template<class _Tp> 3821template<class _A0, class _A1> 3822shared_ptr<_Tp> 3823shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1) 3824{ 3825 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 3826 typedef allocator<_CntrlBlk> _Alloc2; 3827 typedef __allocator_destructor<_Alloc2> _D2; 3828 _Alloc2 __alloc2; 3829 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3830 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1); 3831 shared_ptr<_Tp> __r; 3832 __r.__ptr_ = __hold2.get()->get(); 3833 __r.__cntrl_ = __hold2.release(); 3834 __r.__enable_weak_this(__r.__ptr_); 3835 return __r; 3836} 3837 3838template<class _Tp> 3839template<class _A0, class _A1, class _A2> 3840shared_ptr<_Tp> 3841shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 3842{ 3843 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 3844 typedef allocator<_CntrlBlk> _Alloc2; 3845 typedef __allocator_destructor<_Alloc2> _D2; 3846 _Alloc2 __alloc2; 3847 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3848 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1, __a2); 3849 shared_ptr<_Tp> __r; 3850 __r.__ptr_ = __hold2.get()->get(); 3851 __r.__cntrl_ = __hold2.release(); 3852 __r.__enable_weak_this(__r.__ptr_); 3853 return __r; 3854} 3855 3856template<class _Tp> 3857template<class _Alloc> 3858shared_ptr<_Tp> 3859shared_ptr<_Tp>::allocate_shared(const _Alloc& __a) 3860{ 3861 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 3862 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 3863 typedef __allocator_destructor<_Alloc2> _D2; 3864 _Alloc2 __alloc2(__a); 3865 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3866 ::new(__hold2.get()) _CntrlBlk(__a); 3867 shared_ptr<_Tp> __r; 3868 __r.__ptr_ = __hold2.get()->get(); 3869 __r.__cntrl_ = __hold2.release(); 3870 __r.__enable_weak_this(__r.__ptr_); 3871 return __r; 3872} 3873 3874template<class _Tp> 3875template<class _Alloc, class _A0> 3876shared_ptr<_Tp> 3877shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0) 3878{ 3879 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 3880 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 3881 typedef __allocator_destructor<_Alloc2> _D2; 3882 _Alloc2 __alloc2(__a); 3883 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3884 ::new(__hold2.get()) _CntrlBlk(__a, __a0); 3885 shared_ptr<_Tp> __r; 3886 __r.__ptr_ = __hold2.get()->get(); 3887 __r.__cntrl_ = __hold2.release(); 3888 __r.__enable_weak_this(__r.__ptr_); 3889 return __r; 3890} 3891 3892template<class _Tp> 3893template<class _Alloc, class _A0, class _A1> 3894shared_ptr<_Tp> 3895shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 3896{ 3897 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 3898 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 3899 typedef __allocator_destructor<_Alloc2> _D2; 3900 _Alloc2 __alloc2(__a); 3901 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3902 ::new(__hold2.get()) _CntrlBlk(__a, __a0, __a1); 3903 shared_ptr<_Tp> __r; 3904 __r.__ptr_ = __hold2.get()->get(); 3905 __r.__cntrl_ = __hold2.release(); 3906 __r.__enable_weak_this(__r.__ptr_); 3907 return __r; 3908} 3909 3910template<class _Tp> 3911template<class _Alloc, class _A0, class _A1, class _A2> 3912shared_ptr<_Tp> 3913shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 3914{ 3915 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 3916 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 3917 typedef __allocator_destructor<_Alloc2> _D2; 3918 _Alloc2 __alloc2(__a); 3919 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 3920 ::new(__hold2.get()) _CntrlBlk(__a, __a0, __a1, __a2); 3921 shared_ptr<_Tp> __r; 3922 __r.__ptr_ = __hold2.get()->get(); 3923 __r.__cntrl_ = __hold2.release(); 3924 __r.__enable_weak_this(__r.__ptr_); 3925 return __r; 3926} 3927 3928#endif // _LIBCPP_HAS_NO_VARIADICS 3929 3930template<class _Tp> 3931shared_ptr<_Tp>::~shared_ptr() 3932{ 3933 if (__cntrl_) 3934 __cntrl_->__release_shared(); 3935} 3936 3937template<class _Tp> 3938inline _LIBCPP_INLINE_VISIBILITY 3939shared_ptr<_Tp>& 3940shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT 3941{ 3942 shared_ptr(__r).swap(*this); 3943 return *this; 3944} 3945 3946template<class _Tp> 3947template<class _Yp> 3948inline _LIBCPP_INLINE_VISIBILITY 3949shared_ptr<_Tp>& 3950shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT 3951{ 3952 shared_ptr(__r).swap(*this); 3953 return *this; 3954} 3955 3956#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3957 3958template<class _Tp> 3959inline _LIBCPP_INLINE_VISIBILITY 3960shared_ptr<_Tp>& 3961shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT 3962{ 3963 shared_ptr(_VSTD::move(__r)).swap(*this); 3964 return *this; 3965} 3966 3967template<class _Tp> 3968template<class _Yp> 3969inline _LIBCPP_INLINE_VISIBILITY 3970shared_ptr<_Tp>& 3971shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r) 3972{ 3973 shared_ptr(_VSTD::move(__r)).swap(*this); 3974 return *this; 3975} 3976 3977template<class _Tp> 3978template<class _Yp> 3979inline _LIBCPP_INLINE_VISIBILITY 3980shared_ptr<_Tp>& 3981shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r) 3982{ 3983 shared_ptr(_VSTD::move(__r)).swap(*this); 3984 return *this; 3985} 3986 3987template<class _Tp> 3988template <class _Yp, class _Dp> 3989inline _LIBCPP_INLINE_VISIBILITY 3990shared_ptr<_Tp>& 3991shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r) 3992{ 3993 shared_ptr(_VSTD::move(__r)).swap(*this); 3994 return *this; 3995} 3996 3997#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3998 3999template<class _Tp> 4000template<class _Yp> 4001inline _LIBCPP_INLINE_VISIBILITY 4002shared_ptr<_Tp>& 4003shared_ptr<_Tp>::operator=(auto_ptr<_Yp> __r) 4004{ 4005 shared_ptr(__r).swap(*this); 4006 return *this; 4007} 4008 4009template<class _Tp> 4010template <class _Yp, class _Dp> 4011inline _LIBCPP_INLINE_VISIBILITY 4012shared_ptr<_Tp>& 4013shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r) 4014{ 4015 shared_ptr(_VSTD::move(__r)).swap(*this); 4016 return *this; 4017} 4018 4019#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4020 4021template<class _Tp> 4022inline _LIBCPP_INLINE_VISIBILITY 4023void 4024shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT 4025{ 4026 _VSTD::swap(__ptr_, __r.__ptr_); 4027 _VSTD::swap(__cntrl_, __r.__cntrl_); 4028} 4029 4030template<class _Tp> 4031inline _LIBCPP_INLINE_VISIBILITY 4032void 4033shared_ptr<_Tp>::reset() _NOEXCEPT 4034{ 4035 shared_ptr().swap(*this); 4036} 4037 4038template<class _Tp> 4039template<class _Yp> 4040inline _LIBCPP_INLINE_VISIBILITY 4041void 4042shared_ptr<_Tp>::reset(_Yp* __p) 4043{ 4044 shared_ptr(__p).swap(*this); 4045} 4046 4047template<class _Tp> 4048template<class _Yp, class _Dp> 4049inline _LIBCPP_INLINE_VISIBILITY 4050void 4051shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d) 4052{ 4053 shared_ptr(__p, __d).swap(*this); 4054} 4055 4056template<class _Tp> 4057template<class _Yp, class _Dp, class _Alloc> 4058inline _LIBCPP_INLINE_VISIBILITY 4059void 4060shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a) 4061{ 4062 shared_ptr(__p, __d, __a).swap(*this); 4063} 4064 4065#ifndef _LIBCPP_HAS_NO_VARIADICS 4066 4067template<class _Tp, class ..._Args> 4068inline _LIBCPP_INLINE_VISIBILITY 4069shared_ptr<_Tp> 4070make_shared(_Args&& ...__args) 4071{ 4072 return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...); 4073} 4074 4075template<class _Tp, class _Alloc, class ..._Args> 4076inline _LIBCPP_INLINE_VISIBILITY 4077shared_ptr<_Tp> 4078allocate_shared(const _Alloc& __a, _Args&& ...__args) 4079{ 4080 return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...); 4081} 4082 4083#else // _LIBCPP_HAS_NO_VARIADICS 4084 4085template<class _Tp> 4086inline _LIBCPP_INLINE_VISIBILITY 4087shared_ptr<_Tp> 4088make_shared() 4089{ 4090 return shared_ptr<_Tp>::make_shared(); 4091} 4092 4093template<class _Tp, class _A0> 4094inline _LIBCPP_INLINE_VISIBILITY 4095shared_ptr<_Tp> 4096make_shared(_A0& __a0) 4097{ 4098 return shared_ptr<_Tp>::make_shared(__a0); 4099} 4100 4101template<class _Tp, class _A0, class _A1> 4102inline _LIBCPP_INLINE_VISIBILITY 4103shared_ptr<_Tp> 4104make_shared(_A0& __a0, _A1& __a1) 4105{ 4106 return shared_ptr<_Tp>::make_shared(__a0, __a1); 4107} 4108 4109template<class _Tp, class _A0, class _A1, class _A2> 4110inline _LIBCPP_INLINE_VISIBILITY 4111shared_ptr<_Tp> 4112make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 4113{ 4114 return shared_ptr<_Tp>::make_shared(__a0, __a1, __a2); 4115} 4116 4117template<class _Tp, class _Alloc> 4118inline _LIBCPP_INLINE_VISIBILITY 4119shared_ptr<_Tp> 4120allocate_shared(const _Alloc& __a) 4121{ 4122 return shared_ptr<_Tp>::allocate_shared(__a); 4123} 4124 4125template<class _Tp, class _Alloc, class _A0> 4126inline _LIBCPP_INLINE_VISIBILITY 4127shared_ptr<_Tp> 4128allocate_shared(const _Alloc& __a, _A0& __a0) 4129{ 4130 return shared_ptr<_Tp>::allocate_shared(__a, __a0); 4131} 4132 4133template<class _Tp, class _Alloc, class _A0, class _A1> 4134inline _LIBCPP_INLINE_VISIBILITY 4135shared_ptr<_Tp> 4136allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 4137{ 4138 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1); 4139} 4140 4141template<class _Tp, class _Alloc, class _A0, class _A1, class _A2> 4142inline _LIBCPP_INLINE_VISIBILITY 4143shared_ptr<_Tp> 4144allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 4145{ 4146 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1, __a2); 4147} 4148 4149#endif // _LIBCPP_HAS_NO_VARIADICS 4150 4151template<class _Tp, class _Up> 4152inline _LIBCPP_INLINE_VISIBILITY 4153bool 4154operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4155{ 4156 return __x.get() == __y.get(); 4157} 4158 4159template<class _Tp, class _Up> 4160inline _LIBCPP_INLINE_VISIBILITY 4161bool 4162operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4163{ 4164 return !(__x == __y); 4165} 4166 4167template<class _Tp, class _Up> 4168inline _LIBCPP_INLINE_VISIBILITY 4169bool 4170operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4171{ 4172 return __x.get() < __y.get(); 4173} 4174 4175template<class _Tp> 4176inline _LIBCPP_INLINE_VISIBILITY 4177void 4178swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT 4179{ 4180 __x.swap(__y); 4181} 4182 4183template<class _Tp, class _Up> 4184inline _LIBCPP_INLINE_VISIBILITY 4185shared_ptr<_Tp> 4186static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4187{ 4188 return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); 4189} 4190 4191template<class _Tp, class _Up> 4192inline _LIBCPP_INLINE_VISIBILITY 4193shared_ptr<_Tp> 4194dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4195{ 4196 _Tp* __p = dynamic_cast<_Tp*>(__r.get()); 4197 return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>(); 4198} 4199 4200template<class _Tp, class _Up> 4201shared_ptr<_Tp> 4202const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4203{ 4204 return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); 4205} 4206 4207#ifndef _LIBCPP_NO_RTTI 4208 4209template<class _Dp, class _Tp> 4210inline _LIBCPP_INLINE_VISIBILITY 4211_Dp* 4212get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT 4213{ 4214 return __p.template __get_deleter<_Dp>(); 4215} 4216 4217#endif // _LIBCPP_NO_RTTI 4218 4219template<class _Tp> 4220class _LIBCPP_VISIBLE weak_ptr 4221{ 4222public: 4223 typedef _Tp element_type; 4224private: 4225 element_type* __ptr_; 4226 __shared_weak_count* __cntrl_; 4227 4228public: 4229 weak_ptr() _NOEXCEPT; 4230 template<class _Yp> weak_ptr(shared_ptr<_Yp> const& __r, 4231 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 4232 _NOEXCEPT; 4233 weak_ptr(weak_ptr const& __r) _NOEXCEPT; 4234 template<class _Yp> weak_ptr(weak_ptr<_Yp> const& __r, 4235 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 4236 _NOEXCEPT; 4237 4238 ~weak_ptr(); 4239 4240 weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT; 4241 template<class _Yp> weak_ptr& operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT; 4242 template<class _Yp> weak_ptr& operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT; 4243 4244 void swap(weak_ptr& __r) _NOEXCEPT; 4245 void reset() _NOEXCEPT; 4246 4247 _LIBCPP_INLINE_VISIBILITY 4248 long use_count() const _NOEXCEPT 4249 {return __cntrl_ ? __cntrl_->use_count() : 0;} 4250 _LIBCPP_INLINE_VISIBILITY 4251 bool expired() const _NOEXCEPT 4252 {return __cntrl_ == 0 || __cntrl_->use_count() == 0;} 4253 shared_ptr<_Tp> lock() const _NOEXCEPT; 4254 template<class _Up> 4255 _LIBCPP_INLINE_VISIBILITY 4256 bool owner_before(const shared_ptr<_Up>& __r) const 4257 {return __cntrl_ < __r.__cntrl_;} 4258 template<class _Up> 4259 _LIBCPP_INLINE_VISIBILITY 4260 bool owner_before(const weak_ptr<_Up>& __r) const 4261 {return __cntrl_ < __r.__cntrl_;} 4262 4263 template <class _Up> friend class _LIBCPP_VISIBLE weak_ptr; 4264 template <class _Up> friend class _LIBCPP_VISIBLE shared_ptr; 4265}; 4266 4267template<class _Tp> 4268inline _LIBCPP_INLINE_VISIBILITY 4269weak_ptr<_Tp>::weak_ptr() _NOEXCEPT 4270 : __ptr_(0), 4271 __cntrl_(0) 4272{ 4273} 4274 4275template<class _Tp> 4276inline _LIBCPP_INLINE_VISIBILITY 4277weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT 4278 : __ptr_(__r.__ptr_), 4279 __cntrl_(__r.__cntrl_) 4280{ 4281 if (__cntrl_) 4282 __cntrl_->__add_weak(); 4283} 4284 4285template<class _Tp> 4286template<class _Yp> 4287inline _LIBCPP_INLINE_VISIBILITY 4288weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r, 4289 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 4290 _NOEXCEPT 4291 : __ptr_(__r.__ptr_), 4292 __cntrl_(__r.__cntrl_) 4293{ 4294 if (__cntrl_) 4295 __cntrl_->__add_weak(); 4296} 4297 4298template<class _Tp> 4299template<class _Yp> 4300inline _LIBCPP_INLINE_VISIBILITY 4301weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r, 4302 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 4303 _NOEXCEPT 4304 : __ptr_(__r.__ptr_), 4305 __cntrl_(__r.__cntrl_) 4306{ 4307 if (__cntrl_) 4308 __cntrl_->__add_weak(); 4309} 4310 4311template<class _Tp> 4312weak_ptr<_Tp>::~weak_ptr() 4313{ 4314 if (__cntrl_) 4315 __cntrl_->__release_weak(); 4316} 4317 4318template<class _Tp> 4319inline _LIBCPP_INLINE_VISIBILITY 4320weak_ptr<_Tp>& 4321weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT 4322{ 4323 weak_ptr(__r).swap(*this); 4324 return *this; 4325} 4326 4327template<class _Tp> 4328template<class _Yp> 4329inline _LIBCPP_INLINE_VISIBILITY 4330weak_ptr<_Tp>& 4331weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT 4332{ 4333 weak_ptr(__r).swap(*this); 4334 return *this; 4335} 4336 4337template<class _Tp> 4338template<class _Yp> 4339inline _LIBCPP_INLINE_VISIBILITY 4340weak_ptr<_Tp>& 4341weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT 4342{ 4343 weak_ptr(__r).swap(*this); 4344 return *this; 4345} 4346 4347template<class _Tp> 4348inline _LIBCPP_INLINE_VISIBILITY 4349void 4350weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT 4351{ 4352 _VSTD::swap(__ptr_, __r.__ptr_); 4353 _VSTD::swap(__cntrl_, __r.__cntrl_); 4354} 4355 4356template<class _Tp> 4357inline _LIBCPP_INLINE_VISIBILITY 4358void 4359swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT 4360{ 4361 __x.swap(__y); 4362} 4363 4364template<class _Tp> 4365inline _LIBCPP_INLINE_VISIBILITY 4366void 4367weak_ptr<_Tp>::reset() _NOEXCEPT 4368{ 4369 weak_ptr().swap(*this); 4370} 4371 4372template<class _Tp> 4373template<class _Yp> 4374shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r, 4375 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type) 4376 : __ptr_(__r.__ptr_), 4377 __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) 4378{ 4379 if (__cntrl_ == 0) 4380#ifndef _LIBCPP_NO_EXCEPTIONS 4381 throw bad_weak_ptr(); 4382#else 4383 assert(!"bad_weak_ptr"); 4384#endif 4385} 4386 4387template<class _Tp> 4388shared_ptr<_Tp> 4389weak_ptr<_Tp>::lock() const _NOEXCEPT 4390{ 4391 shared_ptr<_Tp> __r; 4392 __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_; 4393 if (__r.__cntrl_) 4394 __r.__ptr_ = __ptr_; 4395 return __r; 4396} 4397 4398template <class _Tp> struct owner_less; 4399 4400template <class _Tp> 4401struct _LIBCPP_VISIBLE owner_less<shared_ptr<_Tp> > 4402 : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> 4403{ 4404 typedef bool result_type; 4405 _LIBCPP_INLINE_VISIBILITY 4406 bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const 4407 {return __x.owner_before(__y);} 4408 _LIBCPP_INLINE_VISIBILITY 4409 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const 4410 {return __x.owner_before(__y);} 4411 _LIBCPP_INLINE_VISIBILITY 4412 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const 4413 {return __x.owner_before(__y);} 4414}; 4415 4416template <class _Tp> 4417struct _LIBCPP_VISIBLE owner_less<weak_ptr<_Tp> > 4418 : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> 4419{ 4420 typedef bool result_type; 4421 _LIBCPP_INLINE_VISIBILITY 4422 bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const 4423 {return __x.owner_before(__y);} 4424 _LIBCPP_INLINE_VISIBILITY 4425 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const 4426 {return __x.owner_before(__y);} 4427 _LIBCPP_INLINE_VISIBILITY 4428 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const 4429 {return __x.owner_before(__y);} 4430}; 4431 4432template<class _Tp> 4433class _LIBCPP_VISIBLE enable_shared_from_this 4434{ 4435 mutable weak_ptr<_Tp> __weak_this_; 4436protected: 4437 _LIBCPP_INLINE_VISIBILITY 4438 enable_shared_from_this() _NOEXCEPT {} 4439 _LIBCPP_INLINE_VISIBILITY 4440 enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {} 4441 _LIBCPP_INLINE_VISIBILITY 4442 enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT 4443 {return *this;} 4444 _LIBCPP_INLINE_VISIBILITY 4445 ~enable_shared_from_this() {} 4446public: 4447 _LIBCPP_INLINE_VISIBILITY 4448 shared_ptr<_Tp> shared_from_this() 4449 {return shared_ptr<_Tp>(__weak_this_);} 4450 _LIBCPP_INLINE_VISIBILITY 4451 shared_ptr<_Tp const> shared_from_this() const 4452 {return shared_ptr<const _Tp>(__weak_this_);} 4453 4454 template <class _Up> friend class shared_ptr; 4455}; 4456 4457template <class _Tp> 4458struct _LIBCPP_VISIBLE hash<shared_ptr<_Tp> > 4459{ 4460 typedef shared_ptr<_Tp> argument_type; 4461 typedef size_t result_type; 4462 _LIBCPP_INLINE_VISIBILITY 4463 result_type operator()(const argument_type& __ptr) const _NOEXCEPT 4464 { 4465 return hash<_Tp*>()(__ptr.get()); 4466 } 4467}; 4468 4469template<class _CharT, class _Traits, class _Yp> 4470inline _LIBCPP_INLINE_VISIBILITY 4471basic_ostream<_CharT, _Traits>& 4472operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p); 4473 4474//enum class 4475struct _LIBCPP_VISIBLE pointer_safety 4476{ 4477 enum _ 4478 { 4479 relaxed, 4480 preferred, 4481 strict 4482 }; 4483 4484 _ __v_; 4485 4486 _LIBCPP_INLINE_VISIBILITY 4487 pointer_safety(_ __v) : __v_(__v) {} 4488 _LIBCPP_INLINE_VISIBILITY 4489 operator int() const {return __v_;} 4490}; 4491 4492void declare_reachable(void* __p); 4493void declare_no_pointers(char* __p, size_t __n); 4494void undeclare_no_pointers(char* __p, size_t __n); 4495pointer_safety get_pointer_safety() _NOEXCEPT; 4496void* __undeclare_reachable(void* __p); 4497 4498template <class _Tp> 4499inline _LIBCPP_INLINE_VISIBILITY 4500_Tp* 4501undeclare_reachable(_Tp* __p) 4502{ 4503 return static_cast<_Tp*>(__undeclare_reachable(__p)); 4504} 4505 4506void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space); 4507 4508_LIBCPP_END_NAMESPACE_STD 4509 4510#endif // _LIBCPP_MEMORY 4511