14#ifndef RANGES_V3_ITERATOR_BASIC_ITERATOR_HPP
15#define RANGES_V3_ITERATOR_BASIC_ITERATOR_HPP
29#include <range/v3/utility/addressof.hpp>
33#include <range/v3/utility/static_const.hpp>
35#include <range/v3/detail/prologue.hpp>
38RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS
50 noexcept(std::is_nothrow_default_constructible<T>::value)
51 requires default_constructible<T>)
56 noexcept(std::is_nothrow_move_constructible<T>::value)
57 requires move_constructible<T>)
61 constexpr explicit CPP_ctor(
basic_mixin)(T
const & t)(
62 noexcept(std::is_nothrow_copy_constructible<T>::value)
63 requires copy_constructible<T>)
74 template<
typename Cur>
75 using cursor_reference_t =
76 decltype(range_access::read(std::declval<Cur const &>()));
79 template<
typename Cur>
80 auto cursor_move(Cur
const & cur,
int) ->
decltype(range_access::move(cur));
81 template<
typename Cur>
84 template<
typename Cur>
85 using cursor_rvalue_reference_t =
86 decltype(detail::cursor_move(std::declval<Cur const &>(), 42));
91 template<
typename Derived,
typename Head>
92 struct proxy_reference_conversion
95 noexcept(noexcept(Head(Head(std::declval<Derived const &>().read_()))))
97 return Head(
static_cast<Derived
const *
>(
this)->read_());
102 template<
typename Cur,
bool IsReadable>
103 struct cursor_traits_
110 using value_t_ = private_;
111 using reference_t_ = private_;
112 using rvalue_reference_t_ = private_;
116 template<
typename Cur>
117 struct cursor_traits_<Cur, true>
119 using value_t_ = range_access::cursor_value_t<Cur>;
120 using reference_t_ = cursor_reference_t<Cur>;
121 using rvalue_reference_t_ = cursor_rvalue_reference_t<Cur>;
124 using R1 = reference_t_;
125 using R2 = common_reference_t<reference_t_, value_t_ &>;
126 using R3 = common_reference_t<reference_t_, rvalue_reference_t_>;
137 template<
typename Cur>
138 using cursor_traits = cursor_traits_<Cur, (bool)readable_cursor<Cur>>;
140 template<
typename Cur>
141 using cursor_value_t =
typename cursor_traits<Cur>::value_t_;
143 template<
typename Cur,
bool IsReadable>
144 struct basic_proxy_reference_;
145 template<
typename Cur>
146 using basic_proxy_reference =
147 basic_proxy_reference_<Cur, (bool)readable_cursor<Cur>>;
152 template<
typename Cur,
bool IsReadable >
153 struct RANGES_EMPTY_BASES basic_proxy_reference_
158 typename cursor_traits<Cur>::common_refs,
159 meta::bind_front<meta::quote<proxy_reference_conversion>,
160 basic_proxy_reference_<Cur, IsReadable>>>>
164 template<
typename,
bool>
165 friend struct basic_proxy_reference_;
166 template<
typename,
typename>
167 friend struct proxy_reference_conversion;
168 using typename cursor_traits<Cur>::value_t_;
169 using typename cursor_traits<Cur>::reference_t_;
170 using typename cursor_traits<Cur>::rvalue_reference_t_;
171 static_assert((bool)common_reference_with<value_t_ &, reference_t_>,
172 "Your readable and writable cursor must have a value type and "
173 "a reference type that share a common reference type. See the "
174 "ranges::common_reference type trait.");
177 constexpr reference_t_ read_() const noexcept(
178 noexcept(reference_t_(range_access::read(std::declval<Cur const &>()))))
180 return range_access::read(*cur_);
183 constexpr void write_(T && t)
const
185 range_access::write(*cur_, (T &&) t);
188 basic_proxy_reference_() =
default;
189 basic_proxy_reference_(basic_proxy_reference_
const &) =
default;
190 template(
typename OtherCur)(
191 requires convertible_to<OtherCur *, Cur *>)
192 constexpr basic_proxy_reference_(
193 basic_proxy_reference<OtherCur>
const & that) noexcept
196 constexpr explicit basic_proxy_reference_(Cur & cur) noexcept
200 constexpr auto operator=(basic_proxy_reference_ && that)
201 -> CPP_ret(basic_proxy_reference_ &)(
202 requires readable_cursor<Cur>)
207 constexpr auto operator=(basic_proxy_reference_
const & that)
208 -> CPP_ret(basic_proxy_reference_ &)(
209 requires readable_cursor<Cur>)
211 this->write_(that.read_());
215 constexpr auto operator=(basic_proxy_reference_ && that)
const
216 -> CPP_ret(basic_proxy_reference_
const &)(
217 requires readable_cursor<Cur>)
222 constexpr auto operator=(basic_proxy_reference_
const & that)
const
223 -> CPP_ret(basic_proxy_reference_
const &)(
224 requires readable_cursor<Cur>)
226 this->write_(that.read_());
229 template(
typename OtherCur)(
230 requires readable_cursor<OtherCur> AND
231 writable_cursor<Cur, cursor_reference_t<OtherCur>>)
232 constexpr basic_proxy_reference_ &
233 operator=(basic_proxy_reference<OtherCur> && that)
237 template(
typename OtherCur)(
238 requires readable_cursor<OtherCur> AND
239 writable_cursor<Cur, cursor_reference_t<OtherCur>>)
240 constexpr basic_proxy_reference_ &
241 operator=(basic_proxy_reference<OtherCur>
const & that)
243 this->write_(that.read_());
246 template(
typename OtherCur)(
247 requires readable_cursor<OtherCur> AND
248 writable_cursor<Cur, cursor_reference_t<OtherCur>>)
249 constexpr basic_proxy_reference_
const &
250 operator=(basic_proxy_reference<OtherCur> && that)
const
254 template(
typename OtherCur)(
255 requires readable_cursor<OtherCur> AND
256 writable_cursor<Cur, cursor_reference_t<OtherCur>>)
257 constexpr basic_proxy_reference_
const &
258 operator=(basic_proxy_reference<OtherCur>
const & that)
const
260 this->write_(that.read_());
263 template(
typename T)(
264 requires writable_cursor<Cur, T>)
265 constexpr basic_proxy_reference_ & operator=(T && t)
267 this->write_((T &&) t);
270 template(
typename T)(
271 requires writable_cursor<Cur, T>)
272 constexpr basic_proxy_reference_
const & operator=(T && t)
const
274 this->write_((T &&) t);
279 template(
typename Cur,
bool IsReadable)(
280 requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
281 constexpr bool operator==(basic_proxy_reference_<Cur, IsReadable>
const & x,
282 cursor_value_t<Cur>
const & y)
284 return x.read_() == y;
286 template(
typename Cur,
bool IsReadable)(
287 requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
288 constexpr bool operator!=(basic_proxy_reference_<Cur, IsReadable>
const & x,
289 cursor_value_t<Cur>
const & y)
293 template(
typename Cur,
bool IsReadable)(
294 requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
295 constexpr bool operator==(cursor_value_t<Cur>
const & x,
296 basic_proxy_reference_<Cur, IsReadable>
const & y)
298 return x == y.read_();
300 template(
typename Cur,
bool IsReadable)(
301 requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
302 constexpr bool operator!=(cursor_value_t<Cur>
const & x,
303 basic_proxy_reference_<Cur, IsReadable>
const & y)
307 template(
typename Cur,
bool IsReadable)(
308 requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
309 constexpr bool operator==(basic_proxy_reference_<Cur, IsReadable>
const & x,
310 basic_proxy_reference_<Cur, IsReadable>
const & y)
312 return x.read_() == y.read_();
314 template(
typename Cur,
bool IsReadable)(
315 requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
316 constexpr bool operator!=(basic_proxy_reference_<Cur, IsReadable>
const & x,
317 basic_proxy_reference_<Cur, IsReadable>
const & y)
322 template<
typename Cur>
323 using cpp20_iter_cat_of_t =
327 contiguous_cursor<Cur>,
330 random_access_cursor<Cur>,
331 std::random_access_iterator_tag,
333 bidirectional_cursor<Cur>,
334 std::bidirectional_iterator_tag,
337 std::forward_iterator_tag,
338 std::input_iterator_tag>>>>>;
343 template(
typename C)(
344 concept (cpp17_input_cursor_)(C),
347 !range_access::single_pass_t<uncvref_t<C>>::value ||
348 (move_constructible<range_access::cursor_value_t<C>> &&
349 constructible_from<range_access::cursor_value_t<C>, cursor_reference_t<C>>)
355 CPP_concept cpp17_input_cursor =
357 sentinel_for_cursor<C, C> &&
358 CPP_concept_ref(cpp17_input_cursor_, C);
362 template(
typename C)(
363 concept (cpp17_forward_cursor_)(C),
364 std::is_reference<cursor_reference_t<C>>::value
370 CPP_concept cpp17_forward_cursor =
372 CPP_concept_ref(cpp17_forward_cursor_, C);
375 template<
typename Category,
typename Base =
void>
376 struct with_iterator_category : Base
378 using iterator_category = Category;
381 template<
typename Category>
382 struct with_iterator_category<Category>
384 using iterator_category = Category;
387 template<
typename Cur>
388 using cpp17_iter_cat_of_t =
390 cpp17_input_cursor<Cur>,
392 random_access_cursor<Cur>,
393 std::random_access_iterator_tag,
395 bidirectional_cursor<Cur>,
396 std::bidirectional_iterator_tag,
398 cpp17_forward_cursor<Cur>,
399 std::forward_iterator_tag,
400 std::input_iterator_tag>>>>;
402 template<
typename Cur,
typename =
void>
403 struct readable_iterator_associated_types_base : range_access::mixin_base_t<Cur>
405 readable_iterator_associated_types_base() =
default;
406 using range_access::mixin_base_t<Cur>::mixin_base_t;
407 readable_iterator_associated_types_base(Cur && cur)
408 : range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
410 readable_iterator_associated_types_base(Cur
const & cur)
411 : range_access::mixin_base_t<Cur>(cur)
415 template<
typename Cur>
416 struct readable_iterator_associated_types_base<
417 Cur, always_<void, cpp17_iter_cat_of_t<Cur>>>
418 : range_access::mixin_base_t<Cur>
420 using iterator_category = cpp17_iter_cat_of_t<Cur>;
421 readable_iterator_associated_types_base() =
default;
422 using range_access::mixin_base_t<Cur>::mixin_base_t;
423 readable_iterator_associated_types_base(Cur && cur)
424 : range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
426 readable_iterator_associated_types_base(Cur
const & cur)
427 : range_access::mixin_base_t<Cur>(cur)
431 template<
typename Cur,
bool IsReadable >
432 struct iterator_associated_types_base_ : range_access::mixin_base_t<Cur>
436 using iter_reference_t = basic_proxy_reference<Cur>;
437 using const_reference_t = basic_proxy_reference<Cur const>;
440 using reference = void;
441 using difference_type = range_access::cursor_difference_t<Cur>;
443 iterator_associated_types_base_() =
default;
444 using range_access::mixin_base_t<Cur>::mixin_base_t;
445 iterator_associated_types_base_(Cur && cur)
446 : range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
448 iterator_associated_types_base_(Cur
const & cur)
449 : range_access::mixin_base_t<Cur>(cur)
453 template<
typename Cur>
454 using cursor_arrow_t =
decltype(range_access::arrow(std::declval<Cur const &>()));
456 template<
typename Cur>
457 struct iterator_associated_types_base_<Cur, true>
458 : readable_iterator_associated_types_base<Cur>
462 using iter_reference_t =
464 basic_proxy_reference<Cur const>,
466 basic_proxy_reference<Cur>, cursor_reference_t<Cur>>>;
467 using const_reference_t =
469 basic_proxy_reference<Cur const>, cursor_reference_t<Cur>>;
472 using difference_type = range_access::cursor_difference_t<Cur>;
473 using value_type = range_access::cursor_value_t<Cur>;
474 using reference = iter_reference_t;
475 using iterator_concept = cpp20_iter_cat_of_t<Cur>;
478 (bool)has_cursor_arrow<Cur>,
480 std::add_pointer<reference>>>;
481 using common_reference = common_reference_t<reference, value_type &>;
483 iterator_associated_types_base_() =
default;
484 using readable_iterator_associated_types_base<
485 Cur>::readable_iterator_associated_types_base;
486 iterator_associated_types_base_(Cur && cur)
487 : readable_iterator_associated_types_base<Cur>(static_cast<Cur &&>(cur))
489 iterator_associated_types_base_(Cur
const & cur)
490 : readable_iterator_associated_types_base<Cur>(cur)
494 template<
typename Cur>
495 using iterator_associated_types_base =
496 iterator_associated_types_base_<Cur, (bool)readable_cursor<Cur>>;
498 template<
typename Value>
499 struct postfix_increment_proxy
506 constexpr postfix_increment_proxy(T && t)
507 : cache_(static_cast<T &&>(t))
509 constexpr Value
const &
operator*() const noexcept
517#if RANGES_BROKEN_CPO_LOOKUP
518 namespace _basic_iterator_
526 template<
typename Cur>
528 : detail::iterator_associated_types_base<Cur>
529#if RANGES_BROKEN_CPO_LOOKUP
530 ,
private _basic_iterator_::adl_hook<basic_iterator<Cur>>
537 using base_t = detail::iterator_associated_types_base<Cur>;
538 using mixin_t = range_access::mixin_base_t<Cur>;
539 static_assert((bool)detail::cursor<Cur>,
"");
540 using assoc_types_ = detail::iterator_associated_types_base<Cur>;
541 using typename assoc_types_::const_reference_t;
542 using typename assoc_types_::iter_reference_t;
543 constexpr Cur & pos()
noexcept
545 return this->mixin_t::basic_mixin::get();
547 constexpr Cur
const & pos()
const noexcept
549 return this->mixin_t::basic_mixin::get();
553 using typename assoc_types_::difference_type;
555 template(
typename OtherCur)(
556 requires (!same_as<OtherCur, Cur>) AND convertible_to<OtherCur, Cur> AND
557 constructible_from<mixin_t, OtherCur>)
559 : base_t{std::move(that.pos())}
562 using base_t::base_t;
565 : base_t(
static_cast<Cur &&
>(cur))
572 template(
typename OtherCur)(
573 requires (!same_as<OtherCur, Cur>) AND convertible_to<OtherCur, Cur>)
576 pos() = std::move(that.pos());
581 constexpr auto operator*()
const
582 noexcept(
noexcept(range_access::read(std::declval<Cur const &>())))
583 -> CPP_ret(const_reference_t)(
584 requires detail::readable_cursor<Cur> &&
585 (!detail::is_writable_cursor_v<Cur>))
587 return range_access::read(pos());
590 constexpr auto operator*()
591 noexcept(
noexcept(iter_reference_t{std::declval<Cur &>()}))
592 -> CPP_ret(iter_reference_t)(
593 requires detail::has_cursor_next<Cur> &&
594 detail::is_writable_cursor_v<Cur>)
596 return iter_reference_t{pos()};
599 constexpr auto operator*()
const
600 noexcept(
noexcept(const_reference_t{std::declval<Cur const &>()}))
601 -> CPP_ret(const_reference_t)(
602 requires detail::has_cursor_next<Cur> &&
603 detail::is_writable_cursor_v<Cur const>)
605 return const_reference_t{pos()};
608 constexpr auto operator*()
noexcept
610 requires (!detail::has_cursor_next<Cur>))
616 template(
typename C = Cur)(
617 requires detail::has_cursor_arrow<C>)
618 constexpr detail::cursor_arrow_t<C> operator-> ()
const
619 noexcept(
noexcept(range_access::arrow(std::declval<C const &>())))
621 return range_access::arrow(pos());
625 template(
typename C = Cur)(
626 requires (!detail::has_cursor_arrow<C>) AND detail::readable_cursor<C> AND
627 std::is_lvalue_reference<const_reference_t>::value AND
628 same_as<typename detail::iterator_associated_types_base<C>::value_type,
629 uncvref_t<const_reference_t>>)
630 constexpr std::add_pointer_t<const_reference_t> operator-> ()
const
631 noexcept(
noexcept(*std::declval<basic_iterator const &>()))
633 return detail::addressof(**
this);
637 constexpr auto operator++()
639 requires detail::has_cursor_next<Cur>)
641 range_access::next(pos());
645 constexpr auto operator++()
noexcept
647 requires (!detail::has_cursor_next<Cur>))
661 template(
typename A = assoc_types_,
typename V =
typename A::value_type)(
662 requires constructible_from<V, typename A::reference> AND
663 move_constructible<V>)
664 constexpr auto post_increment_(std::true_type,
int)
665 -> detail::postfix_increment_proxy<V>
667 detail::postfix_increment_proxy<V> p{**
this};
671 constexpr void post_increment_(std::true_type,
long)
678 constexpr auto operator++(
int)
680 return this->post_increment_(
meta::bool_ < detail::input_cursor<Cur> &&
681 !detail::forward_cursor<Cur>> {},
686 constexpr auto operator--()
688 requires detail::bidirectional_cursor<Cur>)
690 range_access::prev(pos());
694 constexpr auto operator--(
int)
696 requires detail::bidirectional_cursor<Cur>)
703 constexpr auto operator+=(difference_type n)
705 requires detail::random_access_cursor<Cur>)
707 range_access::advance(pos(), n);
711 constexpr auto operator-=(difference_type n)
713 requires detail::random_access_cursor<Cur>)
715 range_access::advance(pos(), (difference_type)-n);
719 constexpr auto operator[](difference_type n)
const
720 -> CPP_ret(const_reference_t)(
721 requires detail::random_access_cursor<Cur>)
726#if !RANGES_BROKEN_CPO_LOOKUP
729 template<
typename C = Cur>
730 friend constexpr auto iter_move(
basic_iterator const & it)
noexcept(
731 noexcept(range_access::move(std::declval<C const &>())))
732 -> CPP_broken_friend_ret(
733 decltype(range_access::move(std::declval<C const &>())))(
734 requires same_as<C, Cur> && detail::input_cursor<Cur>)
736 return range_access::move(it.pos());
741 template(
typename Cur,
typename Cur2)(
742 requires detail::sentinel_for_cursor<Cur2, Cur>)
746 return range_access::equal(range_access::pos(left), range_access::pos(right));
748 template(
typename Cur,
typename Cur2)(
749 requires detail::sentinel_for_cursor<Cur2, Cur>)
750 constexpr bool operator!=(basic_iterator<Cur>
const & left,
751 basic_iterator<Cur2>
const & right)
753 return !(left == right);
755 template(
typename Cur,
typename S)(
756 requires detail::sentinel_for_cursor<S, Cur>)
757 constexpr bool operator==(basic_iterator<Cur>
const & left,
760 return range_access::equal(range_access::pos(left), right);
762 template(
typename Cur,
typename S)(
763 requires detail::sentinel_for_cursor<S, Cur>)
764 constexpr bool operator!=(basic_iterator<Cur>
const & left,
767 return !(left == right);
769 template(
typename S,
typename Cur)(
770 requires detail::sentinel_for_cursor<S, Cur>)
771 constexpr bool operator==(S
const & left,
772 basic_iterator<Cur>
const & right)
774 return right == left;
776 template(
typename S,
typename Cur)(
777 requires detail::sentinel_for_cursor<S, Cur>)
778 constexpr bool operator!=(S
const & left,
779 basic_iterator<Cur>
const & right)
781 return right != left;
784 template(
typename Cur)(
785 requires detail::random_access_cursor<Cur>)
786 constexpr basic_iterator<Cur>
787 operator+(basic_iterator<Cur> left,
typename basic_iterator<Cur>::difference_type n)
792 template(
typename Cur)(
793 requires detail::random_access_cursor<Cur>)
794 constexpr basic_iterator<Cur>
795 operator+(
typename basic_iterator<Cur>::difference_type n, basic_iterator<Cur> right)
800 template(
typename Cur)(
801 requires detail::random_access_cursor<Cur>)
802 constexpr basic_iterator<Cur>
803 operator-(basic_iterator<Cur> left,
typename basic_iterator<Cur>::difference_type n)
808 template(
typename Cur2,
typename Cur)(
809 requires detail::sized_sentinel_for_cursor<Cur2, Cur>)
810 constexpr typename basic_iterator<Cur>::difference_type
811 operator-(basic_iterator<Cur2>
const & left, basic_iterator<Cur>
const & right)
813 return range_access::distance_to(range_access::pos(right),
814 range_access::pos(left));
816 template(
typename S,
typename Cur)(
817 requires detail::sized_sentinel_for_cursor<S, Cur>)
818 constexpr typename basic_iterator<Cur>::difference_type
819 operator-(S
const & left, basic_iterator<Cur>
const & right)
821 return range_access::distance_to(range_access::pos(right), left);
823 template(
typename Cur,
typename S)(
824 requires detail::sized_sentinel_for_cursor<S, Cur>)
825 constexpr typename basic_iterator<Cur>::difference_type
826 operator-(basic_iterator<Cur>
const & left, S
const & right)
828 return -(right - left);
831 template(
typename Left,
typename Right)(
832 requires detail::sized_sentinel_for_cursor<Right, Left>)
833 constexpr bool operator<(basic_iterator<Left>
const & left,
834 basic_iterator<Right>
const & right)
836 return 0 < (right - left);
838 template(
typename Left,
typename Right)(
839 requires detail::sized_sentinel_for_cursor<Right, Left>)
840 constexpr bool operator<=(basic_iterator<Left>
const & left,
841 basic_iterator<Right>
const & right)
843 return 0 <= (right - left);
845 template(
typename Left,
typename Right)(
846 requires detail::sized_sentinel_for_cursor<Right, Left>)
847 constexpr bool operator>(basic_iterator<Left>
const & left,
848 basic_iterator<Right>
const & right)
850 return (right - left) < 0;
852 template(
typename Left,
typename Right)(
853 requires detail::sized_sentinel_for_cursor<Right, Left>)
854 constexpr bool operator>=(basic_iterator<Left>
const & left,
855 basic_iterator<Right>
const & right)
857 return (right - left) <= 0;
860#if RANGES_BROKEN_CPO_LOOKUP
861 namespace _basic_iterator_
865 template<
typename Cur>
866 constexpr auto iter_move(basic_iterator<Cur>
const & it)
noexcept(
867 noexcept(range_access::move(std::declval<Cur const &>())))
868 -> CPP_broken_friend_ret(
869 decltype(range_access::move(std::declval<Cur const &>())))(
870 requires detail::input_cursor<Cur>)
872 return range_access::move(range_access::pos(it));
880 template<
typename Cur>
881 constexpr Cur & operator()(basic_iterator<Cur> & it)
const noexcept
883 return range_access::pos(it);
885 template<
typename Cur>
886 constexpr Cur
const & operator()(basic_iterator<Cur>
const & it)
const noexcept
888 return range_access::pos(it);
890 template<
typename Cur>
891 constexpr Cur operator()(basic_iterator<Cur> && it)
const
892 noexcept(std::is_nothrow_move_constructible<Cur>::value)
894 return range_access::pos(std::move(it));
899 RANGES_INLINE_VARIABLE(get_cursor_fn, get_cursor)
907 template<
typename Cur,
typename U,
template<
typename>
class TQual,
908 template<
typename>
class UQual>
909 struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur, true>, U,
911 : basic_common_reference<::ranges::detail::cursor_reference_t<Cur>, U, TQual, UQual>
913 template<
typename T,
typename Cur,
template<
typename>
class TQual,
914 template<
typename>
class UQual>
915 struct basic_common_reference<T, ::ranges::detail::basic_proxy_reference_<Cur, true>,
917 : basic_common_reference<T, ::ranges::detail::cursor_reference_t<Cur>, TQual, UQual>
919 template<
typename Cur1,
typename Cur2,
template<
typename>
class TQual,
920 template<
typename>
class UQual>
921 struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur1, true>,
922 ::ranges::detail::basic_proxy_reference_<Cur2, true>,
924 : basic_common_reference<::ranges::detail::cursor_reference_t<Cur1>,
925 ::ranges::detail::cursor_reference_t<Cur2>, TQual, UQual>
929 template<
typename Cur,
typename U>
930 struct common_type<::ranges::detail::basic_proxy_reference_<Cur, true>, U>
931 : common_type<::ranges::range_access::cursor_value_t<Cur>, U>
933 template<
typename T,
typename Cur>
934 struct common_type<T, ::ranges::detail::basic_proxy_reference_<Cur, true>>
935 : common_type<T, ::ranges::range_access::cursor_value_t<Cur>>
937 template<
typename Cur1,
typename Cur2>
938 struct common_type<::ranges::detail::basic_proxy_reference_<Cur1, true>,
939 ::ranges::detail::basic_proxy_reference_<Cur2, true>>
940 : common_type<::ranges::range_access::cursor_value_t<Cur1>,
941 ::ranges::range_access::cursor_value_t<Cur2>>
945#if RANGES_CXX_VER > RANGES_CXX_STD_17
946RANGES_DIAGNOSTIC_PUSH
947RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
948RANGES_BEGIN_NAMESPACE_STD
949RANGES_BEGIN_NAMESPACE_VERSION
950 template<
typename,
typename,
template <
typename>
class,
template<
typename>
class>
951 struct basic_common_reference;
954 template<
typename Cur,
typename U,
template<
typename>
class TQual,
955 template<
typename>
class UQual>
956 struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur, true>, U,
958 : basic_common_reference<::ranges::detail::cursor_reference_t<Cur>, U, TQual, UQual>
960 template<
typename T,
typename Cur,
template<
typename>
class TQual,
961 template<
typename>
class UQual>
962 struct basic_common_reference<T, ::ranges::detail::basic_proxy_reference_<Cur, true>,
964 : basic_common_reference<T, ::ranges::detail::cursor_reference_t<Cur>, TQual, UQual>
966 template<
typename Cur1,
typename Cur2,
template<
typename>
class TQual,
967 template<
typename>
class UQual>
968 struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur1, true>,
969 ::ranges::detail::basic_proxy_reference_<Cur2, true>,
971 : basic_common_reference<::ranges::detail::cursor_reference_t<Cur1>,
972 ::ranges::detail::cursor_reference_t<Cur2>, TQual, UQual>
975 template<
typename...>
979 template<
typename Cur,
typename U>
980 struct common_type<::ranges::detail::basic_proxy_reference_<Cur, true>, U>
981 : common_type<::ranges::range_access::cursor_value_t<Cur>, U>
983 template<
typename T,
typename Cur>
984 struct common_type<T, ::ranges::detail::basic_proxy_reference_<Cur, true>>
985 : common_type<T, ::ranges::range_access::cursor_value_t<Cur>>
987 template<
typename Cur1,
typename Cur2>
988 struct common_type<::ranges::detail::basic_proxy_reference_<Cur1, true>,
989 ::ranges::detail::basic_proxy_reference_<Cur2, true>>
990 : common_type<::ranges::range_access::cursor_value_t<Cur1>,
991 ::ranges::range_access::cursor_value_t<Cur2>>
993RANGES_END_NAMESPACE_VERSION
994RANGES_END_NAMESPACE_STD
1003 template<
typename Cur,
bool IsReadable>
1004 struct std_iterator_traits_
1006 using difference_type =
1007 typename iterator_associated_types_base<Cur>::difference_type;
1008 using value_type = void;
1009 using reference = void;
1010 using pointer = void;
1011 using iterator_category = std::output_iterator_tag;
1012 using iterator_concept = std::output_iterator_tag;
1015 template<
typename Cur>
1016 struct std_iterator_traits_<Cur, true> : iterator_associated_types_base<Cur>
1019 template<
typename Cur>
1020 using std_iterator_traits = std_iterator_traits_<Cur, (bool)readable_cursor<Cur>>;
1027 template<
typename Cur>
1029 : ::ranges::detail::std_iterator_traits<Cur>
1034RANGES_DIAGNOSTIC_POP
1036#include <range/v3/detail/epilogue.hpp>
meta::_t< detail::inherit_< L > > inherit
A type that inherits from all the types in the list.
Definition meta.hpp:3114
meta::if_c< std::is_reference< R >::value, meta::_t< std::remove_reference< R > > &&, detail::decay_t< R > > move_t
Definition move.hpp:59
std::integral_constant< bool, B > bool_
An integral constant wrapper for bool.
Definition meta.hpp:168
typename T::type _t
Type alias for T::type.
Definition meta.hpp:141
_t< detail::_if_< list< Args... > > > if_
Select one type or another depending on a compile-time Boolean.
Definition meta.hpp:1247
typename detail::_cond< If >::template invoke< Then, Else > conditional_t
Select one type or another depending on a compile-time Boolean.
Definition meta.hpp:1148
Point operator*(double s, const Point &a)
Multiply point by scalar.
Definition shapes.h:250
Point operator-(const Point &a, const Point &b)
Subtract two points_ component-wise.
Definition shapes.h:244
Definition basic_iterator.hpp:532
Definition basic_iterator.hpp:47