1// Raw memory manipulators -*- C++ -*- 2 3// Copyright (C) 2020-2022 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/ranges_uninitialized.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 _RANGES_UNINITIALIZED_H 31#define _RANGES_UNINITIALIZED_H 1 32 33#if __cplusplus > 201703L 34#if __cpp_lib_concepts 35 36#include <bits/ranges_algobase.h> 37 38namespace std _GLIBCXX_VISIBILITY(default) 39{ 40_GLIBCXX_BEGIN_NAMESPACE_VERSION 41namespace ranges 42{ 43 namespace __detail 44 { 45 template<typename _Tp> 46 constexpr void* 47 __voidify(_Tp& __obj) noexcept 48 { 49 return const_cast<void*> 50 (static_cast<const volatile void*>(std::__addressof(__obj))); 51 } 52 53 template<typename _Iter> 54 concept __nothrow_input_iterator 55 = (input_iterator<_Iter> 56 && is_lvalue_reference_v<iter_reference_t<_Iter>> 57 && same_as<remove_cvref_t<iter_reference_t<_Iter>>, 58 iter_value_t<_Iter>>); 59 60 template<typename _Sent, typename _Iter> 61 concept __nothrow_sentinel = sentinel_for<_Sent, _Iter>; 62 63 template<typename _Range> 64 concept __nothrow_input_range 65 = (range<_Range> 66 && __nothrow_input_iterator<iterator_t<_Range>> 67 && __nothrow_sentinel<sentinel_t<_Range>, iterator_t<_Range>>); 68 69 template<typename _Iter> 70 concept __nothrow_forward_iterator 71 = (__nothrow_input_iterator<_Iter> 72 && forward_iterator<_Iter> 73 && __nothrow_sentinel<_Iter, _Iter>); 74 75 template<typename _Range> 76 concept __nothrow_forward_range 77 = (__nothrow_input_range<_Range> 78 && __nothrow_forward_iterator<iterator_t<_Range>>); 79 } // namespace __detail 80 81 struct __destroy_fn 82 { 83 template<__detail::__nothrow_input_iterator _Iter, 84 __detail::__nothrow_sentinel<_Iter> _Sent> 85 requires destructible<iter_value_t<_Iter>> 86 constexpr _Iter 87 operator()(_Iter __first, _Sent __last) const noexcept; 88 89 template<__detail::__nothrow_input_range _Range> 90 requires destructible<range_value_t<_Range>> 91 constexpr borrowed_iterator_t<_Range> 92 operator()(_Range&& __r) const noexcept; 93 }; 94 95 inline constexpr __destroy_fn destroy{}; 96 97 namespace __detail 98 { 99 template<typename _Iter> 100 requires destructible<iter_value_t<_Iter>> 101 struct _DestroyGuard 102 { 103 private: 104 _Iter _M_first; 105 const _Iter* _M_cur; 106 107 public: 108 explicit 109 _DestroyGuard(const _Iter& __iter) 110 : _M_first(__iter), _M_cur(std::__addressof(__iter)) 111 { } 112 113 void 114 release() noexcept 115 { _M_cur = nullptr; } 116 117 ~_DestroyGuard() 118 { 119 if (_M_cur != nullptr) 120 ranges::destroy(std::move(_M_first), *_M_cur); 121 } 122 }; 123 124 template<typename _Iter> 125 requires destructible<iter_value_t<_Iter>> 126 && is_trivially_destructible_v<iter_value_t<_Iter>> 127 struct _DestroyGuard<_Iter> 128 { 129 explicit 130 _DestroyGuard(const _Iter&) 131 { } 132 133 void 134 release() noexcept 135 { } 136 }; 137 } // namespace __detail 138 139 struct __uninitialized_default_construct_fn 140 { 141 template<__detail::__nothrow_forward_iterator _Iter, 142 __detail::__nothrow_sentinel<_Iter> _Sent> 143 requires default_initializable<iter_value_t<_Iter>> 144 _Iter 145 operator()(_Iter __first, _Sent __last) const 146 { 147 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>; 148 if constexpr (is_trivially_default_constructible_v<_ValueType>) 149 return ranges::next(__first, __last); 150 else 151 { 152 auto __guard = __detail::_DestroyGuard(__first); 153 for (; __first != __last; ++__first) 154 ::new (__detail::__voidify(*__first)) _ValueType; 155 __guard.release(); 156 return __first; 157 } 158 } 159 160 template<__detail::__nothrow_forward_range _Range> 161 requires default_initializable<range_value_t<_Range>> 162 borrowed_iterator_t<_Range> 163 operator()(_Range&& __r) const 164 { 165 return (*this)(ranges::begin(__r), ranges::end(__r)); 166 } 167 }; 168 169 inline constexpr __uninitialized_default_construct_fn 170 uninitialized_default_construct{}; 171 172 struct __uninitialized_default_construct_n_fn 173 { 174 template<__detail::__nothrow_forward_iterator _Iter> 175 requires default_initializable<iter_value_t<_Iter>> 176 _Iter 177 operator()(_Iter __first, iter_difference_t<_Iter> __n) const 178 { 179 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>; 180 if constexpr (is_trivially_default_constructible_v<_ValueType>) 181 return ranges::next(__first, __n); 182 else 183 { 184 auto __guard = __detail::_DestroyGuard(__first); 185 for (; __n > 0; ++__first, (void) --__n) 186 ::new (__detail::__voidify(*__first)) _ValueType; 187 __guard.release(); 188 return __first; 189 } 190 } 191 }; 192 193 inline constexpr __uninitialized_default_construct_n_fn 194 uninitialized_default_construct_n; 195 196 struct __uninitialized_value_construct_fn 197 { 198 template<__detail::__nothrow_forward_iterator _Iter, 199 __detail::__nothrow_sentinel<_Iter> _Sent> 200 requires default_initializable<iter_value_t<_Iter>> 201 _Iter 202 operator()(_Iter __first, _Sent __last) const 203 { 204 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>; 205 if constexpr (is_trivial_v<_ValueType> 206 && is_copy_assignable_v<_ValueType>) 207 return ranges::fill(__first, __last, _ValueType()); 208 else 209 { 210 auto __guard = __detail::_DestroyGuard(__first); 211 for (; __first != __last; ++__first) 212 ::new (__detail::__voidify(*__first)) _ValueType(); 213 __guard.release(); 214 return __first; 215 } 216 } 217 218 template<__detail::__nothrow_forward_range _Range> 219 requires default_initializable<range_value_t<_Range>> 220 borrowed_iterator_t<_Range> 221 operator()(_Range&& __r) const 222 { 223 return (*this)(ranges::begin(__r), ranges::end(__r)); 224 } 225 }; 226 227 inline constexpr __uninitialized_value_construct_fn 228 uninitialized_value_construct{}; 229 230 struct __uninitialized_value_construct_n_fn 231 { 232 template<__detail::__nothrow_forward_iterator _Iter> 233 requires default_initializable<iter_value_t<_Iter>> 234 _Iter 235 operator()(_Iter __first, iter_difference_t<_Iter> __n) const 236 { 237 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>; 238 if constexpr (is_trivial_v<_ValueType> 239 && is_copy_assignable_v<_ValueType>) 240 return ranges::fill_n(__first, __n, _ValueType()); 241 else 242 { 243 auto __guard = __detail::_DestroyGuard(__first); 244 for (; __n > 0; ++__first, (void) --__n) 245 ::new (__detail::__voidify(*__first)) _ValueType(); 246 __guard.release(); 247 return __first; 248 } 249 } 250 }; 251 252 inline constexpr __uninitialized_value_construct_n_fn 253 uninitialized_value_construct_n; 254 255 template<typename _Iter, typename _Out> 256 using uninitialized_copy_result = in_out_result<_Iter, _Out>; 257 258 struct __uninitialized_copy_fn 259 { 260 template<input_iterator _Iter, sentinel_for<_Iter> _ISent, 261 __detail::__nothrow_forward_iterator _Out, 262 __detail::__nothrow_sentinel<_Out> _OSent> 263 requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>> 264 uninitialized_copy_result<_Iter, _Out> 265 operator()(_Iter __ifirst, _ISent __ilast, 266 _Out __ofirst, _OSent __olast) const 267 { 268 using _OutType = remove_reference_t<iter_reference_t<_Out>>; 269 if constexpr (sized_sentinel_for<_ISent, _Iter> 270 && sized_sentinel_for<_OSent, _Out> 271 && is_trivial_v<_OutType> 272 && is_nothrow_assignable_v<_OutType&, 273 iter_reference_t<_Iter>>) 274 { 275 auto __d1 = __ilast - __ifirst; 276 auto __d2 = __olast - __ofirst; 277 return ranges::copy_n(std::move(__ifirst), std::min(__d1, __d2), 278 __ofirst); 279 } 280 else 281 { 282 auto __guard = __detail::_DestroyGuard(__ofirst); 283 for (; __ifirst != __ilast && __ofirst != __olast; 284 ++__ofirst, (void)++__ifirst) 285 ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst); 286 __guard.release(); 287 return {std::move(__ifirst), __ofirst}; 288 } 289 } 290 291 template<input_range _IRange, __detail::__nothrow_forward_range _ORange> 292 requires constructible_from<range_value_t<_ORange>, 293 range_reference_t<_IRange>> 294 uninitialized_copy_result<borrowed_iterator_t<_IRange>, 295 borrowed_iterator_t<_ORange>> 296 operator()(_IRange&& __inr, _ORange&& __outr) const 297 { 298 return (*this)(ranges::begin(__inr), ranges::end(__inr), 299 ranges::begin(__outr), ranges::end(__outr)); 300 } 301 }; 302 303 inline constexpr __uninitialized_copy_fn uninitialized_copy{}; 304 305 template<typename _Iter, typename _Out> 306 using uninitialized_copy_n_result = in_out_result<_Iter, _Out>; 307 308 struct __uninitialized_copy_n_fn 309 { 310 template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out, 311 __detail::__nothrow_sentinel<_Out> _Sent> 312 requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>> 313 uninitialized_copy_n_result<_Iter, _Out> 314 operator()(_Iter __ifirst, iter_difference_t<_Iter> __n, 315 _Out __ofirst, _Sent __olast) const 316 { 317 using _OutType = remove_reference_t<iter_reference_t<_Out>>; 318 if constexpr (sized_sentinel_for<_Sent, _Out> 319 && is_trivial_v<_OutType> 320 && is_nothrow_assignable_v<_OutType&, 321 iter_reference_t<_Iter>>) 322 { 323 auto __d = __olast - __ofirst; 324 return ranges::copy_n(std::move(__ifirst), std::min(__n, __d), 325 __ofirst); 326 } 327 else 328 { 329 auto __guard = __detail::_DestroyGuard(__ofirst); 330 for (; __n > 0 && __ofirst != __olast; 331 ++__ofirst, (void)++__ifirst, (void)--__n) 332 ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst); 333 __guard.release(); 334 return {std::move(__ifirst), __ofirst}; 335 } 336 } 337 }; 338 339 inline constexpr __uninitialized_copy_n_fn uninitialized_copy_n{}; 340 341 template<typename _Iter, typename _Out> 342 using uninitialized_move_result = in_out_result<_Iter, _Out>; 343 344 struct __uninitialized_move_fn 345 { 346 template<input_iterator _Iter, sentinel_for<_Iter> _ISent, 347 __detail::__nothrow_forward_iterator _Out, 348 __detail::__nothrow_sentinel<_Out> _OSent> 349 requires constructible_from<iter_value_t<_Out>, 350 iter_rvalue_reference_t<_Iter>> 351 uninitialized_move_result<_Iter, _Out> 352 operator()(_Iter __ifirst, _ISent __ilast, 353 _Out __ofirst, _OSent __olast) const 354 { 355 using _OutType = remove_reference_t<iter_reference_t<_Out>>; 356 if constexpr (sized_sentinel_for<_ISent, _Iter> 357 && sized_sentinel_for<_OSent, _Out> 358 && is_trivial_v<_OutType> 359 && is_nothrow_assignable_v<_OutType&, 360 iter_rvalue_reference_t<_Iter>>) 361 { 362 auto __d1 = __ilast - __ifirst; 363 auto __d2 = __olast - __ofirst; 364 auto [__in, __out] 365 = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)), 366 std::min(__d1, __d2), __ofirst); 367 return {std::move(__in).base(), __out}; 368 } 369 else 370 { 371 auto __guard = __detail::_DestroyGuard(__ofirst); 372 for (; __ifirst != __ilast && __ofirst != __olast; 373 ++__ofirst, (void)++__ifirst) 374 ::new (__detail::__voidify(*__ofirst)) 375 _OutType(ranges::iter_move(__ifirst)); 376 __guard.release(); 377 return {std::move(__ifirst), __ofirst}; 378 } 379 } 380 381 template<input_range _IRange, __detail::__nothrow_forward_range _ORange> 382 requires constructible_from<range_value_t<_ORange>, 383 range_rvalue_reference_t<_IRange>> 384 uninitialized_move_result<borrowed_iterator_t<_IRange>, 385 borrowed_iterator_t<_ORange>> 386 operator()(_IRange&& __inr, _ORange&& __outr) const 387 { 388 return (*this)(ranges::begin(__inr), ranges::end(__inr), 389 ranges::begin(__outr), ranges::end(__outr)); 390 } 391 }; 392 393 inline constexpr __uninitialized_move_fn uninitialized_move{}; 394 395 template<typename _Iter, typename _Out> 396 using uninitialized_move_n_result = in_out_result<_Iter, _Out>; 397 398 struct __uninitialized_move_n_fn 399 { 400 template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out, 401 __detail::__nothrow_sentinel<_Out> _Sent> 402 requires constructible_from<iter_value_t<_Out>, 403 iter_rvalue_reference_t<_Iter>> 404 uninitialized_move_n_result<_Iter, _Out> 405 operator()(_Iter __ifirst, iter_difference_t<_Iter> __n, 406 _Out __ofirst, _Sent __olast) const 407 { 408 using _OutType = remove_reference_t<iter_reference_t<_Out>>; 409 if constexpr (sized_sentinel_for<_Sent, _Out> 410 && is_trivial_v<_OutType> 411 && is_nothrow_assignable_v<_OutType&, 412 iter_rvalue_reference_t<_Iter>>) 413 { 414 auto __d = __olast - __ofirst; 415 auto [__in, __out] 416 = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)), 417 std::min(__n, __d), __ofirst); 418 return {std::move(__in).base(), __out}; 419 } 420 else 421 { 422 auto __guard = __detail::_DestroyGuard(__ofirst); 423 for (; __n > 0 && __ofirst != __olast; 424 ++__ofirst, (void)++__ifirst, (void)--__n) 425 ::new (__detail::__voidify(*__ofirst)) 426 _OutType(ranges::iter_move(__ifirst)); 427 __guard.release(); 428 return {std::move(__ifirst), __ofirst}; 429 } 430 } 431 }; 432 433 inline constexpr __uninitialized_move_n_fn uninitialized_move_n{}; 434 435 struct __uninitialized_fill_fn 436 { 437 template<__detail::__nothrow_forward_iterator _Iter, 438 __detail::__nothrow_sentinel<_Iter> _Sent, typename _Tp> 439 requires constructible_from<iter_value_t<_Iter>, const _Tp&> 440 _Iter 441 operator()(_Iter __first, _Sent __last, const _Tp& __x) const 442 { 443 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>; 444 if constexpr (is_trivial_v<_ValueType> 445 && is_nothrow_assignable_v<_ValueType&, const _Tp&>) 446 return ranges::fill(__first, __last, __x); 447 else 448 { 449 auto __guard = __detail::_DestroyGuard(__first); 450 for (; __first != __last; ++__first) 451 ::new (__detail::__voidify(*__first)) _ValueType(__x); 452 __guard.release(); 453 return __first; 454 } 455 } 456 457 template<__detail::__nothrow_forward_range _Range, typename _Tp> 458 requires constructible_from<range_value_t<_Range>, const _Tp&> 459 borrowed_iterator_t<_Range> 460 operator()(_Range&& __r, const _Tp& __x) const 461 { 462 return (*this)(ranges::begin(__r), ranges::end(__r), __x); 463 } 464 }; 465 466 inline constexpr __uninitialized_fill_fn uninitialized_fill{}; 467 468 struct __uninitialized_fill_n_fn 469 { 470 template<__detail::__nothrow_forward_iterator _Iter, typename _Tp> 471 requires constructible_from<iter_value_t<_Iter>, const _Tp&> 472 _Iter 473 operator()(_Iter __first, iter_difference_t<_Iter> __n, 474 const _Tp& __x) const 475 { 476 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>; 477 if constexpr (is_trivial_v<_ValueType> 478 && is_nothrow_assignable_v<_ValueType&, const _Tp&>) 479 return ranges::fill_n(__first, __n, __x); 480 else 481 { 482 auto __guard = __detail::_DestroyGuard(__first); 483 for (; __n > 0; ++__first, (void)--__n) 484 ::new (__detail::__voidify(*__first)) _ValueType(__x); 485 __guard.release(); 486 return __first; 487 } 488 } 489 }; 490 491 inline constexpr __uninitialized_fill_n_fn uninitialized_fill_n{}; 492 493 struct __construct_at_fn 494 { 495 template<typename _Tp, typename... _Args> 496 requires requires { 497 ::new (std::declval<void*>()) _Tp(std::declval<_Args>()...); 498 } 499 constexpr _Tp* 500 operator()(_Tp* __location, _Args&&... __args) const 501 noexcept(noexcept(std::construct_at(__location, 502 std::forward<_Args>(__args)...))) 503 { 504 return std::construct_at(__location, 505 std::forward<_Args>(__args)...); 506 } 507 }; 508 509 inline constexpr __construct_at_fn construct_at{}; 510 511 struct __destroy_at_fn 512 { 513 template<destructible _Tp> 514 constexpr void 515 operator()(_Tp* __location) const noexcept 516 { 517 if constexpr (is_array_v<_Tp>) 518 ranges::destroy(ranges::begin(*__location), ranges::end(*__location)); 519 else 520 __location->~_Tp(); 521 } 522 }; 523 524 inline constexpr __destroy_at_fn destroy_at{}; 525 526 template<__detail::__nothrow_input_iterator _Iter, 527 __detail::__nothrow_sentinel<_Iter> _Sent> 528 requires destructible<iter_value_t<_Iter>> 529 constexpr _Iter 530 __destroy_fn::operator()(_Iter __first, _Sent __last) const noexcept 531 { 532 if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>) 533 return ranges::next(std::move(__first), __last); 534 else 535 { 536 for (; __first != __last; ++__first) 537 ranges::destroy_at(std::__addressof(*__first)); 538 return __first; 539 } 540 } 541 542 template<__detail::__nothrow_input_range _Range> 543 requires destructible<range_value_t<_Range>> 544 constexpr borrowed_iterator_t<_Range> 545 __destroy_fn::operator()(_Range&& __r) const noexcept 546 { 547 return (*this)(ranges::begin(__r), ranges::end(__r)); 548 } 549 550 struct __destroy_n_fn 551 { 552 template<__detail::__nothrow_input_iterator _Iter> 553 requires destructible<iter_value_t<_Iter>> 554 constexpr _Iter 555 operator()(_Iter __first, iter_difference_t<_Iter> __n) const noexcept 556 { 557 if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>) 558 return ranges::next(std::move(__first), __n); 559 else 560 { 561 for (; __n > 0; ++__first, (void)--__n) 562 ranges::destroy_at(std::__addressof(*__first)); 563 return __first; 564 } 565 } 566 }; 567 568 inline constexpr __destroy_n_fn destroy_n{}; 569} 570_GLIBCXX_END_NAMESPACE_VERSION 571} // namespace std 572#endif // concepts 573#endif // C++20 574#endif // _RANGES_UNINITIALIZED_H 575