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