Line data Source code
1 : // Allocator traits -*- C++ -*-
2 :
3 : // Copyright (C) 2011-2016 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
11 : // This library is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 :
16 : // Under Section 7 of GPL version 3, you are granted additional
17 : // permissions described in the GCC Runtime Library Exception, version
18 : // 3.1, as published by the Free Software Foundation.
19 :
20 : // You should have received a copy of the GNU General Public License and
21 : // a copy of the GCC Runtime Library Exception along with this program;
22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : // <http://www.gnu.org/licenses/>.
24 :
25 : /** @file bits/alloc_traits.h
26 : * This is an internal header file, included by other library headers.
27 : * Do not attempt to use it directly. @headername{memory}
28 : */
29 :
30 : #ifndef _ALLOC_TRAITS_H
31 : #define _ALLOC_TRAITS_H 1
32 :
33 : #if __cplusplus >= 201103L
34 :
35 : #include <bits/memoryfwd.h>
36 : #include <bits/ptr_traits.h>
37 : #include <ext/numeric_traits.h>
38 :
39 : #define __cpp_lib_allocator_traits_is_always_equal 201411
40 :
41 : namespace std _GLIBCXX_VISIBILITY(default)
42 : {
43 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 :
45 : struct __allocator_traits_base
46 : {
47 : template<typename _Tp, typename _Up, typename = void>
48 : struct __rebind : __replace_first_arg<_Tp, _Up> { };
49 :
50 : template<typename _Tp, typename _Up>
51 : struct __rebind<_Tp, _Up,
52 : __void_t<typename _Tp::template rebind<_Up>::other>>
53 : { using type = typename _Tp::template rebind<_Up>::other; };
54 :
55 : protected:
56 : template<typename _Tp>
57 : using __pointer = typename _Tp::pointer;
58 : template<typename _Tp>
59 : using __c_pointer = typename _Tp::const_pointer;
60 : template<typename _Tp>
61 : using __v_pointer = typename _Tp::void_pointer;
62 : template<typename _Tp>
63 : using __cv_pointer = typename _Tp::const_void_pointer;
64 : template<typename _Tp>
65 : using __pocca = typename _Tp::propagate_on_container_copy_assignment;
66 : template<typename _Tp>
67 : using __pocma = typename _Tp::propagate_on_container_move_assignment;
68 : template<typename _Tp>
69 : using __pocs = typename _Tp::propagate_on_container_swap;
70 : template<typename _Tp>
71 : using __equal = typename _Tp::is_always_equal;
72 : };
73 :
74 : template<typename _Alloc, typename _Up>
75 : using __alloc_rebind
76 : = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
77 :
78 : /**
79 : * @brief Uniform interface to all allocator types.
80 : * @ingroup allocators
81 : */
82 : template<typename _Alloc>
83 : struct allocator_traits : __allocator_traits_base
84 : {
85 : /// The allocator type
86 : typedef _Alloc allocator_type;
87 : /// The allocated type
88 : typedef typename _Alloc::value_type value_type;
89 :
90 : /**
91 : * @brief The allocator's pointer type.
92 : *
93 : * @c Alloc::pointer if that type exists, otherwise @c value_type*
94 : */
95 : using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
96 :
97 : private:
98 : // Select _Func<_Alloc> or pointer_traits<pointer>::rebind<_Tp>
99 : template<template<typename> class _Func, typename _Tp, typename = void>
100 : struct _Ptr
101 : {
102 : using type = typename pointer_traits<pointer>::template rebind<_Tp>;
103 : };
104 :
105 : template<template<typename> class _Func, typename _Tp>
106 : struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
107 : {
108 : using type = _Func<_Alloc>;
109 : };
110 :
111 : // Select _A2::difference_type or pointer_traits<_Ptr>::difference_type
112 : template<typename _A2, typename _PtrT, typename = void>
113 : struct _Diff
114 : { using type = typename pointer_traits<_PtrT>::difference_type; };
115 :
116 : template<typename _A2, typename _PtrT>
117 : struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
118 : { using type = typename _A2::difference_type; };
119 :
120 : // Select _A2::size_type or make_unsigned<_DiffT>::type
121 : template<typename _A2, typename _DiffT, typename = void>
122 : struct _Size : make_unsigned<_DiffT> { };
123 :
124 : template<typename _A2, typename _DiffT>
125 : struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
126 : { using type = typename _A2::size_type; };
127 :
128 : public:
129 : /**
130 : * @brief The allocator's const pointer type.
131 : *
132 : * @c Alloc::const_pointer if that type exists, otherwise
133 : * <tt> pointer_traits<pointer>::rebind<const value_type> </tt>
134 : */
135 : using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;
136 :
137 : /**
138 : * @brief The allocator's void pointer type.
139 : *
140 : * @c Alloc::void_pointer if that type exists, otherwise
141 : * <tt> pointer_traits<pointer>::rebind<void> </tt>
142 : */
143 : using void_pointer = typename _Ptr<__v_pointer, void>::type;
144 :
145 : /**
146 : * @brief The allocator's const void pointer type.
147 : *
148 : * @c Alloc::const_void_pointer if that type exists, otherwise
149 : * <tt> pointer_traits<pointer>::rebind<const void> </tt>
150 : */
151 : using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;
152 :
153 : /**
154 : * @brief The allocator's difference type
155 : *
156 : * @c Alloc::difference_type if that type exists, otherwise
157 : * <tt> pointer_traits<pointer>::difference_type </tt>
158 : */
159 : using difference_type = typename _Diff<_Alloc, pointer>::type;
160 :
161 : /**
162 : * @brief The allocator's size type
163 : *
164 : * @c Alloc::size_type if that type exists, otherwise
165 : * <tt> make_unsigned<difference_type>::type </tt>
166 : */
167 : using size_type = typename _Size<_Alloc, difference_type>::type;
168 :
169 : /**
170 : * @brief How the allocator is propagated on copy assignment
171 : *
172 : * @c Alloc::propagate_on_container_copy_assignment if that type exists,
173 : * otherwise @c false_type
174 : */
175 : using propagate_on_container_copy_assignment
176 : = __detected_or_t<false_type, __pocca, _Alloc>;
177 :
178 : /**
179 : * @brief How the allocator is propagated on move assignment
180 : *
181 : * @c Alloc::propagate_on_container_move_assignment if that type exists,
182 : * otherwise @c false_type
183 : */
184 : using propagate_on_container_move_assignment
185 : = __detected_or_t<false_type, __pocma, _Alloc>;
186 :
187 : /**
188 : * @brief How the allocator is propagated on swap
189 : *
190 : * @c Alloc::propagate_on_container_swap if that type exists,
191 : * otherwise @c false_type
192 : */
193 : using propagate_on_container_swap
194 : = __detected_or_t<false_type, __pocs, _Alloc>;
195 :
196 : /**
197 : * @brief Whether all instances of the allocator type compare equal.
198 : *
199 : * @c Alloc::is_always_equal if that type exists,
200 : * otherwise @c is_empty<Alloc>::type
201 : */
202 : using is_always_equal
203 : = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
204 :
205 : template<typename _Tp>
206 : using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
207 : template<typename _Tp>
208 : using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
209 :
210 : private:
211 : template<typename _Alloc2>
212 : static auto
213 : _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
214 : -> decltype(__a.allocate(__n, __hint))
215 : { return __a.allocate(__n, __hint); }
216 :
217 : template<typename _Alloc2>
218 : static pointer
219 : _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
220 : { return __a.allocate(__n); }
221 :
222 : template<typename _Tp, typename... _Args>
223 : struct __construct_helper
224 : {
225 : template<typename _Alloc2,
226 : typename = decltype(std::declval<_Alloc2*>()->construct(
227 : std::declval<_Tp*>(), std::declval<_Args>()...))>
228 : static true_type __test(int);
229 :
230 : template<typename>
231 : static false_type __test(...);
232 :
233 : using type = decltype(__test<_Alloc>(0));
234 : };
235 :
236 : template<typename _Tp, typename... _Args>
237 : using __has_construct
238 : = typename __construct_helper<_Tp, _Args...>::type;
239 :
240 : template<typename _Tp, typename... _Args>
241 : static _Require<__has_construct<_Tp, _Args...>>
242 : _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
243 : { __a.construct(__p, std::forward<_Args>(__args)...); }
244 :
245 : template<typename _Tp, typename... _Args>
246 : static
247 : _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
248 : is_constructible<_Tp, _Args...>>>
249 : _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
250 : { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
251 :
252 : template<typename _Alloc2, typename _Tp>
253 : static auto
254 : _S_destroy(_Alloc2& __a, _Tp* __p, int)
255 : -> decltype(__a.destroy(__p))
256 : { __a.destroy(__p); }
257 :
258 : template<typename _Alloc2, typename _Tp>
259 : static void
260 : _S_destroy(_Alloc2&, _Tp* __p, ...)
261 : { __p->~_Tp(); }
262 :
263 : template<typename _Alloc2>
264 : static auto
265 : _S_max_size(_Alloc2& __a, int)
266 : -> decltype(__a.max_size())
267 : { return __a.max_size(); }
268 :
269 : template<typename _Alloc2>
270 : static size_type
271 : _S_max_size(_Alloc2&, ...)
272 : {
273 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
274 : // 2466. allocator_traits::max_size() default behavior is incorrect
275 : return __gnu_cxx::__numeric_traits<size_type>::__max
276 : / sizeof(value_type);
277 : }
278 :
279 : template<typename _Alloc2>
280 : static auto
281 : _S_select(_Alloc2& __a, int)
282 : -> decltype(__a.select_on_container_copy_construction())
283 : { return __a.select_on_container_copy_construction(); }
284 :
285 : template<typename _Alloc2>
286 : static _Alloc2
287 : _S_select(_Alloc2& __a, ...)
288 : { return __a; }
289 :
290 : public:
291 :
292 : /**
293 : * @brief Allocate memory.
294 : * @param __a An allocator.
295 : * @param __n The number of objects to allocate space for.
296 : *
297 : * Calls @c a.allocate(n)
298 : */
299 : static pointer
300 : allocate(_Alloc& __a, size_type __n)
301 : { return __a.allocate(__n); }
302 :
303 : /**
304 : * @brief Allocate memory.
305 : * @param __a An allocator.
306 : * @param __n The number of objects to allocate space for.
307 : * @param __hint Aid to locality.
308 : * @return Memory of suitable size and alignment for @a n objects
309 : * of type @c value_type
310 : *
311 : * Returns <tt> a.allocate(n, hint) </tt> if that expression is
312 : * well-formed, otherwise returns @c a.allocate(n)
313 : */
314 : static pointer
315 : allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
316 : { return _S_allocate(__a, __n, __hint, 0); }
317 :
318 : /**
319 : * @brief Deallocate memory.
320 : * @param __a An allocator.
321 : * @param __p Pointer to the memory to deallocate.
322 : * @param __n The number of objects space was allocated for.
323 : *
324 : * Calls <tt> a.deallocate(p, n) </tt>
325 : */
326 : static void
327 : deallocate(_Alloc& __a, pointer __p, size_type __n)
328 : { __a.deallocate(__p, __n); }
329 :
330 : /**
331 : * @brief Construct an object of type @a _Tp
332 : * @param __a An allocator.
333 : * @param __p Pointer to memory of suitable size and alignment for Tp
334 : * @param __args Constructor arguments.
335 : *
336 : * Calls <tt> __a.construct(__p, std::forward<Args>(__args)...) </tt>
337 : * if that expression is well-formed, otherwise uses placement-new
338 : * to construct an object of type @a _Tp at location @a __p from the
339 : * arguments @a __args...
340 : */
341 : template<typename _Tp, typename... _Args>
342 : static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
343 : -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
344 : { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
345 :
346 : /**
347 : * @brief Destroy an object of type @a _Tp
348 : * @param __a An allocator.
349 : * @param __p Pointer to the object to destroy
350 : *
351 : * Calls @c __a.destroy(__p) if that expression is well-formed,
352 : * otherwise calls @c __p->~_Tp()
353 : */
354 : template<typename _Tp>
355 : static void destroy(_Alloc& __a, _Tp* __p)
356 : { _S_destroy(__a, __p, 0); }
357 :
358 : /**
359 : * @brief The maximum supported allocation size
360 : * @param __a An allocator.
361 : * @return @c __a.max_size() or @c numeric_limits<size_type>::max()
362 : *
363 : * Returns @c __a.max_size() if that expression is well-formed,
364 : * otherwise returns @c numeric_limits<size_type>::max()
365 : */
366 : static size_type max_size(const _Alloc& __a) noexcept
367 : { return _S_max_size(__a, 0); }
368 :
369 : /**
370 : * @brief Obtain an allocator to use when copying a container.
371 : * @param __rhs An allocator.
372 : * @return @c __rhs.select_on_container_copy_construction() or @a __rhs
373 : *
374 : * Returns @c __rhs.select_on_container_copy_construction() if that
375 : * expression is well-formed, otherwise returns @a __rhs
376 : */
377 : static _Alloc
378 : select_on_container_copy_construction(const _Alloc& __rhs)
379 : { return _S_select(__rhs, 0); }
380 : };
381 :
382 : /// Partial specialization for std::allocator.
383 : template<typename _Tp>
384 : struct allocator_traits<allocator<_Tp>>
385 : {
386 : /// The allocator type
387 : using allocator_type = allocator<_Tp>;
388 : /// The allocated type
389 : using value_type = _Tp;
390 :
391 : /// The allocator's pointer type.
392 : using pointer = _Tp*;
393 :
394 : /// The allocator's const pointer type.
395 : using const_pointer = const _Tp*;
396 :
397 : /// The allocator's void pointer type.
398 : using void_pointer = void*;
399 :
400 : /// The allocator's const void pointer type.
401 : using const_void_pointer = const void*;
402 :
403 : /// The allocator's difference type
404 : using difference_type = std::ptrdiff_t;
405 :
406 : /// The allocator's size type
407 : using size_type = std::size_t;
408 :
409 : /// How the allocator is propagated on copy assignment
410 : using propagate_on_container_copy_assignment = false_type;
411 :
412 : /// How the allocator is propagated on move assignment
413 : using propagate_on_container_move_assignment = true_type;
414 :
415 : /// How the allocator is propagated on swap
416 : using propagate_on_container_swap = false_type;
417 :
418 : /// Whether all instances of the allocator type compare equal.
419 : using is_always_equal = true_type;
420 :
421 : template<typename _Up>
422 : using rebind_alloc = allocator<_Up>;
423 :
424 : template<typename _Up>
425 : using rebind_traits = allocator_traits<allocator<_Up>>;
426 :
427 : /**
428 : * @brief Allocate memory.
429 : * @param __a An allocator.
430 : * @param __n The number of objects to allocate space for.
431 : *
432 : * Calls @c a.allocate(n)
433 : */
434 : static pointer
435 4664 : allocate(allocator_type& __a, size_type __n)
436 4664 : { return __a.allocate(__n); }
437 :
438 : /**
439 : * @brief Allocate memory.
440 : * @param __a An allocator.
441 : * @param __n The number of objects to allocate space for.
442 : * @param __hint Aid to locality.
443 : * @return Memory of suitable size and alignment for @a n objects
444 : * of type @c value_type
445 : *
446 : * Returns <tt> a.allocate(n, hint) </tt>
447 : */
448 : static pointer
449 : allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
450 : { return __a.allocate(__n, __hint); }
451 :
452 : /**
453 : * @brief Deallocate memory.
454 : * @param __a An allocator.
455 : * @param __p Pointer to the memory to deallocate.
456 : * @param __n The number of objects space was allocated for.
457 : *
458 : * Calls <tt> a.deallocate(p, n) </tt>
459 : */
460 : static void
461 4658 : deallocate(allocator_type& __a, pointer __p, size_type __n)
462 4658 : { __a.deallocate(__p, __n); }
463 :
464 : /**
465 : * @brief Construct an object of type @a _Up
466 : * @param __a An allocator.
467 : * @param __p Pointer to memory of suitable size and alignment for Tp
468 : * @param __args Constructor arguments.
469 : *
470 : * Calls <tt> __a.construct(__p, std::forward<Args>(__args)...) </tt>
471 : */
472 : template<typename _Up, typename... _Args>
473 : static void
474 8563 : construct(allocator_type& __a, _Up* __p, _Args&&... __args)
475 8563 : { __a.construct(__p, std::forward<_Args>(__args)...); }
476 :
477 : /**
478 : * @brief Destroy an object of type @a _Up
479 : * @param __a An allocator.
480 : * @param __p Pointer to the object to destroy
481 : *
482 : * Calls @c __a.destroy(__p).
483 : */
484 : template<typename _Up>
485 : static void
486 17 : destroy(allocator_type& __a, _Up* __p)
487 17 : { __a.destroy(__p); }
488 :
489 : /**
490 : * @brief The maximum supported allocation size
491 : * @param __a An allocator.
492 : * @return @c __a.max_size()
493 : */
494 : static size_type
495 8242 : max_size(const allocator_type& __a) noexcept
496 8242 : { return __a.max_size(); }
497 :
498 : /**
499 : * @brief Obtain an allocator to use when copying a container.
500 : * @param __rhs An allocator.
501 : * @return @c __rhs
502 : */
503 : static allocator_type
504 209 : select_on_container_copy_construction(const allocator_type& __rhs)
505 209 : { return __rhs; }
506 : };
507 :
508 :
509 : template<typename _Alloc>
510 : inline void
511 : __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
512 : { __one = __two; }
513 :
514 : template<typename _Alloc>
515 : inline void
516 0 : __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
517 0 : { }
518 :
519 : template<typename _Alloc>
520 0 : inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
521 : {
522 : typedef allocator_traits<_Alloc> __traits;
523 : typedef typename __traits::propagate_on_container_copy_assignment __pocca;
524 0 : __do_alloc_on_copy(__one, __two, __pocca());
525 0 : }
526 :
527 : template<typename _Alloc>
528 : inline _Alloc __alloc_on_copy(const _Alloc& __a)
529 : {
530 : typedef allocator_traits<_Alloc> __traits;
531 : return __traits::select_on_container_copy_construction(__a);
532 : }
533 :
534 : template<typename _Alloc>
535 3 : inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
536 3 : { __one = std::move(__two); }
537 :
538 : template<typename _Alloc>
539 : inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
540 : { }
541 :
542 : template<typename _Alloc>
543 3 : inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
544 : {
545 : typedef allocator_traits<_Alloc> __traits;
546 : typedef typename __traits::propagate_on_container_move_assignment __pocma;
547 3 : __do_alloc_on_move(__one, __two, __pocma());
548 3 : }
549 :
550 : template<typename _Alloc>
551 : inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
552 : {
553 : using std::swap;
554 : swap(__one, __two);
555 : }
556 :
557 : template<typename _Alloc>
558 0 : inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
559 0 : { }
560 :
561 : template<typename _Alloc>
562 0 : inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
563 : {
564 : typedef allocator_traits<_Alloc> __traits;
565 : typedef typename __traits::propagate_on_container_swap __pocs;
566 0 : __do_alloc_on_swap(__one, __two, __pocs());
567 0 : }
568 :
569 : template<typename _Alloc>
570 : class __is_copy_insertable_impl
571 : {
572 : typedef allocator_traits<_Alloc> _Traits;
573 :
574 : template<typename _Up, typename
575 : = decltype(_Traits::construct(std::declval<_Alloc&>(),
576 : std::declval<_Up*>(),
577 : std::declval<const _Up&>()))>
578 : static true_type
579 : _M_select(int);
580 :
581 : template<typename _Up>
582 : static false_type
583 : _M_select(...);
584 :
585 : public:
586 : typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
587 : };
588 :
589 : // true if _Alloc::value_type is CopyInsertable into containers using _Alloc
590 : template<typename _Alloc>
591 : struct __is_copy_insertable
592 : : __is_copy_insertable_impl<_Alloc>::type
593 : { };
594 :
595 : // std::allocator<_Tp> just requires CopyConstructible
596 : template<typename _Tp>
597 : struct __is_copy_insertable<allocator<_Tp>>
598 : : is_copy_constructible<_Tp>
599 : { };
600 :
601 : _GLIBCXX_END_NAMESPACE_VERSION
602 : } // namespace std
603 :
604 : #endif
605 : #endif
|
