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