libstdc++
ranges_util.h
Go to the documentation of this file.
1 // Utilities for representing and manipulating ranges -*- C++ -*-
2 
3 // Copyright (C) 2019-2021 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_util.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{ranges}
28  */
29 
30 #ifndef _RANGES_UTIL_H
31 #define _RANGES_UTIL_H 1
32 
33 #if __cplusplus > 201703L
34 # include <bits/ranges_base.h>
35 
36 #ifdef __cpp_lib_ranges
37 namespace std _GLIBCXX_VISIBILITY(default)
38 {
39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
40 namespace ranges
41 {
42  // C++20 24.5 [range.utility] Range utilities
43 
44  namespace __detail
45  {
46  template<typename _Range>
47  concept __simple_view = view<_Range> && range<const _Range>
48  && same_as<iterator_t<_Range>, iterator_t<const _Range>>
49  && same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;
50 
51  template<typename _It>
52  concept __has_arrow = input_iterator<_It>
53  && (is_pointer_v<_It> || requires(_It __it) { __it.operator->(); });
54 
55  template<typename _Tp, typename _Up>
56  concept __not_same_as
57  = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
58  } // namespace __detail
59 
60  /// The ranges::view_interface class template
61  template<typename _Derived>
62  requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
63  class view_interface : public view_base
64  {
65  private:
66  constexpr _Derived& _M_derived() noexcept
67  {
68  static_assert(derived_from<_Derived, view_interface<_Derived>>);
69  static_assert(view<_Derived>);
70  return static_cast<_Derived&>(*this);
71  }
72 
73  constexpr const _Derived& _M_derived() const noexcept
74  {
75  static_assert(derived_from<_Derived, view_interface<_Derived>>);
76  static_assert(view<_Derived>);
77  return static_cast<const _Derived&>(*this);
78  }
79 
80  public:
81  constexpr bool
82  empty() requires forward_range<_Derived>
83  { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); }
84 
85  constexpr bool
86  empty() const requires forward_range<const _Derived>
87  { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); }
88 
89  constexpr explicit
90  operator bool() requires requires { ranges::empty(_M_derived()); }
91  { return !ranges::empty(_M_derived()); }
92 
93  constexpr explicit
94  operator bool() const requires requires { ranges::empty(_M_derived()); }
95  { return !ranges::empty(_M_derived()); }
96 
97  constexpr auto
98  data() requires contiguous_iterator<iterator_t<_Derived>>
99  { return to_address(ranges::begin(_M_derived())); }
100 
101  constexpr auto
102  data() const
103  requires range<const _Derived>
104  && contiguous_iterator<iterator_t<const _Derived>>
105  { return to_address(ranges::begin(_M_derived())); }
106 
107  constexpr auto
108  size()
109  requires forward_range<_Derived>
110  && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
111  { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); }
112 
113  constexpr auto
114  size() const
115  requires forward_range<const _Derived>
116  && sized_sentinel_for<sentinel_t<const _Derived>,
117  iterator_t<const _Derived>>
118  { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); }
119 
120  constexpr decltype(auto)
121  front() requires forward_range<_Derived>
122  {
123  __glibcxx_assert(!empty());
124  return *ranges::begin(_M_derived());
125  }
126 
127  constexpr decltype(auto)
128  front() const requires forward_range<const _Derived>
129  {
130  __glibcxx_assert(!empty());
131  return *ranges::begin(_M_derived());
132  }
133 
134  constexpr decltype(auto)
135  back()
136  requires bidirectional_range<_Derived> && common_range<_Derived>
137  {
138  __glibcxx_assert(!empty());
139  return *ranges::prev(ranges::end(_M_derived()));
140  }
141 
142  constexpr decltype(auto)
143  back() const
144  requires bidirectional_range<const _Derived>
145  && common_range<const _Derived>
146  {
147  __glibcxx_assert(!empty());
148  return *ranges::prev(ranges::end(_M_derived()));
149  }
150 
151  template<random_access_range _Range = _Derived>
152  constexpr decltype(auto)
153  operator[](range_difference_t<_Range> __n)
154  { return ranges::begin(_M_derived())[__n]; }
155 
156  template<random_access_range _Range = const _Derived>
157  constexpr decltype(auto)
158  operator[](range_difference_t<_Range> __n) const
159  { return ranges::begin(_M_derived())[__n]; }
160  };
161 
162  namespace __detail
163  {
164  template<typename _From, typename _To>
165  concept __uses_nonqualification_pointer_conversion
166  = is_pointer_v<_From> && is_pointer_v<_To>
167  && !convertible_to<remove_pointer_t<_From>(*)[],
168  remove_pointer_t<_To>(*)[]>;
169 
170  template<typename _From, typename _To>
171  concept __convertible_to_non_slicing = convertible_to<_From, _To>
172  && !__uses_nonqualification_pointer_conversion<decay_t<_From>,
173  decay_t<_To>>;
174 
175  template<typename _Tp>
176  concept __pair_like
177  = !is_reference_v<_Tp> && requires(_Tp __t)
178  {
179  typename tuple_size<_Tp>::type;
180  requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
181  typename tuple_element_t<0, remove_const_t<_Tp>>;
182  typename tuple_element_t<1, remove_const_t<_Tp>>;
183  { get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
184  { get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
185  };
186 
187  template<typename _Tp, typename _Up, typename _Vp>
188  concept __pair_like_convertible_from
189  = !range<_Tp> && __pair_like<_Tp>
190  && constructible_from<_Tp, _Up, _Vp>
191  && __convertible_to_non_slicing<_Up, tuple_element_t<0, _Tp>>
192  && convertible_to<_Vp, tuple_element_t<1, _Tp>>;
193 
194  } // namespace __detail
195 
196  enum class subrange_kind : bool { unsized, sized };
197 
198  /// The ranges::subrange class template
199  template<input_or_output_iterator _It, sentinel_for<_It> _Sent = _It,
200  subrange_kind _Kind = sized_sentinel_for<_Sent, _It>
201  ? subrange_kind::sized : subrange_kind::unsized>
202  requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _It>)
203  class subrange : public view_interface<subrange<_It, _Sent, _Kind>>
204  {
205  private:
206  // XXX: gcc complains when using constexpr here
207  static const bool _S_store_size
208  = _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>;
209 
210  _It _M_begin = _It();
211  [[no_unique_address]] _Sent _M_end = _Sent();
212 
213  using __size_type
214  = __detail::__make_unsigned_like_t<iter_difference_t<_It>>;
215 
216  template<typename, bool = _S_store_size>
217  struct _Size
218  { };
219 
220  template<typename _Tp>
221  struct _Size<_Tp, true>
222  { _Tp _M_size; };
223 
224  [[no_unique_address]] _Size<__size_type> _M_size = {};
225 
226  public:
227  subrange() requires default_initializable<_It> = default;
228 
229  constexpr
230  subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s)
231  requires (!_S_store_size)
232  : _M_begin(std::move(__i)), _M_end(__s)
233  { }
234 
235  constexpr
236  subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s,
237  __size_type __n)
238  requires (_Kind == subrange_kind::sized)
239  : _M_begin(std::move(__i)), _M_end(__s)
240  {
241  if constexpr (_S_store_size)
242  _M_size._M_size = __n;
243  }
244 
245  template<__detail::__not_same_as<subrange> _Rng>
246  requires borrowed_range<_Rng>
247  && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
248  && convertible_to<sentinel_t<_Rng>, _Sent>
249  constexpr
250  subrange(_Rng&& __r) requires _S_store_size && sized_range<_Rng>
251  : subrange(__r, ranges::size(__r))
252  { }
253 
254  template<__detail::__not_same_as<subrange> _Rng>
255  requires borrowed_range<_Rng>
256  && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
257  && convertible_to<sentinel_t<_Rng>, _Sent>
258  constexpr
259  subrange(_Rng&& __r) requires (!_S_store_size)
260  : subrange(ranges::begin(__r), ranges::end(__r))
261  { }
262 
263  template<borrowed_range _Rng>
264  requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
265  && convertible_to<sentinel_t<_Rng>, _Sent>
266  constexpr
267  subrange(_Rng&& __r, __size_type __n)
268  requires (_Kind == subrange_kind::sized)
269  : subrange{ranges::begin(__r), ranges::end(__r), __n}
270  { }
271 
272  template<__detail::__not_same_as<subrange> _PairLike>
273  requires __detail::__pair_like_convertible_from<_PairLike, const _It&,
274  const _Sent&>
275  constexpr
276  operator _PairLike() const
277  { return _PairLike(_M_begin, _M_end); }
278 
279  constexpr _It
280  begin() const requires copyable<_It>
281  { return _M_begin; }
282 
283  [[nodiscard]] constexpr _It
284  begin() requires (!copyable<_It>)
285  { return std::move(_M_begin); }
286 
287  constexpr _Sent end() const { return _M_end; }
288 
289  constexpr bool empty() const { return _M_begin == _M_end; }
290 
291  constexpr __size_type
292  size() const requires (_Kind == subrange_kind::sized)
293  {
294  if constexpr (_S_store_size)
295  return _M_size._M_size;
296  else
297  return __detail::__to_unsigned_like(_M_end - _M_begin);
298  }
299 
300  [[nodiscard]] constexpr subrange
301  next(iter_difference_t<_It> __n = 1) const &
302  requires forward_iterator<_It>
303  {
304  auto __tmp = *this;
305  __tmp.advance(__n);
306  return __tmp;
307  }
308 
309  [[nodiscard]] constexpr subrange
310  next(iter_difference_t<_It> __n = 1) &&
311  {
312  advance(__n);
313  return std::move(*this);
314  }
315 
316  [[nodiscard]] constexpr subrange
317  prev(iter_difference_t<_It> __n = 1) const
318  requires bidirectional_iterator<_It>
319  {
320  auto __tmp = *this;
321  __tmp.advance(-__n);
322  return __tmp;
323  }
324 
325  constexpr subrange&
326  advance(iter_difference_t<_It> __n)
327  {
328  // _GLIBCXX_RESOLVE_LIB_DEFECTS
329  // 3433. subrange::advance(n) has UB when n < 0
330  if constexpr (bidirectional_iterator<_It>)
331  if (__n < 0)
332  {
333  ranges::advance(_M_begin, __n);
334  if constexpr (_S_store_size)
335  _M_size._M_size += __detail::__to_unsigned_like(-__n);
336  return *this;
337  }
338 
339  __glibcxx_assert(__n >= 0);
340  auto __d = __n - ranges::advance(_M_begin, __n, _M_end);
341  if constexpr (_S_store_size)
342  _M_size._M_size -= __detail::__to_unsigned_like(__d);
343  return *this;
344  }
345  };
346 
347  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
348  subrange(_It, _Sent) -> subrange<_It, _Sent>;
349 
350  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
351  subrange(_It, _Sent,
352  __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
353  -> subrange<_It, _Sent, subrange_kind::sized>;
354 
355  template<borrowed_range _Rng>
356  subrange(_Rng&&)
357  -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
358  (sized_range<_Rng>
359  || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
360  ? subrange_kind::sized : subrange_kind::unsized>;
361 
362  template<borrowed_range _Rng>
363  subrange(_Rng&&,
364  __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
365  -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
366 
367  template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>
368  requires (_Num < 2)
369  constexpr auto
370  get(const subrange<_It, _Sent, _Kind>& __r)
371  {
372  if constexpr (_Num == 0)
373  return __r.begin();
374  else
375  return __r.end();
376  }
377 
378  template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>
379  requires (_Num < 2)
380  constexpr auto
381  get(subrange<_It, _Sent, _Kind>&& __r)
382  {
383  if constexpr (_Num == 0)
384  return __r.begin();
385  else
386  return __r.end();
387  }
388 
389  template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
390  subrange_kind _Kind>
391  inline constexpr bool
392  enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;
393 
394  template<range _Range>
395  using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
396  subrange<iterator_t<_Range>>,
397  dangling>;
398 } // namespace ranges
399 
400 // The following ranges algorithms are used by <ranges>, and are defined here
401 // so that <ranges> can avoid including all of <bits/ranges_algo.h>.
402 namespace ranges
403 {
404  struct __find_fn
405  {
406  template<input_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp,
407  typename _Proj = identity>
408  requires indirect_binary_predicate<ranges::equal_to,
409  projected<_Iter, _Proj>, const _Tp*>
410  constexpr _Iter
411  operator()(_Iter __first, _Sent __last,
412  const _Tp& __value, _Proj __proj = {}) const
413  {
414  while (__first != __last
415  && !(std::__invoke(__proj, *__first) == __value))
416  ++__first;
417  return __first;
418  }
419 
420  template<input_range _Range, typename _Tp, typename _Proj = identity>
421  requires indirect_binary_predicate<ranges::equal_to,
422  projected<iterator_t<_Range>, _Proj>,
423  const _Tp*>
424  constexpr borrowed_iterator_t<_Range>
425  operator()(_Range&& __r, const _Tp& __value, _Proj __proj = {}) const
426  {
427  return (*this)(ranges::begin(__r), ranges::end(__r),
428  __value, std::move(__proj));
429  }
430  };
431 
432  inline constexpr __find_fn find{};
433 
434  struct __find_if_fn
435  {
436  template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
437  typename _Proj = identity,
438  indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
439  constexpr _Iter
440  operator()(_Iter __first, _Sent __last,
441  _Pred __pred, _Proj __proj = {}) const
442  {
443  while (__first != __last
444  && !(bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
445  ++__first;
446  return __first;
447  }
448 
449  template<input_range _Range, typename _Proj = identity,
450  indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
451  _Pred>
452  constexpr borrowed_iterator_t<_Range>
453  operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
454  {
455  return (*this)(ranges::begin(__r), ranges::end(__r),
456  std::move(__pred), std::move(__proj));
457  }
458  };
459 
460  inline constexpr __find_if_fn find_if{};
461 
462  struct __find_if_not_fn
463  {
464  template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
465  typename _Proj = identity,
466  indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
467  constexpr _Iter
468  operator()(_Iter __first, _Sent __last,
469  _Pred __pred, _Proj __proj = {}) const
470  {
471  while (__first != __last
472  && (bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
473  ++__first;
474  return __first;
475  }
476 
477  template<input_range _Range, typename _Proj = identity,
478  indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
479  _Pred>
480  constexpr borrowed_iterator_t<_Range>
481  operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
482  {
483  return (*this)(ranges::begin(__r), ranges::end(__r),
484  std::move(__pred), std::move(__proj));
485  }
486  };
487 
488  inline constexpr __find_if_not_fn find_if_not{};
489 
490  template<typename _Iter1, typename _Iter2>
491  struct in_in_result
492  {
493  [[no_unique_address]] _Iter1 in1;
494  [[no_unique_address]] _Iter2 in2;
495 
496  template<typename _IIter1, typename _IIter2>
497  requires convertible_to<const _Iter1&, _IIter1>
498  && convertible_to<const _Iter2&, _IIter2>
499  constexpr
500  operator in_in_result<_IIter1, _IIter2>() const &
501  { return {in1, in2}; }
502 
503  template<typename _IIter1, typename _IIter2>
504  requires convertible_to<_Iter1, _IIter1>
505  && convertible_to<_Iter2, _IIter2>
506  constexpr
507  operator in_in_result<_IIter1, _IIter2>() &&
508  { return {std::move(in1), std::move(in2)}; }
509  };
510 
511  template<typename _Iter1, typename _Iter2>
512  using mismatch_result = in_in_result<_Iter1, _Iter2>;
513 
514  struct __mismatch_fn
515  {
516  template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
517  input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
518  typename _Pred = ranges::equal_to,
519  typename _Proj1 = identity, typename _Proj2 = identity>
520  requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
521  constexpr mismatch_result<_Iter1, _Iter2>
522  operator()(_Iter1 __first1, _Sent1 __last1,
523  _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
524  _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
525  {
526  while (__first1 != __last1 && __first2 != __last2
527  && (bool)std::__invoke(__pred,
528  std::__invoke(__proj1, *__first1),
529  std::__invoke(__proj2, *__first2)))
530  {
531  ++__first1;
532  ++__first2;
533  }
534  return { std::move(__first1), std::move(__first2) };
535  }
536 
537  template<input_range _Range1, input_range _Range2,
538  typename _Pred = ranges::equal_to,
539  typename _Proj1 = identity, typename _Proj2 = identity>
540  requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
541  _Pred, _Proj1, _Proj2>
542  constexpr mismatch_result<iterator_t<_Range1>, iterator_t<_Range2>>
543  operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
544  _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
545  {
546  return (*this)(ranges::begin(__r1), ranges::end(__r1),
547  ranges::begin(__r2), ranges::end(__r2),
548  std::move(__pred),
549  std::move(__proj1), std::move(__proj2));
550  }
551  };
552 
553  inline constexpr __mismatch_fn mismatch{};
554 
555  struct __search_fn
556  {
557  template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
558  forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
559  typename _Pred = ranges::equal_to,
560  typename _Proj1 = identity, typename _Proj2 = identity>
561  requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
562  constexpr subrange<_Iter1>
563  operator()(_Iter1 __first1, _Sent1 __last1,
564  _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
565  _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
566  {
567  if (__first1 == __last1 || __first2 == __last2)
568  return {__first1, __first1};
569 
570  for (;;)
571  {
572  for (;;)
573  {
574  if (__first1 == __last1)
575  return {__first1, __first1};
576  if (std::__invoke(__pred,
577  std::__invoke(__proj1, *__first1),
578  std::__invoke(__proj2, *__first2)))
579  break;
580  ++__first1;
581  }
582  auto __cur1 = __first1;
583  auto __cur2 = __first2;
584  for (;;)
585  {
586  if (++__cur2 == __last2)
587  return {__first1, ++__cur1};
588  if (++__cur1 == __last1)
589  return {__cur1, __cur1};
590  if (!(bool)std::__invoke(__pred,
591  std::__invoke(__proj1, *__cur1),
592  std::__invoke(__proj2, *__cur2)))
593  {
594  ++__first1;
595  break;
596  }
597  }
598  }
599  }
600 
601  template<forward_range _Range1, forward_range _Range2,
602  typename _Pred = ranges::equal_to,
603  typename _Proj1 = identity, typename _Proj2 = identity>
604  requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
605  _Pred, _Proj1, _Proj2>
606  constexpr borrowed_subrange_t<_Range1>
607  operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
608  _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
609  {
610  return (*this)(ranges::begin(__r1), ranges::end(__r1),
611  ranges::begin(__r2), ranges::end(__r2),
612  std::move(__pred),
613  std::move(__proj1), std::move(__proj2));
614  }
615  };
616 
617  inline constexpr __search_fn search{};
618 } // namespace ranges
619 
620  using ranges::get;
621 
622  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
623  struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
624  : integral_constant<size_t, 2>
625  { };
626 
627  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
628  struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
629  { using type = _Iter; };
630 
631  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
632  struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
633  { using type = _Sent; };
634 
635  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
636  struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
637  { using type = _Iter; };
638 
639  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
640  struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
641  { using type = _Sent; };
642 
643 _GLIBCXX_END_NAMESPACE_VERSION
644 } // namespace std
645 #endif // library concepts
646 #endif // C++20
647 #endif // _RANGES_UTIL_H
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
Definition: type_traits:2583
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:90
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:104
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
Definition: valarray:1239
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
Definition: valarray:1217
ISO C++ entities toplevel namespace is std.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
Definition: range_access.h:263
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
Definition: range_access.h:245
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
Definition: range_access.h:290