[range.lazy.split.inner] (original) (raw)

25 Ranges library [ranges]

25.7 Range adaptors [range.adaptors]

25.7.16 Lazy split view [range.lazy.split]

25.7.16.5 Class template lazy_split_view​::​inner-iterator [range.lazy.split.inner]

namespace std::ranges { template<input_range V, forward_range Pattern> requires view<V> && view<Pattern> && indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> && (forward_range<V> || tiny-range<Pattern>) template<bool Const> struct lazy_split_view<V, Pattern>::inner-iterator { private: using Base = maybe-const<Const, V>; outer-iterator<Const> i_ = outer-iterator<Const>(); bool incremented_ = false; public: using iterator_concept = typename outer-iterator<Const>::iterator_concept;using iterator_category = see below; using value_type = range_value_t<_Base_>;using difference_type = range_difference_t<_Base_>;inner-iterator() = default;constexpr explicit inner-iterator(outer-iterator<Const> i);constexpr const iterator_t<_Base_>& base() const & noexcept;constexpr iterator_t<_Base_> base() && requires forward_range<V>;constexpr decltype(auto) operator*() const { return *i_.current; } constexpr inner-iterator& operator++();constexpr decltype(auto) operator++(int) { if constexpr (forward_range<_Base_>) { auto tmp = *this;++*this;return tmp;} else ++*this;} friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y) requires forward_range<_Base_>;friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);friend constexpr decltype(auto) iter_move(const inner-iterator& i) noexcept(noexcept(ranges::iter_move(i.i_.current))) { return ranges::iter_move(i.i_.current);} friend constexpr void iter_swap(const inner-iterator& x, const inner-iterator& y) noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current))) requires indirectly_swappable<iterator_t<_Base_>>;};}

If Base does not model forward_rangethere is no member iterator_category.

Otherwise, the typedef-name iterator_category denotes:

• forward_iterator_tag ifiterator_traits<iterator_t<_Base_>>​::​iterator_category modelsderived_from<forward_iterator_tag>;
• otherwise, iterator_traits<iterator_t<_Base_>>​::​iterator_category.

constexpr explicit _inner-iterator_(_outer-iterator_<Const> i);

Effects: Initializes i_ with std​::​move(i).

constexpr const iterator_t<_Base_>& base() const & noexcept;

Effects: Equivalent to: return i_.current;

Effects: Equivalent to: return std​::​move(i_.current);

constexpr _inner-iterator_& operator++();

Effects: Equivalent to:incremented_ = true;if constexpr (<_Base_>) { if constexpr (Pattern::size() == 0) { return *this;} } ++i_.current;return *this;

friend constexpr bool operator==(const _inner-iterator_& x, const _inner-iterator_& y) requires [forward_range](range.refinements#concept:forward%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;

Effects: Equivalent to: return x.i_.current == y.i_.current;

friend constexpr bool operator==(const _inner-iterator_& x, default_sentinel_t);

Effects: Equivalent to:auto [pcur, pend] = subrange{x.i_._parent__->pattern_};auto end = ranges::end(x.i_._parent__->base_);if constexpr (tiny-range<Pattern>) { const auto & cur = x.i_.current;if (cur == end) return true;if (pcur == pend) return x.incremented_;return *cur == *pcur;} else { auto cur = x.i_.current;if (cur == end) return true;if (pcur == pend) return x.incremented_;do { if (*cur != *pcur) return false;if (++pcur == pend) return true;} while (++cur != end);return false;}

friend constexpr void iter_swap(const _inner-iterator_& x, const _inner-iterator_& y) noexcept(noexcept(ranges::iter_swap(x._i_._current_, y._i_._current_))) requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly%5Fswappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<_Base_>>;

Effects: Equivalent toranges​::​iter_swap(x.i_.current, y.i_.current).