libstdc++
ranges_algobase.h
Go to the documentation of this file.
1 // Core algorithmic facilities -*- C++ -*-
2 
3 // Copyright (C) 2020 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 <iterator>
37 // #include <bits/range_concepts.h>
38 #include <ranges>
39 #include <bits/invoke.h>
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  || __detail::__is_normal_iterator<_Iter2>)
89  return (*this)(std::__niter_base(std::move(__first1)),
90  std::__niter_base(std::move(__last1)),
91  std::__niter_base(std::move(__first2)),
92  std::__niter_base(std::move(__last2)),
93  std::move(__pred),
94  std::move(__proj1), std::move(__proj2));
95  else if constexpr (sized_sentinel_for<_Sent1, _Iter1>
96  && sized_sentinel_for<_Sent2, _Iter2>)
97  {
98  auto __d1 = ranges::distance(__first1, __last1);
99  auto __d2 = ranges::distance(__first2, __last2);
100  if (__d1 != __d2)
101  return false;
102 
103  using _ValueType1 = iter_value_t<_Iter1>;
104  using _ValueType2 = iter_value_t<_Iter2>;
105  constexpr bool __use_memcmp
106  = ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
107  && is_same_v<_ValueType1, _ValueType2>
108  && is_pointer_v<_Iter1>
109  && is_pointer_v<_Iter2>
110  && is_same_v<_Pred, ranges::equal_to>
111  && is_same_v<_Proj1, identity>
112  && is_same_v<_Proj2, identity>);
113  if constexpr (__use_memcmp)
114  {
115  if (const size_t __len = (__last1 - __first1))
116  return !std::__memcmp(__first1, __first2, __len);
117  return true;
118  }
119  else
120  {
121  for (; __first1 != __last1; ++__first1, (void)++__first2)
122  if (!(bool)std::__invoke(__pred,
123  std::__invoke(__proj1, *__first1),
124  std::__invoke(__proj2, *__first2)))
125  return false;
126  return true;
127  }
128  }
129  else
130  {
131  for (; __first1 != __last1 && __first2 != __last2;
132  ++__first1, (void)++__first2)
133  if (!(bool)std::__invoke(__pred,
134  std::__invoke(__proj1, *__first1),
135  std::__invoke(__proj2, *__first2)))
136  return false;
137  return __first1 == __last1 && __first2 == __last2;
138  }
139  }
140 
141  template<input_range _Range1, input_range _Range2,
142  typename _Pred = ranges::equal_to,
143  typename _Proj1 = identity, typename _Proj2 = identity>
144  requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
145  _Pred, _Proj1, _Proj2>
146  constexpr bool
147  operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
148  _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
149  {
150  return (*this)(ranges::begin(__r1), ranges::end(__r1),
151  ranges::begin(__r2), ranges::end(__r2),
152  std::move(__pred),
153  std::move(__proj1), std::move(__proj2));
154  }
155  };
156 
157  inline constexpr __equal_fn equal{};
158 
159  template<typename _Iter, typename _Out>
160  struct in_out_result
161  {
162  [[no_unique_address]] _Iter in;
163  [[no_unique_address]] _Out out;
164 
165  template<typename _Iter2, typename _Out2>
166  requires convertible_to<const _Iter&, _Iter2>
167  && convertible_to<const _Out&, _Out2>
168  constexpr
169  operator in_out_result<_Iter2, _Out2>() const &
170  { return {in, out}; }
171 
172  template<typename _Iter2, typename _Out2>
173  requires convertible_to<_Iter, _Iter2>
174  && convertible_to<_Out, _Out2>
175  constexpr
176  operator in_out_result<_Iter2, _Out2>() &&
177  { return {std::move(in), std::move(out)}; }
178  };
179 
180  template<typename _Iter, typename _Out>
181  using copy_result = in_out_result<_Iter, _Out>;
182 
183  template<typename _Iter, typename _Out>
184  using move_result = in_out_result<_Iter, _Out>;
185 
186  template<typename _Iter1, typename _Iter2>
187  using move_backward_result = in_out_result<_Iter1, _Iter2>;
188 
189  template<typename _Iter1, typename _Iter2>
190  using copy_backward_result = in_out_result<_Iter1, _Iter2>;
191 
192  template<bool _IsMove,
193  bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
194  bidirectional_iterator _Out>
195  requires (_IsMove
196  ? indirectly_movable<_Iter, _Out>
197  : indirectly_copyable<_Iter, _Out>)
198  constexpr conditional_t<_IsMove,
199  move_backward_result<_Iter, _Out>,
200  copy_backward_result<_Iter, _Out>>
201  __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);
202 
203  template<bool _IsMove,
204  input_iterator _Iter, sentinel_for<_Iter> _Sent,
205  weakly_incrementable _Out>
206  requires (_IsMove
207  ? indirectly_movable<_Iter, _Out>
208  : indirectly_copyable<_Iter, _Out>)
209  constexpr conditional_t<_IsMove,
210  move_result<_Iter, _Out>,
211  copy_result<_Iter, _Out>>
212  __copy_or_move(_Iter __first, _Sent __last, _Out __result)
213  {
214  // TODO: implement more specializations to be at least on par with
215  // std::copy/std::move.
216  constexpr bool __normal_iterator_p
217  = (__detail::__is_normal_iterator<_Iter>
218  || __detail::__is_normal_iterator<_Out>);
219  constexpr bool __reverse_p
220  = (__detail::__is_reverse_iterator<_Iter>
221  && __detail::__is_reverse_iterator<_Out>);
222  constexpr bool __move_iterator_p = __detail::__is_move_iterator<_Iter>;
223  if constexpr (__move_iterator_p)
224  {
225  auto [__in, __out]
226  = ranges::__copy_or_move<true>(std::move(__first).base(),
227  std::move(__last).base(),
228  std::move(__result));
229  return {move_iterator{std::move(__in)}, std::move(__out)};
230  }
231  else if constexpr (__reverse_p)
232  {
233  auto [__in,__out]
234  = ranges::__copy_or_move_backward<_IsMove>(__last.base(),
235  __first.base(),
236  __result.base());
237  return {reverse_iterator{std::move(__in)},
238  reverse_iterator{std::move(__out)}};
239  }
240  else if constexpr (__normal_iterator_p)
241  {
242  auto [__in,__out]
243  = ranges::__copy_or_move<_IsMove>(std::__niter_base(__first),
244  std::__niter_base(__last),
245  std::__niter_base(__result));
246  return {std::__niter_wrap(__first, std::move(__in)),
247  std::__niter_wrap(__result, std::move(__out))};
248  }
249  else if constexpr (sized_sentinel_for<_Sent, _Iter>)
250  {
251 #ifdef __cpp_lib_is_constant_evaluated
252  if (!std::is_constant_evaluated())
253 #endif
254  {
255  using _ValueTypeI = iter_value_t<_Iter>;
256  using _ValueTypeO = typename iterator_traits<_Out>::value_type;
257  constexpr bool __use_memmove
258  = (is_trivially_copyable_v<_ValueTypeI>
259  && is_same_v<_ValueTypeI, _ValueTypeO>
260  && is_pointer_v<_Iter>
261  && is_pointer_v<_Out>);
262 
263  if constexpr (__use_memmove)
264  {
265  static_assert(_IsMove
266  ? is_move_assignable_v<_ValueTypeI>
267  : is_copy_assignable_v<_ValueTypeI>);
268  auto __num = __last - __first;
269  if (__num)
270  __builtin_memmove(__result, __first,
271  sizeof(_ValueTypeI) * __num);
272  return {__first + __num, __result + __num};
273  }
274  }
275 
276  for (auto __n = __last - __first; __n > 0; --__n)
277  {
278  if constexpr (_IsMove)
279  *__result = std::move(*__first);
280  else
281  *__result = *__first;
282  ++__first;
283  ++__result;
284  }
285  return {std::move(__first), std::move(__result)};
286  }
287  else
288  {
289  while (__first != __last)
290  {
291  if constexpr (_IsMove)
292  *__result = std::move(*__first);
293  else
294  *__result = *__first;
295  ++__first;
296  ++__result;
297  }
298  return {std::move(__first), std::move(__result)};
299  }
300  }
301 
302  struct __copy_fn
303  {
304  template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
305  weakly_incrementable _Out>
306  requires indirectly_copyable<_Iter, _Out>
307  constexpr copy_result<_Iter, _Out>
308  operator()(_Iter __first, _Sent __last, _Out __result) const
309  {
310  return ranges::__copy_or_move<false>(std::move(__first),
311  std::move(__last),
312  std::move(__result));
313  }
314 
315  template<input_range _Range, weakly_incrementable _Out>
316  requires indirectly_copyable<iterator_t<_Range>, _Out>
317  constexpr copy_result<borrowed_iterator_t<_Range>, _Out>
318  operator()(_Range&& __r, _Out __result) const
319  {
320  return (*this)(ranges::begin(__r), ranges::end(__r),
321  std::move(__result));
322  }
323  };
324 
325  inline constexpr __copy_fn copy{};
326 
327  struct __move_fn
328  {
329  template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
330  weakly_incrementable _Out>
331  requires indirectly_movable<_Iter, _Out>
332  constexpr move_result<_Iter, _Out>
333  operator()(_Iter __first, _Sent __last, _Out __result) const
334  {
335  return ranges::__copy_or_move<true>(std::move(__first),
336  std::move(__last),
337  std::move(__result));
338  }
339 
340  template<input_range _Range, weakly_incrementable _Out>
341  requires indirectly_movable<iterator_t<_Range>, _Out>
342  constexpr move_result<borrowed_iterator_t<_Range>, _Out>
343  operator()(_Range&& __r, _Out __result) const
344  {
345  return (*this)(ranges::begin(__r), ranges::end(__r),
346  std::move(__result));
347  }
348  };
349 
350  inline constexpr __move_fn move{};
351 
352  template<bool _IsMove,
353  bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
354  bidirectional_iterator _Out>
355  requires (_IsMove
356  ? indirectly_movable<_Iter, _Out>
357  : indirectly_copyable<_Iter, _Out>)
358  constexpr conditional_t<_IsMove,
359  move_backward_result<_Iter, _Out>,
360  copy_backward_result<_Iter, _Out>>
361  __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
362  {
363  // TODO: implement more specializations to be at least on par with
364  // std::copy_backward/std::move_backward.
365  constexpr bool __normal_iterator_p
366  = (__detail::__is_normal_iterator<_Iter>
367  || __detail::__is_normal_iterator<_Out>);
368  constexpr bool __reverse_p
369  = (__detail::__is_reverse_iterator<_Iter>
370  && __detail::__is_reverse_iterator<_Out>);
371  if constexpr (__reverse_p)
372  {
373  auto [__in,__out]
374  = ranges::__copy_or_move<_IsMove>(__last.base(),
375  __first.base(),
376  __result.base());
377  return {reverse_iterator{std::move(__in)},
378  reverse_iterator{std::move(__out)}};
379  }
380  else if constexpr (__normal_iterator_p)
381  {
382  auto [__in,__out]
383  = ranges::__copy_or_move_backward<_IsMove>
384  (std::__niter_base(__first),
385  std::__niter_base(__last),
386  std::__niter_base(__result));
387  return {std::__niter_wrap(__first, std::move(__in)),
388  std::__niter_wrap(__result, std::move(__out))};
389  }
390  else if constexpr (sized_sentinel_for<_Sent, _Iter>)
391  {
392 #ifdef __cpp_lib_is_constant_evaluated
393  if (!std::is_constant_evaluated())
394 #endif
395  {
396  using _ValueTypeI = iter_value_t<_Iter>;
397  using _ValueTypeO = typename iterator_traits<_Out>::value_type;
398  constexpr bool __use_memmove
399  = (is_trivially_copyable_v<_ValueTypeI>
400  && is_same_v<_ValueTypeI, _ValueTypeO>
401  && is_pointer_v<_Iter>
402  && is_pointer_v<_Out>);
403  if constexpr (__use_memmove)
404  {
405  static_assert(_IsMove
406  ? is_move_assignable_v<_ValueTypeI>
407  : is_copy_assignable_v<_ValueTypeI>);
408  auto __num = __last - __first;
409  if (__num)
410  __builtin_memmove(__result - __num, __first,
411  sizeof(_ValueTypeI) * __num);
412  return {__first + __num, __result - __num};
413  }
414  }
415 
416  auto __lasti = ranges::next(__first, __last);
417  auto __tail = __lasti;
418 
419  for (auto __n = __last - __first; __n > 0; --__n)
420  {
421  --__tail;
422  --__result;
423  if constexpr (_IsMove)
424  *__result = std::move(*__tail);
425  else
426  *__result = *__tail;
427  }
428  return {std::move(__lasti), std::move(__result)};
429  }
430  else
431  {
432  auto __lasti = ranges::next(__first, __last);
433  auto __tail = __lasti;
434 
435  while (__first != __tail)
436  {
437  --__tail;
438  --__result;
439  if constexpr (_IsMove)
440  *__result = std::move(*__tail);
441  else
442  *__result = *__tail;
443  }
444  return {std::move(__lasti), std::move(__result)};
445  }
446  }
447 
448  struct __copy_backward_fn
449  {
450  template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
451  bidirectional_iterator _Iter2>
452  requires indirectly_copyable<_Iter1, _Iter2>
453  constexpr copy_backward_result<_Iter1, _Iter2>
454  operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
455  {
456  return ranges::__copy_or_move_backward<false>(std::move(__first),
457  std::move(__last),
458  std::move(__result));
459  }
460 
461  template<bidirectional_range _Range, bidirectional_iterator _Iter>
462  requires indirectly_copyable<iterator_t<_Range>, _Iter>
463  constexpr copy_backward_result<borrowed_iterator_t<_Range>, _Iter>
464  operator()(_Range&& __r, _Iter __result) const
465  {
466  return (*this)(ranges::begin(__r), ranges::end(__r),
467  std::move(__result));
468  }
469  };
470 
471  inline constexpr __copy_backward_fn copy_backward{};
472 
473  struct __move_backward_fn
474  {
475  template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
476  bidirectional_iterator _Iter2>
477  requires indirectly_movable<_Iter1, _Iter2>
478  constexpr move_backward_result<_Iter1, _Iter2>
479  operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
480  {
481  return ranges::__copy_or_move_backward<true>(std::move(__first),
482  std::move(__last),
483  std::move(__result));
484  }
485 
486  template<bidirectional_range _Range, bidirectional_iterator _Iter>
487  requires indirectly_movable<iterator_t<_Range>, _Iter>
488  constexpr move_backward_result<borrowed_iterator_t<_Range>, _Iter>
489  operator()(_Range&& __r, _Iter __result) const
490  {
491  return (*this)(ranges::begin(__r), ranges::end(__r),
492  std::move(__result));
493  }
494  };
495 
496  inline constexpr __move_backward_fn move_backward{};
497 
498  template<typename _Iter, typename _Out>
499  using copy_n_result = in_out_result<_Iter, _Out>;
500 
501  struct __copy_n_fn
502  {
503  template<input_iterator _Iter, weakly_incrementable _Out>
504  requires indirectly_copyable<_Iter, _Out>
505  constexpr copy_n_result<_Iter, _Out>
506  operator()(_Iter __first, iter_difference_t<_Iter> __n,
507  _Out __result) const
508  {
509  if constexpr (random_access_iterator<_Iter>)
510  return ranges::copy(__first, __first + __n, std::move(__result));
511  else
512  {
513  for (; __n > 0; --__n, (void)++__result, (void)++__first)
514  *__result = *__first;
515  return {std::move(__first), std::move(__result)};
516  }
517  }
518  };
519 
520  inline constexpr __copy_n_fn copy_n{};
521 
522  struct __fill_n_fn
523  {
524  template<typename _Tp, output_iterator<const _Tp&> _Out>
525  constexpr _Out
526  operator()(_Out __first, iter_difference_t<_Out> __n,
527  const _Tp& __value) const
528  {
529  // TODO: implement more specializations to be at least on par with
530  // std::fill_n
531  if (__n <= 0)
532  return __first;
533 
534  // TODO: is __is_byte the best condition?
535  if constexpr (is_pointer_v<_Out> && __is_byte<_Tp>::__value)
536  {
537  __builtin_memset(__first, static_cast<unsigned char>(__value), __n);
538  return __first + __n;
539  }
540  else if constexpr (is_scalar_v<_Tp>)
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
std::distance
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
Definition: stl_iterator_base_funcs.h:138
std::move_backward
constexpr _BI2 move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
Moves the range [first,last) into result.
Definition: stl_algobase.h:842
ranges
std
ISO C++ entities toplevel namespace is std.
invoke.h
std::conditional_t
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
Definition: type_traits:2561
std::end
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
Definition: valarray:1234
cpp_type_traits.h
std::begin
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
Definition: valarray:1214
std::__invoke
constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
Invoke a callable object.
Definition: invoke.h:89
compare
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:101