Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/bits/alloc_traits.h
$ cat -n /usr/include/c++/13/bits/alloc_traits.h 1 // Allocator traits -*- C++ -*- 2 3 // Copyright (C) 2011-2023 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 #include <bits/stl_construct.h> 34 #include <bits/memoryfwd.h> 35 #if __cplusplus >= 201103L 36 # include <bits/ptr_traits.h> 37 # include <ext/numeric_traits.h> 38 # if _GLIBCXX_HOSTED 39 # include <bits/allocator.h> 40 # endif 41 #endif 42 43 namespace std _GLIBCXX_VISIBILITY(default) 44 { 45 _GLIBCXX_BEGIN_NAMESPACE_VERSION 46 47 #if __cplusplus >= 201103L 48 #define __cpp_lib_allocator_traits_is_always_equal 201411L 49 50 /// @cond undocumented 51 struct __allocator_traits_base 52 { 53 template<typename _Tp, typename _Up, typename = void> 54 struct __rebind : __replace_first_arg<_Tp, _Up> 55 { 56 static_assert(is_same< 57 typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, 58 _Tp>::value, 59 "allocator_traits<A>::rebind_alloc<A::value_type> must be A"); 60 }; 61 62 template<typename _Tp, typename _Up> 63 struct __rebind<_Tp, _Up, 64 __void_t<typename _Tp::template rebind<_Up>::other>> 65 { 66 using type = typename _Tp::template rebind<_Up>::other; 67 68 static_assert(is_same< 69 typename _Tp::template rebind<typename _Tp::value_type>::other, 70 _Tp>::value, 71 "allocator_traits<A>::rebind_alloc<A::value_type> must be A"); 72 }; 73 74 protected: 75 template<typename _Tp> 76 using __pointer = typename _Tp::pointer; 77 template<typename _Tp> 78 using __c_pointer = typename _Tp::const_pointer; 79 template<typename _Tp> 80 using __v_pointer = typename _Tp::void_pointer; 81 template<typename _Tp> 82 using __cv_pointer = typename _Tp::const_void_pointer; 83 template<typename _Tp> 84 using __pocca = typename _Tp::propagate_on_container_copy_assignment; 85 template<typename _Tp> 86 using __pocma = typename _Tp::propagate_on_container_move_assignment; 87 template<typename _Tp> 88 using __pocs = typename _Tp::propagate_on_container_swap; 89 template<typename _Tp> 90 using __equal = __type_identity<typename _Tp::is_always_equal>; 91 }; 92 93 template<typename _Alloc, typename _Up> 94 using __alloc_rebind 95 = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; 96 /// @endcond 97 98 /** 99 * @brief Uniform interface to all allocator types. 100 * @headerfile memory 101 * @ingroup allocators 102 * @since C++11 103 */ 104 template<typename _Alloc> 105 struct allocator_traits : __allocator_traits_base 106 { 107 /// The allocator type 108 typedef _Alloc allocator_type; 109 /// The allocated type 110 typedef typename _Alloc::value_type value_type; 111 112 /** 113 * @brief The allocator's pointer type. 114 * 115 * @c Alloc::pointer if that type exists, otherwise @c value_type* 116 */ 117 using pointer = __detected_or_t<value_type*, __pointer, _Alloc>; 118 119 private: 120 // Select _Func<_Alloc> or pointer_traits<pointer>::rebind<_Tp> 121 template<template<typename> class _Func, typename _Tp, typename = void> 122 struct _Ptr 123 { 124 using type = typename pointer_traits<pointer>::template rebind<_Tp>; 125 }; 126 127 template<template<typename> class _Func, typename _Tp> 128 struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> 129 { 130 using type = _Func<_Alloc>; 131 }; 132 133 // Select _A2::difference_type or pointer_traits<_Ptr>::difference_type 134 template<typename _A2, typename _PtrT, typename = void> 135 struct _Diff 136 { using type = typename pointer_traits<_PtrT>::difference_type; }; 137 138 template<typename _A2, typename _PtrT> 139 struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>> 140 { using type = typename _A2::difference_type; }; 141 142 // Select _A2::size_type or make_unsigned<_DiffT>::type 143 template<typename _A2, typename _DiffT, typename = void> 144 struct _Size : make_unsigned<_DiffT> { }; 145 146 template<typename _A2, typename _DiffT> 147 struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>> 148 { using type = typename _A2::size_type; }; 149 150 public: 151 /** 152 * @brief The allocator's const pointer type. 153 * 154 * @c Alloc::const_pointer if that type exists, otherwise 155 * <tt> pointer_traits<pointer>::rebind<const value_type> </tt> 156 */ 157 using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; 158 159 /** 160 * @brief The allocator's void pointer type. 161 * 162 * @c Alloc::void_pointer if that type exists, otherwise 163 * <tt> pointer_traits<pointer>::rebind<void> </tt> 164 */ 165 using void_pointer = typename _Ptr<__v_pointer, void>::type; 166 167 /** 168 * @brief The allocator's const void pointer type. 169 * 170 * @c Alloc::const_void_pointer if that type exists, otherwise 171 * <tt> pointer_traits<pointer>::rebind<const void> </tt> 172 */ 173 using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; 174 175 /** 176 * @brief The allocator's difference type 177 * 178 * @c Alloc::difference_type if that type exists, otherwise 179 * <tt> pointer_traits<pointer>::difference_type </tt> 180 */ 181 using difference_type = typename _Diff<_Alloc, pointer>::type; 182 183 /** 184 * @brief The allocator's size type 185 * 186 * @c Alloc::size_type if that type exists, otherwise 187 * <tt> make_unsigned<difference_type>::type </tt> 188 */ 189 using size_type = typename _Size<_Alloc, difference_type>::type; 190 191 /** 192 * @brief How the allocator is propagated on copy assignment 193 * 194 * @c Alloc::propagate_on_container_copy_assignment if that type exists, 195 * otherwise @c false_type 196 */ 197 using propagate_on_container_copy_assignment 198 = __detected_or_t<false_type, __pocca, _Alloc>; 199 200 /** 201 * @brief How the allocator is propagated on move assignment 202 * 203 * @c Alloc::propagate_on_container_move_assignment if that type exists, 204 * otherwise @c false_type 205 */ 206 using propagate_on_container_move_assignment 207 = __detected_or_t<false_type, __pocma, _Alloc>; 208 209 /** 210 * @brief How the allocator is propagated on swap 211 * 212 * @c Alloc::propagate_on_container_swap if that type exists, 213 * otherwise @c false_type 214 */ 215 using propagate_on_container_swap 216 = __detected_or_t<false_type, __pocs, _Alloc>; 217 218 /** 219 * @brief Whether all instances of the allocator type compare equal. 220 * 221 * @c Alloc::is_always_equal if that type exists, 222 * otherwise @c is_empty<Alloc>::type 223 */ 224 using is_always_equal 225 = typename __detected_or_t<is_empty<_Alloc>, __equal, _Alloc>::type; 226 227 template<typename _Tp> 228 using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; 229 template<typename _Tp> 230 using rebind_traits = allocator_traits<rebind_alloc<_Tp>>; 231 232 private: 233 template<typename _Alloc2> 234 static constexpr auto 235 _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) 236 -> decltype(__a.allocate(__n, __hint)) 237 { return __a.allocate(__n, __hint); } 238 239 template<typename _Alloc2> 240 static constexpr pointer 241 _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) 242 { return __a.allocate(__n); } 243 244 template<typename _Tp, typename... _Args> 245 struct __construct_helper 246 { 247 template<typename _Alloc2, 248 typename = decltype(std::declval<_Alloc2*>()->construct( 249 std::declval<_Tp*>(), std::declval<_Args>()...))> 250 static true_type __test(int); 251 252 template<typename> 253 static false_type __test(...); 254 255 using type = decltype(__test<_Alloc>(0)); 256 }; 257 258 template<typename _Tp, typename... _Args> 259 using __has_construct 260 = typename __construct_helper<_Tp, _Args...>::type; 261 262 template<typename _Tp, typename... _Args> 263 static _GLIBCXX14_CONSTEXPR _Require<__has_construct<_Tp, _Args...>> 264 _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) 265 noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) 266 { __a.construct(__p, std::forward<_Args>(__args)...); } 267 268 template<typename _Tp, typename... _Args> 269 static _GLIBCXX14_CONSTEXPR 270 _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, 271 is_constructible<_Tp, _Args...>>> 272 _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) 273 noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) 274 { 275 #if __cplusplus <= 201703L 276 ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); 277 #else 278 std::construct_at(__p, std::forward<_Args>(__args)...); 279 #endif 280 } 281 282 template<typename _Alloc2, typename _Tp> 283 static _GLIBCXX14_CONSTEXPR auto 284 _S_destroy(_Alloc2& __a, _Tp* __p, int) 285 noexcept(noexcept(__a.destroy(__p))) 286 -> decltype(__a.destroy(__p)) 287 { __a.destroy(__p); } 288 289 template<typename _Alloc2, typename _Tp> 290 static _GLIBCXX14_CONSTEXPR void 291 _S_destroy(_Alloc2&, _Tp* __p, ...) 292 noexcept(std::is_nothrow_destructible<_Tp>::value) 293 { std::_Destroy(__p); } 294 295 template<typename _Alloc2> 296 static constexpr auto 297 _S_max_size(_Alloc2& __a, int) 298 -> decltype(__a.max_size()) 299 { return __a.max_size(); } 300 301 template<typename _Alloc2> 302 static constexpr size_type 303 _S_max_size(_Alloc2&, ...) 304 { 305 // _GLIBCXX_RESOLVE_LIB_DEFECTS 306 // 2466. allocator_traits::max_size() default behavior is incorrect 307 return __gnu_cxx::__numeric_traits<size_type>::__max 308 / sizeof(value_type); 309 } 310 311 template<typename _Alloc2> 312 static constexpr auto 313 _S_select(_Alloc2& __a, int) 314 -> decltype(__a.select_on_container_copy_construction()) 315 { return __a.select_on_container_copy_construction(); } 316 317 template<typename _Alloc2> 318 static constexpr _Alloc2 319 _S_select(_Alloc2& __a, ...) 320 { return __a; } 321 322 public: 323 324 /** 325 * @brief Allocate memory. 326 * @param __a An allocator. 327 * @param __n The number of objects to allocate space for. 328 * 329 * Calls @c a.allocate(n) 330 */ 331 _GLIBCXX_NODISCARD static _GLIBCXX20_CONSTEXPR pointer 332 allocate(_Alloc& __a, size_type __n) 333 { return __a.allocate(__n); } 334 335 /** 336 * @brief Allocate memory. 337 * @param __a An allocator. 338 * @param __n The number of objects to allocate space for. 339 * @param __hint Aid to locality. 340 * @return Memory of suitable size and alignment for @a n objects 341 * of type @c value_type 342 * 343 * Returns <tt> a.allocate(n, hint) </tt> if that expression is 344 * well-formed, otherwise returns @c a.allocate(n) 345 */ 346 _GLIBCXX_NODISCARD static _GLIBCXX20_CONSTEXPR pointer 347 allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) 348 { return _S_allocate(__a, __n, __hint, 0); } 349 350 /** 351 * @brief Deallocate memory. 352 * @param __a An allocator. 353 * @param __p Pointer to the memory to deallocate. 354 * @param __n The number of objects space was allocated for. 355 * 356 * Calls <tt> a.deallocate(p, n) </tt> 357 */ 358 static _GLIBCXX20_CONSTEXPR void 359 deallocate(_Alloc& __a, pointer __p, size_type __n) 360 { __a.deallocate(__p, __n); } 361 362 /** 363 * @brief Construct an object of type `_Tp` 364 * @param __a An allocator. 365 * @param __p Pointer to memory of suitable size and alignment for Tp 366 * @param __args Constructor arguments. 367 * 368 * Calls <tt> __a.construct(__p, std::forward<Args>(__args)...) </tt> 369 * if that expression is well-formed, otherwise uses placement-new 370 * to construct an object of type @a _Tp at location @a __p from the 371 * arguments @a __args... 372 */ 373 template<typename _Tp, typename... _Args> 374 static _GLIBCXX20_CONSTEXPR auto 375 construct(_Alloc& __a, _Tp* __p, _Args&&... __args) 376 noexcept(noexcept(_S_construct(__a, __p, 377 std::forward<_Args>(__args)...))) 378 -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) 379 { _S_construct(__a, __p, std::forward<_Args>(__args)...); } 380 381 /** 382 * @brief Destroy an object of type @a _Tp 383 * @param __a An allocator. 384 * @param __p Pointer to the object to destroy 385 * 386 * Calls @c __a.destroy(__p) if that expression is well-formed, 387 * otherwise calls @c __p->~_Tp() 388 */ 389 template<typename _Tp> 390 static _GLIBCXX20_CONSTEXPR void 391 destroy(_Alloc& __a, _Tp* __p) 392 noexcept(noexcept(_S_destroy(__a, __p, 0))) 393 { _S_destroy(__a, __p, 0); } 394 395 /** 396 * @brief The maximum supported allocation size 397 * @param __a An allocator. 398 * @return @c __a.max_size() or @c numeric_limits<size_type>::max() 399 * 400 * Returns @c __a.max_size() if that expression is well-formed, 401 * otherwise returns @c numeric_limits<size_type>::max() 402 */ 403 static _GLIBCXX20_CONSTEXPR size_type 404 max_size(const _Alloc& __a) noexcept 405 { return _S_max_size(__a, 0); } 406 407 /** 408 * @brief Obtain an allocator to use when copying a container. 409 * @param __rhs An allocator. 410 * @return @c __rhs.select_on_container_copy_construction() or @a __rhs 411 * 412 * Returns @c __rhs.select_on_container_copy_construction() if that 413 * expression is well-formed, otherwise returns @a __rhs 414 */ 415 static _GLIBCXX20_CONSTEXPR _Alloc 416 select_on_container_copy_construction(const _Alloc& __rhs) 417 { return _S_select(__rhs, 0); } 418 }; 419 420 #if _GLIBCXX_HOSTED 421 422 #if __cplusplus > 201703L 423 # define __cpp_lib_constexpr_dynamic_alloc 201907L 424 #endif 425 426 /// Partial specialization for std::allocator. 427 template<typename _Tp> 428 struct allocator_traits<allocator<_Tp>> 429 { 430 /// The allocator type 431 using allocator_type = allocator<_Tp>; 432 433 /// The allocated type 434 using value_type = _Tp; 435 436 /// The allocator's pointer type. 437 using pointer = _Tp*; 438 439 /// The allocator's const pointer type. 440 using const_pointer = const _Tp*; 441 442 /// The allocator's void pointer type. 443 using void_pointer = void*; 444 445 /// The allocator's const void pointer type. 446 using const_void_pointer = const void*; 447 448 /// The allocator's difference type 449 using difference_type = std::ptrdiff_t; 450 451 /// The allocator's size type 452 using size_type = std::size_t; 453 454 /// How the allocator is propagated on copy assignment 455 using propagate_on_container_copy_assignment = false_type; 456 457 /// How the allocator is propagated on move assignment 458 using propagate_on_container_move_assignment = true_type; 459 460 /// How the allocator is propagated on swap 461 using propagate_on_container_swap = false_type; 462 463 /// Whether all instances of the allocator type compare equal. 464 using is_always_equal = true_type; 465 466 template<typename _Up> 467 using rebind_alloc = allocator<_Up>; 468 469 template<typename _Up> 470 using rebind_traits = allocator_traits<allocator<_Up>>; 471 472 /** 473 * @brief Allocate memory. 474 * @param __a An allocator. 475 * @param __n The number of objects to allocate space for. 476 * 477 * Calls @c a.allocate(n) 478 */ 479 [[__nodiscard__,__gnu__::__always_inline__]] 480 static _GLIBCXX20_CONSTEXPR pointer 481 allocate(allocator_type& __a, size_type __n) 482 { return __a.allocate(__n); } 483 484 /** 485 * @brief Allocate memory. 486 * @param __a An allocator. 487 * @param __n The number of objects to allocate space for. 488 * @param __hint Aid to locality. 489 * @return Memory of suitable size and alignment for @a n objects 490 * of type @c value_type 491 * 492 * Returns <tt> a.allocate(n, hint) </tt> 493 */ 494 [[__nodiscard__,__gnu__::__always_inline__]] 495 static _GLIBCXX20_CONSTEXPR pointer 496 allocate(allocator_type& __a, size_type __n, 497 [[maybe_unused]] const_void_pointer __hint) 498 { 499 #if __cplusplus <= 201703L 500 return __a.allocate(__n, __hint); 501 #else 502 return __a.allocate(__n); 503 #endif 504 } 505 506 /** 507 * @brief Deallocate memory. 508 * @param __a An allocator. 509 * @param __p Pointer to the memory to deallocate. 510 * @param __n The number of objects space was allocated for. 511 * 512 * Calls <tt> a.deallocate(p, n) </tt> 513 */ 514 [[__gnu__::__always_inline__]] 515 static _GLIBCXX20_CONSTEXPR void 516 deallocate(allocator_type& __a, pointer __p, size_type __n) 517 { __a.deallocate(__p, __n); } 518 519 /** 520 * @brief Construct an object of type `_Up` 521 * @param __a An allocator. 522 * @param __p Pointer to memory of suitable size and alignment for 523 * an object of type `_Up`. 524 * @param __args Constructor arguments. 525 * 526 * Calls `__a.construct(__p, std::forward<_Args>(__args)...)` 527 * in C++11, C++14 and C++17. Changed in C++20 to call 528 * `std::construct_at(__p, std::forward<_Args>(__args)...)` instead. 529 */ 530 template<typename _Up, typename... _Args> 531 [[__gnu__::__always_inline__]] 532 static _GLIBCXX20_CONSTEXPR void 533 construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, 534 _Args&&... __args) 535 noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) 536 { 537 #if __cplusplus <= 201703L 538 __a.construct(__p, std::forward<_Args>(__args)...); 539 #else 540 std::construct_at(__p, std::forward<_Args>(__args)...); 541 #endif 542 } 543 544 /** 545 * @brief Destroy an object of type @a _Up 546 * @param __a An allocator. 547 * @param __p Pointer to the object to destroy 548 * 549 * Calls @c __a.destroy(__p). 550 */ 551 template<typename _Up> 552 [[__gnu__::__always_inline__]] 553 static _GLIBCXX20_CONSTEXPR void 554 destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) 555 noexcept(is_nothrow_destructible<_Up>::value) 556 { 557 #if __cplusplus <= 201703L 558 __a.destroy(__p); 559 #else 560 std::destroy_at(__p); 561 #endif 562 } 563 564 /** 565 * @brief The maximum supported allocation size 566 * @param __a An allocator. 567 * @return @c __a.max_size() 568 */ 569 [[__gnu__::__always_inline__]] 570 static _GLIBCXX20_CONSTEXPR size_type 571 max_size(const allocator_type& __a __attribute__((__unused__))) noexcept 572 { 573 #if __cplusplus <= 201703L 574 return __a.max_size(); 575 #else 576 return size_t(-1) / sizeof(value_type); 577 #endif 578 } 579 580 /** 581 * @brief Obtain an allocator to use when copying a container. 582 * @param __rhs An allocator. 583 * @return @c __rhs 584 */ 585 [[__gnu__::__always_inline__]] 586 static _GLIBCXX20_CONSTEXPR allocator_type 587 select_on_container_copy_construction(const allocator_type& __rhs) 588 { return __rhs; } 589 }; 590 591 /// Explicit specialization for std::allocator<void>. 592 template<> 593 struct allocator_traits<allocator<void>> 594 { 595 /// The allocator type 596 using allocator_type = allocator<void>; 597 598 /// The allocated type 599 using value_type = void; 600 601 /// The allocator's pointer type. 602 using pointer = void*; 603 604 /// The allocator's const pointer type. 605 using const_pointer = const void*; 606 607 /// The allocator's void pointer type. 608 using void_pointer = void*; 609 610 /// The allocator's const void pointer type. 611 using const_void_pointer = const void*; 612 613 /// The allocator's difference type 614 using difference_type = std::ptrdiff_t; 615 616 /// The allocator's size type 617 using size_type = std::size_t; 618 619 /// How the allocator is propagated on copy assignment 620 using propagate_on_container_copy_assignment = false_type; 621 622 /// How the allocator is propagated on move assignment 623 using propagate_on_container_move_assignment = true_type; 624 625 /// How the allocator is propagated on swap 626 using propagate_on_container_swap = false_type; 627 628 /// Whether all instances of the allocator type compare equal. 629 using is_always_equal = true_type; 630 631 template<typename _Up> 632 using rebind_alloc = allocator<_Up>; 633 634 template<typename _Up> 635 using rebind_traits = allocator_traits<allocator<_Up>>; 636 637 /// allocate is ill-formed for allocator<void> 638 static void* 639 allocate(allocator_type&, size_type, const void* = nullptr) = delete; 640 641 /// deallocate is ill-formed for allocator<void> 642 static void 643 deallocate(allocator_type&, void*, size_type) = delete; 644 645 /** 646 * @brief Construct an object of type `_Up` 647 * @param __a An allocator. 648 * @param __p Pointer to memory of suitable size and alignment for 649 * an object of type `_Up`. 650 * @param __args Constructor arguments. 651 * 652 * Calls `__a.construct(__p, std::forward<_Args>(__args)...)` 653 * in C++11, C++14 and C++17. Changed in C++20 to call 654 * `std::construct_at(__p, std::forward<_Args>(__args)...)` instead. 655 */ 656 template<typename _Up, typename... _Args> 657 [[__gnu__::__always_inline__]] 658 static _GLIBCXX20_CONSTEXPR void 659 construct(allocator_type&, _Up* __p, _Args&&... __args) 660 noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) 661 { std::_Construct(__p, std::forward<_Args>(__args)...); } 662 663 /** 664 * @brief Destroy an object of type `_Up` 665 * @param __a An allocator. 666 * @param __p Pointer to the object to destroy 667 * 668 * Invokes the destructor for `*__p`. 669 */ 670 template<typename _Up> 671 [[__gnu__::__always_inline__]] 672 static _GLIBCXX20_CONSTEXPR void 673 destroy(allocator_type&, _Up* __p) 674 noexcept(is_nothrow_destructible<_Up>::value) 675 { std::_Destroy(__p); } 676 677 /// max_size is ill-formed for allocator<void> 678 static size_type 679 max_size(const allocator_type&) = delete; 680 681 /** 682 * @brief Obtain an allocator to use when copying a container. 683 * @param __rhs An allocator. 684 * @return `__rhs` 685 */ 686 [[__gnu__::__always_inline__]] 687 static _GLIBCXX20_CONSTEXPR allocator_type 688 select_on_container_copy_construction(const allocator_type& __rhs) 689 { return __rhs; } 690 }; 691 #endif 692 693 /// @cond undocumented 694 #if __cplusplus < 201703L 695 template<typename _Alloc> 696 [[__gnu__::__always_inline__]] 697 inline void 698 __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type) 699 { __one = __two; } 700 701 template<typename _Alloc> 702 [[__gnu__::__always_inline__]] 703 inline void 704 __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type) 705 { } 706 #endif 707 708 template<typename _Alloc> 709 [[__gnu__::__always_inline__]] 710 _GLIBCXX14_CONSTEXPR inline void 711 __alloc_on_copy(_Alloc& __one, const _Alloc& __two) 712 { 713 using __traits = allocator_traits<_Alloc>; 714 using __pocca = 715 typename __traits::propagate_on_container_copy_assignment::type; 716 #if __cplusplus >= 201703L 717 if constexpr (__pocca::value) 718 __one = __two; 719 #else 720 __do_alloc_on_copy(__one, __two, __pocca()); 721 #endif 722 } 723 724 template<typename _Alloc> 725 [[__gnu__::__always_inline__]] 726 constexpr _Alloc 727 __alloc_on_copy(const _Alloc& __a) 728 { 729 typedef allocator_traits<_Alloc> __traits; 730 return __traits::select_on_container_copy_construction(__a); 731 } 732 733 #if __cplusplus < 201703L 734 template<typename _Alloc> 735 [[__gnu__::__always_inline__]] 736 inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type) 737 { __one = std::move(__two); } 738 739 template<typename _Alloc> 740 [[__gnu__::__always_inline__]] 741 inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type) 742 { } 743 #endif 744 745 template<typename _Alloc> 746 [[__gnu__::__always_inline__]] 747 _GLIBCXX14_CONSTEXPR inline void 748 __alloc_on_move(_Alloc& __one, _Alloc& __two) 749 { 750 using __traits = allocator_traits<_Alloc>; 751 using __pocma 752 = typename __traits::propagate_on_container_move_assignment::type; 753 #if __cplusplus >= 201703L 754 if constexpr (__pocma::value) 755 __one = std::move(__two); 756 #else 757 __do_alloc_on_move(__one, __two, __pocma()); 758 #endif 759 } 760 761 #if __cplusplus < 201703L 762 template<typename _Alloc> 763 [[__gnu__::__always_inline__]] 764 inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type) 765 { 766 using std::swap; 767 swap(__one, __two); 768 } 769 770 template<typename _Alloc> 771 [[__gnu__::__always_inline__]] 772 inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type) 773 { } 774 #endif 775 776 template<typename _Alloc> 777 [[__gnu__::__always_inline__]] 778 _GLIBCXX14_CONSTEXPR inline void 779 __alloc_on_swap(_Alloc& __one, _Alloc& __two) 780 { 781 using __traits = allocator_traits<_Alloc>; 782 using __pocs = typename __traits::propagate_on_container_swap::type; 783 #if __cplusplus >= 201703L 784 if constexpr (__pocs::value) 785 { 786 using std::swap; 787 swap(__one, __two); 788 } 789 #else 790 __do_alloc_on_swap(__one, __two, __pocs()); 791 #endif 792 } 793 794 template<typename _Alloc, typename _Tp, 795 typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>, 796 typename = void> 797 struct __is_alloc_insertable_impl 798 : false_type 799 { }; 800 801 template<typename _Alloc, typename _Tp, typename _ValueT> 802 struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, 803 __void_t<decltype(allocator_traits<_Alloc>::construct( 804 std::declval<_Alloc&>(), std::declval<_ValueT*>(), 805 std::declval<_Tp>()))>> 806 : true_type 807 { }; 808 809 // true if _Alloc::value_type is CopyInsertable into containers using _Alloc 810 // (might be wrong if _Alloc::construct exists but is not constrained, 811 // i.e. actually trying to use it would still be invalid. Use with caution.) 812 template<typename _Alloc> 813 struct __is_copy_insertable 814 : __is_alloc_insertable_impl<_Alloc, 815 typename _Alloc::value_type const&>::type 816 { }; 817 818 #if _GLIBCXX_HOSTED 819 // std::allocator<_Tp> just requires CopyConstructible 820 template<typename _Tp> 821 struct __is_copy_insertable<allocator<_Tp>> 822 : is_copy_constructible<_Tp> 823 { }; 824 #endif 825 826 // true if _Alloc::value_type is MoveInsertable into containers using _Alloc 827 // (might be wrong if _Alloc::construct exists but is not constrained, 828 // i.e. actually trying to use it would still be invalid. Use with caution.) 829 template<typename _Alloc> 830 struct __is_move_insertable 831 : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type 832 { }; 833 834 #if _GLIBCXX_HOSTED 835 // std::allocator<_Tp> just requires MoveConstructible 836 template<typename _Tp> 837 struct __is_move_insertable<allocator<_Tp>> 838 : is_move_constructible<_Tp> 839 { }; 840 #endif 841 842 // Trait to detect Allocator-like types. 843 template<typename _Alloc, typename = void> 844 struct __is_allocator : false_type { }; 845 846 template<typename _Alloc> 847 struct __is_allocator<_Alloc, 848 __void_t<typename _Alloc::value_type, 849 decltype(std::declval<_Alloc&>().allocate(size_t{}))>> 850 : true_type { }; 851 852 template<typename _Alloc> 853 using _RequireAllocator 854 = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; 855 856 template<typename _Alloc> 857 using _RequireNotAllocator 858 = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type; 859 860 #if __cpp_concepts >= 201907L 861 template<typename _Alloc> 862 concept __allocator_like = requires (_Alloc& __a) { 863 typename _Alloc::value_type; 864 __a.deallocate(__a.allocate(1u), 1u); 865 }; 866 #endif 867 /// @endcond 868 #endif // C++11 869 870 /// @cond undocumented 871 872 // To implement Option 3 of DR 431. 873 template<typename _Alloc, bool = __is_empty(_Alloc)> 874 struct __alloc_swap 875 { static void _S_do_it(_Alloc&, _Alloc&) _GLIBCXX_NOEXCEPT { } }; 876 877 template<typename _Alloc> 878 struct __alloc_swap<_Alloc, false> 879 { 880 static void 881 _S_do_it(_Alloc& __one, _Alloc& __two) _GLIBCXX_NOEXCEPT 882 { 883 // Precondition: swappable allocators. 884 if (__one != __two) 885 swap(__one, __two); 886 } 887 }; 888 889 #if __cplusplus >= 201103L 890 template<typename _Tp, bool 891 = __or_<is_copy_constructible<typename _Tp::value_type>, 892 is_nothrow_move_constructible<typename _Tp::value_type>>::value> 893 struct __shrink_to_fit_aux 894 { static bool _S_do_it(_Tp&) noexcept { return false; } }; 895 896 template<typename _Tp> 897 struct __shrink_to_fit_aux<_Tp, true> 898 { 899 _GLIBCXX20_CONSTEXPR 900 static bool 901 _S_do_it(_Tp& __c) noexcept 902 { 903 #if __cpp_exceptions 904 try 905 { 906 _Tp(__make_move_if_noexcept_iterator(__c.begin()), 907 __make_move_if_noexcept_iterator(__c.end()), 908 __c.get_allocator()).swap(__c); 909 return true; 910 } 911 catch(...) 912 { return false; } 913 #else 914 return false; 915 #endif 916 } 917 }; 918 #endif 919 920 /** 921 * Destroy a range of objects using the supplied allocator. For 922 * non-default allocators we do not optimize away invocation of 923 * destroy() even if _Tp has a trivial destructor. 924 */ 925 926 template<typename _ForwardIterator, typename _Allocator> 927 _GLIBCXX20_CONSTEXPR 928 void 929 _Destroy(_ForwardIterator __first, _ForwardIterator __last, 930 _Allocator& __alloc) 931 { 932 for (; __first != __last; ++__first) 933 #if __cplusplus < 201103L 934 __alloc.destroy(std::__addressof(*__first)); 935 #else 936 allocator_traits<_Allocator>::destroy(__alloc, 937 std::__addressof(*__first)); 938 #endif 939 } 940 941 #if _GLIBCXX_HOSTED 942 template<typename _ForwardIterator, typename _Tp> 943 __attribute__((__always_inline__)) _GLIBCXX20_CONSTEXPR 944 inline void 945 _Destroy(_ForwardIterator __first, _ForwardIterator __last, 946 allocator<_Tp>&) 947 { 948 std::_Destroy(__first, __last); 949 } 950 #endif 951 /// @endcond 952 953 _GLIBCXX_END_NAMESPACE_VERSION 954 } // namespace std 955 #endif // _ALLOC_TRAITS_H
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
