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