[range.to.input] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp2irwv4q0/{from.md → to.md} +228 -0

tmp/tmp2irwv4q0/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,228 @@

+### To input view <a id="range.to.input">[[range.to.input]]</a>
+#### Overview <a id="range.to.input.overview">[[range.to.input.overview]]</a>
+`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*]
+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:
+- `views::all(E)` if `T` models `input_range`, does not satisfy
+  `common_range`, and does not satisfy `forward_range`.
+- Otherwise, `to_input_view(E)`.
+#### Class template `to_input_view` <a id="range.to.input.view">[[range.to.input.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V>
+  class to_input_view : public view_interface<to_input_view<V>> {
+    V base_ = V();                        // exposition only
+    // [range.to.input.iterator], class template to_input_view::iterator
+    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>;
+    constexpr auto reserve_hint() requires approximately_sized_range<V>;
+    constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+  };
+  template<class R>
+    to_input_view(R&&) -> to_input_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit to_input_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+``` cpp
+constexpr auto begin() requires (!simple-view<V>);
+```
+*Effects:* Equivalent to:
+`return `*`iterator`*`<false>(ranges::begin(`*`base_`*`));`
+``` cpp
+constexpr auto begin() const requires range<const V>;
+```
+*Effects:* Equivalent to:
+`return `*`iterator`*`<true>(ranges::begin(`*`base_`*`));`
+``` cpp
+constexpr auto end() requires (!simple-view<V>);
+constexpr auto end() const requires range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::end(`*`base_`*`);`
+``` cpp
+constexpr auto size() requires sized_range<V>;
+constexpr auto size() const requires sized_range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::size(`*`base_`*`);`
+``` cpp
+constexpr auto reserve_hint() requires approximately_sized_range<V>;
+constexpr auto reserve_hint() const requires approximately_sized_range<const V>;
+```
+*Effects:* Equivalent to: `return ranges::reserve_hint(`*`base_`*`);`
+#### Class template `to_input_view::iterator` <a id="range.to.input.iterator">[[range.to.input.iterator]]</a>
+``` cpp
+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>>;
+  };
+}
+```
+``` cpp
+constexpr explicit iterator(iterator_t<Base> current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+```
+*Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`.
+``` cpp
+constexpr iterator_t<Base> base() &&;
+```
+*Returns:* `std::move(`*`current_`*`)`.
+``` cpp
+constexpr const iterator_t<Base>& base() const & noexcept;
+```
+*Returns:* *current\_*.
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to: `++*this;`
+``` cpp
+friend constexpr bool operator==(const iterator& x, const sentinel_t<Base>& y);
+```
+*Returns:* `x.`*`current_`*` == y`.
+``` cpp
+friend constexpr difference_type operator-(const sentinel_t<Base>& y, const iterator& x)
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Returns:* `y - x.`*`current_`*.
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const sentinel_t<Base>& y)
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Returns:* `x.`*`current_`*` - y`.
+``` cpp
+friend constexpr range_rvalue_reference_t<Base> iter_move(const iterator& i)
+  noexcept(noexcept(ranges::iter_move(i.current_)));
+```
+*Effects:* Equivalent to: `return ranges::iter_move(i.`*`current_`*`);`
+``` cpp
+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>>;
+```
+*Effects:* Equivalent to:
+`ranges::iter_swap(x.`*`current_`*`, y.`*`current_`*`);`

Diff to HTML by rtfpessoa