25 Ranges library [ranges]

25.7 Range adaptors [range.adaptors]

25.7.35 To input view [range.to.input]

25.7.35.1 Overview [range.to.input.overview]

1
#
to_input_view presents a view of an underlying sequence as an input-only non-common range.
[Note 1: 
This is useful to avoid overhead that can be necessary to provide support for the operations needed for greater iterator strength.
— end note]
2
#
The name views​::​to_input denotes a range adaptor object ([range.adaptor.object]).
Let E be an expression and let T be decltype((E)).
The expression views​::​to_input(E) is expression-equivalent to:

25.7.35.2 Class template to_input_view [range.to.input.view]

template<input_range V> requires view<V> class to_input_view : public view_interface<to_input_view<V>> { V base_ = V(); // exposition only template<bool Const> class iterator; // exposition only public: to_input_view() requires default_initializable<V> = default; constexpr explicit to_input_view(V base); constexpr V base() const & requires copy_constructible<V> { return base_; } constexpr V base() && { return std::move(base_); } constexpr auto begin() requires (!simple-view<V>); constexpr auto begin() const requires range<const V>; constexpr auto end() requires (!simple-view<V>); constexpr auto end() const requires range<const V>; constexpr auto size() requires sized_range<V>; constexpr auto size() const requires sized_range<const V>; }; template<class R> to_input_view(R&&) -> to_input_view<views::all_t<R>>;
🔗
constexpr explicit to_input_view(V base);
1
#
Effects: Initializes base_ with std​::​move(base).
🔗
constexpr auto begin() requires (!simple-view<V>);
2
#
Effects: Equivalent to: return iterator<false>(ranges​::​begin(base_));
🔗
constexpr auto begin() const requires range<const V>;
3
#
Effects: Equivalent to: return iterator<true>(ranges​::​begin(base_));
🔗
constexpr auto end() requires (!simple-view<V>); constexpr auto end() const requires range<const V>;
4
#
Effects: Equivalent to: return ranges​::​end(base_);
🔗
constexpr auto size() requires sized_range<V>; constexpr auto size() const requires sized_range<const V>;
5
#
Effects: Equivalent to: return ranges​::​size(base_);

25.7.35.3 Class template to_input_view​::​iterator [range.to.input.iterator]

namespace std::ranges { template<input_range V> requires view<V> template<bool Const> class to_input_view<V>::iterator { using Base = maybe-const<Const, V>; // exposition only iterator_t<Base> current_ = iterator_t<Base>(); // exposition only constexpr explicit iterator(iterator_t<Base> current); // exposition only public: using difference_type = range_difference_t<Base>; using value_type = range_value_t<Base>; using iterator_concept = input_iterator_tag; iterator() requires default_initializable<iterator_t<Base>> = default; iterator(iterator&&) = default; iterator& operator=(iterator&&) = default; constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>; constexpr iterator_t<Base> base() &&; constexpr const iterator_t<Base>& base() const & noexcept; constexpr decltype(auto) operator*() const { return *current_; } constexpr iterator& operator++(); constexpr void operator++(int); friend constexpr bool operator==(const iterator& x, const sentinel_t<Base>& y); friend constexpr difference_type operator-(const sentinel_t<Base>& y, const iterator& x) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>; friend constexpr difference_type operator-(const iterator& x, const sentinel_t<Base>& y) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>; friend constexpr range_rvalue_reference_t<Base> iter_move(const iterator& i) noexcept(noexcept(ranges::iter_move(i.current_))); friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(noexcept(ranges::iter_swap(x.current_, y.current_))) requires indirectly_swappable<iterator_t<Base>>; }; }
🔗
constexpr explicit iterator(iterator_t<Base> current);
1
#
Effects: Initializes current_ with std​::​move(current).
🔗
constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
2
#
Effects: Initializes current_ with std​::​move(i.current_).
🔗
constexpr iterator_t<Base> base() &&;
3
#
Returns: std​::​move(current_).
🔗
constexpr const iterator_t<Base>& base() const & noexcept;
4
#
Returns: current_.
🔗
constexpr iterator& operator++();
5
#
Effects: Equivalent to: ++current_; return *this;
🔗
constexpr void operator++(int);
6
#
Effects: Equivalent to: ++*this;
🔗
friend constexpr bool operator==(const iterator& x, const sentinel_t<Base>& y);
7
#
Returns: x.current_ == y.
🔗
friend constexpr difference_type operator-(const sentinel_t<Base>& y, const iterator& x) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
8
#
Returns: y - x.current_.
🔗
friend constexpr difference_type operator-(const iterator& x, const sentinel_t<Base>& y) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
9
#
Returns: x.current_ - y.
🔗
friend constexpr range_rvalue_reference_t<Base> iter_move(const iterator& i) noexcept(noexcept(ranges::iter_move(i.current_)));
10
#
Effects: Equivalent to: return ranges​::​iter_move(i.current_);
🔗
friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(noexcept(ranges::iter_swap(x.current_, y.current_))) requires indirectly_swappable<iterator_t<Base>>;
11
#
Effects: Equivalent to: ranges​::​iter_swap(x.current_, y.current_);