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