memory revision 256082
153813Simp// -*- C++ -*- 2118063Simp//===-------------------------- memory ------------------------------------===// 3100213Simp// 452506Simp// The LLVM Compiler Infrastructure 552506Simp// 652506Simp// This file is dual licensed under the MIT and the University of Illinois Open 752506Simp// Source Licenses. See LICENSE.TXT for details. 852506Simp// 952506Simp//===----------------------------------------------------------------------===// 1052506Simp 1152506Simp#ifndef _LIBCPP_MEMORY 1252506Simp#define _LIBCPP_MEMORY 1352506Simp 1452506Simp/* 1552506Simp memory synopsis 1652506Simp 1752506Simpnamespace std 1852506Simp{ 1952506Simp 2052506Simpstruct allocator_arg_t { }; 2152506Simpconstexpr allocator_arg_t allocator_arg = allocator_arg_t(); 2252506Simp 2352506Simptemplate <class T, class Alloc> struct uses_allocator; 2452506Simp 2552506Simptemplate <class Ptr> 2652506Simpstruct pointer_traits 2752506Simp{ 2852506Simp typedef Ptr pointer; 2952506Simp typedef <details> element_type; 3052506Simp typedef <details> difference_type; 3152506Simp 3252506Simp template <class U> using rebind = <details>; 3352506Simp 3452506Simp static pointer pointer_to(<details>); 3552506Simp}; 3652506Simp 3752506Simptemplate <class T> 3852506Simpstruct pointer_traits<T*> 3952506Simp{ 4052506Simp typedef T* pointer; 4152506Simp typedef T element_type; 4286269Simp typedef ptrdiff_t difference_type; 4352506Simp 4452506Simp template <class U> using rebind = U*; 4552506Simp 46119213Simp static pointer pointer_to(<details>) noexcept; 4758545Simp}; 4852506Simp 4965039Simptemplate <class Alloc> 5065039Simpstruct allocator_traits 5152506Simp{ 52118063Simp typedef Alloc allocator_type; 5352506Simp typedef typename allocator_type::value_type 5452506Simp value_type; 5552506Simp 5652506Simp typedef Alloc::pointer | value_type* pointer; 5758545Simp typedef Alloc::const_pointer 5852506Simp | pointer_traits<pointer>::rebind<const value_type> 5986455Simp const_pointer; 6079270Simp typedef Alloc::void_pointer 61107359Snon | pointer_traits<pointer>::rebind<void> 6252506Simp void_pointer; 6386269Simp typedef Alloc::const_void_pointer 6486455Simp | pointer_traits<pointer>::rebind<const void> 65119225Simp const_void_pointer; 6652506Simp typedef Alloc::difference_type 6786455Simp | pointer_traits<pointer>::difference_type 6858545Simp difference_type; 69104854Simp typedef Alloc::size_type 7086269Simp | make_unsigned<difference_type>::type 71104854Simp size_type; 7252506Simp typedef Alloc::propagate_on_container_copy_assignment 7386455Simp | false_type propagate_on_container_copy_assignment; 7452506Simp typedef Alloc::propagate_on_container_move_assignment 7586455Simp | false_type propagate_on_container_move_assignment; 7653813Simp typedef Alloc::propagate_on_container_swap 77100213Simp | false_type propagate_on_container_swap; 7858545Simp 7989945Simp template <class T> using rebind_alloc = Alloc::rebind<U>::other | Alloc<T, Args...>; 8084514Simp template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>; 8158545Simp 8269138Speter static pointer allocate(allocator_type& a, size_type n); 83118634Simp static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); 8452506Simp 8558545Simp static void deallocate(allocator_type& a, pointer p, size_type n) noexcept; 8652506Simp 8753813Simp template <class T, class... Args> 8865039Simp static void construct(allocator_type& a, T* p, Args&&... args); 8971279Simp 9058545Simp template <class T> 9165039Simp static void destroy(allocator_type& a, T* p); 9292471Simp 93116207Simp static size_type max_size(const allocator_type& a); 9484514Simp 9579270Simp static allocator_type 9687757Simp select_on_container_copy_construction(const allocator_type& a); 9779270Simp}; 98117438Simp 99117602Simptemplate <> 100118895Simpclass allocator<void> 10193620Simp{ 10286455Simppublic: 10386455Simp typedef void* pointer; 104104854Simp typedef const void* const_pointer; 10594461Simp typedef void value_type; 10658545Simp 10787757Simp template <class _Up> struct rebind {typedef allocator<_Up> other;}; 10858545Simp}; 109117614Simp 11086455Simptemplate <class T> 11186455Simpclass allocator 11289945Simp{ 11352506Simppublic: 11484514Simp typedef size_t size_type; 11553813Simp typedef ptrdiff_t difference_type; 11671279Simp typedef T* pointer; 11771283Simp typedef const T* const_pointer; 118113667Ssanpei typedef typename add_lvalue_reference<T>::type reference; 11953813Simp typedef typename add_lvalue_reference<const T>::type const_reference; 12052506Simp typedef T value_type; 12152506Simp 122107359Snon template <class U> struct rebind {typedef allocator<U> other;}; 12371283Simp 12471279Simp allocator() noexcept; 12552506Simp allocator(const allocator&) noexcept; 12652506Simp template <class U> allocator(const allocator<U>&) noexcept; 12786269Simp ~allocator(); 12886269Simp pointer address(reference x) const noexcept; 12952506Simp const_pointer address(const_reference x) const noexcept; 13053813Simp pointer allocate(size_type, allocator<void>::const_pointer hint = 0); 13152506Simp void deallocate(pointer p, size_type n) noexcept; 13265039Simp size_type max_size() const noexcept; 13386269Simp template<class U, class... Args> 13486269Simp void construct(U* p, Args&&... args); 13586269Simp template <class U> 13686269Simp void destroy(U* p); 13752506Simp}; 13852506Simp 13952506Simptemplate <class T, class U> 14093893Simpbool operator==(const allocator<T>&, const allocator<U>&) noexcept; 14186455Simp 14284514Simptemplate <class T, class U> 14352506Simpbool operator!=(const allocator<T>&, const allocator<U>&) noexcept; 144104854Simp 145104854Simptemplate <class OutputIterator, class T> 14694461Simpclass raw_storage_iterator 14786269Simp : public iterator<output_iterator_tag, 14886269Simp T, // purposefully not C++03 14986269Simp ptrdiff_t, // purposefully not C++03 15086269Simp T*, // purposefully not C++03 15186269Simp raw_storage_iterator&> // purposefully not C++03 15286269Simp{ 15386269Simppublic: 15486269Simp explicit raw_storage_iterator(OutputIterator x); 15586269Simp raw_storage_iterator& operator*(); 156117614Simp raw_storage_iterator& operator=(const T& element); 157117614Simp raw_storage_iterator& operator++(); 158117614Simp raw_storage_iterator operator++(int); 15986269Simp}; 16086269Simp 16186269Simptemplate <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept; 16286455Simptemplate <class T> void return_temporary_buffer(T* p) noexcept; 16386455Simp 16486455Simptemplate <class T> T* addressof(T& r) noexcept; 165116207Simp 166116207Simptemplate <class InputIterator, class ForwardIterator> 167116207SimpForwardIterator 168117438Simpuninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); 169117445Ssimokawa 170117438Simptemplate <class InputIterator, class Size, class ForwardIterator> 17186269SimpForwardIterator 17286269Simpuninitialized_copy_n(InputIterator first, Size n, ForwardIterator result); 17386269Simp 17486269Simptemplate <class ForwardIterator, class T> 175104854Simpvoid uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); 17686269Simp 17787757Simptemplate <class ForwardIterator, class Size, class T> 17887757SimpForwardIterator 17987757Simpuninitialized_fill_n(ForwardIterator first, Size n, const T& x); 18086455Simp 18186455Simptemplate <class Y> struct auto_ptr_ref {}; 18286455Simp 18386269Simptemplate<class X> 184117759Simpclass auto_ptr 18586269Simp{ 186109455Sshibapublic: 187104854Simp typedef X element_type; 18887044Simp 18986269Simp explicit auto_ptr(X* p =0) throw(); 19065039Simp auto_ptr(auto_ptr&) throw(); 19186269Simp template<class Y> auto_ptr(auto_ptr<Y>&) throw(); 19265039Simp auto_ptr& operator=(auto_ptr&) throw(); 19365039Simp template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw(); 19452506Simp auto_ptr& operator=(auto_ptr_ref<X> r) throw(); 19586455Simp ~auto_ptr() throw(); 19652506Simp 19752506Simp typename add_lvalue_reference<X>::type operator*() const throw(); 19886269Simp X* operator->() const throw(); 19986269Simp X* get() const throw(); 20086269Simp X* release() throw(); 20153813Simp void reset(X* p =0) throw(); 20252506Simp 20352506Simp auto_ptr(auto_ptr_ref<X>) throw(); 20452506Simp template<class Y> operator auto_ptr_ref<Y>() throw(); 20552506Simp template<class Y> operator auto_ptr<Y>() throw(); 20652506Simp}; 20752506Simp 20852506Simptemplate <class T> 20979270Simpstruct default_delete 21079270Simp{ 21179270Simp constexpr default_delete() noexcept = default; 212119225Simp template <class U> default_delete(const default_delete<U>&) noexcept; 213119225Simp 214119225Simp void operator()(T*) const noexcept; 215119225Simp}; 21686455Simp 21786455Simptemplate <class T> 21886455Simpstruct default_delete<T[]> 21989945Simp{ 22089945Simp constexpr default_delete() noexcept = default; 22189945Simp void operator()(T*) const noexcept; 22271279Simp template <class U> void operator()(U*) const = delete; 22371279Simp}; 22471279Simp 22586269Simptemplate <class T, class D = default_delete<T>> 226100213Simpclass unique_ptr 22771279Simp{ 22886269Simppublic: 22986269Simp typedef see below pointer; 23086269Simp typedef T element_type; 23189945Simp typedef D deleter_type; 23289945Simp 23389945Simp // constructors 23486269Simp constexpr unique_ptr() noexcept; 23586269Simp explicit unique_ptr(pointer p) noexcept; 23686269Simp unique_ptr(pointer p, see below d1) noexcept; 23752506Simp unique_ptr(pointer p, see below d2) noexcept; 23852506Simp unique_ptr(unique_ptr&& u) noexcept; 23986269Simp unique_ptr(nullptr_t) noexcept : unique_ptr() { } 24053813Simp template <class U, class E> 24153813Simp unique_ptr(unique_ptr<U, E>&& u) noexcept; 242100213Simp template <class U> 243100213Simp unique_ptr(auto_ptr<U>&& u) noexcept; 244100213Simp 24592471Simp // destructor 24692471Simp ~unique_ptr(); 24792471Simp 24852506Simp // assignment 24971279Simp unique_ptr& operator=(unique_ptr&& u) noexcept; 25065039Simp template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept; 25165039Simp unique_ptr& operator=(nullptr_t) noexcept; 25265039Simp 25365039Simp // observers 25487044Simp typename add_lvalue_reference<T>::type operator*() const; 25565039Simp pointer operator->() const noexcept; 25652506Simp pointer get() const noexcept; 25765039Simp deleter_type& get_deleter() noexcept; 25889103Simp const deleter_type& get_deleter() const noexcept; 25953813Simp explicit operator bool() const noexcept; 26052506Simp 26165039Simp // modifiers 26286269Simp pointer release() noexcept; 26365039Simp void reset(pointer p = pointer()) noexcept; 26465039Simp void swap(unique_ptr& u) noexcept; 265119213Simp}; 266119213Simp 267119213Simptemplate <class T, class D> 268119213Simpclass unique_ptr<T[], D> 26952506Simp{ 27053813Simppublic: 27179270Simp typedef implementation-defined pointer; 272117764Simp typedef T element_type; 27352506Simp typedef D deleter_type; 27486269Simp 27586269Simp // constructors 27665039Simp constexpr unique_ptr() noexcept; 27786269Simp explicit unique_ptr(pointer p) noexcept; 27886269Simp unique_ptr(pointer p, see below d) noexcept; 27986269Simp unique_ptr(pointer p, see below d) noexcept; 28058545Simp unique_ptr(unique_ptr&& u) noexcept; 28171279Simp unique_ptr(nullptr_t) noexcept : unique_ptr() { } 28258545Simp 28352506Simp // destructor 28486269Simp ~unique_ptr(); 28558545Simp 28652506Simp // assignment 28752506Simp unique_ptr& operator=(unique_ptr&& u) noexcept; 28886575Simp unique_ptr& operator=(nullptr_t) noexcept; 289104854Simp 290104854Simp // observers 29152506Simp T& operator[](size_t i) const; 29286269Simp pointer get() const noexcept; 29386269Simp deleter_type& get_deleter() noexcept; 29486269Simp const deleter_type& get_deleter() const noexcept; 29586269Simp explicit operator bool() const noexcept; 29686269Simp 297107359Snon // modifiers 29886269Simp pointer release() noexcept; 29952506Simp void reset(pointer p = pointer()) noexcept; 30086269Simp void reset(nullptr_t) noexcept; 30152506Simp template <class U> void reset(U) = delete; 30253813Simp void swap(unique_ptr& u) noexcept; 30352506Simp}; 30452506Simp 30558545Simptemplate <class T, class D> 30658545Simp void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; 307118895Simp 30858545Simptemplate <class T1, class D1, class T2, class D2> 309118895Simp bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 310118895Simptemplate <class T1, class D1, class T2, class D2> 311118895Simp bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 31286269Simptemplate <class T1, class D1, class T2, class D2> 31386269Simp bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 31486269Simptemplate <class T1, class D1, class T2, class D2> 31586455Simp bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 31686269Simptemplate <class T1, class D1, class T2, class D2> 31786269Simp bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 31886269Simptemplate <class T1, class D1, class T2, class D2> 31986455Simp bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); 32086455Simp 32186455Simptemplate <class T, class D> 322104831Simp bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; 323106891Simptemplate <class T, class D> 324106891Simp bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept; 32586455Simptemplate <class T, class D> 32686455Simp bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept; 32786269Simptemplate <class T, class D> 32886455Simp bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept; 329104854Simp 33086455Simptemplate <class T, class D> 33193620Simp bool operator<(const unique_ptr<T, D>& x, nullptr_t); 33286455Simptemplate <class T, class D> 33379270Simp bool operator<(nullptr_t, const unique_ptr<T, D>& y); 33479270Simptemplate <class T, class D> 33579270Simp bool operator<=(const unique_ptr<T, D>& x, nullptr_t); 33658545Simptemplate <class T, class D> 337100213Simp bool operator<=(nullptr_t, const unique_ptr<T, D>& y); 33858545Simptemplate <class T, class D> 33958545Simp bool operator>(const unique_ptr<T, D>& x, nullptr_t); 34093620Simptemplate <class T, class D> 34193620Simp bool operator>(nullptr_t, const unique_ptr<T, D>& y); 34293620Simptemplate <class T, class D> 34393620Simp bool operator>=(const unique_ptr<T, D>& x, nullptr_t); 34465039Simptemplate <class T, class D> 34565039Simp bool operator>=(nullptr_t, const unique_ptr<T, D>& y); 34665039Simp 347104854Simpclass bad_weak_ptr 348104854Simp : public std::exception 349104854Simp{ 35058545Simp bad_weak_ptr() noexcept; 35158545Simp}; 35265039Simp 353107359Snontemplate<class T, class... Args> unique_ptr<T> make_unique(Args&&... args); // C++14 35486269Simptemplate<class T> unique_ptr<T> make_unique(size_t n); // C++14 35586455Simptemplate<class T, class... Args> unspecified make_unique(Args&&...) = delete; // C++14, T == U[N] 35658545Simp 357104831Simptemplate<class T> 358104854Simpclass shared_ptr 359104831Simp{ 36086455Simppublic: 36186455Simp typedef T element_type; 36286455Simp 36393622Simp // constructors: 36486455Simp constexpr shared_ptr() noexcept; 36584514Simp template<class Y> explicit shared_ptr(Y* p); 36684514Simp template<class Y, class D> shared_ptr(Y* p, D d); 36784514Simp template<class Y, class D, class A> shared_ptr(Y* p, D d, A a); 368107359Snon template <class D> shared_ptr(nullptr_t p, D d); 369107359Snon template <class D, class A> shared_ptr(nullptr_t p, D d, A a); 370107359Snon template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept; 37186455Simp shared_ptr(const shared_ptr& r) noexcept; 37286455Simp template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept; 37386455Simp shared_ptr(shared_ptr&& r) noexcept; 37486269Simp template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept; 375109103Sshiba template<class Y> explicit shared_ptr(const weak_ptr<Y>& r); 376109103Sshiba template<class Y> shared_ptr(auto_ptr<Y>&& r); 37752506Simp template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r); 37886269Simp shared_ptr(nullptr_t) : shared_ptr() { } 37986269Simp 38086269Simp // destructor: 38186269Simp ~shared_ptr(); 38286269Simp 38386269Simp // assignment: 38486269Simp shared_ptr& operator=(const shared_ptr& r) noexcept; 38586269Simp template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept; 38686269Simp shared_ptr& operator=(shared_ptr&& r) noexcept; 38752506Simp template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r); 38852506Simp template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); 38952506Simp template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r); 390118063Simp 391118063Simp // modifiers: 392118063Simp void swap(shared_ptr& r) noexcept; 393117602Simp void reset() noexcept; 394117602Simp template<class Y> void reset(Y* p); 395117602Simp template<class Y, class D> void reset(Y* p, D d); 39652506Simp template<class Y, class D, class A> void reset(Y* p, D d, A a); 39752506Simp 39853813Simp // observers: 39953813Simp T* get() const noexcept; 40052506Simp T& operator*() const noexcept; 40186269Simp T* operator->() const noexcept; 40286269Simp long use_count() const noexcept; 40386269Simp bool unique() const noexcept; 40486269Simp explicit operator bool() const noexcept; 40552506Simp template<class U> bool owner_before(shared_ptr<U> const& b) const; 40679270Simp template<class U> bool owner_before(weak_ptr<U> const& b) const; 40789103Simp}; 40852506Simp 40952506Simp// shared_ptr comparisons: 41086269Simptemplate<class T, class U> 41171279Simp bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 412118063Simptemplate<class T, class U> 41352506Simp bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 41486269Simptemplate<class T, class U> 41586269Simp bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 41686269Simptemplate<class T, class U> 41752506Simp bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 41886269Simptemplate<class T, class U> 41952506Simp bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 42086269Simptemplate<class T, class U> 42152506Simp bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; 422104854Simp 42352506Simptemplate <class T> 42486269Simp bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept; 42586269Simptemplate <class T> 42686269Simp bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept; 42786269Simptemplate <class T> 42886269Simp bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept; 42986269Simptemplate <class T> 430107359Snon bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept; 431107359Snontemplate <class T> 432107359Snon bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept; 43365039Simptemplate <class T> 43465039Simpbool operator<(nullptr_t, const shared_ptr<T>& y) noexcept; 43586455Simptemplate <class T> 43665039Simp bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept; 43786571Simptemplate <class T> 43886269Simp bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept; 43986269Simptemplate <class T> 44079270Simp bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept; 44165039Simptemplate <class T> 44286269Simp bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept; 44365039Simptemplate <class T> 44465039Simp bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept; 44565039Simptemplate <class T> 44652506Simp bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept; 44784514Simp 44884514Simp// shared_ptr specialized algorithms: 44984514Simptemplate<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept; 45086269Simp 45186269Simp// shared_ptr casts: 45286269Simptemplate<class T, class U> 45386269Simp shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept; 45452506Simptemplate<class T, class U> 45593622Simp shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept; 456103169Simptemplate<class T, class U> 45786269Simp shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept; 45886269Simp 45986269Simp// shared_ptr I/O: 460113667Ssanpeitemplate<class E, class T, class Y> 46152506Simp basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p); 46286269Simp 463104854Simp// shared_ptr get_deleter: 46486269Simptemplate<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept; 46558545Simp 46658545Simptemplate<class T, class... Args> 467107359Snon shared_ptr<T> make_shared(Args&&... args); 468116481Simptemplate<class T, class A, class... Args> 46986281Simp shared_ptr<T> allocate_shared(const A& a, Args&&... args); 47058545Simp 471119215Simptemplate<class T> 472107359Snonclass weak_ptr 47393620Simp{ 474118634Simppublic: 47586269Simp typedef T element_type; 47686392Simp 477107359Snon // constructors 478114089Simp constexpr weak_ptr() noexcept; 47986269Simp template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept; 48086269Simp weak_ptr(weak_ptr const& r) noexcept; 48186269Simp template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept; 48286269Simp 48386269Simp // destructor 48479270Simp ~weak_ptr(); 48586269Simp 486113318Simp // assignment 487107359Snon weak_ptr& operator=(weak_ptr const& r) noexcept; 48886269Simp template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept; 489110935Sshiba template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept; 49086580Simp 49152506Simp // modifiers 49252506Simp void swap(weak_ptr& r) noexcept; 493104854Simp void reset() noexcept; 494109453Sshiba 49593622Simp // observers 496110175Sshiba long use_count() const noexcept; 49786269Simp bool expired() const noexcept; 498104854Simp shared_ptr<T> lock() const noexcept; 499103169Simp template<class U> bool owner_before(shared_ptr<U> const& b); 500113318Simp template<class U> bool owner_before(weak_ptr<U> const& b); 50186269Simp}; 502113322Simp 50358545Simp// weak_ptr specialized algorithms: 50486269Simptemplate<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept; 50558545Simp 506104854Simp// class owner_less: 50758545Simptemplate<class T> struct owner_less; 50879270Simp 50979270Simptemplate<class T> 51065039Simpstruct owner_less<shared_ptr<T>> 51179270Simp : binary_function<shared_ptr<T>, shared_ptr<T>, bool> 51286269Simp{ 513113318Simp typedef bool result_type; 51486269Simp bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const; 51586269Simp bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const; 51686269Simp bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const; 51786269Simp}; 51886269Simp 519104854Simptemplate<class T> 520112356Simpstruct owner_less<weak_ptr<T>> 521104854Simp : binary_function<weak_ptr<T>, weak_ptr<T>, bool> 52258545Simp{ 52386269Simp typedef bool result_type; 52486269Simp bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const; 52558545Simp bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const; 52686269Simp bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const; 52758545Simp}; 528107359Snon 52958545Simptemplate<class T> 530116481Simpclass enable_shared_from_this 53193620Simp{ 53293620Simpprotected: 53393620Simp constexpr enable_shared_from_this() noexcept; 53493620Simp enable_shared_from_this(enable_shared_from_this const&) noexcept; 535107359Snon enable_shared_from_this& operator=(enable_shared_from_this const&) noexcept; 53686269Simp ~enable_shared_from_this(); 537107359Snonpublic: 53858545Simp shared_ptr<T> shared_from_this(); 539119215Simp shared_ptr<T const> shared_from_this() const; 54086269Simp}; 541107359Snon 54286269Simptemplate<class T> 54393620Simp bool atomic_is_lock_free(const shared_ptr<T>* p); 54486269Simptemplate<class T> 54593620Simp shared_ptr<T> atomic_load(const shared_ptr<T>* p); 546107359Snontemplate<class T> 54786269Simp shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo); 548118634Simptemplate<class T> 54986269Simp void atomic_store(shared_ptr<T>* p, shared_ptr<T> r); 55071283Simptemplate<class T> 55186269Simp void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 55279270Simptemplate<class T> 553107359Snon shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r); 554107359Snontemplate<class T> 55579270Simp shared_ptr<T> 556114089Simp atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo); 557115754Simptemplate<class T> 55886269Simp bool 55984514Simp atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 56086269Simptemplate<class T> 56186269Simp bool 56284514Simp atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w); 56386269Simptemplate<class T> 56486269Simp bool 56586269Simp atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 56686269Simp shared_ptr<T> w, memory_order success, 56786269Simp memory_order failure); 568109103Sshibatemplate<class T> 569107359Snon bool 570107359Snon atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v, 571107359Snon shared_ptr<T> w, memory_order success, 572107359Snon memory_order failure); 573109103Sshiba// Hash support 57489103Simptemplate <class T> struct hash; 57586269Simptemplate <class T, class D> struct hash<unique_ptr<T, D> >; 576113322Simptemplate <class T> struct hash<shared_ptr<T> >; 57786269Simp 57886269Simp// Pointer safety 57986269Simpenum class pointer_safety { relaxed, preferred, strict }; 58086269Simpvoid declare_reachable(void *p); 581113318Simptemplate <class T> T *undeclare_reachable(T *p); 582107359Snonvoid declare_no_pointers(char *p, size_t n); 58386269Simpvoid undeclare_no_pointers(char *p, size_t n); 58486269Simppointer_safety get_pointer_safety() noexcept; 585110935Sshiba 58674634Simpvoid* align(size_t alignment, size_t size, void*& ptr, size_t& space); 587 588} // std 589 590*/ 591 592#include <__config> 593#include <type_traits> 594#include <typeinfo> 595#include <cstddef> 596#include <cstdint> 597#include <new> 598#include <utility> 599#include <limits> 600#include <iterator> 601#include <__functional_base> 602#include <iosfwd> 603#include <tuple> 604#include <cstring> 605#if defined(_LIBCPP_NO_EXCEPTIONS) 606 #include <cassert> 607#endif 608 609#if __has_feature(cxx_atomic) 610# include <atomic> 611#endif 612 613#include <__undef_min_max> 614 615#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 616#pragma GCC system_header 617#endif 618 619_LIBCPP_BEGIN_NAMESPACE_STD 620 621// addressof 622 623template <class _Tp> 624inline _LIBCPP_INLINE_VISIBILITY 625_Tp* 626addressof(_Tp& __x) _NOEXCEPT 627{ 628 return (_Tp*)&reinterpret_cast<const volatile char&>(__x); 629} 630 631#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) 632// Objective-C++ Automatic Reference Counting uses qualified pointers 633// that require special addressof() signatures. When 634// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler 635// itself is providing these definitions. Otherwise, we provide them. 636template <class _Tp> 637inline _LIBCPP_INLINE_VISIBILITY 638__strong _Tp* 639addressof(__strong _Tp& __x) _NOEXCEPT 640{ 641 return &__x; 642} 643 644#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK 645template <class _Tp> 646inline _LIBCPP_INLINE_VISIBILITY 647__weak _Tp* 648addressof(__weak _Tp& __x) _NOEXCEPT 649{ 650 return &__x; 651} 652#endif 653 654template <class _Tp> 655inline _LIBCPP_INLINE_VISIBILITY 656__autoreleasing _Tp* 657addressof(__autoreleasing _Tp& __x) _NOEXCEPT 658{ 659 return &__x; 660} 661 662template <class _Tp> 663inline _LIBCPP_INLINE_VISIBILITY 664__unsafe_unretained _Tp* 665addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT 666{ 667 return &__x; 668} 669#endif 670 671template <class _Tp> class allocator; 672 673template <> 674class _LIBCPP_TYPE_VIS allocator<void> 675{ 676public: 677 typedef void* pointer; 678 typedef const void* const_pointer; 679 typedef void value_type; 680 681 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 682}; 683 684template <> 685class _LIBCPP_TYPE_VIS allocator<const void> 686{ 687public: 688 typedef const void* pointer; 689 typedef const void* const_pointer; 690 typedef const void value_type; 691 692 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 693}; 694 695// pointer_traits 696 697template <class _Tp> 698struct __has_element_type 699{ 700private: 701 struct __two {char __lx; char __lxx;}; 702 template <class _Up> static __two __test(...); 703 template <class _Up> static char __test(typename _Up::element_type* = 0); 704public: 705 static const bool value = sizeof(__test<_Tp>(0)) == 1; 706}; 707 708template <class _Ptr, bool = __has_element_type<_Ptr>::value> 709struct __pointer_traits_element_type; 710 711template <class _Ptr> 712struct __pointer_traits_element_type<_Ptr, true> 713{ 714 typedef typename _Ptr::element_type type; 715}; 716 717#ifndef _LIBCPP_HAS_NO_VARIADICS 718 719template <template <class, class...> class _Sp, class _Tp, class ..._Args> 720struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true> 721{ 722 typedef typename _Sp<_Tp, _Args...>::element_type type; 723}; 724 725template <template <class, class...> class _Sp, class _Tp, class ..._Args> 726struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false> 727{ 728 typedef _Tp type; 729}; 730 731#else // _LIBCPP_HAS_NO_VARIADICS 732 733template <template <class> class _Sp, class _Tp> 734struct __pointer_traits_element_type<_Sp<_Tp>, true> 735{ 736 typedef typename _Sp<_Tp>::element_type type; 737}; 738 739template <template <class> class _Sp, class _Tp> 740struct __pointer_traits_element_type<_Sp<_Tp>, false> 741{ 742 typedef _Tp type; 743}; 744 745template <template <class, class> class _Sp, class _Tp, class _A0> 746struct __pointer_traits_element_type<_Sp<_Tp, _A0>, true> 747{ 748 typedef typename _Sp<_Tp, _A0>::element_type type; 749}; 750 751template <template <class, class> class _Sp, class _Tp, class _A0> 752struct __pointer_traits_element_type<_Sp<_Tp, _A0>, false> 753{ 754 typedef _Tp type; 755}; 756 757template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1> 758struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, true> 759{ 760 typedef typename _Sp<_Tp, _A0, _A1>::element_type type; 761}; 762 763template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1> 764struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, false> 765{ 766 typedef _Tp type; 767}; 768 769template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 770 class _A1, class _A2> 771struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, true> 772{ 773 typedef typename _Sp<_Tp, _A0, _A1, _A2>::element_type type; 774}; 775 776template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 777 class _A1, class _A2> 778struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, false> 779{ 780 typedef _Tp type; 781}; 782 783#endif // _LIBCPP_HAS_NO_VARIADICS 784 785template <class _Tp> 786struct __has_difference_type 787{ 788private: 789 struct __two {char __lx; char __lxx;}; 790 template <class _Up> static __two __test(...); 791 template <class _Up> static char __test(typename _Up::difference_type* = 0); 792public: 793 static const bool value = sizeof(__test<_Tp>(0)) == 1; 794}; 795 796template <class _Ptr, bool = __has_difference_type<_Ptr>::value> 797struct __pointer_traits_difference_type 798{ 799 typedef ptrdiff_t type; 800}; 801 802template <class _Ptr> 803struct __pointer_traits_difference_type<_Ptr, true> 804{ 805 typedef typename _Ptr::difference_type type; 806}; 807 808template <class _Tp, class _Up> 809struct __has_rebind 810{ 811private: 812 struct __two {char __lx; char __lxx;}; 813 template <class _Xp> static __two __test(...); 814 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0); 815public: 816 static const bool value = sizeof(__test<_Tp>(0)) == 1; 817}; 818 819template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> 820struct __pointer_traits_rebind 821{ 822#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 823 typedef typename _Tp::template rebind<_Up> type; 824#else 825 typedef typename _Tp::template rebind<_Up>::other type; 826#endif 827}; 828 829#ifndef _LIBCPP_HAS_NO_VARIADICS 830 831template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 832struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true> 833{ 834#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 835 typedef typename _Sp<_Tp, _Args...>::template rebind<_Up> type; 836#else 837 typedef typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type; 838#endif 839}; 840 841template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up> 842struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false> 843{ 844 typedef _Sp<_Up, _Args...> type; 845}; 846 847#else // _LIBCPP_HAS_NO_VARIADICS 848 849template <template <class> class _Sp, class _Tp, class _Up> 850struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true> 851{ 852#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 853 typedef typename _Sp<_Tp>::template rebind<_Up> type; 854#else 855 typedef typename _Sp<_Tp>::template rebind<_Up>::other type; 856#endif 857}; 858 859template <template <class> class _Sp, class _Tp, class _Up> 860struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false> 861{ 862 typedef _Sp<_Up> type; 863}; 864 865template <template <class, class> class _Sp, class _Tp, class _A0, class _Up> 866struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true> 867{ 868#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 869 typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type; 870#else 871 typedef typename _Sp<_Tp, _A0>::template rebind<_Up>::other type; 872#endif 873}; 874 875template <template <class, class> class _Sp, class _Tp, class _A0, class _Up> 876struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false> 877{ 878 typedef _Sp<_Up, _A0> type; 879}; 880 881template <template <class, class, class> class _Sp, class _Tp, class _A0, 882 class _A1, class _Up> 883struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true> 884{ 885#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 886 typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type; 887#else 888 typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up>::other type; 889#endif 890}; 891 892template <template <class, class, class> class _Sp, class _Tp, class _A0, 893 class _A1, class _Up> 894struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false> 895{ 896 typedef _Sp<_Up, _A0, _A1> type; 897}; 898 899template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 900 class _A1, class _A2, class _Up> 901struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true> 902{ 903#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 904 typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type; 905#else 906 typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type; 907#endif 908}; 909 910template <template <class, class, class, class> class _Sp, class _Tp, class _A0, 911 class _A1, class _A2, class _Up> 912struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false> 913{ 914 typedef _Sp<_Up, _A0, _A1, _A2> type; 915}; 916 917#endif // _LIBCPP_HAS_NO_VARIADICS 918 919template <class _Ptr> 920struct _LIBCPP_TYPE_VIS pointer_traits 921{ 922 typedef _Ptr pointer; 923 typedef typename __pointer_traits_element_type<pointer>::type element_type; 924 typedef typename __pointer_traits_difference_type<pointer>::type difference_type; 925 926#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 927 template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type; 928#else 929 template <class _Up> struct rebind 930 {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;}; 931#endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES 932 933private: 934 struct __nat {}; 935public: 936 _LIBCPP_INLINE_VISIBILITY 937 static pointer pointer_to(typename conditional<is_void<element_type>::value, 938 __nat, element_type>::type& __r) 939 {return pointer::pointer_to(__r);} 940}; 941 942template <class _Tp> 943struct _LIBCPP_TYPE_VIS pointer_traits<_Tp*> 944{ 945 typedef _Tp* pointer; 946 typedef _Tp element_type; 947 typedef ptrdiff_t difference_type; 948 949#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 950 template <class _Up> using rebind = _Up*; 951#else 952 template <class _Up> struct rebind {typedef _Up* other;}; 953#endif 954 955private: 956 struct __nat {}; 957public: 958 _LIBCPP_INLINE_VISIBILITY 959 static pointer pointer_to(typename conditional<is_void<element_type>::value, 960 __nat, element_type>::type& __r) _NOEXCEPT 961 {return _VSTD::addressof(__r);} 962}; 963 964// allocator_traits 965 966namespace __has_pointer_type_imp 967{ 968 template <class _Up> static __two __test(...); 969 template <class _Up> static char __test(typename _Up::pointer* = 0); 970} 971 972template <class _Tp> 973struct __has_pointer_type 974 : public integral_constant<bool, sizeof(__has_pointer_type_imp::__test<_Tp>(0)) == 1> 975{ 976}; 977 978namespace __pointer_type_imp 979{ 980 981template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value> 982struct __pointer_type 983{ 984 typedef typename _Dp::pointer type; 985}; 986 987template <class _Tp, class _Dp> 988struct __pointer_type<_Tp, _Dp, false> 989{ 990 typedef _Tp* type; 991}; 992 993} // __pointer_type_imp 994 995template <class _Tp, class _Dp> 996struct __pointer_type 997{ 998 typedef typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type; 999}; 1000 1001template <class _Tp> 1002struct __has_const_pointer 1003{ 1004private: 1005 struct __two {char __lx; char __lxx;}; 1006 template <class _Up> static __two __test(...); 1007 template <class _Up> static char __test(typename _Up::const_pointer* = 0); 1008public: 1009 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1010}; 1011 1012template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value> 1013struct __const_pointer 1014{ 1015 typedef typename _Alloc::const_pointer type; 1016}; 1017 1018template <class _Tp, class _Ptr, class _Alloc> 1019struct __const_pointer<_Tp, _Ptr, _Alloc, false> 1020{ 1021#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1022 typedef typename pointer_traits<_Ptr>::template rebind<const _Tp> type; 1023#else 1024 typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type; 1025#endif 1026}; 1027 1028template <class _Tp> 1029struct __has_void_pointer 1030{ 1031private: 1032 struct __two {char __lx; char __lxx;}; 1033 template <class _Up> static __two __test(...); 1034 template <class _Up> static char __test(typename _Up::void_pointer* = 0); 1035public: 1036 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1037}; 1038 1039template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value> 1040struct __void_pointer 1041{ 1042 typedef typename _Alloc::void_pointer type; 1043}; 1044 1045template <class _Ptr, class _Alloc> 1046struct __void_pointer<_Ptr, _Alloc, false> 1047{ 1048#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1049 typedef typename pointer_traits<_Ptr>::template rebind<void> type; 1050#else 1051 typedef typename pointer_traits<_Ptr>::template rebind<void>::other type; 1052#endif 1053}; 1054 1055template <class _Tp> 1056struct __has_const_void_pointer 1057{ 1058private: 1059 struct __two {char __lx; char __lxx;}; 1060 template <class _Up> static __two __test(...); 1061 template <class _Up> static char __test(typename _Up::const_void_pointer* = 0); 1062public: 1063 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1064}; 1065 1066template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value> 1067struct __const_void_pointer 1068{ 1069 typedef typename _Alloc::const_void_pointer type; 1070}; 1071 1072template <class _Ptr, class _Alloc> 1073struct __const_void_pointer<_Ptr, _Alloc, false> 1074{ 1075#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1076 typedef typename pointer_traits<_Ptr>::template rebind<const void> type; 1077#else 1078 typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type; 1079#endif 1080}; 1081 1082template <class _Tp> 1083inline _LIBCPP_INLINE_VISIBILITY 1084_Tp* 1085__to_raw_pointer(_Tp* __p) _NOEXCEPT 1086{ 1087 return __p; 1088} 1089 1090template <class _Pointer> 1091inline _LIBCPP_INLINE_VISIBILITY 1092typename pointer_traits<_Pointer>::element_type* 1093__to_raw_pointer(_Pointer __p) _NOEXCEPT 1094{ 1095 return _VSTD::__to_raw_pointer(__p.operator->()); 1096} 1097 1098template <class _Tp> 1099struct __has_size_type 1100{ 1101private: 1102 struct __two {char __lx; char __lxx;}; 1103 template <class _Up> static __two __test(...); 1104 template <class _Up> static char __test(typename _Up::size_type* = 0); 1105public: 1106 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1107}; 1108 1109template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value> 1110struct __size_type 1111{ 1112 typedef typename make_unsigned<_DiffType>::type type; 1113}; 1114 1115template <class _Alloc, class _DiffType> 1116struct __size_type<_Alloc, _DiffType, true> 1117{ 1118 typedef typename _Alloc::size_type type; 1119}; 1120 1121template <class _Tp> 1122struct __has_propagate_on_container_copy_assignment 1123{ 1124private: 1125 struct __two {char __lx; char __lxx;}; 1126 template <class _Up> static __two __test(...); 1127 template <class _Up> static char __test(typename _Up::propagate_on_container_copy_assignment* = 0); 1128public: 1129 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1130}; 1131 1132template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value> 1133struct __propagate_on_container_copy_assignment 1134{ 1135 typedef false_type type; 1136}; 1137 1138template <class _Alloc> 1139struct __propagate_on_container_copy_assignment<_Alloc, true> 1140{ 1141 typedef typename _Alloc::propagate_on_container_copy_assignment type; 1142}; 1143 1144template <class _Tp> 1145struct __has_propagate_on_container_move_assignment 1146{ 1147private: 1148 struct __two {char __lx; char __lxx;}; 1149 template <class _Up> static __two __test(...); 1150 template <class _Up> static char __test(typename _Up::propagate_on_container_move_assignment* = 0); 1151public: 1152 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1153}; 1154 1155template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value> 1156struct __propagate_on_container_move_assignment 1157{ 1158 typedef false_type type; 1159}; 1160 1161template <class _Alloc> 1162struct __propagate_on_container_move_assignment<_Alloc, true> 1163{ 1164 typedef typename _Alloc::propagate_on_container_move_assignment type; 1165}; 1166 1167template <class _Tp> 1168struct __has_propagate_on_container_swap 1169{ 1170private: 1171 struct __two {char __lx; char __lxx;}; 1172 template <class _Up> static __two __test(...); 1173 template <class _Up> static char __test(typename _Up::propagate_on_container_swap* = 0); 1174public: 1175 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1176}; 1177 1178template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value> 1179struct __propagate_on_container_swap 1180{ 1181 typedef false_type type; 1182}; 1183 1184template <class _Alloc> 1185struct __propagate_on_container_swap<_Alloc, true> 1186{ 1187 typedef typename _Alloc::propagate_on_container_swap type; 1188}; 1189 1190template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> 1191struct __has_rebind_other 1192{ 1193private: 1194 struct __two {char __lx; char __lxx;}; 1195 template <class _Xp> static __two __test(...); 1196 template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0); 1197public: 1198 static const bool value = sizeof(__test<_Tp>(0)) == 1; 1199}; 1200 1201template <class _Tp, class _Up> 1202struct __has_rebind_other<_Tp, _Up, false> 1203{ 1204 static const bool value = false; 1205}; 1206 1207template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value> 1208struct __allocator_traits_rebind 1209{ 1210 typedef typename _Tp::template rebind<_Up>::other type; 1211}; 1212 1213#ifndef _LIBCPP_HAS_NO_VARIADICS 1214 1215template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> 1216struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> 1217{ 1218 typedef typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type; 1219}; 1220 1221template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> 1222struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> 1223{ 1224 typedef _Alloc<_Up, _Args...> type; 1225}; 1226 1227#else // _LIBCPP_HAS_NO_VARIADICS 1228 1229template <template <class> class _Alloc, class _Tp, class _Up> 1230struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, true> 1231{ 1232 typedef typename _Alloc<_Tp>::template rebind<_Up>::other type; 1233}; 1234 1235template <template <class> class _Alloc, class _Tp, class _Up> 1236struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, false> 1237{ 1238 typedef _Alloc<_Up> type; 1239}; 1240 1241template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up> 1242struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, true> 1243{ 1244 typedef typename _Alloc<_Tp, _A0>::template rebind<_Up>::other type; 1245}; 1246 1247template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up> 1248struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, false> 1249{ 1250 typedef _Alloc<_Up, _A0> type; 1251}; 1252 1253template <template <class, class, class> class _Alloc, class _Tp, class _A0, 1254 class _A1, class _Up> 1255struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, true> 1256{ 1257 typedef typename _Alloc<_Tp, _A0, _A1>::template rebind<_Up>::other type; 1258}; 1259 1260template <template <class, class, class> class _Alloc, class _Tp, class _A0, 1261 class _A1, class _Up> 1262struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, false> 1263{ 1264 typedef _Alloc<_Up, _A0, _A1> type; 1265}; 1266 1267template <template <class, class, class, class> class _Alloc, class _Tp, class _A0, 1268 class _A1, class _A2, class _Up> 1269struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, true> 1270{ 1271 typedef typename _Alloc<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type; 1272}; 1273 1274template <template <class, class, class, class> class _Alloc, class _Tp, class _A0, 1275 class _A1, class _A2, class _Up> 1276struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false> 1277{ 1278 typedef _Alloc<_Up, _A0, _A1, _A2> type; 1279}; 1280 1281#endif // _LIBCPP_HAS_NO_VARIADICS 1282 1283#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE 1284 1285template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1286auto 1287__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) 1288 -> decltype(__a.allocate(__sz, __p), true_type()); 1289 1290template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1291auto 1292__has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) 1293 -> false_type; 1294 1295template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1296struct __has_allocate_hint 1297 : integral_constant<bool, 1298 is_same< 1299 decltype(__has_allocate_hint_test(declval<_Alloc>(), 1300 declval<_SizeType>(), 1301 declval<_ConstVoidPtr>())), 1302 true_type>::value> 1303{ 1304}; 1305 1306#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1307 1308template <class _Alloc, class _SizeType, class _ConstVoidPtr> 1309struct __has_allocate_hint 1310 : true_type 1311{ 1312}; 1313 1314#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1315 1316#if !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1317 1318template <class _Alloc, class _Tp, class ..._Args> 1319decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(), 1320 _VSTD::declval<_Args>()...), 1321 true_type()) 1322__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args); 1323 1324template <class _Alloc, class _Pointer, class ..._Args> 1325false_type 1326__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args); 1327 1328template <class _Alloc, class _Pointer, class ..._Args> 1329struct __has_construct 1330 : integral_constant<bool, 1331 is_same< 1332 decltype(__has_construct_test(declval<_Alloc>(), 1333 declval<_Pointer>(), 1334 declval<_Args>()...)), 1335 true_type>::value> 1336{ 1337}; 1338 1339template <class _Alloc, class _Pointer> 1340auto 1341__has_destroy_test(_Alloc&& __a, _Pointer&& __p) 1342 -> decltype(__a.destroy(__p), true_type()); 1343 1344template <class _Alloc, class _Pointer> 1345auto 1346__has_destroy_test(const _Alloc& __a, _Pointer&& __p) 1347 -> false_type; 1348 1349template <class _Alloc, class _Pointer> 1350struct __has_destroy 1351 : integral_constant<bool, 1352 is_same< 1353 decltype(__has_destroy_test(declval<_Alloc>(), 1354 declval<_Pointer>())), 1355 true_type>::value> 1356{ 1357}; 1358 1359template <class _Alloc> 1360auto 1361__has_max_size_test(_Alloc&& __a) 1362 -> decltype(__a.max_size(), true_type()); 1363 1364template <class _Alloc> 1365auto 1366__has_max_size_test(const volatile _Alloc& __a) 1367 -> false_type; 1368 1369template <class _Alloc> 1370struct __has_max_size 1371 : integral_constant<bool, 1372 is_same< 1373 decltype(__has_max_size_test(declval<_Alloc&>())), 1374 true_type>::value> 1375{ 1376}; 1377 1378template <class _Alloc> 1379auto 1380__has_select_on_container_copy_construction_test(_Alloc&& __a) 1381 -> decltype(__a.select_on_container_copy_construction(), true_type()); 1382 1383template <class _Alloc> 1384auto 1385__has_select_on_container_copy_construction_test(const volatile _Alloc& __a) 1386 -> false_type; 1387 1388template <class _Alloc> 1389struct __has_select_on_container_copy_construction 1390 : integral_constant<bool, 1391 is_same< 1392 decltype(__has_select_on_container_copy_construction_test(declval<_Alloc&>())), 1393 true_type>::value> 1394{ 1395}; 1396 1397#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1398 1399#ifndef _LIBCPP_HAS_NO_VARIADICS 1400 1401template <class _Alloc, class _Pointer, class ..._Args> 1402struct __has_construct 1403 : false_type 1404{ 1405}; 1406 1407#else // _LIBCPP_HAS_NO_VARIADICS 1408 1409template <class _Alloc, class _Pointer, class _Args> 1410struct __has_construct 1411 : false_type 1412{ 1413}; 1414 1415#endif // _LIBCPP_HAS_NO_VARIADICS 1416 1417template <class _Alloc, class _Pointer> 1418struct __has_destroy 1419 : false_type 1420{ 1421}; 1422 1423template <class _Alloc> 1424struct __has_max_size 1425 : true_type 1426{ 1427}; 1428 1429template <class _Alloc> 1430struct __has_select_on_container_copy_construction 1431 : false_type 1432{ 1433}; 1434 1435#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE 1436 1437template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value> 1438struct __alloc_traits_difference_type 1439{ 1440 typedef typename pointer_traits<_Ptr>::difference_type type; 1441}; 1442 1443template <class _Alloc, class _Ptr> 1444struct __alloc_traits_difference_type<_Alloc, _Ptr, true> 1445{ 1446 typedef typename _Alloc::difference_type type; 1447}; 1448 1449template <class _Alloc> 1450struct _LIBCPP_TYPE_VIS allocator_traits 1451{ 1452 typedef _Alloc allocator_type; 1453 typedef typename allocator_type::value_type value_type; 1454 1455 typedef typename __pointer_type<value_type, allocator_type>::type pointer; 1456 typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer; 1457 typedef typename __void_pointer<pointer, allocator_type>::type void_pointer; 1458 typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer; 1459 1460 typedef typename __alloc_traits_difference_type<allocator_type, pointer>::type difference_type; 1461 typedef typename __size_type<allocator_type, difference_type>::type size_type; 1462 1463 typedef typename __propagate_on_container_copy_assignment<allocator_type>::type 1464 propagate_on_container_copy_assignment; 1465 typedef typename __propagate_on_container_move_assignment<allocator_type>::type 1466 propagate_on_container_move_assignment; 1467 typedef typename __propagate_on_container_swap<allocator_type>::type 1468 propagate_on_container_swap; 1469 1470#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1471 template <class _Tp> using rebind_alloc = 1472 typename __allocator_traits_rebind<allocator_type, _Tp>::type; 1473 template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>; 1474#else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1475 template <class _Tp> struct rebind_alloc 1476 {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;}; 1477 template <class _Tp> struct rebind_traits 1478 {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;}; 1479#endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1480 1481 _LIBCPP_INLINE_VISIBILITY 1482 static pointer allocate(allocator_type& __a, size_type __n) 1483 {return __a.allocate(__n);} 1484 _LIBCPP_INLINE_VISIBILITY 1485 static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) 1486 {return allocate(__a, __n, __hint, 1487 __has_allocate_hint<allocator_type, size_type, const_void_pointer>());} 1488 1489 _LIBCPP_INLINE_VISIBILITY 1490 static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT 1491 {__a.deallocate(__p, __n);} 1492 1493#ifndef _LIBCPP_HAS_NO_VARIADICS 1494 template <class _Tp, class... _Args> 1495 _LIBCPP_INLINE_VISIBILITY 1496 static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) 1497 {__construct(__has_construct<allocator_type, pointer, _Args...>(), 1498 __a, __p, _VSTD::forward<_Args>(__args)...);} 1499#else // _LIBCPP_HAS_NO_VARIADICS 1500 template <class _Tp> 1501 _LIBCPP_INLINE_VISIBILITY 1502 static void construct(allocator_type& __a, _Tp* __p) 1503 { 1504 ::new ((void*)__p) _Tp(); 1505 } 1506 template <class _Tp, class _A0> 1507 _LIBCPP_INLINE_VISIBILITY 1508 static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0) 1509 { 1510 ::new ((void*)__p) _Tp(__a0); 1511 } 1512 template <class _Tp, class _A0, class _A1> 1513 _LIBCPP_INLINE_VISIBILITY 1514 static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0, 1515 const _A1& __a1) 1516 { 1517 ::new ((void*)__p) _Tp(__a0, __a1); 1518 } 1519 template <class _Tp, class _A0, class _A1, class _A2> 1520 _LIBCPP_INLINE_VISIBILITY 1521 static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0, 1522 const _A1& __a1, const _A2& __a2) 1523 { 1524 ::new ((void*)__p) _Tp(__a0, __a1, __a2); 1525 } 1526#endif // _LIBCPP_HAS_NO_VARIADICS 1527 1528 template <class _Tp> 1529 _LIBCPP_INLINE_VISIBILITY 1530 static void destroy(allocator_type& __a, _Tp* __p) 1531 {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);} 1532 1533 _LIBCPP_INLINE_VISIBILITY 1534 static size_type max_size(const allocator_type& __a) 1535 {return __max_size(__has_max_size<const allocator_type>(), __a);} 1536 1537 _LIBCPP_INLINE_VISIBILITY 1538 static allocator_type 1539 select_on_container_copy_construction(const allocator_type& __a) 1540 {return select_on_container_copy_construction( 1541 __has_select_on_container_copy_construction<const allocator_type>(), 1542 __a);} 1543 1544 template <class _Ptr> 1545 _LIBCPP_INLINE_VISIBILITY 1546 static 1547 void 1548 __construct_forward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) 1549 { 1550 for (; __begin1 != __end1; ++__begin1, ++__begin2) 1551 construct(__a, _VSTD::__to_raw_pointer(__begin2), _VSTD::move_if_noexcept(*__begin1)); 1552 } 1553 1554 template <class _Tp> 1555 _LIBCPP_INLINE_VISIBILITY 1556 static 1557 typename enable_if 1558 < 1559 (is_same<allocator_type, allocator<_Tp> >::value 1560 || !__has_construct<allocator_type, _Tp*, _Tp>::value) && 1561 is_trivially_move_constructible<_Tp>::value, 1562 void 1563 >::type 1564 __construct_forward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) 1565 { 1566 ptrdiff_t _Np = __end1 - __begin1; 1567 _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp)); 1568 __begin2 += _Np; 1569 } 1570 1571 template <class _Ptr> 1572 _LIBCPP_INLINE_VISIBILITY 1573 static 1574 void 1575 __construct_backward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2) 1576 { 1577 while (__end1 != __begin1) 1578 { 1579 construct(__a, _VSTD::__to_raw_pointer(__end2-1), _VSTD::move_if_noexcept(*--__end1)); 1580 --__end2; 1581 } 1582 } 1583 1584 template <class _Tp> 1585 _LIBCPP_INLINE_VISIBILITY 1586 static 1587 typename enable_if 1588 < 1589 (is_same<allocator_type, allocator<_Tp> >::value 1590 || !__has_construct<allocator_type, _Tp*, _Tp>::value) && 1591 is_trivially_move_constructible<_Tp>::value, 1592 void 1593 >::type 1594 __construct_backward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __end2) 1595 { 1596 ptrdiff_t _Np = __end1 - __begin1; 1597 __end2 -= _Np; 1598 _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); 1599 } 1600 1601private: 1602 1603 _LIBCPP_INLINE_VISIBILITY 1604 static pointer allocate(allocator_type& __a, size_type __n, 1605 const_void_pointer __hint, true_type) 1606 {return __a.allocate(__n, __hint);} 1607 _LIBCPP_INLINE_VISIBILITY 1608 static pointer allocate(allocator_type& __a, size_type __n, 1609 const_void_pointer, false_type) 1610 {return __a.allocate(__n);} 1611 1612#ifndef _LIBCPP_HAS_NO_VARIADICS 1613 template <class _Tp, class... _Args> 1614 _LIBCPP_INLINE_VISIBILITY 1615 static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args) 1616 {__a.construct(__p, _VSTD::forward<_Args>(__args)...);} 1617 template <class _Tp, class... _Args> 1618 _LIBCPP_INLINE_VISIBILITY 1619 static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args) 1620 { 1621 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); 1622 } 1623#endif // _LIBCPP_HAS_NO_VARIADICS 1624 1625 template <class _Tp> 1626 _LIBCPP_INLINE_VISIBILITY 1627 static void __destroy(true_type, allocator_type& __a, _Tp* __p) 1628 {__a.destroy(__p);} 1629 template <class _Tp> 1630 _LIBCPP_INLINE_VISIBILITY 1631 static void __destroy(false_type, allocator_type&, _Tp* __p) 1632 { 1633 __p->~_Tp(); 1634 } 1635 1636 _LIBCPP_INLINE_VISIBILITY 1637 static size_type __max_size(true_type, const allocator_type& __a) 1638 {return __a.max_size();} 1639 _LIBCPP_INLINE_VISIBILITY 1640 static size_type __max_size(false_type, const allocator_type&) 1641 {return numeric_limits<size_type>::max();} 1642 1643 _LIBCPP_INLINE_VISIBILITY 1644 static allocator_type 1645 select_on_container_copy_construction(true_type, const allocator_type& __a) 1646 {return __a.select_on_container_copy_construction();} 1647 _LIBCPP_INLINE_VISIBILITY 1648 static allocator_type 1649 select_on_container_copy_construction(false_type, const allocator_type& __a) 1650 {return __a;} 1651}; 1652 1653// allocator 1654 1655template <class _Tp> 1656class _LIBCPP_TYPE_VIS allocator 1657{ 1658public: 1659 typedef size_t size_type; 1660 typedef ptrdiff_t difference_type; 1661 typedef _Tp* pointer; 1662 typedef const _Tp* const_pointer; 1663 typedef _Tp& reference; 1664 typedef const _Tp& const_reference; 1665 typedef _Tp value_type; 1666 1667 typedef true_type propagate_on_container_move_assignment; 1668 1669 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 1670 1671 _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {} 1672 template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {} 1673 _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT 1674 {return _VSTD::addressof(__x);} 1675 _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT 1676 {return _VSTD::addressof(__x);} 1677 _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0) 1678 {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));} 1679 _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT 1680 {::operator delete((void*)__p);} 1681 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT 1682 {return size_type(~0) / sizeof(_Tp);} 1683#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1684 template <class _Up, class... _Args> 1685 _LIBCPP_INLINE_VISIBILITY 1686 void 1687 construct(_Up* __p, _Args&&... __args) 1688 { 1689 ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); 1690 } 1691#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1692 _LIBCPP_INLINE_VISIBILITY 1693 void 1694 construct(pointer __p) 1695 { 1696 ::new((void*)__p) _Tp(); 1697 } 1698# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1699 1700 template <class _A0> 1701 _LIBCPP_INLINE_VISIBILITY 1702 void 1703 construct(pointer __p, _A0& __a0) 1704 { 1705 ::new((void*)__p) _Tp(__a0); 1706 } 1707 template <class _A0> 1708 _LIBCPP_INLINE_VISIBILITY 1709 void 1710 construct(pointer __p, const _A0& __a0) 1711 { 1712 ::new((void*)__p) _Tp(__a0); 1713 } 1714# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1715 template <class _A0, class _A1> 1716 _LIBCPP_INLINE_VISIBILITY 1717 void 1718 construct(pointer __p, _A0& __a0, _A1& __a1) 1719 { 1720 ::new((void*)__p) _Tp(__a0, __a1); 1721 } 1722 template <class _A0, class _A1> 1723 _LIBCPP_INLINE_VISIBILITY 1724 void 1725 construct(pointer __p, const _A0& __a0, _A1& __a1) 1726 { 1727 ::new((void*)__p) _Tp(__a0, __a1); 1728 } 1729 template <class _A0, class _A1> 1730 _LIBCPP_INLINE_VISIBILITY 1731 void 1732 construct(pointer __p, _A0& __a0, const _A1& __a1) 1733 { 1734 ::new((void*)__p) _Tp(__a0, __a1); 1735 } 1736 template <class _A0, class _A1> 1737 _LIBCPP_INLINE_VISIBILITY 1738 void 1739 construct(pointer __p, const _A0& __a0, const _A1& __a1) 1740 { 1741 ::new((void*)__p) _Tp(__a0, __a1); 1742 } 1743#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1744 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} 1745}; 1746 1747template <class _Tp> 1748class _LIBCPP_TYPE_VIS allocator<const _Tp> 1749{ 1750public: 1751 typedef size_t size_type; 1752 typedef ptrdiff_t difference_type; 1753 typedef const _Tp* pointer; 1754 typedef const _Tp* const_pointer; 1755 typedef const _Tp& reference; 1756 typedef const _Tp& const_reference; 1757 typedef const _Tp value_type; 1758 1759 typedef true_type propagate_on_container_move_assignment; 1760 1761 template <class _Up> struct rebind {typedef allocator<_Up> other;}; 1762 1763 _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {} 1764 template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {} 1765 _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT 1766 {return _VSTD::addressof(__x);} 1767 _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0) 1768 {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));} 1769 _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT 1770 {::operator delete((void*)__p);} 1771 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT 1772 {return size_type(~0) / sizeof(_Tp);} 1773#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1774 template <class _Up, class... _Args> 1775 _LIBCPP_INLINE_VISIBILITY 1776 void 1777 construct(_Up* __p, _Args&&... __args) 1778 { 1779 ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); 1780 } 1781#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1782 _LIBCPP_INLINE_VISIBILITY 1783 void 1784 construct(pointer __p) 1785 { 1786 ::new((void*)__p) _Tp(); 1787 } 1788# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1789 1790 template <class _A0> 1791 _LIBCPP_INLINE_VISIBILITY 1792 void 1793 construct(pointer __p, _A0& __a0) 1794 { 1795 ::new((void*)__p) _Tp(__a0); 1796 } 1797 template <class _A0> 1798 _LIBCPP_INLINE_VISIBILITY 1799 void 1800 construct(pointer __p, const _A0& __a0) 1801 { 1802 ::new((void*)__p) _Tp(__a0); 1803 } 1804# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) 1805 template <class _A0, class _A1> 1806 _LIBCPP_INLINE_VISIBILITY 1807 void 1808 construct(pointer __p, _A0& __a0, _A1& __a1) 1809 { 1810 ::new((void*)__p) _Tp(__a0, __a1); 1811 } 1812 template <class _A0, class _A1> 1813 _LIBCPP_INLINE_VISIBILITY 1814 void 1815 construct(pointer __p, const _A0& __a0, _A1& __a1) 1816 { 1817 ::new((void*)__p) _Tp(__a0, __a1); 1818 } 1819 template <class _A0, class _A1> 1820 _LIBCPP_INLINE_VISIBILITY 1821 void 1822 construct(pointer __p, _A0& __a0, const _A1& __a1) 1823 { 1824 ::new((void*)__p) _Tp(__a0, __a1); 1825 } 1826 template <class _A0, class _A1> 1827 _LIBCPP_INLINE_VISIBILITY 1828 void 1829 construct(pointer __p, const _A0& __a0, const _A1& __a1) 1830 { 1831 ::new((void*)__p) _Tp(__a0, __a1); 1832 } 1833#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) 1834 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} 1835}; 1836 1837template <class _Tp, class _Up> 1838inline _LIBCPP_INLINE_VISIBILITY 1839bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;} 1840 1841template <class _Tp, class _Up> 1842inline _LIBCPP_INLINE_VISIBILITY 1843bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;} 1844 1845template <class _OutputIterator, class _Tp> 1846class _LIBCPP_TYPE_VIS raw_storage_iterator 1847 : public iterator<output_iterator_tag, 1848 _Tp, // purposefully not C++03 1849 ptrdiff_t, // purposefully not C++03 1850 _Tp*, // purposefully not C++03 1851 raw_storage_iterator<_OutputIterator, _Tp>&> // purposefully not C++03 1852{ 1853private: 1854 _OutputIterator __x_; 1855public: 1856 _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {} 1857 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;} 1858 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element) 1859 {::new(&*__x_) _Tp(__element); return *this;} 1860 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;} 1861 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator operator++(int) 1862 {raw_storage_iterator __t(*this); ++__x_; return __t;} 1863}; 1864 1865template <class _Tp> 1866pair<_Tp*, ptrdiff_t> 1867get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT 1868{ 1869 pair<_Tp*, ptrdiff_t> __r(0, 0); 1870 const ptrdiff_t __m = (~ptrdiff_t(0) ^ 1871 ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1))) 1872 / sizeof(_Tp); 1873 if (__n > __m) 1874 __n = __m; 1875 while (__n > 0) 1876 { 1877 __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow)); 1878 if (__r.first) 1879 { 1880 __r.second = __n; 1881 break; 1882 } 1883 __n /= 2; 1884 } 1885 return __r; 1886} 1887 1888template <class _Tp> 1889inline _LIBCPP_INLINE_VISIBILITY 1890void return_temporary_buffer(_Tp* __p) _NOEXCEPT {::operator delete(__p);} 1891 1892template <class _Tp> 1893struct auto_ptr_ref 1894{ 1895 _Tp* __ptr_; 1896}; 1897 1898template<class _Tp> 1899class _LIBCPP_TYPE_VIS auto_ptr 1900{ 1901private: 1902 _Tp* __ptr_; 1903public: 1904 typedef _Tp element_type; 1905 1906 _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {} 1907 _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {} 1908 template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) throw() 1909 : __ptr_(__p.release()) {} 1910 _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) throw() 1911 {reset(__p.release()); return *this;} 1912 template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) throw() 1913 {reset(__p.release()); return *this;} 1914 _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) throw() 1915 {reset(__p.__ptr_); return *this;} 1916 _LIBCPP_INLINE_VISIBILITY ~auto_ptr() throw() {delete __ptr_;} 1917 1918 _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const throw() 1919 {return *__ptr_;} 1920 _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const throw() {return __ptr_;} 1921 _LIBCPP_INLINE_VISIBILITY _Tp* get() const throw() {return __ptr_;} 1922 _LIBCPP_INLINE_VISIBILITY _Tp* release() throw() 1923 { 1924 _Tp* __t = __ptr_; 1925 __ptr_ = 0; 1926 return __t; 1927 } 1928 _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) throw() 1929 { 1930 if (__ptr_ != __p) 1931 delete __ptr_; 1932 __ptr_ = __p; 1933 } 1934 1935 _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {} 1936 template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() throw() 1937 {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;} 1938 template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() throw() 1939 {return auto_ptr<_Up>(release());} 1940}; 1941 1942template <> 1943class _LIBCPP_TYPE_VIS auto_ptr<void> 1944{ 1945public: 1946 typedef void element_type; 1947}; 1948 1949template <class _T1, class _T2, bool = is_same<typename remove_cv<_T1>::type, 1950 typename remove_cv<_T2>::type>::value, 1951 bool = is_empty<_T1>::value 1952#if __has_feature(is_final) 1953 && !__is_final(_T1) 1954#endif 1955 , 1956 bool = is_empty<_T2>::value 1957#if __has_feature(is_final) 1958 && !__is_final(_T2) 1959#endif 1960 > 1961struct __libcpp_compressed_pair_switch; 1962 1963template <class _T1, class _T2, bool IsSame> 1964struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, false, false> {enum {value = 0};}; 1965 1966template <class _T1, class _T2, bool IsSame> 1967struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, true, false> {enum {value = 1};}; 1968 1969template <class _T1, class _T2, bool IsSame> 1970struct __libcpp_compressed_pair_switch<_T1, _T2, IsSame, false, true> {enum {value = 2};}; 1971 1972template <class _T1, class _T2> 1973struct __libcpp_compressed_pair_switch<_T1, _T2, false, true, true> {enum {value = 3};}; 1974 1975template <class _T1, class _T2> 1976struct __libcpp_compressed_pair_switch<_T1, _T2, true, true, true> {enum {value = 1};}; 1977 1978template <class _T1, class _T2, unsigned = __libcpp_compressed_pair_switch<_T1, _T2>::value> 1979class __libcpp_compressed_pair_imp; 1980 1981template <class _T1, class _T2> 1982class __libcpp_compressed_pair_imp<_T1, _T2, 0> 1983{ 1984private: 1985 _T1 __first_; 1986 _T2 __second_; 1987public: 1988 typedef _T1 _T1_param; 1989 typedef _T2 _T2_param; 1990 1991 typedef typename remove_reference<_T1>::type& _T1_reference; 1992 typedef typename remove_reference<_T2>::type& _T2_reference; 1993 1994 typedef const typename remove_reference<_T1>::type& _T1_const_reference; 1995 typedef const typename remove_reference<_T2>::type& _T2_const_reference; 1996 1997 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 1998 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) 1999 : __first_(_VSTD::forward<_T1_param>(__t1)) {} 2000 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) 2001 : __second_(_VSTD::forward<_T2_param>(__t2)) {} 2002 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 2003 : __first_(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {} 2004 2005#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2006 2007 _LIBCPP_INLINE_VISIBILITY 2008 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 2009 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2010 is_nothrow_copy_constructible<_T2>::value) 2011 : __first_(__p.first()), 2012 __second_(__p.second()) {} 2013 2014 _LIBCPP_INLINE_VISIBILITY 2015 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 2016 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2017 is_nothrow_copy_assignable<_T2>::value) 2018 { 2019 __first_ = __p.first(); 2020 __second_ = __p.second(); 2021 return *this; 2022 } 2023 2024#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2025 2026 _LIBCPP_INLINE_VISIBILITY 2027 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 2028 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2029 is_nothrow_move_constructible<_T2>::value) 2030 : __first_(_VSTD::forward<_T1>(__p.first())), 2031 __second_(_VSTD::forward<_T2>(__p.second())) {} 2032 2033 _LIBCPP_INLINE_VISIBILITY 2034 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 2035 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2036 is_nothrow_move_assignable<_T2>::value) 2037 { 2038 __first_ = _VSTD::forward<_T1>(__p.first()); 2039 __second_ = _VSTD::forward<_T2>(__p.second()); 2040 return *this; 2041 } 2042 2043#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2044 2045#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2046 2047#ifndef _LIBCPP_HAS_NO_VARIADICS 2048 2049 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> 2050 _LIBCPP_INLINE_VISIBILITY 2051 __libcpp_compressed_pair_imp(piecewise_construct_t __pc, 2052 tuple<_Args1...> __first_args, 2053 tuple<_Args2...> __second_args, 2054 __tuple_indices<_I1...>, 2055 __tuple_indices<_I2...>) 2056 : __first_(_VSTD::forward<_Args1>(get<_I1>(__first_args))...), 2057 __second_(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) 2058 {} 2059 2060#endif // _LIBCPP_HAS_NO_VARIADICS 2061 2062 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return __first_;} 2063 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;} 2064 2065 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return __second_;} 2066 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return __second_;} 2067 2068 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x) 2069 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2070 __is_nothrow_swappable<_T1>::value) 2071 { 2072 using _VSTD::swap; 2073 swap(__first_, __x.__first_); 2074 swap(__second_, __x.__second_); 2075 } 2076}; 2077 2078template <class _T1, class _T2> 2079class __libcpp_compressed_pair_imp<_T1, _T2, 1> 2080 : private _T1 2081{ 2082private: 2083 _T2 __second_; 2084public: 2085 typedef _T1 _T1_param; 2086 typedef _T2 _T2_param; 2087 2088 typedef _T1& _T1_reference; 2089 typedef typename remove_reference<_T2>::type& _T2_reference; 2090 2091 typedef const _T1& _T1_const_reference; 2092 typedef const typename remove_reference<_T2>::type& _T2_const_reference; 2093 2094 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 2095 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) 2096 : _T1(_VSTD::forward<_T1_param>(__t1)) {} 2097 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) 2098 : __second_(_VSTD::forward<_T2_param>(__t2)) {} 2099 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 2100 : _T1(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {} 2101 2102#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2103 2104 _LIBCPP_INLINE_VISIBILITY 2105 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 2106 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2107 is_nothrow_copy_constructible<_T2>::value) 2108 : _T1(__p.first()), __second_(__p.second()) {} 2109 2110 _LIBCPP_INLINE_VISIBILITY 2111 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 2112 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2113 is_nothrow_copy_assignable<_T2>::value) 2114 { 2115 _T1::operator=(__p.first()); 2116 __second_ = __p.second(); 2117 return *this; 2118 } 2119 2120#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2121 2122 _LIBCPP_INLINE_VISIBILITY 2123 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 2124 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2125 is_nothrow_move_constructible<_T2>::value) 2126 : _T1(_VSTD::move(__p.first())), __second_(_VSTD::forward<_T2>(__p.second())) {} 2127 2128 _LIBCPP_INLINE_VISIBILITY 2129 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 2130 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2131 is_nothrow_move_assignable<_T2>::value) 2132 { 2133 _T1::operator=(_VSTD::move(__p.first())); 2134 __second_ = _VSTD::forward<_T2>(__p.second()); 2135 return *this; 2136 } 2137 2138#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2139 2140#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2141 2142#ifndef _LIBCPP_HAS_NO_VARIADICS 2143 2144 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> 2145 _LIBCPP_INLINE_VISIBILITY 2146 __libcpp_compressed_pair_imp(piecewise_construct_t __pc, 2147 tuple<_Args1...> __first_args, 2148 tuple<_Args2...> __second_args, 2149 __tuple_indices<_I1...>, 2150 __tuple_indices<_I2...>) 2151 : _T1(_VSTD::forward<_Args1>(get<_I1>(__first_args))...), 2152 __second_(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) 2153 {} 2154 2155#endif // _LIBCPP_HAS_NO_VARIADICS 2156 2157 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return *this;} 2158 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;} 2159 2160 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return __second_;} 2161 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return __second_;} 2162 2163 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x) 2164 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2165 __is_nothrow_swappable<_T1>::value) 2166 { 2167 using _VSTD::swap; 2168 swap(__second_, __x.__second_); 2169 } 2170}; 2171 2172template <class _T1, class _T2> 2173class __libcpp_compressed_pair_imp<_T1, _T2, 2> 2174 : private _T2 2175{ 2176private: 2177 _T1 __first_; 2178public: 2179 typedef _T1 _T1_param; 2180 typedef _T2 _T2_param; 2181 2182 typedef typename remove_reference<_T1>::type& _T1_reference; 2183 typedef _T2& _T2_reference; 2184 2185 typedef const typename remove_reference<_T1>::type& _T1_const_reference; 2186 typedef const _T2& _T2_const_reference; 2187 2188 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 2189 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) 2190 : __first_(_VSTD::forward<_T1_param>(__t1)) {} 2191 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) 2192 : _T2(_VSTD::forward<_T2_param>(__t2)) {} 2193 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 2194 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2195 is_nothrow_move_constructible<_T2>::value) 2196 : _T2(_VSTD::forward<_T2_param>(__t2)), __first_(_VSTD::forward<_T1_param>(__t1)) {} 2197 2198#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2199 2200 _LIBCPP_INLINE_VISIBILITY 2201 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 2202 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2203 is_nothrow_copy_constructible<_T2>::value) 2204 : _T2(__p.second()), __first_(__p.first()) {} 2205 2206 _LIBCPP_INLINE_VISIBILITY 2207 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 2208 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2209 is_nothrow_copy_assignable<_T2>::value) 2210 { 2211 _T2::operator=(__p.second()); 2212 __first_ = __p.first(); 2213 return *this; 2214 } 2215 2216#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2217 2218 _LIBCPP_INLINE_VISIBILITY 2219 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 2220 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2221 is_nothrow_move_constructible<_T2>::value) 2222 : _T2(_VSTD::forward<_T2>(__p.second())), __first_(_VSTD::move(__p.first())) {} 2223 2224 _LIBCPP_INLINE_VISIBILITY 2225 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 2226 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2227 is_nothrow_move_assignable<_T2>::value) 2228 { 2229 _T2::operator=(_VSTD::forward<_T2>(__p.second())); 2230 __first_ = _VSTD::move(__p.first()); 2231 return *this; 2232 } 2233 2234#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2235 2236#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2237 2238#ifndef _LIBCPP_HAS_NO_VARIADICS 2239 2240 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> 2241 _LIBCPP_INLINE_VISIBILITY 2242 __libcpp_compressed_pair_imp(piecewise_construct_t __pc, 2243 tuple<_Args1...> __first_args, 2244 tuple<_Args2...> __second_args, 2245 __tuple_indices<_I1...>, 2246 __tuple_indices<_I2...>) 2247 : _T2(_VSTD::forward<_Args2>(get<_I2>(__second_args))...), 2248 __first_(_VSTD::forward<_Args1>(get<_I1>(__first_args))...) 2249 2250 {} 2251 2252#endif // _LIBCPP_HAS_NO_VARIADICS 2253 2254 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return __first_;} 2255 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;} 2256 2257 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return *this;} 2258 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return *this;} 2259 2260 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x) 2261 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2262 __is_nothrow_swappable<_T1>::value) 2263 { 2264 using _VSTD::swap; 2265 swap(__first_, __x.__first_); 2266 } 2267}; 2268 2269template <class _T1, class _T2> 2270class __libcpp_compressed_pair_imp<_T1, _T2, 3> 2271 : private _T1, 2272 private _T2 2273{ 2274public: 2275 typedef _T1 _T1_param; 2276 typedef _T2 _T2_param; 2277 2278 typedef _T1& _T1_reference; 2279 typedef _T2& _T2_reference; 2280 2281 typedef const _T1& _T1_const_reference; 2282 typedef const _T2& _T2_const_reference; 2283 2284 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} 2285 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) 2286 : _T1(_VSTD::forward<_T1_param>(__t1)) {} 2287 _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) 2288 : _T2(_VSTD::forward<_T2_param>(__t2)) {} 2289 _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) 2290 : _T1(_VSTD::forward<_T1_param>(__t1)), _T2(_VSTD::forward<_T2_param>(__t2)) {} 2291 2292#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2293 2294 _LIBCPP_INLINE_VISIBILITY 2295 __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p) 2296 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2297 is_nothrow_copy_constructible<_T2>::value) 2298 : _T1(__p.first()), _T2(__p.second()) {} 2299 2300 _LIBCPP_INLINE_VISIBILITY 2301 __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p) 2302 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2303 is_nothrow_copy_assignable<_T2>::value) 2304 { 2305 _T1::operator=(__p.first()); 2306 _T2::operator=(__p.second()); 2307 return *this; 2308 } 2309 2310#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2311 2312 _LIBCPP_INLINE_VISIBILITY 2313 __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p) 2314 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2315 is_nothrow_move_constructible<_T2>::value) 2316 : _T1(_VSTD::move(__p.first())), _T2(_VSTD::move(__p.second())) {} 2317 2318 _LIBCPP_INLINE_VISIBILITY 2319 __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p) 2320 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2321 is_nothrow_move_assignable<_T2>::value) 2322 { 2323 _T1::operator=(_VSTD::move(__p.first())); 2324 _T2::operator=(_VSTD::move(__p.second())); 2325 return *this; 2326 } 2327 2328#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2329 2330#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2331 2332#ifndef _LIBCPP_HAS_NO_VARIADICS 2333 2334 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> 2335 _LIBCPP_INLINE_VISIBILITY 2336 __libcpp_compressed_pair_imp(piecewise_construct_t __pc, 2337 tuple<_Args1...> __first_args, 2338 tuple<_Args2...> __second_args, 2339 __tuple_indices<_I1...>, 2340 __tuple_indices<_I2...>) 2341 : _T1(_VSTD::forward<_Args1>(get<_I1>(__first_args))...), 2342 _T2(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) 2343 {} 2344 2345#endif // _LIBCPP_HAS_NO_VARIADICS 2346 2347 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return *this;} 2348 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;} 2349 2350 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return *this;} 2351 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return *this;} 2352 2353 _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp&) 2354 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2355 __is_nothrow_swappable<_T1>::value) 2356 { 2357 } 2358}; 2359 2360template <class _T1, class _T2> 2361class __compressed_pair 2362 : private __libcpp_compressed_pair_imp<_T1, _T2> 2363{ 2364 typedef __libcpp_compressed_pair_imp<_T1, _T2> base; 2365public: 2366 typedef typename base::_T1_param _T1_param; 2367 typedef typename base::_T2_param _T2_param; 2368 2369 typedef typename base::_T1_reference _T1_reference; 2370 typedef typename base::_T2_reference _T2_reference; 2371 2372 typedef typename base::_T1_const_reference _T1_const_reference; 2373 typedef typename base::_T2_const_reference _T2_const_reference; 2374 2375 _LIBCPP_INLINE_VISIBILITY __compressed_pair() {} 2376 _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T1_param __t1) 2377 : base(_VSTD::forward<_T1_param>(__t1)) {} 2378 _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T2_param __t2) 2379 : base(_VSTD::forward<_T2_param>(__t2)) {} 2380 _LIBCPP_INLINE_VISIBILITY __compressed_pair(_T1_param __t1, _T2_param __t2) 2381 : base(_VSTD::forward<_T1_param>(__t1), _VSTD::forward<_T2_param>(__t2)) {} 2382 2383#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2384 2385 _LIBCPP_INLINE_VISIBILITY 2386 __compressed_pair(const __compressed_pair& __p) 2387 _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value && 2388 is_nothrow_copy_constructible<_T2>::value) 2389 : base(__p) {} 2390 2391 _LIBCPP_INLINE_VISIBILITY 2392 __compressed_pair& operator=(const __compressed_pair& __p) 2393 _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value && 2394 is_nothrow_copy_assignable<_T2>::value) 2395 { 2396 base::operator=(__p); 2397 return *this; 2398 } 2399 2400#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2401 _LIBCPP_INLINE_VISIBILITY 2402 __compressed_pair(__compressed_pair&& __p) 2403 _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && 2404 is_nothrow_move_constructible<_T2>::value) 2405 : base(_VSTD::move(__p)) {} 2406 2407 _LIBCPP_INLINE_VISIBILITY 2408 __compressed_pair& operator=(__compressed_pair&& __p) 2409 _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value && 2410 is_nothrow_move_assignable<_T2>::value) 2411 { 2412 base::operator=(_VSTD::move(__p)); 2413 return *this; 2414 } 2415 2416#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2417 2418#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2419 2420#ifndef _LIBCPP_HAS_NO_VARIADICS 2421 2422 template <class... _Args1, class... _Args2> 2423 _LIBCPP_INLINE_VISIBILITY 2424 __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, 2425 tuple<_Args2...> __second_args) 2426 : base(__pc, _VSTD::move(__first_args), _VSTD::move(__second_args), 2427 typename __make_tuple_indices<sizeof...(_Args1)>::type(), 2428 typename __make_tuple_indices<sizeof...(_Args2) >::type()) 2429 {} 2430 2431#endif // _LIBCPP_HAS_NO_VARIADICS 2432 2433 _LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return base::first();} 2434 _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return base::first();} 2435 2436 _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return base::second();} 2437 _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return base::second();} 2438 2439 _LIBCPP_INLINE_VISIBILITY void swap(__compressed_pair& __x) 2440 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2441 __is_nothrow_swappable<_T1>::value) 2442 {base::swap(__x);} 2443}; 2444 2445template <class _T1, class _T2> 2446inline _LIBCPP_INLINE_VISIBILITY 2447void 2448swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y) 2449 _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && 2450 __is_nothrow_swappable<_T1>::value) 2451 {__x.swap(__y);} 2452 2453// __same_or_less_cv_qualified 2454 2455template <class _Ptr1, class _Ptr2, 2456 bool = is_same<typename remove_cv<typename pointer_traits<_Ptr1>::element_type>::type, 2457 typename remove_cv<typename pointer_traits<_Ptr2>::element_type>::type 2458 >::value 2459 > 2460struct __same_or_less_cv_qualified_imp 2461 : is_convertible<_Ptr1, _Ptr2> {}; 2462 2463template <class _Ptr1, class _Ptr2> 2464struct __same_or_less_cv_qualified_imp<_Ptr1, _Ptr2, false> 2465 : false_type {}; 2466 2467template <class _Ptr1, class _Ptr2, bool = is_scalar<_Ptr1>::value && 2468 !is_pointer<_Ptr1>::value> 2469struct __same_or_less_cv_qualified 2470 : __same_or_less_cv_qualified_imp<_Ptr1, _Ptr2> {}; 2471 2472template <class _Ptr1, class _Ptr2> 2473struct __same_or_less_cv_qualified<_Ptr1, _Ptr2, true> 2474 : false_type {}; 2475 2476// default_delete 2477 2478template <class _Tp> 2479struct _LIBCPP_TYPE_VIS default_delete 2480{ 2481#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2482 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default; 2483#else 2484 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT {} 2485#endif 2486 template <class _Up> 2487 _LIBCPP_INLINE_VISIBILITY default_delete(const default_delete<_Up>&, 2488 typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {} 2489 _LIBCPP_INLINE_VISIBILITY void operator() (_Tp* __ptr) const _NOEXCEPT 2490 { 2491 static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type"); 2492 static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type"); 2493 delete __ptr; 2494 } 2495}; 2496 2497template <class _Tp> 2498struct _LIBCPP_TYPE_VIS default_delete<_Tp[]> 2499{ 2500public: 2501#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS 2502 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default; 2503#else 2504 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT {} 2505#endif 2506 template <class _Up> 2507 _LIBCPP_INLINE_VISIBILITY default_delete(const default_delete<_Up[]>&, 2508 typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {} 2509 template <class _Up> 2510 _LIBCPP_INLINE_VISIBILITY 2511 void operator() (_Up* __ptr, 2512 typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) const _NOEXCEPT 2513 { 2514 static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type"); 2515 static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type"); 2516 delete [] __ptr; 2517 } 2518}; 2519 2520template <class _Tp, class _Dp = default_delete<_Tp> > 2521class _LIBCPP_TYPE_VIS unique_ptr 2522{ 2523public: 2524 typedef _Tp element_type; 2525 typedef _Dp deleter_type; 2526 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2527private: 2528 __compressed_pair<pointer, deleter_type> __ptr_; 2529 2530#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2531 unique_ptr(unique_ptr&); 2532 template <class _Up, class _Ep> 2533 unique_ptr(unique_ptr<_Up, _Ep>&); 2534 unique_ptr& operator=(unique_ptr&); 2535 template <class _Up, class _Ep> 2536 unique_ptr& operator=(unique_ptr<_Up, _Ep>&); 2537#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2538 2539 struct __nat {int __for_bool_;}; 2540 2541 typedef typename remove_reference<deleter_type>::type& _Dp_reference; 2542 typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference; 2543public: 2544 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT 2545 : __ptr_(pointer()) 2546 { 2547 static_assert(!is_pointer<deleter_type>::value, 2548 "unique_ptr constructed with null function pointer deleter"); 2549 } 2550 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT 2551 : __ptr_(pointer()) 2552 { 2553 static_assert(!is_pointer<deleter_type>::value, 2554 "unique_ptr constructed with null function pointer deleter"); 2555 } 2556 _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) _NOEXCEPT 2557 : __ptr_(_VSTD::move(__p)) 2558 { 2559 static_assert(!is_pointer<deleter_type>::value, 2560 "unique_ptr constructed with null function pointer deleter"); 2561 } 2562 2563#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2564 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, typename conditional< 2565 is_reference<deleter_type>::value, 2566 deleter_type, 2567 typename add_lvalue_reference<const deleter_type>::type>::type __d) 2568 _NOEXCEPT 2569 : __ptr_(__p, __d) {} 2570 2571 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, typename remove_reference<deleter_type>::type&& __d) 2572 _NOEXCEPT 2573 : __ptr_(__p, _VSTD::move(__d)) 2574 { 2575 static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference"); 2576 } 2577 _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT 2578 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {} 2579 template <class _Up, class _Ep> 2580 _LIBCPP_INLINE_VISIBILITY 2581 unique_ptr(unique_ptr<_Up, _Ep>&& __u, 2582 typename enable_if 2583 < 2584 !is_array<_Up>::value && 2585 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value && 2586 is_convertible<_Ep, deleter_type>::value && 2587 ( 2588 !is_reference<deleter_type>::value || 2589 is_same<deleter_type, _Ep>::value 2590 ), 2591 __nat 2592 >::type = __nat()) _NOEXCEPT 2593 : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {} 2594 2595 template <class _Up> 2596 _LIBCPP_INLINE_VISIBILITY unique_ptr(auto_ptr<_Up>&& __p, 2597 typename enable_if< 2598 is_convertible<_Up*, _Tp*>::value && 2599 is_same<_Dp, default_delete<_Tp> >::value, 2600 __nat 2601 >::type = __nat()) _NOEXCEPT 2602 : __ptr_(__p.release()) 2603 { 2604 } 2605 2606 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT 2607 { 2608 reset(__u.release()); 2609 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2610 return *this; 2611 } 2612 2613 template <class _Up, class _Ep> 2614 _LIBCPP_INLINE_VISIBILITY 2615 typename enable_if 2616 < 2617 !is_array<_Up>::value && 2618 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value && 2619 is_assignable<deleter_type&, _Ep&&>::value, 2620 unique_ptr& 2621 >::type 2622 operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT 2623 { 2624 reset(__u.release()); 2625 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2626 return *this; 2627 } 2628#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2629 2630 _LIBCPP_INLINE_VISIBILITY operator __rv<unique_ptr>() 2631 { 2632 return __rv<unique_ptr>(*this); 2633 } 2634 2635 _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u) 2636 : __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2637 2638 template <class _Up, class _Ep> 2639 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr<_Up, _Ep> __u) 2640 { 2641 reset(__u.release()); 2642 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2643 return *this; 2644 } 2645 2646 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d) 2647 : __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {} 2648 2649 template <class _Up> 2650 _LIBCPP_INLINE_VISIBILITY 2651 typename enable_if< 2652 is_convertible<_Up*, _Tp*>::value && 2653 is_same<_Dp, default_delete<_Tp> >::value, 2654 unique_ptr& 2655 >::type 2656 operator=(auto_ptr<_Up> __p) 2657 {reset(__p.release()); return *this;} 2658 2659#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2660 _LIBCPP_INLINE_VISIBILITY ~unique_ptr() {reset();} 2661 2662 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(nullptr_t) _NOEXCEPT 2663 { 2664 reset(); 2665 return *this; 2666 } 2667 2668 _LIBCPP_INLINE_VISIBILITY typename add_lvalue_reference<_Tp>::type operator*() const 2669 {return *__ptr_.first();} 2670 _LIBCPP_INLINE_VISIBILITY pointer operator->() const _NOEXCEPT {return __ptr_.first();} 2671 _LIBCPP_INLINE_VISIBILITY pointer get() const _NOEXCEPT {return __ptr_.first();} 2672 _LIBCPP_INLINE_VISIBILITY _Dp_reference get_deleter() _NOEXCEPT 2673 {return __ptr_.second();} 2674 _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT 2675 {return __ptr_.second();} 2676 _LIBCPP_INLINE_VISIBILITY 2677 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT 2678 {return __ptr_.first() != nullptr;} 2679 2680 _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT 2681 { 2682 pointer __t = __ptr_.first(); 2683 __ptr_.first() = pointer(); 2684 return __t; 2685 } 2686 2687 _LIBCPP_INLINE_VISIBILITY void reset(pointer __p = pointer()) _NOEXCEPT 2688 { 2689 pointer __tmp = __ptr_.first(); 2690 __ptr_.first() = __p; 2691 if (__tmp) 2692 __ptr_.second()(__tmp); 2693 } 2694 2695 _LIBCPP_INLINE_VISIBILITY void swap(unique_ptr& __u) _NOEXCEPT 2696 {__ptr_.swap(__u.__ptr_);} 2697}; 2698 2699template <class _Tp, class _Dp> 2700class _LIBCPP_TYPE_VIS unique_ptr<_Tp[], _Dp> 2701{ 2702public: 2703 typedef _Tp element_type; 2704 typedef _Dp deleter_type; 2705 typedef typename __pointer_type<_Tp, deleter_type>::type pointer; 2706private: 2707 __compressed_pair<pointer, deleter_type> __ptr_; 2708 2709#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2710 unique_ptr(unique_ptr&); 2711 template <class _Up> 2712 unique_ptr(unique_ptr<_Up>&); 2713 unique_ptr& operator=(unique_ptr&); 2714 template <class _Up> 2715 unique_ptr& operator=(unique_ptr<_Up>&); 2716#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2717 2718 struct __nat {int __for_bool_;}; 2719 2720 typedef typename remove_reference<deleter_type>::type& _Dp_reference; 2721 typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference; 2722public: 2723 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT 2724 : __ptr_(pointer()) 2725 { 2726 static_assert(!is_pointer<deleter_type>::value, 2727 "unique_ptr constructed with null function pointer deleter"); 2728 } 2729 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT 2730 : __ptr_(pointer()) 2731 { 2732 static_assert(!is_pointer<deleter_type>::value, 2733 "unique_ptr constructed with null function pointer deleter"); 2734 } 2735#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2736 template <class _Pp, 2737 class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type 2738 > 2739 _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(_Pp __p) _NOEXCEPT 2740 : __ptr_(__p) 2741 { 2742 static_assert(!is_pointer<deleter_type>::value, 2743 "unique_ptr constructed with null function pointer deleter"); 2744 } 2745 2746 template <class _Pp, 2747 class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type 2748 > 2749 _LIBCPP_INLINE_VISIBILITY unique_ptr(_Pp __p, typename conditional< 2750 is_reference<deleter_type>::value, 2751 deleter_type, 2752 typename add_lvalue_reference<const deleter_type>::type>::type __d) 2753 _NOEXCEPT 2754 : __ptr_(__p, __d) {} 2755 2756 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, typename conditional< 2757 is_reference<deleter_type>::value, 2758 deleter_type, 2759 typename add_lvalue_reference<const deleter_type>::type>::type __d) 2760 _NOEXCEPT 2761 : __ptr_(pointer(), __d) {} 2762 2763 template <class _Pp, 2764 class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type 2765 > 2766 _LIBCPP_INLINE_VISIBILITY unique_ptr(_Pp __p, typename remove_reference<deleter_type>::type&& __d) 2767 _NOEXCEPT 2768 : __ptr_(__p, _VSTD::move(__d)) 2769 { 2770 static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference"); 2771 } 2772 2773 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, typename remove_reference<deleter_type>::type&& __d) 2774 _NOEXCEPT 2775 : __ptr_(pointer(), _VSTD::move(__d)) 2776 { 2777 static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference"); 2778 } 2779 2780 _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT 2781 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {} 2782 2783 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT 2784 { 2785 reset(__u.release()); 2786 __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); 2787 return *this; 2788 } 2789 2790 template <class _Up, class _Ep> 2791 _LIBCPP_INLINE_VISIBILITY 2792 unique_ptr(unique_ptr<_Up, _Ep>&& __u, 2793 typename enable_if 2794 < 2795 is_array<_Up>::value && 2796 __same_or_less_cv_qualified<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value 2797 && is_convertible<_Ep, deleter_type>::value && 2798 ( 2799 !is_reference<deleter_type>::value || 2800 is_same<deleter_type, _Ep>::value 2801 ), 2802 __nat 2803 >::type = __nat() 2804 ) _NOEXCEPT 2805 : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {} 2806 2807 2808 template <class _Up, class _Ep> 2809 _LIBCPP_INLINE_VISIBILITY 2810 typename enable_if 2811 < 2812 is_array<_Up>::value && 2813 __same_or_less_cv_qualified<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value && 2814 is_assignable<deleter_type&, _Ep&&>::value, 2815 unique_ptr& 2816 >::type 2817 operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT 2818 { 2819 reset(__u.release()); 2820 __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); 2821 return *this; 2822 } 2823#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2824 2825 _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) 2826 : __ptr_(__p) 2827 { 2828 static_assert(!is_pointer<deleter_type>::value, 2829 "unique_ptr constructed with null function pointer deleter"); 2830 } 2831 2832 _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d) 2833 : __ptr_(__p, _VSTD::forward<deleter_type>(__d)) {} 2834 2835 _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, deleter_type __d) 2836 : __ptr_(pointer(), _VSTD::forward<deleter_type>(__d)) {} 2837 2838 _LIBCPP_INLINE_VISIBILITY operator __rv<unique_ptr>() 2839 { 2840 return __rv<unique_ptr>(*this); 2841 } 2842 2843 _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u) 2844 : __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {} 2845 2846 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(__rv<unique_ptr> __u) 2847 { 2848 reset(__u->release()); 2849 __ptr_.second() = _VSTD::forward<deleter_type>(__u->get_deleter()); 2850 return *this; 2851 } 2852 2853#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2854 _LIBCPP_INLINE_VISIBILITY ~unique_ptr() {reset();} 2855 2856 _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(nullptr_t) _NOEXCEPT 2857 { 2858 reset(); 2859 return *this; 2860 } 2861 2862 _LIBCPP_INLINE_VISIBILITY typename add_lvalue_reference<_Tp>::type operator[](size_t __i) const 2863 {return __ptr_.first()[__i];} 2864 _LIBCPP_INLINE_VISIBILITY pointer get() const _NOEXCEPT {return __ptr_.first();} 2865 _LIBCPP_INLINE_VISIBILITY _Dp_reference get_deleter() _NOEXCEPT 2866 {return __ptr_.second();} 2867 _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT 2868 {return __ptr_.second();} 2869 _LIBCPP_INLINE_VISIBILITY 2870 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT 2871 {return __ptr_.first() != nullptr;} 2872 2873 _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT 2874 { 2875 pointer __t = __ptr_.first(); 2876 __ptr_.first() = pointer(); 2877 return __t; 2878 } 2879 2880#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2881 template <class _Pp, 2882 class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type 2883 > 2884 _LIBCPP_INLINE_VISIBILITY void reset(_Pp __p) _NOEXCEPT 2885 { 2886 pointer __tmp = __ptr_.first(); 2887 __ptr_.first() = __p; 2888 if (__tmp) 2889 __ptr_.second()(__tmp); 2890 } 2891 _LIBCPP_INLINE_VISIBILITY void reset(nullptr_t) _NOEXCEPT 2892 { 2893 pointer __tmp = __ptr_.first(); 2894 __ptr_.first() = nullptr; 2895 if (__tmp) 2896 __ptr_.second()(__tmp); 2897 } 2898 _LIBCPP_INLINE_VISIBILITY void reset() _NOEXCEPT 2899 { 2900 pointer __tmp = __ptr_.first(); 2901 __ptr_.first() = nullptr; 2902 if (__tmp) 2903 __ptr_.second()(__tmp); 2904 } 2905#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2906 _LIBCPP_INLINE_VISIBILITY void reset(pointer __p = pointer()) 2907 { 2908 pointer __tmp = __ptr_.first(); 2909 __ptr_.first() = __p; 2910 if (__tmp) 2911 __ptr_.second()(__tmp); 2912 } 2913#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2914 2915 _LIBCPP_INLINE_VISIBILITY void swap(unique_ptr& __u) {__ptr_.swap(__u.__ptr_);} 2916private: 2917 2918#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2919 template <class _Up> 2920 explicit unique_ptr(_Up); 2921 template <class _Up> 2922 unique_ptr(_Up __u, 2923 typename conditional< 2924 is_reference<deleter_type>::value, 2925 deleter_type, 2926 typename add_lvalue_reference<const deleter_type>::type>::type, 2927 typename enable_if 2928 < 2929 is_convertible<_Up, pointer>::value, 2930 __nat 2931 >::type = __nat()); 2932#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2933}; 2934 2935template <class _Tp, class _Dp> 2936inline _LIBCPP_INLINE_VISIBILITY 2937void 2938swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);} 2939 2940template <class _T1, class _D1, class _T2, class _D2> 2941inline _LIBCPP_INLINE_VISIBILITY 2942bool 2943operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();} 2944 2945template <class _T1, class _D1, class _T2, class _D2> 2946inline _LIBCPP_INLINE_VISIBILITY 2947bool 2948operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);} 2949 2950template <class _T1, class _D1, class _T2, class _D2> 2951inline _LIBCPP_INLINE_VISIBILITY 2952bool 2953operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) 2954{ 2955 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 2956 typedef typename unique_ptr<_T2, _D2>::pointer _P2; 2957 typedef typename common_type<_P1, _P2>::type _V; 2958 return less<_V>()(__x.get(), __y.get()); 2959} 2960 2961template <class _T1, class _D1, class _T2, class _D2> 2962inline _LIBCPP_INLINE_VISIBILITY 2963bool 2964operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;} 2965 2966template <class _T1, class _D1, class _T2, class _D2> 2967inline _LIBCPP_INLINE_VISIBILITY 2968bool 2969operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);} 2970 2971template <class _T1, class _D1, class _T2, class _D2> 2972inline _LIBCPP_INLINE_VISIBILITY 2973bool 2974operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);} 2975 2976template <class _T1, class _D1> 2977inline _LIBCPP_INLINE_VISIBILITY 2978bool 2979operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT 2980{ 2981 return !__x; 2982} 2983 2984template <class _T1, class _D1> 2985inline _LIBCPP_INLINE_VISIBILITY 2986bool 2987operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT 2988{ 2989 return !__x; 2990} 2991 2992template <class _T1, class _D1> 2993inline _LIBCPP_INLINE_VISIBILITY 2994bool 2995operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT 2996{ 2997 return static_cast<bool>(__x); 2998} 2999 3000template <class _T1, class _D1> 3001inline _LIBCPP_INLINE_VISIBILITY 3002bool 3003operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT 3004{ 3005 return static_cast<bool>(__x); 3006} 3007 3008template <class _T1, class _D1> 3009inline _LIBCPP_INLINE_VISIBILITY 3010bool 3011operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3012{ 3013 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 3014 return less<_P1>()(__x.get(), nullptr); 3015} 3016 3017template <class _T1, class _D1> 3018inline _LIBCPP_INLINE_VISIBILITY 3019bool 3020operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3021{ 3022 typedef typename unique_ptr<_T1, _D1>::pointer _P1; 3023 return less<_P1>()(nullptr, __x.get()); 3024} 3025 3026template <class _T1, class _D1> 3027inline _LIBCPP_INLINE_VISIBILITY 3028bool 3029operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3030{ 3031 return nullptr < __x; 3032} 3033 3034template <class _T1, class _D1> 3035inline _LIBCPP_INLINE_VISIBILITY 3036bool 3037operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3038{ 3039 return __x < nullptr; 3040} 3041 3042template <class _T1, class _D1> 3043inline _LIBCPP_INLINE_VISIBILITY 3044bool 3045operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3046{ 3047 return !(nullptr < __x); 3048} 3049 3050template <class _T1, class _D1> 3051inline _LIBCPP_INLINE_VISIBILITY 3052bool 3053operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3054{ 3055 return !(__x < nullptr); 3056} 3057 3058template <class _T1, class _D1> 3059inline _LIBCPP_INLINE_VISIBILITY 3060bool 3061operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) 3062{ 3063 return !(__x < nullptr); 3064} 3065 3066template <class _T1, class _D1> 3067inline _LIBCPP_INLINE_VISIBILITY 3068bool 3069operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) 3070{ 3071 return !(nullptr < __x); 3072} 3073 3074#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3075 3076template <class _Tp, class _Dp> 3077inline _LIBCPP_INLINE_VISIBILITY 3078unique_ptr<_Tp, _Dp> 3079move(unique_ptr<_Tp, _Dp>& __t) 3080{ 3081 return unique_ptr<_Tp, _Dp>(__rv<unique_ptr<_Tp, _Dp> >(__t)); 3082} 3083 3084#endif 3085 3086#if _LIBCPP_STD_VER > 11 3087 3088template<class _Tp> 3089struct __unique_if 3090{ 3091 typedef unique_ptr<_Tp> __unique_single; 3092}; 3093 3094template<class _Tp> 3095struct __unique_if<_Tp[]> 3096{ 3097 typedef unique_ptr<_Tp[]> __unique_array_unknown_bound; 3098}; 3099 3100template<class _Tp, size_t _Np> 3101struct __unique_if<_Tp[_Np]> 3102{ 3103 typedef void __unique_array_known_bound; 3104}; 3105 3106template<class _Tp, class... _Args> 3107inline _LIBCPP_INLINE_VISIBILITY 3108typename __unique_if<_Tp>::__unique_single 3109make_unique(_Args&&... __args) 3110{ 3111 return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...)); 3112} 3113 3114template<class _Tp> 3115inline _LIBCPP_INLINE_VISIBILITY 3116typename __unique_if<_Tp>::__unique_array_unknown_bound 3117make_unique(size_t __n) 3118{ 3119 typedef typename remove_extent<_Tp>::type _Up; 3120 return unique_ptr<_Tp>(new _Up[__n]()); 3121} 3122 3123template<class _Tp, class... _Args> 3124 typename __unique_if<_Tp>::__unique_array_known_bound 3125 make_unique(_Args&&...) = delete; 3126 3127#endif // _LIBCPP_STD_VER > 11 3128 3129template <class _Tp> struct hash; 3130 3131template <class _Size> 3132inline _LIBCPP_INLINE_VISIBILITY 3133_Size 3134__loadword(const void* __p) 3135{ 3136 _Size __r; 3137 std::memcpy(&__r, __p, sizeof(__r)); 3138 return __r; 3139} 3140 3141// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t 3142// is 64 bits. This is because cityhash64 uses 64bit x 64bit 3143// multiplication, which can be very slow on 32-bit systems. 3144template <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__> 3145struct __murmur2_or_cityhash; 3146 3147template <class _Size> 3148struct __murmur2_or_cityhash<_Size, 32> 3149{ 3150 _Size operator()(const void* __key, _Size __len); 3151}; 3152 3153// murmur2 3154template <class _Size> 3155_Size 3156__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len) 3157{ 3158 const _Size __m = 0x5bd1e995; 3159 const _Size __r = 24; 3160 _Size __h = __len; 3161 const unsigned char* __data = static_cast<const unsigned char*>(__key); 3162 for (; __len >= 4; __data += 4, __len -= 4) 3163 { 3164 _Size __k = __loadword<_Size>(__data); 3165 __k *= __m; 3166 __k ^= __k >> __r; 3167 __k *= __m; 3168 __h *= __m; 3169 __h ^= __k; 3170 } 3171 switch (__len) 3172 { 3173 case 3: 3174 __h ^= __data[2] << 16; 3175 case 2: 3176 __h ^= __data[1] << 8; 3177 case 1: 3178 __h ^= __data[0]; 3179 __h *= __m; 3180 } 3181 __h ^= __h >> 13; 3182 __h *= __m; 3183 __h ^= __h >> 15; 3184 return __h; 3185} 3186 3187template <class _Size> 3188struct __murmur2_or_cityhash<_Size, 64> 3189{ 3190 _Size operator()(const void* __key, _Size __len); 3191 3192 private: 3193 // Some primes between 2^63 and 2^64. 3194 static const _Size __k0 = 0xc3a5c85c97cb3127ULL; 3195 static const _Size __k1 = 0xb492b66fbe98f273ULL; 3196 static const _Size __k2 = 0x9ae16a3b2f90404fULL; 3197 static const _Size __k3 = 0xc949d7c7509e6557ULL; 3198 3199 static _Size __rotate(_Size __val, int __shift) { 3200 return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift))); 3201 } 3202 3203 static _Size __rotate_by_at_least_1(_Size __val, int __shift) { 3204 return (__val >> __shift) | (__val << (64 - __shift)); 3205 } 3206 3207 static _Size __shift_mix(_Size __val) { 3208 return __val ^ (__val >> 47); 3209 } 3210 3211 static _Size __hash_len_16(_Size __u, _Size __v) { 3212 const _Size __mul = 0x9ddfea08eb382d69ULL; 3213 _Size __a = (__u ^ __v) * __mul; 3214 __a ^= (__a >> 47); 3215 _Size __b = (__v ^ __a) * __mul; 3216 __b ^= (__b >> 47); 3217 __b *= __mul; 3218 return __b; 3219 } 3220 3221 static _Size __hash_len_0_to_16(const char* __s, _Size __len) { 3222 if (__len > 8) { 3223 const _Size __a = __loadword<_Size>(__s); 3224 const _Size __b = __loadword<_Size>(__s + __len - 8); 3225 return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b; 3226 } 3227 if (__len >= 4) { 3228 const uint32_t __a = __loadword<uint32_t>(__s); 3229 const uint32_t __b = __loadword<uint32_t>(__s + __len - 4); 3230 return __hash_len_16(__len + (__a << 3), __b); 3231 } 3232 if (__len > 0) { 3233 const unsigned char __a = __s[0]; 3234 const unsigned char __b = __s[__len >> 1]; 3235 const unsigned char __c = __s[__len - 1]; 3236 const uint32_t __y = static_cast<uint32_t>(__a) + 3237 (static_cast<uint32_t>(__b) << 8); 3238 const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2); 3239 return __shift_mix(__y * __k2 ^ __z * __k3) * __k2; 3240 } 3241 return __k2; 3242 } 3243 3244 static _Size __hash_len_17_to_32(const char *__s, _Size __len) { 3245 const _Size __a = __loadword<_Size>(__s) * __k1; 3246 const _Size __b = __loadword<_Size>(__s + 8); 3247 const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2; 3248 const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0; 3249 return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d, 3250 __a + __rotate(__b ^ __k3, 20) - __c + __len); 3251 } 3252 3253 // Return a 16-byte hash for 48 bytes. Quick and dirty. 3254 // Callers do best to use "random-looking" values for a and b. 3255 static pair<_Size, _Size> __weak_hash_len_32_with_seeds( 3256 _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b) { 3257 __a += __w; 3258 __b = __rotate(__b + __a + __z, 21); 3259 const _Size __c = __a; 3260 __a += __x; 3261 __a += __y; 3262 __b += __rotate(__a, 44); 3263 return pair<_Size, _Size>(__a + __z, __b + __c); 3264 } 3265 3266 // Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. 3267 static pair<_Size, _Size> __weak_hash_len_32_with_seeds( 3268 const char* __s, _Size __a, _Size __b) { 3269 return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s), 3270 __loadword<_Size>(__s + 8), 3271 __loadword<_Size>(__s + 16), 3272 __loadword<_Size>(__s + 24), 3273 __a, 3274 __b); 3275 } 3276 3277 // Return an 8-byte hash for 33 to 64 bytes. 3278 static _Size __hash_len_33_to_64(const char *__s, size_t __len) { 3279 _Size __z = __loadword<_Size>(__s + 24); 3280 _Size __a = __loadword<_Size>(__s) + 3281 (__len + __loadword<_Size>(__s + __len - 16)) * __k0; 3282 _Size __b = __rotate(__a + __z, 52); 3283 _Size __c = __rotate(__a, 37); 3284 __a += __loadword<_Size>(__s + 8); 3285 __c += __rotate(__a, 7); 3286 __a += __loadword<_Size>(__s + 16); 3287 _Size __vf = __a + __z; 3288 _Size __vs = __b + __rotate(__a, 31) + __c; 3289 __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32); 3290 __z += __loadword<_Size>(__s + __len - 8); 3291 __b = __rotate(__a + __z, 52); 3292 __c = __rotate(__a, 37); 3293 __a += __loadword<_Size>(__s + __len - 24); 3294 __c += __rotate(__a, 7); 3295 __a += __loadword<_Size>(__s + __len - 16); 3296 _Size __wf = __a + __z; 3297 _Size __ws = __b + __rotate(__a, 31) + __c; 3298 _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0); 3299 return __shift_mix(__r * __k0 + __vs) * __k2; 3300 } 3301}; 3302 3303// cityhash64 3304template <class _Size> 3305_Size 3306__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len) 3307{ 3308 const char* __s = static_cast<const char*>(__key); 3309 if (__len <= 32) { 3310 if (__len <= 16) { 3311 return __hash_len_0_to_16(__s, __len); 3312 } else { 3313 return __hash_len_17_to_32(__s, __len); 3314 } 3315 } else if (__len <= 64) { 3316 return __hash_len_33_to_64(__s, __len); 3317 } 3318 3319 // For strings over 64 bytes we hash the end first, and then as we 3320 // loop we keep 56 bytes of state: v, w, x, y, and z. 3321 _Size __x = __loadword<_Size>(__s + __len - 40); 3322 _Size __y = __loadword<_Size>(__s + __len - 16) + 3323 __loadword<_Size>(__s + __len - 56); 3324 _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len, 3325 __loadword<_Size>(__s + __len - 24)); 3326 pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z); 3327 pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x); 3328 __x = __x * __k1 + __loadword<_Size>(__s); 3329 3330 // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. 3331 __len = (__len - 1) & ~static_cast<_Size>(63); 3332 do { 3333 __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1; 3334 __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1; 3335 __x ^= __w.second; 3336 __y += __v.first + __loadword<_Size>(__s + 40); 3337 __z = __rotate(__z + __w.first, 33) * __k1; 3338 __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first); 3339 __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second, 3340 __y + __loadword<_Size>(__s + 16)); 3341 std::swap(__z, __x); 3342 __s += 64; 3343 __len -= 64; 3344 } while (__len != 0); 3345 return __hash_len_16( 3346 __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z, 3347 __hash_len_16(__v.second, __w.second) + __x); 3348} 3349 3350template <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)> 3351struct __scalar_hash; 3352 3353template <class _Tp> 3354struct __scalar_hash<_Tp, 0> 3355 : public unary_function<_Tp, size_t> 3356{ 3357 _LIBCPP_INLINE_VISIBILITY 3358 size_t operator()(_Tp __v) const _NOEXCEPT 3359 { 3360 union 3361 { 3362 _Tp __t; 3363 size_t __a; 3364 } __u; 3365 __u.__a = 0; 3366 __u.__t = __v; 3367 return __u.__a; 3368 } 3369}; 3370 3371template <class _Tp> 3372struct __scalar_hash<_Tp, 1> 3373 : public unary_function<_Tp, size_t> 3374{ 3375 _LIBCPP_INLINE_VISIBILITY 3376 size_t operator()(_Tp __v) const _NOEXCEPT 3377 { 3378 union 3379 { 3380 _Tp __t; 3381 size_t __a; 3382 } __u; 3383 __u.__t = __v; 3384 return __u.__a; 3385 } 3386}; 3387 3388template <class _Tp> 3389struct __scalar_hash<_Tp, 2> 3390 : public unary_function<_Tp, size_t> 3391{ 3392 _LIBCPP_INLINE_VISIBILITY 3393 size_t operator()(_Tp __v) const _NOEXCEPT 3394 { 3395 union 3396 { 3397 _Tp __t; 3398 struct 3399 { 3400 size_t __a; 3401 size_t __b; 3402 }; 3403 } __u; 3404 __u.__t = __v; 3405 return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 3406 } 3407}; 3408 3409template <class _Tp> 3410struct __scalar_hash<_Tp, 3> 3411 : public unary_function<_Tp, size_t> 3412{ 3413 _LIBCPP_INLINE_VISIBILITY 3414 size_t operator()(_Tp __v) const _NOEXCEPT 3415 { 3416 union 3417 { 3418 _Tp __t; 3419 struct 3420 { 3421 size_t __a; 3422 size_t __b; 3423 size_t __c; 3424 }; 3425 } __u; 3426 __u.__t = __v; 3427 return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 3428 } 3429}; 3430 3431template <class _Tp> 3432struct __scalar_hash<_Tp, 4> 3433 : public unary_function<_Tp, size_t> 3434{ 3435 _LIBCPP_INLINE_VISIBILITY 3436 size_t operator()(_Tp __v) const _NOEXCEPT 3437 { 3438 union 3439 { 3440 _Tp __t; 3441 struct 3442 { 3443 size_t __a; 3444 size_t __b; 3445 size_t __c; 3446 size_t __d; 3447 }; 3448 } __u; 3449 __u.__t = __v; 3450 return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 3451 } 3452}; 3453 3454template<class _Tp> 3455struct _LIBCPP_TYPE_VIS hash<_Tp*> 3456 : public unary_function<_Tp*, size_t> 3457{ 3458 _LIBCPP_INLINE_VISIBILITY 3459 size_t operator()(_Tp* __v) const _NOEXCEPT 3460 { 3461 union 3462 { 3463 _Tp* __t; 3464 size_t __a; 3465 } __u; 3466 __u.__t = __v; 3467 return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 3468 } 3469}; 3470 3471template <class _Tp, class _Dp> 3472struct _LIBCPP_TYPE_VIS hash<unique_ptr<_Tp, _Dp> > 3473{ 3474 typedef unique_ptr<_Tp, _Dp> argument_type; 3475 typedef size_t result_type; 3476 _LIBCPP_INLINE_VISIBILITY 3477 result_type operator()(const argument_type& __ptr) const _NOEXCEPT 3478 { 3479 typedef typename argument_type::pointer pointer; 3480 return hash<pointer>()(__ptr.get()); 3481 } 3482}; 3483 3484struct __destruct_n 3485{ 3486private: 3487 size_t size; 3488 3489 template <class _Tp> 3490 _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT 3491 {for (size_t __i = 0; __i < size; ++__i, ++__p) __p->~_Tp();} 3492 3493 template <class _Tp> 3494 _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT 3495 {} 3496 3497 _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT 3498 {++size;} 3499 _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT 3500 {} 3501 3502 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT 3503 {size = __s;} 3504 _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT 3505 {} 3506public: 3507 _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT 3508 : size(__s) {} 3509 3510 template <class _Tp> 3511 _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*) _NOEXCEPT 3512 {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3513 3514 template <class _Tp> 3515 _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT 3516 {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3517 3518 template <class _Tp> 3519 _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT 3520 {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} 3521}; 3522 3523template <class _Alloc> 3524class __allocator_destructor 3525{ 3526 typedef allocator_traits<_Alloc> __alloc_traits; 3527public: 3528 typedef typename __alloc_traits::pointer pointer; 3529 typedef typename __alloc_traits::size_type size_type; 3530private: 3531 _Alloc& __alloc_; 3532 size_type __s_; 3533public: 3534 _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s) 3535 _NOEXCEPT 3536 : __alloc_(__a), __s_(__s) {} 3537 _LIBCPP_INLINE_VISIBILITY 3538 void operator()(pointer __p) _NOEXCEPT 3539 {__alloc_traits::deallocate(__alloc_, __p, __s_);} 3540}; 3541 3542template <class _InputIterator, class _ForwardIterator> 3543_ForwardIterator 3544uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r) 3545{ 3546 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3547#ifndef _LIBCPP_NO_EXCEPTIONS 3548 _ForwardIterator __s = __r; 3549 try 3550 { 3551#endif 3552 for (; __f != __l; ++__f, ++__r) 3553 ::new(&*__r) value_type(*__f); 3554#ifndef _LIBCPP_NO_EXCEPTIONS 3555 } 3556 catch (...) 3557 { 3558 for (; __s != __r; ++__s) 3559 __s->~value_type(); 3560 throw; 3561 } 3562#endif 3563 return __r; 3564} 3565 3566template <class _InputIterator, class _Size, class _ForwardIterator> 3567_ForwardIterator 3568uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r) 3569{ 3570 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3571#ifndef _LIBCPP_NO_EXCEPTIONS 3572 _ForwardIterator __s = __r; 3573 try 3574 { 3575#endif 3576 for (; __n > 0; ++__f, ++__r, --__n) 3577 ::new(&*__r) value_type(*__f); 3578#ifndef _LIBCPP_NO_EXCEPTIONS 3579 } 3580 catch (...) 3581 { 3582 for (; __s != __r; ++__s) 3583 __s->~value_type(); 3584 throw; 3585 } 3586#endif 3587 return __r; 3588} 3589 3590template <class _ForwardIterator, class _Tp> 3591void 3592uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x) 3593{ 3594 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3595#ifndef _LIBCPP_NO_EXCEPTIONS 3596 _ForwardIterator __s = __f; 3597 try 3598 { 3599#endif 3600 for (; __f != __l; ++__f) 3601 ::new(&*__f) value_type(__x); 3602#ifndef _LIBCPP_NO_EXCEPTIONS 3603 } 3604 catch (...) 3605 { 3606 for (; __s != __f; ++__s) 3607 __s->~value_type(); 3608 throw; 3609 } 3610#endif 3611} 3612 3613template <class _ForwardIterator, class _Size, class _Tp> 3614_ForwardIterator 3615uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x) 3616{ 3617 typedef typename iterator_traits<_ForwardIterator>::value_type value_type; 3618#ifndef _LIBCPP_NO_EXCEPTIONS 3619 _ForwardIterator __s = __f; 3620 try 3621 { 3622#endif 3623 for (; __n > 0; ++__f, --__n) 3624 ::new(&*__f) value_type(__x); 3625#ifndef _LIBCPP_NO_EXCEPTIONS 3626 } 3627 catch (...) 3628 { 3629 for (; __s != __f; ++__s) 3630 __s->~value_type(); 3631 throw; 3632 } 3633#endif 3634 return __f; 3635} 3636 3637class _LIBCPP_EXCEPTION_ABI bad_weak_ptr 3638 : public std::exception 3639{ 3640public: 3641 virtual ~bad_weak_ptr() _NOEXCEPT; 3642 virtual const char* what() const _NOEXCEPT; 3643}; 3644 3645template<class _Tp> class _LIBCPP_TYPE_VIS weak_ptr; 3646 3647class __shared_count 3648{ 3649 __shared_count(const __shared_count&); 3650 __shared_count& operator=(const __shared_count&); 3651 3652protected: 3653 long __shared_owners_; 3654 virtual ~__shared_count(); 3655private: 3656 virtual void __on_zero_shared() _NOEXCEPT = 0; 3657 3658public: 3659 _LIBCPP_INLINE_VISIBILITY 3660 explicit __shared_count(long __refs = 0) _NOEXCEPT 3661 : __shared_owners_(__refs) {} 3662 3663 void __add_shared() _NOEXCEPT; 3664 bool __release_shared() _NOEXCEPT; 3665 _LIBCPP_INLINE_VISIBILITY 3666 long use_count() const _NOEXCEPT {return __shared_owners_ + 1;} 3667}; 3668 3669class __shared_weak_count 3670 : private __shared_count 3671{ 3672 long __shared_weak_owners_; 3673 3674public: 3675 _LIBCPP_INLINE_VISIBILITY 3676 explicit __shared_weak_count(long __refs = 0) _NOEXCEPT 3677 : __shared_count(__refs), 3678 __shared_weak_owners_(__refs) {} 3679protected: 3680 virtual ~__shared_weak_count(); 3681 3682public: 3683 void __add_shared() _NOEXCEPT; 3684 void __add_weak() _NOEXCEPT; 3685 void __release_shared() _NOEXCEPT; 3686 void __release_weak() _NOEXCEPT; 3687 _LIBCPP_INLINE_VISIBILITY 3688 long use_count() const _NOEXCEPT {return __shared_count::use_count();} 3689 __shared_weak_count* lock() _NOEXCEPT; 3690 3691 // Define the function out only if we build static libc++ without RTTI. 3692 // Otherwise we may break clients who need to compile their projects with 3693 // -fno-rtti and yet link against a libc++.dylib compiled 3694 // without -fno-rtti. 3695#if !defined(_LIBCPP_NO_RTTI) || !defined(_LIBCPP_BUILD_STATIC) 3696 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3697#endif 3698private: 3699 virtual void __on_zero_shared_weak() _NOEXCEPT = 0; 3700}; 3701 3702template <class _Tp, class _Dp, class _Alloc> 3703class __shared_ptr_pointer 3704 : public __shared_weak_count 3705{ 3706 __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_; 3707public: 3708 _LIBCPP_INLINE_VISIBILITY 3709 __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a) 3710 : __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {} 3711 3712#ifndef _LIBCPP_NO_RTTI 3713 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; 3714#endif 3715 3716private: 3717 virtual void __on_zero_shared() _NOEXCEPT; 3718 virtual void __on_zero_shared_weak() _NOEXCEPT; 3719}; 3720 3721#ifndef _LIBCPP_NO_RTTI 3722 3723template <class _Tp, class _Dp, class _Alloc> 3724const void* 3725__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT 3726{ 3727 return __t == typeid(_Dp) ? &__data_.first().second() : 0; 3728} 3729 3730#endif // _LIBCPP_NO_RTTI 3731 3732template <class _Tp, class _Dp, class _Alloc> 3733void 3734__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT 3735{ 3736 __data_.first().second()(__data_.first().first()); 3737 __data_.first().second().~_Dp(); 3738} 3739 3740template <class _Tp, class _Dp, class _Alloc> 3741void 3742__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3743{ 3744 typename _Alloc::template rebind<__shared_ptr_pointer>::other __a(__data_.second()); 3745 __data_.second().~_Alloc(); 3746 __a.deallocate(this, 1); 3747} 3748 3749template <class _Tp, class _Alloc> 3750class __shared_ptr_emplace 3751 : public __shared_weak_count 3752{ 3753 __compressed_pair<_Alloc, _Tp> __data_; 3754public: 3755#ifndef _LIBCPP_HAS_NO_VARIADICS 3756 3757 _LIBCPP_INLINE_VISIBILITY 3758 __shared_ptr_emplace(_Alloc __a) 3759 : __data_(_VSTD::move(__a)) {} 3760 3761 template <class ..._Args> 3762 _LIBCPP_INLINE_VISIBILITY 3763 __shared_ptr_emplace(_Alloc __a, _Args&& ...__args) 3764 : __data_(piecewise_construct, _VSTD::forward_as_tuple(__a), 3765 _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {} 3766 3767#else // _LIBCPP_HAS_NO_VARIADICS 3768 3769 _LIBCPP_INLINE_VISIBILITY 3770 __shared_ptr_emplace(_Alloc __a) 3771 : __data_(__a) {} 3772 3773 template <class _A0> 3774 _LIBCPP_INLINE_VISIBILITY 3775 __shared_ptr_emplace(_Alloc __a, _A0& __a0) 3776 : __data_(__a, _Tp(__a0)) {} 3777 3778 template <class _A0, class _A1> 3779 _LIBCPP_INLINE_VISIBILITY 3780 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1) 3781 : __data_(__a, _Tp(__a0, __a1)) {} 3782 3783 template <class _A0, class _A1, class _A2> 3784 _LIBCPP_INLINE_VISIBILITY 3785 __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1, _A2& __a2) 3786 : __data_(__a, _Tp(__a0, __a1, __a2)) {} 3787 3788#endif // _LIBCPP_HAS_NO_VARIADICS 3789 3790private: 3791 virtual void __on_zero_shared() _NOEXCEPT; 3792 virtual void __on_zero_shared_weak() _NOEXCEPT; 3793public: 3794 _LIBCPP_INLINE_VISIBILITY 3795 _Tp* get() _NOEXCEPT {return &__data_.second();} 3796}; 3797 3798template <class _Tp, class _Alloc> 3799void 3800__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT 3801{ 3802 __data_.second().~_Tp(); 3803} 3804 3805template <class _Tp, class _Alloc> 3806void 3807__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT 3808{ 3809 typename _Alloc::template rebind<__shared_ptr_emplace>::other __a(__data_.first()); 3810 __data_.first().~_Alloc(); 3811 __a.deallocate(this, 1); 3812} 3813 3814template<class _Tp> class _LIBCPP_TYPE_VIS enable_shared_from_this; 3815 3816template<class _Tp> 3817class _LIBCPP_TYPE_VIS shared_ptr 3818{ 3819public: 3820 typedef _Tp element_type; 3821private: 3822 element_type* __ptr_; 3823 __shared_weak_count* __cntrl_; 3824 3825 struct __nat {int __for_bool_;}; 3826public: 3827 _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT; 3828 _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT; 3829 template<class _Yp, 3830 class = typename enable_if 3831 < 3832 is_convertible<_Yp*, element_type*>::value 3833 >::type 3834 > 3835 explicit shared_ptr(_Yp* __p); 3836 template<class _Yp, class _Dp, 3837 class = typename enable_if 3838 < 3839 is_convertible<_Yp*, element_type*>::value 3840 >::type 3841 > 3842 shared_ptr(_Yp* __p, _Dp __d); 3843 template<class _Yp, class _Dp, class _Alloc, 3844 class = typename enable_if 3845 < 3846 is_convertible<_Yp*, element_type*>::value 3847 >::type 3848 > 3849 shared_ptr(_Yp* __p, _Dp __d, _Alloc __a); 3850 template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d); 3851 template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a); 3852 template<class _Yp> shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT; 3853 shared_ptr(const shared_ptr& __r) _NOEXCEPT; 3854 template<class _Yp> 3855 shared_ptr(const shared_ptr<_Yp>& __r, 3856 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat()) 3857 _NOEXCEPT; 3858#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3859 shared_ptr(shared_ptr&& __r) _NOEXCEPT; 3860 template<class _Yp> shared_ptr(shared_ptr<_Yp>&& __r, 3861 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat()) 3862 _NOEXCEPT; 3863#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3864 template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r, 3865 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type= __nat()); 3866#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3867 template<class _Yp, 3868 class = typename enable_if 3869 < 3870 is_convertible<_Yp*, element_type*>::value 3871 >::type 3872 > 3873 shared_ptr(auto_ptr<_Yp>&& __r); 3874#else 3875 template<class _Yp, 3876 class = typename enable_if 3877 < 3878 is_convertible<_Yp*, element_type*>::value 3879 >::type 3880 > 3881 shared_ptr(auto_ptr<_Yp> __r); 3882#endif 3883#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3884 template <class _Yp, class _Dp, 3885 class = typename enable_if 3886 < 3887 !is_array<_Yp>::value && 3888 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value 3889 >::type 3890 > 3891 shared_ptr(unique_ptr<_Yp, _Dp>&&, 3892 typename enable_if<!is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3893 template <class _Yp, class _Dp, 3894 class = typename enable_if 3895 < 3896 !is_array<_Yp>::value && 3897 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value 3898 >::type 3899 > 3900 shared_ptr(unique_ptr<_Yp, _Dp>&&, 3901 typename enable_if<is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3902#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3903 template <class _Yp, class _Dp, 3904 class = typename enable_if 3905 < 3906 !is_array<_Yp>::value && 3907 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value 3908 >::type 3909 > shared_ptr(unique_ptr<_Yp, _Dp>, 3910 typename enable_if<!is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3911 template <class _Yp, class _Dp, 3912 class = typename enable_if 3913 < 3914 !is_array<_Yp>::value && 3915 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value 3916 >::type 3917 > 3918 shared_ptr(unique_ptr<_Yp, _Dp>, 3919 typename enable_if<is_lvalue_reference<_Dp>::value, __nat>::type = __nat()); 3920#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3921 3922 ~shared_ptr(); 3923 3924 shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT; 3925 template<class _Yp> 3926 typename enable_if 3927 < 3928 is_convertible<_Yp*, element_type*>::value, 3929 shared_ptr& 3930 >::type 3931 operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT; 3932#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3933 shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT; 3934 template<class _Yp> 3935 typename enable_if 3936 < 3937 is_convertible<_Yp*, element_type*>::value, 3938 shared_ptr<_Tp>& 3939 >::type 3940 operator=(shared_ptr<_Yp>&& __r); 3941 template<class _Yp> 3942 typename enable_if 3943 < 3944 !is_array<_Yp>::value && 3945 is_convertible<_Yp*, element_type*>::value, 3946 shared_ptr& 3947 >::type 3948 operator=(auto_ptr<_Yp>&& __r); 3949#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3950 template<class _Yp> 3951 typename enable_if 3952 < 3953 !is_array<_Yp>::value && 3954 is_convertible<_Yp*, element_type*>::value, 3955 shared_ptr& 3956 >::type 3957 operator=(auto_ptr<_Yp> __r); 3958#endif 3959 template <class _Yp, class _Dp> 3960 typename enable_if 3961 < 3962 !is_array<_Yp>::value && 3963 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, 3964 shared_ptr& 3965 >::type 3966#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 3967 operator=(unique_ptr<_Yp, _Dp>&& __r); 3968#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 3969 operator=(unique_ptr<_Yp, _Dp> __r); 3970#endif 3971 3972 void swap(shared_ptr& __r) _NOEXCEPT; 3973 void reset() _NOEXCEPT; 3974 template<class _Yp> 3975 typename enable_if 3976 < 3977 is_convertible<_Yp*, element_type*>::value, 3978 void 3979 >::type 3980 reset(_Yp* __p); 3981 template<class _Yp, class _Dp> 3982 typename enable_if 3983 < 3984 is_convertible<_Yp*, element_type*>::value, 3985 void 3986 >::type 3987 reset(_Yp* __p, _Dp __d); 3988 template<class _Yp, class _Dp, class _Alloc> 3989 typename enable_if 3990 < 3991 is_convertible<_Yp*, element_type*>::value, 3992 void 3993 >::type 3994 reset(_Yp* __p, _Dp __d, _Alloc __a); 3995 3996 _LIBCPP_INLINE_VISIBILITY 3997 element_type* get() const _NOEXCEPT {return __ptr_;} 3998 _LIBCPP_INLINE_VISIBILITY 3999 typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT 4000 {return *__ptr_;} 4001 _LIBCPP_INLINE_VISIBILITY 4002 element_type* operator->() const _NOEXCEPT {return __ptr_;} 4003 _LIBCPP_INLINE_VISIBILITY 4004 long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;} 4005 _LIBCPP_INLINE_VISIBILITY 4006 bool unique() const _NOEXCEPT {return use_count() == 1;} 4007 _LIBCPP_INLINE_VISIBILITY 4008 _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != 0;} 4009 template <class _Up> 4010 _LIBCPP_INLINE_VISIBILITY 4011 bool owner_before(shared_ptr<_Up> const& __p) const 4012 {return __cntrl_ < __p.__cntrl_;} 4013 template <class _Up> 4014 _LIBCPP_INLINE_VISIBILITY 4015 bool owner_before(weak_ptr<_Up> const& __p) const 4016 {return __cntrl_ < __p.__cntrl_;} 4017 _LIBCPP_INLINE_VISIBILITY 4018 bool 4019 __owner_equivalent(const shared_ptr& __p) const 4020 {return __cntrl_ == __p.__cntrl_;} 4021 4022#ifndef _LIBCPP_NO_RTTI 4023 template <class _Dp> 4024 _LIBCPP_INLINE_VISIBILITY 4025 _Dp* __get_deleter() const _NOEXCEPT 4026 {return (_Dp*)(__cntrl_ ? __cntrl_->__get_deleter(typeid(_Dp)) : 0);} 4027#endif // _LIBCPP_NO_RTTI 4028 4029#ifndef _LIBCPP_HAS_NO_VARIADICS 4030 4031 template<class ..._Args> 4032 static 4033 shared_ptr<_Tp> 4034 make_shared(_Args&& ...__args); 4035 4036 template<class _Alloc, class ..._Args> 4037 static 4038 shared_ptr<_Tp> 4039 allocate_shared(const _Alloc& __a, _Args&& ...__args); 4040 4041#else // _LIBCPP_HAS_NO_VARIADICS 4042 4043 static shared_ptr<_Tp> make_shared(); 4044 4045 template<class _A0> 4046 static shared_ptr<_Tp> make_shared(_A0&); 4047 4048 template<class _A0, class _A1> 4049 static shared_ptr<_Tp> make_shared(_A0&, _A1&); 4050 4051 template<class _A0, class _A1, class _A2> 4052 static shared_ptr<_Tp> make_shared(_A0&, _A1&, _A2&); 4053 4054 template<class _Alloc> 4055 static shared_ptr<_Tp> 4056 allocate_shared(const _Alloc& __a); 4057 4058 template<class _Alloc, class _A0> 4059 static shared_ptr<_Tp> 4060 allocate_shared(const _Alloc& __a, _A0& __a0); 4061 4062 template<class _Alloc, class _A0, class _A1> 4063 static shared_ptr<_Tp> 4064 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1); 4065 4066 template<class _Alloc, class _A0, class _A1, class _A2> 4067 static shared_ptr<_Tp> 4068 allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2); 4069 4070#endif // _LIBCPP_HAS_NO_VARIADICS 4071 4072private: 4073 4074 template <class _Yp> 4075 _LIBCPP_INLINE_VISIBILITY 4076 void 4077 __enable_weak_this(const enable_shared_from_this<_Yp>* __e) _NOEXCEPT 4078 { 4079 if (__e) 4080 __e->__weak_this_ = *this; 4081 } 4082 4083 _LIBCPP_INLINE_VISIBILITY 4084 void __enable_weak_this(const void*) _NOEXCEPT {} 4085 4086 template <class _Up> friend class _LIBCPP_TYPE_VIS shared_ptr; 4087 template <class _Up> friend class _LIBCPP_TYPE_VIS weak_ptr; 4088}; 4089 4090template<class _Tp> 4091inline _LIBCPP_INLINE_VISIBILITY 4092_LIBCPP_CONSTEXPR 4093shared_ptr<_Tp>::shared_ptr() _NOEXCEPT 4094 : __ptr_(0), 4095 __cntrl_(0) 4096{ 4097} 4098 4099template<class _Tp> 4100inline _LIBCPP_INLINE_VISIBILITY 4101_LIBCPP_CONSTEXPR 4102shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT 4103 : __ptr_(0), 4104 __cntrl_(0) 4105{ 4106} 4107 4108template<class _Tp> 4109template<class _Yp, class> 4110shared_ptr<_Tp>::shared_ptr(_Yp* __p) 4111 : __ptr_(__p) 4112{ 4113 unique_ptr<_Yp> __hold(__p); 4114 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk; 4115 __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), allocator<_Yp>()); 4116 __hold.release(); 4117 __enable_weak_this(__p); 4118} 4119 4120template<class _Tp> 4121template<class _Yp, class _Dp, class> 4122shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d) 4123 : __ptr_(__p) 4124{ 4125#ifndef _LIBCPP_NO_EXCEPTIONS 4126 try 4127 { 4128#endif // _LIBCPP_NO_EXCEPTIONS 4129 typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk; 4130 __cntrl_ = new _CntrlBlk(__p, __d, allocator<_Yp>()); 4131 __enable_weak_this(__p); 4132#ifndef _LIBCPP_NO_EXCEPTIONS 4133 } 4134 catch (...) 4135 { 4136 __d(__p); 4137 throw; 4138 } 4139#endif // _LIBCPP_NO_EXCEPTIONS 4140} 4141 4142template<class _Tp> 4143template<class _Dp> 4144shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d) 4145 : __ptr_(0) 4146{ 4147#ifndef _LIBCPP_NO_EXCEPTIONS 4148 try 4149 { 4150#endif // _LIBCPP_NO_EXCEPTIONS 4151 typedef __shared_ptr_pointer<nullptr_t, _Dp, allocator<_Tp> > _CntrlBlk; 4152 __cntrl_ = new _CntrlBlk(__p, __d, allocator<_Tp>()); 4153#ifndef _LIBCPP_NO_EXCEPTIONS 4154 } 4155 catch (...) 4156 { 4157 __d(__p); 4158 throw; 4159 } 4160#endif // _LIBCPP_NO_EXCEPTIONS 4161} 4162 4163template<class _Tp> 4164template<class _Yp, class _Dp, class _Alloc, class> 4165shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a) 4166 : __ptr_(__p) 4167{ 4168#ifndef _LIBCPP_NO_EXCEPTIONS 4169 try 4170 { 4171#endif // _LIBCPP_NO_EXCEPTIONS 4172 typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk; 4173 typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2; 4174 typedef __allocator_destructor<_A2> _D2; 4175 _A2 __a2(__a); 4176 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4177 ::new(__hold2.get()) _CntrlBlk(__p, __d, __a); 4178 __cntrl_ = __hold2.release(); 4179 __enable_weak_this(__p); 4180#ifndef _LIBCPP_NO_EXCEPTIONS 4181 } 4182 catch (...) 4183 { 4184 __d(__p); 4185 throw; 4186 } 4187#endif // _LIBCPP_NO_EXCEPTIONS 4188} 4189 4190template<class _Tp> 4191template<class _Dp, class _Alloc> 4192shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a) 4193 : __ptr_(0) 4194{ 4195#ifndef _LIBCPP_NO_EXCEPTIONS 4196 try 4197 { 4198#endif // _LIBCPP_NO_EXCEPTIONS 4199 typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk; 4200 typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2; 4201 typedef __allocator_destructor<_A2> _D2; 4202 _A2 __a2(__a); 4203 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4204 ::new(__hold2.get()) _CntrlBlk(__p, __d, __a); 4205 __cntrl_ = __hold2.release(); 4206#ifndef _LIBCPP_NO_EXCEPTIONS 4207 } 4208 catch (...) 4209 { 4210 __d(__p); 4211 throw; 4212 } 4213#endif // _LIBCPP_NO_EXCEPTIONS 4214} 4215 4216template<class _Tp> 4217template<class _Yp> 4218inline _LIBCPP_INLINE_VISIBILITY 4219shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT 4220 : __ptr_(__p), 4221 __cntrl_(__r.__cntrl_) 4222{ 4223 if (__cntrl_) 4224 __cntrl_->__add_shared(); 4225} 4226 4227template<class _Tp> 4228inline _LIBCPP_INLINE_VISIBILITY 4229shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT 4230 : __ptr_(__r.__ptr_), 4231 __cntrl_(__r.__cntrl_) 4232{ 4233 if (__cntrl_) 4234 __cntrl_->__add_shared(); 4235} 4236 4237template<class _Tp> 4238template<class _Yp> 4239inline _LIBCPP_INLINE_VISIBILITY 4240shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, 4241 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type) 4242 _NOEXCEPT 4243 : __ptr_(__r.__ptr_), 4244 __cntrl_(__r.__cntrl_) 4245{ 4246 if (__cntrl_) 4247 __cntrl_->__add_shared(); 4248} 4249 4250#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4251 4252template<class _Tp> 4253inline _LIBCPP_INLINE_VISIBILITY 4254shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT 4255 : __ptr_(__r.__ptr_), 4256 __cntrl_(__r.__cntrl_) 4257{ 4258 __r.__ptr_ = 0; 4259 __r.__cntrl_ = 0; 4260} 4261 4262template<class _Tp> 4263template<class _Yp> 4264inline _LIBCPP_INLINE_VISIBILITY 4265shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r, 4266 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type) 4267 _NOEXCEPT 4268 : __ptr_(__r.__ptr_), 4269 __cntrl_(__r.__cntrl_) 4270{ 4271 __r.__ptr_ = 0; 4272 __r.__cntrl_ = 0; 4273} 4274 4275#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4276 4277template<class _Tp> 4278template<class _Yp, class> 4279#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4280shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r) 4281#else 4282shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r) 4283#endif 4284 : __ptr_(__r.get()) 4285{ 4286 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk; 4287 __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>()); 4288 __enable_weak_this(__r.get()); 4289 __r.release(); 4290} 4291 4292template<class _Tp> 4293template <class _Yp, class _Dp, class> 4294#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4295shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 4296#else 4297shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 4298#endif 4299 typename enable_if<!is_lvalue_reference<_Dp>::value, __nat>::type) 4300 : __ptr_(__r.get()) 4301{ 4302 typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk; 4303 __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), allocator<_Yp>()); 4304 __enable_weak_this(__r.get()); 4305 __r.release(); 4306} 4307 4308template<class _Tp> 4309template <class _Yp, class _Dp, class> 4310#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4311shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, 4312#else 4313shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, 4314#endif 4315 typename enable_if<is_lvalue_reference<_Dp>::value, __nat>::type) 4316 : __ptr_(__r.get()) 4317{ 4318 typedef __shared_ptr_pointer<_Yp*, 4319 reference_wrapper<typename remove_reference<_Dp>::type>, 4320 allocator<_Yp> > _CntrlBlk; 4321 __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), allocator<_Yp>()); 4322 __enable_weak_this(__r.get()); 4323 __r.release(); 4324} 4325 4326#ifndef _LIBCPP_HAS_NO_VARIADICS 4327 4328template<class _Tp> 4329template<class ..._Args> 4330shared_ptr<_Tp> 4331shared_ptr<_Tp>::make_shared(_Args&& ...__args) 4332{ 4333 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4334 typedef allocator<_CntrlBlk> _A2; 4335 typedef __allocator_destructor<_A2> _D2; 4336 _A2 __a2; 4337 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4338 ::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...); 4339 shared_ptr<_Tp> __r; 4340 __r.__ptr_ = __hold2.get()->get(); 4341 __r.__cntrl_ = __hold2.release(); 4342 __r.__enable_weak_this(__r.__ptr_); 4343 return __r; 4344} 4345 4346template<class _Tp> 4347template<class _Alloc, class ..._Args> 4348shared_ptr<_Tp> 4349shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args) 4350{ 4351 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4352 typedef typename _Alloc::template rebind<_CntrlBlk>::other _A2; 4353 typedef __allocator_destructor<_A2> _D2; 4354 _A2 __a2(__a); 4355 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); 4356 ::new(__hold2.get()) _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...); 4357 shared_ptr<_Tp> __r; 4358 __r.__ptr_ = __hold2.get()->get(); 4359 __r.__cntrl_ = __hold2.release(); 4360 __r.__enable_weak_this(__r.__ptr_); 4361 return __r; 4362} 4363 4364#else // _LIBCPP_HAS_NO_VARIADICS 4365 4366template<class _Tp> 4367shared_ptr<_Tp> 4368shared_ptr<_Tp>::make_shared() 4369{ 4370 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4371 typedef allocator<_CntrlBlk> _Alloc2; 4372 typedef __allocator_destructor<_Alloc2> _D2; 4373 _Alloc2 __alloc2; 4374 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4375 ::new(__hold2.get()) _CntrlBlk(__alloc2); 4376 shared_ptr<_Tp> __r; 4377 __r.__ptr_ = __hold2.get()->get(); 4378 __r.__cntrl_ = __hold2.release(); 4379 __r.__enable_weak_this(__r.__ptr_); 4380 return __r; 4381} 4382 4383template<class _Tp> 4384template<class _A0> 4385shared_ptr<_Tp> 4386shared_ptr<_Tp>::make_shared(_A0& __a0) 4387{ 4388 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4389 typedef allocator<_CntrlBlk> _Alloc2; 4390 typedef __allocator_destructor<_Alloc2> _D2; 4391 _Alloc2 __alloc2; 4392 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4393 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0); 4394 shared_ptr<_Tp> __r; 4395 __r.__ptr_ = __hold2.get()->get(); 4396 __r.__cntrl_ = __hold2.release(); 4397 __r.__enable_weak_this(__r.__ptr_); 4398 return __r; 4399} 4400 4401template<class _Tp> 4402template<class _A0, class _A1> 4403shared_ptr<_Tp> 4404shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1) 4405{ 4406 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4407 typedef allocator<_CntrlBlk> _Alloc2; 4408 typedef __allocator_destructor<_Alloc2> _D2; 4409 _Alloc2 __alloc2; 4410 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4411 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1); 4412 shared_ptr<_Tp> __r; 4413 __r.__ptr_ = __hold2.get()->get(); 4414 __r.__cntrl_ = __hold2.release(); 4415 __r.__enable_weak_this(__r.__ptr_); 4416 return __r; 4417} 4418 4419template<class _Tp> 4420template<class _A0, class _A1, class _A2> 4421shared_ptr<_Tp> 4422shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 4423{ 4424 typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk; 4425 typedef allocator<_CntrlBlk> _Alloc2; 4426 typedef __allocator_destructor<_Alloc2> _D2; 4427 _Alloc2 __alloc2; 4428 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4429 ::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1, __a2); 4430 shared_ptr<_Tp> __r; 4431 __r.__ptr_ = __hold2.get()->get(); 4432 __r.__cntrl_ = __hold2.release(); 4433 __r.__enable_weak_this(__r.__ptr_); 4434 return __r; 4435} 4436 4437template<class _Tp> 4438template<class _Alloc> 4439shared_ptr<_Tp> 4440shared_ptr<_Tp>::allocate_shared(const _Alloc& __a) 4441{ 4442 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4443 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 4444 typedef __allocator_destructor<_Alloc2> _D2; 4445 _Alloc2 __alloc2(__a); 4446 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4447 ::new(__hold2.get()) _CntrlBlk(__a); 4448 shared_ptr<_Tp> __r; 4449 __r.__ptr_ = __hold2.get()->get(); 4450 __r.__cntrl_ = __hold2.release(); 4451 __r.__enable_weak_this(__r.__ptr_); 4452 return __r; 4453} 4454 4455template<class _Tp> 4456template<class _Alloc, class _A0> 4457shared_ptr<_Tp> 4458shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0) 4459{ 4460 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4461 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 4462 typedef __allocator_destructor<_Alloc2> _D2; 4463 _Alloc2 __alloc2(__a); 4464 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4465 ::new(__hold2.get()) _CntrlBlk(__a, __a0); 4466 shared_ptr<_Tp> __r; 4467 __r.__ptr_ = __hold2.get()->get(); 4468 __r.__cntrl_ = __hold2.release(); 4469 __r.__enable_weak_this(__r.__ptr_); 4470 return __r; 4471} 4472 4473template<class _Tp> 4474template<class _Alloc, class _A0, class _A1> 4475shared_ptr<_Tp> 4476shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 4477{ 4478 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4479 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 4480 typedef __allocator_destructor<_Alloc2> _D2; 4481 _Alloc2 __alloc2(__a); 4482 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4483 ::new(__hold2.get()) _CntrlBlk(__a, __a0, __a1); 4484 shared_ptr<_Tp> __r; 4485 __r.__ptr_ = __hold2.get()->get(); 4486 __r.__cntrl_ = __hold2.release(); 4487 __r.__enable_weak_this(__r.__ptr_); 4488 return __r; 4489} 4490 4491template<class _Tp> 4492template<class _Alloc, class _A0, class _A1, class _A2> 4493shared_ptr<_Tp> 4494shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 4495{ 4496 typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk; 4497 typedef typename _Alloc::template rebind<_CntrlBlk>::other _Alloc2; 4498 typedef __allocator_destructor<_Alloc2> _D2; 4499 _Alloc2 __alloc2(__a); 4500 unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); 4501 ::new(__hold2.get()) _CntrlBlk(__a, __a0, __a1, __a2); 4502 shared_ptr<_Tp> __r; 4503 __r.__ptr_ = __hold2.get()->get(); 4504 __r.__cntrl_ = __hold2.release(); 4505 __r.__enable_weak_this(__r.__ptr_); 4506 return __r; 4507} 4508 4509#endif // _LIBCPP_HAS_NO_VARIADICS 4510 4511template<class _Tp> 4512shared_ptr<_Tp>::~shared_ptr() 4513{ 4514 if (__cntrl_) 4515 __cntrl_->__release_shared(); 4516} 4517 4518template<class _Tp> 4519inline _LIBCPP_INLINE_VISIBILITY 4520shared_ptr<_Tp>& 4521shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT 4522{ 4523 shared_ptr(__r).swap(*this); 4524 return *this; 4525} 4526 4527template<class _Tp> 4528template<class _Yp> 4529inline _LIBCPP_INLINE_VISIBILITY 4530typename enable_if 4531< 4532 is_convertible<_Yp*, _Tp*>::value, 4533 shared_ptr<_Tp>& 4534>::type 4535shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT 4536{ 4537 shared_ptr(__r).swap(*this); 4538 return *this; 4539} 4540 4541#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 4542 4543template<class _Tp> 4544inline _LIBCPP_INLINE_VISIBILITY 4545shared_ptr<_Tp>& 4546shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT 4547{ 4548 shared_ptr(_VSTD::move(__r)).swap(*this); 4549 return *this; 4550} 4551 4552template<class _Tp> 4553template<class _Yp> 4554inline _LIBCPP_INLINE_VISIBILITY 4555typename enable_if 4556< 4557 is_convertible<_Yp*, _Tp*>::value, 4558 shared_ptr<_Tp>& 4559>::type 4560shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r) 4561{ 4562 shared_ptr(_VSTD::move(__r)).swap(*this); 4563 return *this; 4564} 4565 4566template<class _Tp> 4567template<class _Yp> 4568inline _LIBCPP_INLINE_VISIBILITY 4569typename enable_if 4570< 4571 !is_array<_Yp>::value && 4572 is_convertible<_Yp*, _Tp*>::value, 4573 shared_ptr<_Tp>& 4574>::type 4575shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r) 4576{ 4577 shared_ptr(_VSTD::move(__r)).swap(*this); 4578 return *this; 4579} 4580 4581template<class _Tp> 4582template <class _Yp, class _Dp> 4583inline _LIBCPP_INLINE_VISIBILITY 4584typename enable_if 4585< 4586 !is_array<_Yp>::value && 4587 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, _Tp*>::value, 4588 shared_ptr<_Tp>& 4589>::type 4590shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r) 4591{ 4592 shared_ptr(_VSTD::move(__r)).swap(*this); 4593 return *this; 4594} 4595 4596#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4597 4598template<class _Tp> 4599template<class _Yp> 4600inline _LIBCPP_INLINE_VISIBILITY 4601typename enable_if 4602< 4603 !is_array<_Yp>::value && 4604 is_convertible<_Yp*, _Tp*>::value, 4605 shared_ptr<_Tp>& 4606>::type 4607shared_ptr<_Tp>::operator=(auto_ptr<_Yp> __r) 4608{ 4609 shared_ptr(__r).swap(*this); 4610 return *this; 4611} 4612 4613template<class _Tp> 4614template <class _Yp, class _Dp> 4615inline _LIBCPP_INLINE_VISIBILITY 4616typename enable_if 4617< 4618 !is_array<_Yp>::value && 4619 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, _Tp*>::value, 4620 shared_ptr<_Tp>& 4621>::type 4622shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r) 4623{ 4624 shared_ptr(_VSTD::move(__r)).swap(*this); 4625 return *this; 4626} 4627 4628#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 4629 4630template<class _Tp> 4631inline _LIBCPP_INLINE_VISIBILITY 4632void 4633shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT 4634{ 4635 _VSTD::swap(__ptr_, __r.__ptr_); 4636 _VSTD::swap(__cntrl_, __r.__cntrl_); 4637} 4638 4639template<class _Tp> 4640inline _LIBCPP_INLINE_VISIBILITY 4641void 4642shared_ptr<_Tp>::reset() _NOEXCEPT 4643{ 4644 shared_ptr().swap(*this); 4645} 4646 4647template<class _Tp> 4648template<class _Yp> 4649inline _LIBCPP_INLINE_VISIBILITY 4650typename enable_if 4651< 4652 is_convertible<_Yp*, _Tp*>::value, 4653 void 4654>::type 4655shared_ptr<_Tp>::reset(_Yp* __p) 4656{ 4657 shared_ptr(__p).swap(*this); 4658} 4659 4660template<class _Tp> 4661template<class _Yp, class _Dp> 4662inline _LIBCPP_INLINE_VISIBILITY 4663typename enable_if 4664< 4665 is_convertible<_Yp*, _Tp*>::value, 4666 void 4667>::type 4668shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d) 4669{ 4670 shared_ptr(__p, __d).swap(*this); 4671} 4672 4673template<class _Tp> 4674template<class _Yp, class _Dp, class _Alloc> 4675inline _LIBCPP_INLINE_VISIBILITY 4676typename enable_if 4677< 4678 is_convertible<_Yp*, _Tp*>::value, 4679 void 4680>::type 4681shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a) 4682{ 4683 shared_ptr(__p, __d, __a).swap(*this); 4684} 4685 4686#ifndef _LIBCPP_HAS_NO_VARIADICS 4687 4688template<class _Tp, class ..._Args> 4689inline _LIBCPP_INLINE_VISIBILITY 4690typename enable_if 4691< 4692 !is_array<_Tp>::value, 4693 shared_ptr<_Tp> 4694>::type 4695make_shared(_Args&& ...__args) 4696{ 4697 return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...); 4698} 4699 4700template<class _Tp, class _Alloc, class ..._Args> 4701inline _LIBCPP_INLINE_VISIBILITY 4702typename enable_if 4703< 4704 !is_array<_Tp>::value, 4705 shared_ptr<_Tp> 4706>::type 4707allocate_shared(const _Alloc& __a, _Args&& ...__args) 4708{ 4709 return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...); 4710} 4711 4712#else // _LIBCPP_HAS_NO_VARIADICS 4713 4714template<class _Tp> 4715inline _LIBCPP_INLINE_VISIBILITY 4716shared_ptr<_Tp> 4717make_shared() 4718{ 4719 return shared_ptr<_Tp>::make_shared(); 4720} 4721 4722template<class _Tp, class _A0> 4723inline _LIBCPP_INLINE_VISIBILITY 4724shared_ptr<_Tp> 4725make_shared(_A0& __a0) 4726{ 4727 return shared_ptr<_Tp>::make_shared(__a0); 4728} 4729 4730template<class _Tp, class _A0, class _A1> 4731inline _LIBCPP_INLINE_VISIBILITY 4732shared_ptr<_Tp> 4733make_shared(_A0& __a0, _A1& __a1) 4734{ 4735 return shared_ptr<_Tp>::make_shared(__a0, __a1); 4736} 4737 4738template<class _Tp, class _A0, class _A1, class _A2> 4739inline _LIBCPP_INLINE_VISIBILITY 4740shared_ptr<_Tp> 4741make_shared(_A0& __a0, _A1& __a1, _A2& __a2) 4742{ 4743 return shared_ptr<_Tp>::make_shared(__a0, __a1, __a2); 4744} 4745 4746template<class _Tp, class _Alloc> 4747inline _LIBCPP_INLINE_VISIBILITY 4748shared_ptr<_Tp> 4749allocate_shared(const _Alloc& __a) 4750{ 4751 return shared_ptr<_Tp>::allocate_shared(__a); 4752} 4753 4754template<class _Tp, class _Alloc, class _A0> 4755inline _LIBCPP_INLINE_VISIBILITY 4756shared_ptr<_Tp> 4757allocate_shared(const _Alloc& __a, _A0& __a0) 4758{ 4759 return shared_ptr<_Tp>::allocate_shared(__a, __a0); 4760} 4761 4762template<class _Tp, class _Alloc, class _A0, class _A1> 4763inline _LIBCPP_INLINE_VISIBILITY 4764shared_ptr<_Tp> 4765allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1) 4766{ 4767 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1); 4768} 4769 4770template<class _Tp, class _Alloc, class _A0, class _A1, class _A2> 4771inline _LIBCPP_INLINE_VISIBILITY 4772shared_ptr<_Tp> 4773allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2) 4774{ 4775 return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1, __a2); 4776} 4777 4778#endif // _LIBCPP_HAS_NO_VARIADICS 4779 4780template<class _Tp, class _Up> 4781inline _LIBCPP_INLINE_VISIBILITY 4782bool 4783operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4784{ 4785 return __x.get() == __y.get(); 4786} 4787 4788template<class _Tp, class _Up> 4789inline _LIBCPP_INLINE_VISIBILITY 4790bool 4791operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4792{ 4793 return !(__x == __y); 4794} 4795 4796template<class _Tp, class _Up> 4797inline _LIBCPP_INLINE_VISIBILITY 4798bool 4799operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4800{ 4801 typedef typename common_type<_Tp*, _Up*>::type _V; 4802 return less<_V>()(__x.get(), __y.get()); 4803} 4804 4805template<class _Tp, class _Up> 4806inline _LIBCPP_INLINE_VISIBILITY 4807bool 4808operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4809{ 4810 return __y < __x; 4811} 4812 4813template<class _Tp, class _Up> 4814inline _LIBCPP_INLINE_VISIBILITY 4815bool 4816operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4817{ 4818 return !(__y < __x); 4819} 4820 4821template<class _Tp, class _Up> 4822inline _LIBCPP_INLINE_VISIBILITY 4823bool 4824operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT 4825{ 4826 return !(__x < __y); 4827} 4828 4829template<class _Tp> 4830inline _LIBCPP_INLINE_VISIBILITY 4831bool 4832operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4833{ 4834 return !__x; 4835} 4836 4837template<class _Tp> 4838inline _LIBCPP_INLINE_VISIBILITY 4839bool 4840operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4841{ 4842 return !__x; 4843} 4844 4845template<class _Tp> 4846inline _LIBCPP_INLINE_VISIBILITY 4847bool 4848operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4849{ 4850 return static_cast<bool>(__x); 4851} 4852 4853template<class _Tp> 4854inline _LIBCPP_INLINE_VISIBILITY 4855bool 4856operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4857{ 4858 return static_cast<bool>(__x); 4859} 4860 4861template<class _Tp> 4862inline _LIBCPP_INLINE_VISIBILITY 4863bool 4864operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4865{ 4866 return less<_Tp*>()(__x.get(), nullptr); 4867} 4868 4869template<class _Tp> 4870inline _LIBCPP_INLINE_VISIBILITY 4871bool 4872operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4873{ 4874 return less<_Tp*>()(nullptr, __x.get()); 4875} 4876 4877template<class _Tp> 4878inline _LIBCPP_INLINE_VISIBILITY 4879bool 4880operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4881{ 4882 return nullptr < __x; 4883} 4884 4885template<class _Tp> 4886inline _LIBCPP_INLINE_VISIBILITY 4887bool 4888operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4889{ 4890 return __x < nullptr; 4891} 4892 4893template<class _Tp> 4894inline _LIBCPP_INLINE_VISIBILITY 4895bool 4896operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4897{ 4898 return !(nullptr < __x); 4899} 4900 4901template<class _Tp> 4902inline _LIBCPP_INLINE_VISIBILITY 4903bool 4904operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4905{ 4906 return !(__x < nullptr); 4907} 4908 4909template<class _Tp> 4910inline _LIBCPP_INLINE_VISIBILITY 4911bool 4912operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT 4913{ 4914 return !(__x < nullptr); 4915} 4916 4917template<class _Tp> 4918inline _LIBCPP_INLINE_VISIBILITY 4919bool 4920operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT 4921{ 4922 return !(nullptr < __x); 4923} 4924 4925template<class _Tp> 4926inline _LIBCPP_INLINE_VISIBILITY 4927void 4928swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT 4929{ 4930 __x.swap(__y); 4931} 4932 4933template<class _Tp, class _Up> 4934inline _LIBCPP_INLINE_VISIBILITY 4935typename enable_if 4936< 4937 !is_array<_Tp>::value && !is_array<_Up>::value, 4938 shared_ptr<_Tp> 4939>::type 4940static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4941{ 4942 return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); 4943} 4944 4945template<class _Tp, class _Up> 4946inline _LIBCPP_INLINE_VISIBILITY 4947typename enable_if 4948< 4949 !is_array<_Tp>::value && !is_array<_Up>::value, 4950 shared_ptr<_Tp> 4951>::type 4952dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4953{ 4954 _Tp* __p = dynamic_cast<_Tp*>(__r.get()); 4955 return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>(); 4956} 4957 4958template<class _Tp, class _Up> 4959typename enable_if 4960< 4961 is_array<_Tp>::value == is_array<_Up>::value, 4962 shared_ptr<_Tp> 4963>::type 4964const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT 4965{ 4966 typedef typename remove_extent<_Tp>::type _RTp; 4967 return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get())); 4968} 4969 4970#ifndef _LIBCPP_NO_RTTI 4971 4972template<class _Dp, class _Tp> 4973inline _LIBCPP_INLINE_VISIBILITY 4974_Dp* 4975get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT 4976{ 4977 return __p.template __get_deleter<_Dp>(); 4978} 4979 4980#endif // _LIBCPP_NO_RTTI 4981 4982template<class _Tp> 4983class _LIBCPP_TYPE_VIS weak_ptr 4984{ 4985public: 4986 typedef _Tp element_type; 4987private: 4988 element_type* __ptr_; 4989 __shared_weak_count* __cntrl_; 4990 4991public: 4992 _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT; 4993 template<class _Yp> weak_ptr(shared_ptr<_Yp> const& __r, 4994 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 4995 _NOEXCEPT; 4996 weak_ptr(weak_ptr const& __r) _NOEXCEPT; 4997 template<class _Yp> weak_ptr(weak_ptr<_Yp> const& __r, 4998 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 4999 _NOEXCEPT; 5000 5001#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5002 weak_ptr(weak_ptr&& __r) _NOEXCEPT; 5003 template<class _Yp> weak_ptr(weak_ptr<_Yp>&& __r, 5004 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) 5005 _NOEXCEPT; 5006#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5007 ~weak_ptr(); 5008 5009 weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT; 5010 template<class _Yp> 5011 typename enable_if 5012 < 5013 is_convertible<_Yp*, element_type*>::value, 5014 weak_ptr& 5015 >::type 5016 operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT; 5017 5018#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5019 5020 weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT; 5021 template<class _Yp> 5022 typename enable_if 5023 < 5024 is_convertible<_Yp*, element_type*>::value, 5025 weak_ptr& 5026 >::type 5027 operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT; 5028 5029#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5030 5031 template<class _Yp> 5032 typename enable_if 5033 < 5034 is_convertible<_Yp*, element_type*>::value, 5035 weak_ptr& 5036 >::type 5037 operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT; 5038 5039 void swap(weak_ptr& __r) _NOEXCEPT; 5040 void reset() _NOEXCEPT; 5041 5042 _LIBCPP_INLINE_VISIBILITY 5043 long use_count() const _NOEXCEPT 5044 {return __cntrl_ ? __cntrl_->use_count() : 0;} 5045 _LIBCPP_INLINE_VISIBILITY 5046 bool expired() const _NOEXCEPT 5047 {return __cntrl_ == 0 || __cntrl_->use_count() == 0;} 5048 shared_ptr<_Tp> lock() const _NOEXCEPT; 5049 template<class _Up> 5050 _LIBCPP_INLINE_VISIBILITY 5051 bool owner_before(const shared_ptr<_Up>& __r) const 5052 {return __cntrl_ < __r.__cntrl_;} 5053 template<class _Up> 5054 _LIBCPP_INLINE_VISIBILITY 5055 bool owner_before(const weak_ptr<_Up>& __r) const 5056 {return __cntrl_ < __r.__cntrl_;} 5057 5058 template <class _Up> friend class _LIBCPP_TYPE_VIS weak_ptr; 5059 template <class _Up> friend class _LIBCPP_TYPE_VIS shared_ptr; 5060}; 5061 5062template<class _Tp> 5063inline _LIBCPP_INLINE_VISIBILITY 5064_LIBCPP_CONSTEXPR 5065weak_ptr<_Tp>::weak_ptr() _NOEXCEPT 5066 : __ptr_(0), 5067 __cntrl_(0) 5068{ 5069} 5070 5071template<class _Tp> 5072inline _LIBCPP_INLINE_VISIBILITY 5073weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT 5074 : __ptr_(__r.__ptr_), 5075 __cntrl_(__r.__cntrl_) 5076{ 5077 if (__cntrl_) 5078 __cntrl_->__add_weak(); 5079} 5080 5081template<class _Tp> 5082template<class _Yp> 5083inline _LIBCPP_INLINE_VISIBILITY 5084weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r, 5085 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5086 _NOEXCEPT 5087 : __ptr_(__r.__ptr_), 5088 __cntrl_(__r.__cntrl_) 5089{ 5090 if (__cntrl_) 5091 __cntrl_->__add_weak(); 5092} 5093 5094template<class _Tp> 5095template<class _Yp> 5096inline _LIBCPP_INLINE_VISIBILITY 5097weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r, 5098 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5099 _NOEXCEPT 5100 : __ptr_(__r.__ptr_), 5101 __cntrl_(__r.__cntrl_) 5102{ 5103 if (__cntrl_) 5104 __cntrl_->__add_weak(); 5105} 5106 5107#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5108 5109template<class _Tp> 5110inline _LIBCPP_INLINE_VISIBILITY 5111weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT 5112 : __ptr_(__r.__ptr_), 5113 __cntrl_(__r.__cntrl_) 5114{ 5115 __r.__ptr_ = 0; 5116 __r.__cntrl_ = 0; 5117} 5118 5119template<class _Tp> 5120template<class _Yp> 5121inline _LIBCPP_INLINE_VISIBILITY 5122weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r, 5123 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) 5124 _NOEXCEPT 5125 : __ptr_(__r.__ptr_), 5126 __cntrl_(__r.__cntrl_) 5127{ 5128 __r.__ptr_ = 0; 5129 __r.__cntrl_ = 0; 5130} 5131 5132#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5133 5134template<class _Tp> 5135weak_ptr<_Tp>::~weak_ptr() 5136{ 5137 if (__cntrl_) 5138 __cntrl_->__release_weak(); 5139} 5140 5141template<class _Tp> 5142inline _LIBCPP_INLINE_VISIBILITY 5143weak_ptr<_Tp>& 5144weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT 5145{ 5146 weak_ptr(__r).swap(*this); 5147 return *this; 5148} 5149 5150template<class _Tp> 5151template<class _Yp> 5152inline _LIBCPP_INLINE_VISIBILITY 5153typename enable_if 5154< 5155 is_convertible<_Yp*, _Tp*>::value, 5156 weak_ptr<_Tp>& 5157>::type 5158weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT 5159{ 5160 weak_ptr(__r).swap(*this); 5161 return *this; 5162} 5163 5164#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 5165 5166template<class _Tp> 5167inline _LIBCPP_INLINE_VISIBILITY 5168weak_ptr<_Tp>& 5169weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT 5170{ 5171 weak_ptr(_VSTD::move(__r)).swap(*this); 5172 return *this; 5173} 5174 5175template<class _Tp> 5176template<class _Yp> 5177inline _LIBCPP_INLINE_VISIBILITY 5178typename enable_if 5179< 5180 is_convertible<_Yp*, _Tp*>::value, 5181 weak_ptr<_Tp>& 5182>::type 5183weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT 5184{ 5185 weak_ptr(_VSTD::move(__r)).swap(*this); 5186 return *this; 5187} 5188 5189#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 5190 5191template<class _Tp> 5192template<class _Yp> 5193inline _LIBCPP_INLINE_VISIBILITY 5194typename enable_if 5195< 5196 is_convertible<_Yp*, _Tp*>::value, 5197 weak_ptr<_Tp>& 5198>::type 5199weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT 5200{ 5201 weak_ptr(__r).swap(*this); 5202 return *this; 5203} 5204 5205template<class _Tp> 5206inline _LIBCPP_INLINE_VISIBILITY 5207void 5208weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT 5209{ 5210 _VSTD::swap(__ptr_, __r.__ptr_); 5211 _VSTD::swap(__cntrl_, __r.__cntrl_); 5212} 5213 5214template<class _Tp> 5215inline _LIBCPP_INLINE_VISIBILITY 5216void 5217swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT 5218{ 5219 __x.swap(__y); 5220} 5221 5222template<class _Tp> 5223inline _LIBCPP_INLINE_VISIBILITY 5224void 5225weak_ptr<_Tp>::reset() _NOEXCEPT 5226{ 5227 weak_ptr().swap(*this); 5228} 5229 5230template<class _Tp> 5231template<class _Yp> 5232shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r, 5233 typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type) 5234 : __ptr_(__r.__ptr_), 5235 __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) 5236{ 5237 if (__cntrl_ == 0) 5238#ifndef _LIBCPP_NO_EXCEPTIONS 5239 throw bad_weak_ptr(); 5240#else 5241 assert(!"bad_weak_ptr"); 5242#endif 5243} 5244 5245template<class _Tp> 5246shared_ptr<_Tp> 5247weak_ptr<_Tp>::lock() const _NOEXCEPT 5248{ 5249 shared_ptr<_Tp> __r; 5250 __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_; 5251 if (__r.__cntrl_) 5252 __r.__ptr_ = __ptr_; 5253 return __r; 5254} 5255 5256template <class _Tp> struct owner_less; 5257 5258template <class _Tp> 5259struct _LIBCPP_TYPE_VIS owner_less<shared_ptr<_Tp> > 5260 : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> 5261{ 5262 typedef bool result_type; 5263 _LIBCPP_INLINE_VISIBILITY 5264 bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const 5265 {return __x.owner_before(__y);} 5266 _LIBCPP_INLINE_VISIBILITY 5267 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const 5268 {return __x.owner_before(__y);} 5269 _LIBCPP_INLINE_VISIBILITY 5270 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const 5271 {return __x.owner_before(__y);} 5272}; 5273 5274template <class _Tp> 5275struct _LIBCPP_TYPE_VIS owner_less<weak_ptr<_Tp> > 5276 : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> 5277{ 5278 typedef bool result_type; 5279 _LIBCPP_INLINE_VISIBILITY 5280 bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const 5281 {return __x.owner_before(__y);} 5282 _LIBCPP_INLINE_VISIBILITY 5283 bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const 5284 {return __x.owner_before(__y);} 5285 _LIBCPP_INLINE_VISIBILITY 5286 bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const 5287 {return __x.owner_before(__y);} 5288}; 5289 5290template<class _Tp> 5291class _LIBCPP_TYPE_VIS enable_shared_from_this 5292{ 5293 mutable weak_ptr<_Tp> __weak_this_; 5294protected: 5295 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 5296 enable_shared_from_this() _NOEXCEPT {} 5297 _LIBCPP_INLINE_VISIBILITY 5298 enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {} 5299 _LIBCPP_INLINE_VISIBILITY 5300 enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT 5301 {return *this;} 5302 _LIBCPP_INLINE_VISIBILITY 5303 ~enable_shared_from_this() {} 5304public: 5305 _LIBCPP_INLINE_VISIBILITY 5306 shared_ptr<_Tp> shared_from_this() 5307 {return shared_ptr<_Tp>(__weak_this_);} 5308 _LIBCPP_INLINE_VISIBILITY 5309 shared_ptr<_Tp const> shared_from_this() const 5310 {return shared_ptr<const _Tp>(__weak_this_);} 5311 5312 template <class _Up> friend class shared_ptr; 5313}; 5314 5315template <class _Tp> 5316struct _LIBCPP_TYPE_VIS hash<shared_ptr<_Tp> > 5317{ 5318 typedef shared_ptr<_Tp> argument_type; 5319 typedef size_t result_type; 5320 _LIBCPP_INLINE_VISIBILITY 5321 result_type operator()(const argument_type& __ptr) const _NOEXCEPT 5322 { 5323 return hash<_Tp*>()(__ptr.get()); 5324 } 5325}; 5326 5327template<class _CharT, class _Traits, class _Yp> 5328inline _LIBCPP_INLINE_VISIBILITY 5329basic_ostream<_CharT, _Traits>& 5330operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p); 5331 5332#if __has_feature(cxx_atomic) 5333 5334class __sp_mut 5335{ 5336 void* __lx; 5337public: 5338 void lock() _NOEXCEPT; 5339 void unlock() _NOEXCEPT; 5340 5341private: 5342 _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT; 5343 __sp_mut(const __sp_mut&); 5344 __sp_mut& operator=(const __sp_mut&); 5345 5346 friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*); 5347}; 5348 5349_LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*); 5350 5351template <class _Tp> 5352inline _LIBCPP_INLINE_VISIBILITY 5353bool 5354atomic_is_lock_free(const shared_ptr<_Tp>*) 5355{ 5356 return false; 5357} 5358 5359template <class _Tp> 5360shared_ptr<_Tp> 5361atomic_load(const shared_ptr<_Tp>* __p) 5362{ 5363 __sp_mut& __m = __get_sp_mut(__p); 5364 __m.lock(); 5365 shared_ptr<_Tp> __q = *__p; 5366 __m.unlock(); 5367 return __q; 5368} 5369 5370template <class _Tp> 5371inline _LIBCPP_INLINE_VISIBILITY 5372shared_ptr<_Tp> 5373atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) 5374{ 5375 return atomic_load(__p); 5376} 5377 5378template <class _Tp> 5379void 5380atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) 5381{ 5382 __sp_mut& __m = __get_sp_mut(__p); 5383 __m.lock(); 5384 __p->swap(__r); 5385 __m.unlock(); 5386} 5387 5388template <class _Tp> 5389inline _LIBCPP_INLINE_VISIBILITY 5390void 5391atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) 5392{ 5393 atomic_store(__p, __r); 5394} 5395 5396template <class _Tp> 5397shared_ptr<_Tp> 5398atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) 5399{ 5400 __sp_mut& __m = __get_sp_mut(__p); 5401 __m.lock(); 5402 __p->swap(__r); 5403 __m.unlock(); 5404 return __r; 5405} 5406 5407template <class _Tp> 5408inline _LIBCPP_INLINE_VISIBILITY 5409shared_ptr<_Tp> 5410atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) 5411{ 5412 return atomic_exchange(__p, __r); 5413} 5414 5415template <class _Tp> 5416bool 5417atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) 5418{ 5419 __sp_mut& __m = __get_sp_mut(__p); 5420 __m.lock(); 5421 if (__p->__owner_equivalent(*__v)) 5422 { 5423 *__p = __w; 5424 __m.unlock(); 5425 return true; 5426 } 5427 *__v = *__p; 5428 __m.unlock(); 5429 return false; 5430} 5431 5432template <class _Tp> 5433inline _LIBCPP_INLINE_VISIBILITY 5434bool 5435atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) 5436{ 5437 return atomic_compare_exchange_strong(__p, __v, __w); 5438} 5439 5440template <class _Tp> 5441inline _LIBCPP_INLINE_VISIBILITY 5442bool 5443atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, 5444 shared_ptr<_Tp> __w, memory_order, memory_order) 5445{ 5446 return atomic_compare_exchange_strong(__p, __v, __w); 5447} 5448 5449template <class _Tp> 5450inline _LIBCPP_INLINE_VISIBILITY 5451bool 5452atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, 5453 shared_ptr<_Tp> __w, memory_order, memory_order) 5454{ 5455 return atomic_compare_exchange_weak(__p, __v, __w); 5456} 5457 5458#endif // __has_feature(cxx_atomic) 5459 5460//enum class 5461struct _LIBCPP_TYPE_VIS pointer_safety 5462{ 5463 enum __lx 5464 { 5465 relaxed, 5466 preferred, 5467 strict 5468 }; 5469 5470 __lx __v_; 5471 5472 _LIBCPP_INLINE_VISIBILITY 5473 pointer_safety(__lx __v) : __v_(__v) {} 5474 _LIBCPP_INLINE_VISIBILITY 5475 operator int() const {return __v_;} 5476}; 5477 5478void declare_reachable(void* __p); 5479void declare_no_pointers(char* __p, size_t __n); 5480void undeclare_no_pointers(char* __p, size_t __n); 5481pointer_safety get_pointer_safety() _NOEXCEPT; 5482void* __undeclare_reachable(void* __p); 5483 5484template <class _Tp> 5485inline _LIBCPP_INLINE_VISIBILITY 5486_Tp* 5487undeclare_reachable(_Tp* __p) 5488{ 5489 return static_cast<_Tp*>(__undeclare_reachable(__p)); 5490} 5491 5492void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space); 5493 5494_LIBCPP_END_NAMESPACE_STD 5495 5496#endif // _LIBCPP_MEMORY 5497