1 // Core algorithmic facilities -*- C++ -*-
2
3 // Copyright (C) 2020-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/ranges_algobase.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{algorithm}
28 */
29
30 #ifndef _RANGES_ALGOBASE_H
31 #define _RANGES_ALGOBASE_H 1
32
33 #if __cplusplus > 201703L
34
35 #include <compare>
36 #include <bits/stl_iterator_base_funcs.h>
37 #include <bits/stl_iterator.h>
38 #include <bits/ranges_base.h> // ranges::begin, ranges::range etc.
39 #include <bits/invoke.h> // __invoke
40 #include <bits/cpp_type_traits.h> // __is_byte
41
42 #if __cpp_lib_concepts
43 namespace std _GLIBCXX_VISIBILITY(default)
44 {
45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
46 namespace ranges
47 {
48 namespace __detail
49 {
50 template<typename _Tp>
51 constexpr inline bool __is_normal_iterator = false;
52
53 template<typename _Iterator, typename _Container>
54 constexpr inline bool
55 __is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator,
56 _Container>> = true;
57
58 template<typename _Tp>
59 constexpr inline bool __is_reverse_iterator = false;
60
61 template<typename _Iterator>
62 constexpr inline bool
63 __is_reverse_iterator<reverse_iterator<_Iterator>> = true;
64
65 template<typename _Tp>
66 constexpr inline bool __is_move_iterator = false;
67
68 template<typename _Iterator>
69 constexpr inline bool
70 __is_move_iterator<move_iterator<_Iterator>> = true;
71 } // namespace __detail
72
73 struct __equal_fn
74 {
75 template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
76 input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
77 typename _Pred = ranges::equal_to,
78 typename _Proj1 = identity, typename _Proj2 = identity>
79 requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
80 constexpr bool
81 operator()(_Iter1 __first1, _Sent1 __last1,
82 _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
83 _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
84 {
85 // TODO: implement more specializations to at least have parity with
86 // std::equal.
87 if constexpr (__detail::__is_normal_iterator<_Iter1>
88 && same_as<_Iter1, _Sent1>)
89 return (*this)(__first1.base(), __last1.base(),
90 std::move(__first2), std::move(__last2),
91 std::move(__pred),
92 std::move(__proj1), std::move(__proj2));
93 else if constexpr (__detail::__is_normal_iterator<_Iter2>
94 && same_as<_Iter2, _Sent2>)
95 return (*this)(std::move(__first1), std::move(__last1),
96 __first2.base(), __last2.base(),
97 std::move(__pred),
98 std::move(__proj1), std::move(__proj2));
99 else if constexpr (sized_sentinel_for<_Sent1, _Iter1>
100 && sized_sentinel_for<_Sent2, _Iter2>)
101 {
102 auto __d1 = ranges::distance(__first1, __last1);
103 auto __d2 = ranges::distance(__first2, __last2);
104 if (__d1 != __d2)
105 return false;
106
107 using _ValueType1 = iter_value_t<_Iter1>;
108 constexpr bool __use_memcmp
109 = ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
110 && __memcmpable<_Iter1, _Iter2>::__value
111 && is_same_v<_Pred, ranges::equal_to>
112 && is_same_v<_Proj1, identity>
113 && is_same_v<_Proj2, identity>);
114 if constexpr (__use_memcmp)
115 {
116 if (const size_t __len = (__last1 - __first1))
117 return !std::__memcmp(__first1, __first2, __len);
118 return true;
119 }
120 else
121 {
122 for (; __first1 != __last1; ++__first1, (void)++__first2)
123 if (!(bool)std::__invoke(__pred,
124 std::__invoke(__proj1, *__first1),
125 std::__invoke(__proj2, *__first2)))
126 return false;
127 return true;
128 }
129 }
130 else
131 {
132 for (; __first1 != __last1 && __first2 != __last2;
133 ++__first1, (void)++__first2)
134 if (!(bool)std::__invoke(__pred,
135 std::__invoke(__proj1, *__first1),
136 std::__invoke(__proj2, *__first2)))
137 return false;
138 return __first1 == __last1 && __first2 == __last2;
139 }
140 }
141
142 template<input_range _Range1, input_range _Range2,
143 typename _Pred = ranges::equal_to,
144 typename _Proj1 = identity, typename _Proj2 = identity>
145 requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
146 _Pred, _Proj1, _Proj2>
147 constexpr bool
148 operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
149 _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
150 {
151 return (*this)(ranges::begin(__r1), ranges::end(__r1),
152 ranges::begin(__r2), ranges::end(__r2),
153 std::move(__pred),
154 std::move(__proj1), std::move(__proj2));
155 }
156 };
157
158 inline constexpr __equal_fn equal{};
159
160 template<typename _Iter, typename _Out>
161 struct in_out_result
162 {
163 [[no_unique_address]] _Iter in;
164 [[no_unique_address]] _Out out;
165
166 template<typename _Iter2, typename _Out2>
167 requires convertible_to<const _Iter&, _Iter2>
168 && convertible_to<const _Out&, _Out2>
169 constexpr
170 operator in_out_result<_Iter2, _Out2>() const &
171 { return {in, out}; }
172
173 template<typename _Iter2, typename _Out2>
174 requires convertible_to<_Iter, _Iter2>
175 && convertible_to<_Out, _Out2>
176 constexpr
177 operator in_out_result<_Iter2, _Out2>() &&
178 { return {std::move(in), std::move(out)}; }
179 };
180
181 template<typename _Iter, typename _Out>
182 using copy_result = in_out_result<_Iter, _Out>;
183
184 template<typename _Iter, typename _Out>
185 using move_result = in_out_result<_Iter, _Out>;
186
187 template<typename _Iter1, typename _Iter2>
188 using move_backward_result = in_out_result<_Iter1, _Iter2>;
189
190 template<typename _Iter1, typename _Iter2>
191 using copy_backward_result = in_out_result<_Iter1, _Iter2>;
192
193 template<bool _IsMove,
194 bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
195 bidirectional_iterator _Out>
196 requires (_IsMove
197 ? indirectly_movable<_Iter, _Out>
198 : indirectly_copyable<_Iter, _Out>)
199 constexpr __conditional_t<_IsMove,
200 move_backward_result<_Iter, _Out>,
201 copy_backward_result<_Iter, _Out>>
202 __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);
203
204 template<bool _IsMove,
205 input_iterator _Iter, sentinel_for<_Iter> _Sent,
206 weakly_incrementable _Out>
207 requires (_IsMove
208 ? indirectly_movable<_Iter, _Out>
209 : indirectly_copyable<_Iter, _Out>)
210 constexpr __conditional_t<_IsMove,
211 move_result<_Iter, _Out>,
212 copy_result<_Iter, _Out>>
213 __copy_or_move(_Iter __first, _Sent __last, _Out __result)
214 {
215 // TODO: implement more specializations to be at least on par with
216 // std::copy/std::move.
217 using __detail::__is_move_iterator;
218 using __detail::__is_reverse_iterator;
219 using __detail::__is_normal_iterator;
220 if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>)
221 {
222 auto [__in, __out]
223 = ranges::__copy_or_move<true>(std::move(__first).base(),
224 std::move(__last).base(),
225 std::move(__result));
226 return {move_iterator{std::move(__in)}, std::move(__out)};
227 }
228 else if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
229 && __is_reverse_iterator<_Out>)
230 {
231 auto [__in,__out]
232 = ranges::__copy_or_move_backward<_IsMove>(std::move(__last).base(),
233 std::move(__first).base(),
234 std::move(__result).base());
235 return {reverse_iterator{std::move(__in)},
236 reverse_iterator{std::move(__out)}};
237 }
238 else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
239 {
240 auto [__in,__out]
241 = ranges::__copy_or_move<_IsMove>(__first.base(), __last.base(),
242 std::move(__result));
243 return {decltype(__first){__in}, std::move(__out)};
244 }
245 else if constexpr (__is_normal_iterator<_Out>)
246 {
247 auto [__in,__out]
248 = ranges::__copy_or_move<_IsMove>(std::move(__first), __last, __result.base());
249 return {std::move(__in), decltype(__result){__out}};
250 }
251 else if constexpr (sized_sentinel_for<_Sent, _Iter>)
252 {
253 if (!std::__is_constant_evaluated())
254 {
255 if constexpr (__memcpyable<_Iter, _Out>::__value)
256 {
257 using _ValueTypeI = iter_value_t<_Iter>;
258 static_assert(_IsMove
259 ? is_move_assignable_v<_ValueTypeI>
260 : is_copy_assignable_v<_ValueTypeI>);
261 auto __num = __last - __first;
262 if (__num)
263 __builtin_memmove(__result, __first,
264 sizeof(_ValueTypeI) * __num);
265 return {__first + __num, __result + __num};
266 }
267 }
268
269 for (auto __n = __last - __first; __n > 0; --__n)
270 {
271 if constexpr (_IsMove)
272 *__result = std::move(*__first);
273 else
274 *__result = *__first;
275 ++__first;
276 ++__result;
277 }
278 return {std::move(__first), std::move(__result)};
279 }
280 else
281 {
282 while (__first != __last)
283 {
284 if constexpr (_IsMove)
285 *__result = std::move(*__first);
286 else
287 *__result = *__first;
288 ++__first;
289 ++__result;
290 }
291 return {std::move(__first), std::move(__result)};
292 }
293 }
294
295 struct __copy_fn
296 {
297 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
298 weakly_incrementable _Out>
299 requires indirectly_copyable<_Iter, _Out>
300 constexpr copy_result<_Iter, _Out>
301 operator()(_Iter __first, _Sent __last, _Out __result) const
302 {
303 return ranges::__copy_or_move<false>(std::move(__first),
304 std::move(__last),
305 std::move(__result));
306 }
307
308 template<input_range _Range, weakly_incrementable _Out>
309 requires indirectly_copyable<iterator_t<_Range>, _Out>
310 constexpr copy_result<borrowed_iterator_t<_Range>, _Out>
311 operator()(_Range&& __r, _Out __result) const
312 {
313 return (*this)(ranges::begin(__r), ranges::end(__r),
314 std::move(__result));
315 }
316 };
317
318 inline constexpr __copy_fn copy{};
319
320 struct __move_fn
321 {
322 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
323 weakly_incrementable _Out>
324 requires indirectly_movable<_Iter, _Out>
325 constexpr move_result<_Iter, _Out>
326 operator()(_Iter __first, _Sent __last, _Out __result) const
327 {
328 return ranges::__copy_or_move<true>(std::move(__first),
329 std::move(__last),
330 std::move(__result));
331 }
332
333 template<input_range _Range, weakly_incrementable _Out>
334 requires indirectly_movable<iterator_t<_Range>, _Out>
335 constexpr move_result<borrowed_iterator_t<_Range>, _Out>
336 operator()(_Range&& __r, _Out __result) const
337 {
338 return (*this)(ranges::begin(__r), ranges::end(__r),
339 std::move(__result));
340 }
341 };
342
343 inline constexpr __move_fn move{};
344
345 template<bool _IsMove,
346 bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
347 bidirectional_iterator _Out>
348 requires (_IsMove
349 ? indirectly_movable<_Iter, _Out>
350 : indirectly_copyable<_Iter, _Out>)
351 constexpr __conditional_t<_IsMove,
352 move_backward_result<_Iter, _Out>,
353 copy_backward_result<_Iter, _Out>>
354 __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
355 {
356 // TODO: implement more specializations to be at least on par with
357 // std::copy_backward/std::move_backward.
358 using __detail::__is_reverse_iterator;
359 using __detail::__is_normal_iterator;
360 if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
361 && __is_reverse_iterator<_Out>)
362 {
363 auto [__in,__out]
364 = ranges::__copy_or_move<_IsMove>(std::move(__last).base(),
365 std::move(__first).base(),
366 std::move(__result).base());
367 return {reverse_iterator{std::move(__in)},
368 reverse_iterator{std::move(__out)}};
369 }
370 else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
371 {
372 auto [__in,__out]
373 = ranges::__copy_or_move_backward<_IsMove>(__first.base(),
374 __last.base(),
375 std::move(__result));
376 return {decltype(__first){__in}, std::move(__out)};
377 }
378 else if constexpr (__is_normal_iterator<_Out>)
379 {
380 auto [__in,__out]
381 = ranges::__copy_or_move_backward<_IsMove>(std::move(__first),
382 std::move(__last),
383 __result.base());
384 return {std::move(__in), decltype(__result){__out}};
385 }
386 else if constexpr (sized_sentinel_for<_Sent, _Iter>)
387 {
388 if (!std::__is_constant_evaluated())
389 {
390 if constexpr (__memcpyable<_Out, _Iter>::__value)
391 {
392 using _ValueTypeI = iter_value_t<_Iter>;
393 static_assert(_IsMove
394 ? is_move_assignable_v<_ValueTypeI>
395 : is_copy_assignable_v<_ValueTypeI>);
396 auto __num = __last - __first;
397 if (__num)
398 __builtin_memmove(__result - __num, __first,
399 sizeof(_ValueTypeI) * __num);
400 return {__first + __num, __result - __num};
401 }
402 }
403
404 auto __lasti = ranges::next(__first, __last);
405 auto __tail = __lasti;
406
407 for (auto __n = __last - __first; __n > 0; --__n)
408 {
409 --__tail;
410 --__result;
411 if constexpr (_IsMove)
412 *__result = std::move(*__tail);
413 else
414 *__result = *__tail;
415 }
416 return {std::move(__lasti), std::move(__result)};
417 }
418 else
419 {
420 auto __lasti = ranges::next(__first, __last);
421 auto __tail = __lasti;
422
423 while (__first != __tail)
424 {
425 --__tail;
426 --__result;
427 if constexpr (_IsMove)
428 *__result = std::move(*__tail);
429 else
430 *__result = *__tail;
431 }
432 return {std::move(__lasti), std::move(__result)};
433 }
434 }
435
436 struct __copy_backward_fn
437 {
438 template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
439 bidirectional_iterator _Iter2>
440 requires indirectly_copyable<_Iter1, _Iter2>
441 constexpr copy_backward_result<_Iter1, _Iter2>
442 operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
443 {
444 return ranges::__copy_or_move_backward<false>(std::move(__first),
445 std::move(__last),
446 std::move(__result));
447 }
448
449 template<bidirectional_range _Range, bidirectional_iterator _Iter>
450 requires indirectly_copyable<iterator_t<_Range>, _Iter>
451 constexpr copy_backward_result<borrowed_iterator_t<_Range>, _Iter>
452 operator()(_Range&& __r, _Iter __result) const
453 {
454 return (*this)(ranges::begin(__r), ranges::end(__r),
455 std::move(__result));
456 }
457 };
458
459 inline constexpr __copy_backward_fn copy_backward{};
460
461 struct __move_backward_fn
462 {
463 template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
464 bidirectional_iterator _Iter2>
465 requires indirectly_movable<_Iter1, _Iter2>
466 constexpr move_backward_result<_Iter1, _Iter2>
467 operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
468 {
469 return ranges::__copy_or_move_backward<true>(std::move(__first),
470 std::move(__last),
471 std::move(__result));
472 }
473
474 template<bidirectional_range _Range, bidirectional_iterator _Iter>
475 requires indirectly_movable<iterator_t<_Range>, _Iter>
476 constexpr move_backward_result<borrowed_iterator_t<_Range>, _Iter>
477 operator()(_Range&& __r, _Iter __result) const
478 {
479 return (*this)(ranges::begin(__r), ranges::end(__r),
480 std::move(__result));
481 }
482 };
483
484 inline constexpr __move_backward_fn move_backward{};
485
486 template<typename _Iter, typename _Out>
487 using copy_n_result = in_out_result<_Iter, _Out>;
488
489 struct __copy_n_fn
490 {
491 template<input_iterator _Iter, weakly_incrementable _Out>
492 requires indirectly_copyable<_Iter, _Out>
493 constexpr copy_n_result<_Iter, _Out>
494 operator()(_Iter __first, iter_difference_t<_Iter> __n,
495 _Out __result) const
496 {
497 if constexpr (random_access_iterator<_Iter>)
498 {
499 if (__n > 0)
500 return ranges::copy(__first, __first + __n, std::move(__result));
501 }
502 else
503 {
504 for (; __n > 0; --__n, (void)++__result, (void)++__first)
505 *__result = *__first;
506 }
507 return {std::move(__first), std::move(__result)};
508 }
509 };
510
511 inline constexpr __copy_n_fn copy_n{};
512
513 struct __fill_n_fn
514 {
515 template<typename _Tp, output_iterator<const _Tp&> _Out>
516 constexpr _Out
517 operator()(_Out __first, iter_difference_t<_Out> __n,
518 const _Tp& __value) const
519 {
520 // TODO: implement more specializations to be at least on par with
521 // std::fill_n
522 if (__n <= 0)
523 return __first;
524
525 if constexpr (is_scalar_v<_Tp>)
526 {
527 // TODO: Generalize this optimization to contiguous iterators.
528 if constexpr (is_pointer_v<_Out>
529 // Note that __is_byte already implies !is_volatile.
530 && __is_byte<remove_pointer_t<_Out>>::__value
531 && integral<_Tp>)
532 {
533 if (!std::__is_constant_evaluated())
534 {
535 __builtin_memset(__first,
536 static_cast<unsigned char>(__value),
537 __n);
538 return __first + __n;
539 }
540 }
541
542 const auto __tmp = __value;
543 for (; __n > 0; --__n, (void)++__first)
544 *__first = __tmp;
545 return __first;
546 }
547 else
548 {
549 for (; __n > 0; --__n, (void)++__first)
550 *__first = __value;
551 return __first;
552 }
553 }
554 };
555
556 inline constexpr __fill_n_fn fill_n{};
557
558 struct __fill_fn
559 {
560 template<typename _Tp,
561 output_iterator<const _Tp&> _Out, sentinel_for<_Out> _Sent>
562 constexpr _Out
563 operator()(_Out __first, _Sent __last, const _Tp& __value) const
564 {
565 // TODO: implement more specializations to be at least on par with
566 // std::fill
567 if constexpr (sized_sentinel_for<_Sent, _Out>)
568 {
569 const auto __len = __last - __first;
570 return ranges::fill_n(__first, __len, __value);
571 }
572 else if constexpr (is_scalar_v<_Tp>)
573 {
574 const auto __tmp = __value;
575 for (; __first != __last; ++__first)
576 *__first = __tmp;
577 return __first;
578 }
579 else
580 {
581 for (; __first != __last; ++__first)
582 *__first = __value;
583 return __first;
584 }
585 }
586
587 template<typename _Tp, output_range<const _Tp&> _Range>
588 constexpr borrowed_iterator_t<_Range>
589 operator()(_Range&& __r, const _Tp& __value) const
590 {
591 return (*this)(ranges::begin(__r), ranges::end(__r), __value);
592 }
593 };
594
595 inline constexpr __fill_fn fill{};
596 }
597 _GLIBCXX_END_NAMESPACE_VERSION
598 } // namespace std
599 #endif // concepts
600 #endif // C++20
601 #endif // _RANGES_ALGOBASE_H