1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
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_ALLOCATOR_TRAITS_H
11#define _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
12
13#include <__config>
14#include <__memory/construct_at.h>
15#include <__memory/pointer_traits.h>
16#include <__utility/forward.h>
17#include <limits>
18#include <type_traits>
19
20#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
21# pragma GCC system_header
22#endif
23
24_LIBCPP_PUSH_MACROS
25#include <__undef_macros>
26
27_LIBCPP_BEGIN_NAMESPACE_STD
28
29#define _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY) \
30 template <class _Tp, class = void> struct NAME : false_type { }; \
31 template <class _Tp> struct NAME<_Tp, typename __void_t<typename _Tp:: PROPERTY >::type> : true_type { }
32
33// __pointer
34_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_pointer, pointer);
35template <class _Tp, class _Alloc,
36 class _RawAlloc = typename remove_reference<_Alloc>::type,
37 bool = __has_pointer<_RawAlloc>::value>
38struct __pointer {
39 using type _LIBCPP_NODEBUG = typename _RawAlloc::pointer;
40};
41template <class _Tp, class _Alloc, class _RawAlloc>
42struct __pointer<_Tp, _Alloc, _RawAlloc, false> {
43 using type _LIBCPP_NODEBUG = _Tp*;
44};
45
46// __const_pointer
47_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_pointer, const_pointer);
48template <class _Tp, class _Ptr, class _Alloc,
49 bool = __has_const_pointer<_Alloc>::value>
50struct __const_pointer {
51 using type _LIBCPP_NODEBUG = typename _Alloc::const_pointer;
52};
53template <class _Tp, class _Ptr, class _Alloc>
54struct __const_pointer<_Tp, _Ptr, _Alloc, false> {
55#ifdef _LIBCPP_CXX03_LANG
56 using type = typename pointer_traits<_Ptr>::template rebind<const _Tp>::other;
57#else
58 using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
59#endif
60};
61
62// __void_pointer
63_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_void_pointer, void_pointer);
64template <class _Ptr, class _Alloc,
65 bool = __has_void_pointer<_Alloc>::value>
66struct __void_pointer {
67 using type _LIBCPP_NODEBUG = typename _Alloc::void_pointer;
68};
69template <class _Ptr, class _Alloc>
70struct __void_pointer<_Ptr, _Alloc, false> {
71#ifdef _LIBCPP_CXX03_LANG
72 using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>::other;
73#else
74 using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>;
75#endif
76};
77
78// __const_void_pointer
79_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_void_pointer, const_void_pointer);
80template <class _Ptr, class _Alloc,
81 bool = __has_const_void_pointer<_Alloc>::value>
82struct __const_void_pointer {
83 using type _LIBCPP_NODEBUG = typename _Alloc::const_void_pointer;
84};
85template <class _Ptr, class _Alloc>
86struct __const_void_pointer<_Ptr, _Alloc, false> {
87#ifdef _LIBCPP_CXX03_LANG
88 using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>::other;
89#else
90 using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>;
91#endif
92};
93
94// __size_type
95_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_size_type, size_type);
96template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
97struct __size_type : make_unsigned<_DiffType> { };
98template <class _Alloc, class _DiffType>
99struct __size_type<_Alloc, _DiffType, true> {
100 using type _LIBCPP_NODEBUG = typename _Alloc::size_type;
101};
102
103// __alloc_traits_difference_type
104_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_alloc_traits_difference_type, difference_type);
105template <class _Alloc, class _Ptr, bool = __has_alloc_traits_difference_type<_Alloc>::value>
106struct __alloc_traits_difference_type {
107 using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::difference_type;
108};
109template <class _Alloc, class _Ptr>
110struct __alloc_traits_difference_type<_Alloc, _Ptr, true> {
111 using type _LIBCPP_NODEBUG = typename _Alloc::difference_type;
112};
113
114// __propagate_on_container_copy_assignment
115_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_copy_assignment, propagate_on_container_copy_assignment);
116template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value>
117struct __propagate_on_container_copy_assignment : false_type { };
118template <class _Alloc>
119struct __propagate_on_container_copy_assignment<_Alloc, true> {
120 using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_copy_assignment;
121};
122
123// __propagate_on_container_move_assignment
124_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_move_assignment, propagate_on_container_move_assignment);
125template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
126struct __propagate_on_container_move_assignment : false_type { };
127template <class _Alloc>
128struct __propagate_on_container_move_assignment<_Alloc, true> {
129 using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_move_assignment;
130};
131
132// __propagate_on_container_swap
133_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_swap, propagate_on_container_swap);
134template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
135struct __propagate_on_container_swap : false_type { };
136template <class _Alloc>
137struct __propagate_on_container_swap<_Alloc, true> {
138 using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_swap;
139};
140
141// __is_always_equal
142_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_is_always_equal, is_always_equal);
143template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
144struct __is_always_equal : is_empty<_Alloc> { };
145template <class _Alloc>
146struct __is_always_equal<_Alloc, true> {
147 using type _LIBCPP_NODEBUG = typename _Alloc::is_always_equal;
148};
149
150// __allocator_traits_rebind
151_LIBCPP_SUPPRESS_DEPRECATED_PUSH
152template <class _Tp, class _Up, class = void>
153struct __has_rebind_other : false_type { };
154template <class _Tp, class _Up>
155struct __has_rebind_other<_Tp, _Up, typename __void_t<
156 typename _Tp::template rebind<_Up>::other
157>::type> : true_type { };
158
159template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
160struct __allocator_traits_rebind {
161 using type _LIBCPP_NODEBUG = typename _Tp::template rebind<_Up>::other;
162};
163template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
164struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> {
165 using type _LIBCPP_NODEBUG = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
166};
167template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
168struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> {
169 using type _LIBCPP_NODEBUG = _Alloc<_Up, _Args...>;
170};
171_LIBCPP_SUPPRESS_DEPRECATED_POP
172
173template<class _Alloc, class _Tp>
174using __allocator_traits_rebind_t = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
175
176_LIBCPP_SUPPRESS_DEPRECATED_PUSH
177
178// __has_allocate_hint
179template <class _Alloc, class _SizeType, class _ConstVoidPtr, class = void>
180struct __has_allocate_hint : false_type { };
181
182template <class _Alloc, class _SizeType, class _ConstVoidPtr>
183struct __has_allocate_hint<_Alloc, _SizeType, _ConstVoidPtr, decltype(
184 (void)declval<_Alloc>().allocate(declval<_SizeType>(), declval<_ConstVoidPtr>())
185)> : true_type { };
186
187// __has_construct
188template <class, class _Alloc, class ..._Args>
189struct __has_construct_impl : false_type { };
190
191template <class _Alloc, class ..._Args>
192struct __has_construct_impl<decltype(
193 (void)declval<_Alloc>().construct(declval<_Args>()...)
194), _Alloc, _Args...> : true_type { };
195
196template <class _Alloc, class ..._Args>
197struct __has_construct : __has_construct_impl<void, _Alloc, _Args...> { };
198
199// __has_destroy
200template <class _Alloc, class _Pointer, class = void>
201struct __has_destroy : false_type { };
202
203template <class _Alloc, class _Pointer>
204struct __has_destroy<_Alloc, _Pointer, decltype(
205 (void)declval<_Alloc>().destroy(declval<_Pointer>())
206)> : true_type { };
207
208// __has_max_size
209template <class _Alloc, class = void>
210struct __has_max_size : false_type { };
211
212template <class _Alloc>
213struct __has_max_size<_Alloc, decltype(
214 (void)declval<_Alloc&>().max_size()
215)> : true_type { };
216
217// __has_select_on_container_copy_construction
218template <class _Alloc, class = void>
219struct __has_select_on_container_copy_construction : false_type { };
220
221template <class _Alloc>
222struct __has_select_on_container_copy_construction<_Alloc, decltype(
223 (void)declval<_Alloc>().select_on_container_copy_construction()
224)> : true_type { };
225
226_LIBCPP_SUPPRESS_DEPRECATED_POP
227
228template <class _Alloc>
229struct _LIBCPP_TEMPLATE_VIS allocator_traits
230{
231 using allocator_type = _Alloc;
232 using value_type = typename allocator_type::value_type;
233 using pointer = typename __pointer<value_type, allocator_type>::type;
234 using const_pointer = typename __const_pointer<value_type, pointer, allocator_type>::type;
235 using void_pointer = typename __void_pointer<pointer, allocator_type>::type;
236 using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type;
237 using difference_type = typename __alloc_traits_difference_type<allocator_type, pointer>::type;
238 using size_type = typename __size_type<allocator_type, difference_type>::type;
239 using propagate_on_container_copy_assignment = typename __propagate_on_container_copy_assignment<allocator_type>::type;
240 using propagate_on_container_move_assignment = typename __propagate_on_container_move_assignment<allocator_type>::type;
241 using propagate_on_container_swap = typename __propagate_on_container_swap<allocator_type>::type;
242 using is_always_equal = typename __is_always_equal<allocator_type>::type;
243
244#ifndef _LIBCPP_CXX03_LANG
245 template <class _Tp>
246 using rebind_alloc = __allocator_traits_rebind_t<allocator_type, _Tp>;
247 template <class _Tp>
248 using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
249#else // _LIBCPP_CXX03_LANG
250 template <class _Tp>
251 struct rebind_alloc {
252 using other = __allocator_traits_rebind_t<allocator_type, _Tp>;
253 };
254 template <class _Tp>
255 struct rebind_traits {
256 using other = allocator_traits<typename rebind_alloc<_Tp>::other>;
257 };
258#endif // _LIBCPP_CXX03_LANG
259
260 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
261 static pointer allocate(allocator_type& __a, size_type __n) {
262 return __a.allocate(__n);
263 }
264
265 template <class _Ap = _Alloc, class =
266 __enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
267 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
268 static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) {
269 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
270 return __a.allocate(__n, __hint);
271 _LIBCPP_SUPPRESS_DEPRECATED_POP
272 }
273 template <class _Ap = _Alloc, class = void, class =
274 __enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
275 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
276 static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer) {
277 return __a.allocate(__n);
278 }
279
280 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
281 static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT {
282 __a.deallocate(__p, __n);
283 }
284
285 template <class _Tp, class... _Args, class =
286 __enable_if_t<__has_construct<allocator_type, _Tp*, _Args...>::value> >
287 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
288 static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) {
289 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
290 __a.construct(__p, _VSTD::forward<_Args>(__args)...);
291 _LIBCPP_SUPPRESS_DEPRECATED_POP
292 }
293 template <class _Tp, class... _Args, class = void, class =
294 __enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value> >
295 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
296 static void construct(allocator_type&, _Tp* __p, _Args&&... __args) {
297#if _LIBCPP_STD_VER > 17
298 _VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...);
299#else
300 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
301#endif
302 }
303
304 template <class _Tp, class =
305 __enable_if_t<__has_destroy<allocator_type, _Tp*>::value> >
306 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
307 static void destroy(allocator_type& __a, _Tp* __p) {
308 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
309 __a.destroy(__p);
310 _LIBCPP_SUPPRESS_DEPRECATED_POP
311 }
312 template <class _Tp, class = void, class =
313 __enable_if_t<!__has_destroy<allocator_type, _Tp*>::value> >
314 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
315 static void destroy(allocator_type&, _Tp* __p) {
316#if _LIBCPP_STD_VER > 17
317 _VSTD::destroy_at(__p);
318#else
319 __p->~_Tp();
320#endif
321 }
322
323 template <class _Ap = _Alloc, class =
324 __enable_if_t<__has_max_size<const _Ap>::value> >
325 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
326 static size_type max_size(const allocator_type& __a) _NOEXCEPT {
327 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
328 return __a.max_size();
329 _LIBCPP_SUPPRESS_DEPRECATED_POP
330 }
331 template <class _Ap = _Alloc, class = void, class =
332 __enable_if_t<!__has_max_size<const _Ap>::value> >
333 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
334 static size_type max_size(const allocator_type&) _NOEXCEPT {
335 return numeric_limits<size_type>::max() / sizeof(value_type);
336 }
337
338 template <class _Ap = _Alloc, class =
339 __enable_if_t<__has_select_on_container_copy_construction<const _Ap>::value> >
340 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
341 static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
342 return __a.select_on_container_copy_construction();
343 }
344 template <class _Ap = _Alloc, class = void, class =
345 __enable_if_t<!__has_select_on_container_copy_construction<const _Ap>::value> >
346 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
347 static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
348 return __a;
349 }
350};
351
352template <class _Traits, class _Tp>
353struct __rebind_alloc_helper {
354#ifndef _LIBCPP_CXX03_LANG
355 using type _LIBCPP_NODEBUG = typename _Traits::template rebind_alloc<_Tp>;
356#else
357 using type = typename _Traits::template rebind_alloc<_Tp>::other;
358#endif
359};
360
361// __is_default_allocator
362template <class _Tp>
363struct __is_default_allocator : false_type { };
364
365template <class> class allocator;
366
367template <class _Tp>
368struct __is_default_allocator<allocator<_Tp> > : true_type { };
369
370// __is_cpp17_move_insertable
371template <class _Alloc, class = void>
372struct __is_cpp17_move_insertable
373 : is_move_constructible<typename _Alloc::value_type>
374{ };
375
376template <class _Alloc>
377struct __is_cpp17_move_insertable<_Alloc, __enable_if_t<
378 !__is_default_allocator<_Alloc>::value &&
379 __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value
380> > : true_type { };
381
382// __is_cpp17_copy_insertable
383template <class _Alloc, class = void>
384struct __is_cpp17_copy_insertable
385 : integral_constant<bool,
386 is_copy_constructible<typename _Alloc::value_type>::value &&
387 __is_cpp17_move_insertable<_Alloc>::value
388 >
389{ };
390
391template <class _Alloc>
392struct __is_cpp17_copy_insertable<_Alloc, __enable_if_t<
393 !__is_default_allocator<_Alloc>::value &&
394 __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value
395> >
396 : __is_cpp17_move_insertable<_Alloc>
397{ };
398
399#undef _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX
400
401_LIBCPP_END_NAMESPACE_STD
402
403_LIBCPP_POP_MACROS
404
405#endif // _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
406

source code of flutter_engine/third_party/libcxx/include/__memory/allocator_traits.h