[range.filter] - C++17 → C++20

Files changed (1) hide show

tmp/tmp7e0s7l8u/{from.md → to.md} +304 -0

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

	@@ -0,0 +1,304 @@

+### Filter view <a id="range.filter">[[range.filter]]</a>
+#### Overview <a id="range.filter.overview">[[range.filter.overview]]</a>
+`filter_view` presents a `view` of the elements of an underlying
+sequence that satisfy a predicate.
+The name `views::filter` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `P`, the
+expression `views::filter(E, P)` is expression-equivalent to
+`filter_view{E, P}`.
+[*Example 1*:
+``` cpp
+vector<int> is{ 0, 1, 2, 3, 4, 5, 6 };
+filter_view evens{is, [](int i) { return 0 == i % 2; }};
+for (int i : evens)
+  cout << i << ' '; // prints: 0 2 4 6
+```
+— *end example*]
+#### Class template `filter_view` <a id="range.filter.view">[[range.filter.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view : public view_interface<filter_view<V, Pred>> {
+  private:
+    V base_ = V();                      // exposition only
+    semiregular-box<Pred> pred_;  // exposition only
+    // [range.filter.iterator], class filter_view::iterator
+    class iterator;                     // exposition only
+    // [range.filter.sentinel], class filter_view::sentinel
+    class sentinel;                     // exposition only
+  public:
+    filter_view() = default;
+    constexpr filter_view(V base, Pred pred);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr const Pred& pred() const;
+    constexpr iterator begin();
+    constexpr auto end() {
+      if constexpr (common_range<V>)
+        return iterator{*this, ranges::end(base_)};
+      else
+        return sentinel{*this};
+    }
+  };
+  template<class R, class Pred>
+    filter_view(R&&, Pred) -> filter_view<views::all_t<R>, Pred>;
+}
+```
+``` cpp
+constexpr filter_view(V base, Pred pred);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and initializes
+*pred\_* with `std::move(pred)`.
+``` cpp
+constexpr const Pred& pred() const;
+```
+*Effects:* Equivalent to: `return *`*`pred_`*`;`
+``` cpp
+constexpr iterator begin();
+```
+*Preconditions:* `pred_.has_value()`.
+*Returns:* `{*this, ranges::find_if(`*`base_`*`, ref(*`*`pred_`*`))}`.
+*Remarks:* In order to provide the amortized constant time complexity
+required by the `range` concept when `filter_view` models
+`forward_range`, this function caches the result within the
+`filter_view` for use on subsequent calls.
+#### Class `filter_view::iterator` <a id="range.filter.iterator">[[range.filter.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view<V, Pred>::iterator {
+  private:
+    iterator_t<V> current_ = iterator_t<V>();   // exposition only
+    filter_view* parent_ = nullptr;             // exposition only
+  public:
+    using iterator_concept  = see below;
+    using iterator_category = see below;
+    using value_type        = range_value_t<V>;
+    using difference_type   = range_difference_t<V>;
+    iterator() = default;
+    constexpr iterator(filter_view& parent, iterator_t<V> current);
+    constexpr iterator_t<V> base() const &
+      requires copyable<iterator_t<V>>;
+    constexpr iterator_t<V> base() &&;
+    constexpr range_reference_t<V> operator*() const;
+    constexpr iterator_t<V> operator->() const
+      requires has-arrow<iterator_t<V>> && copyable<iterator_t<V>>;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int) requires forward_range<V>;
+    constexpr iterator& operator--() requires bidirectional_range<V>;
+    constexpr iterator operator--(int) requires bidirectional_range<V>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires equality_comparable<iterator_t<V>>;
+    friend constexpr range_rvalue_reference_t<V> 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<V>>;
+  };
+}
+```
+Modification of the element a `filter_view::iterator` denotes is
+permitted, but results in undefined behavior if the resulting value does
+not satisfy the filter predicate.
+`iterator::iterator_concept` is defined as follows:
+- If `V` models `bidirectional_range`, then `iterator_concept` denotes
+  `bidirectional_iterator_tag`.
+- Otherwise, if `V` models `forward_range`, then `iterator_concept`
+  denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+`iterator::iterator_category` is defined as follows:
+- Let `C` denote the type
+  `iterator_traits<iterator_t<V>>::iterator_category`.
+- If `C` models `derived_from<bidirectional_iterator_tag>`, then
+  `iterator_category` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `C` models `derived_from<forward_iterator_tag>`, then
+  `iterator_category` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_category` denotes `C`.
+``` cpp
+constexpr iterator(filter_view& parent, iterator_t<V> current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)` and
+*parent\_* with `addressof(parent)`.
+``` cpp
+constexpr iterator_t<V> base() const &
+  requires copyable<iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr iterator_t<V> base() &&;
+```
+*Effects:* Equivalent to: `return std::move(current_);`
+``` cpp
+constexpr range_reference_t<V> operator*() const;
+```
+*Effects:* Equivalent to: `return *`*`current_`*`;`
+``` cpp
+constexpr iterator_t<V> operator->() const
+  requires has-arrow<iterator_t<V>> && copyable<iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ = ranges::find_if(std::move(++current_), ranges::end(parent_->base_),
+                           ref(*parent_->pred_));
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to `++*this`.
+``` cpp
+constexpr iterator operator++(int) requires forward_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+do
+  --current_;
+while (!invoke(*parent_->pred_, *current_));
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires equality_comparable<iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
+``` cpp
+friend constexpr range_rvalue_reference_t<V> 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<V>>;
+```
+*Effects:* Equivalent to
+`ranges::iter_swap(x.`*`current_`*`, y.`*`current_`*`)`.
+#### Class `filter_view::sentinel` <a id="range.filter.sentinel">[[range.filter.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view<V, Pred>::sentinel {
+  private:
+    sentinel_t<V> end_ = sentinel_t<V>();       // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(filter_view& parent);
+    constexpr sentinel_t<V> base() const;
+    friend constexpr bool operator==(const iterator& x, const sentinel& y);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(filter_view& parent);
+```
+*Effects:* Initializes *end\_* with `ranges::end(parent.`*`base_`*`)`.
+``` cpp
+constexpr sentinel_t<V> base() const;
+```
+*Effects:* Equivalent to: `return `*`end_`*`;`
+``` cpp
+friend constexpr bool operator==(const iterator& x, const sentinel& y);
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`end_`*`;`

Diff to HTML by rtfpessoa