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

Files changed (1) hide show

tmp/tmp4c5o9n14/{from.md → to.md} +394 -0

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

	@@ -0,0 +1,394 @@

+### Join view <a id="range.join">[[range.join]]</a>
+#### Overview <a id="range.join.overview">[[range.join.overview]]</a>
+`join_view` flattens a `view` of ranges into a `view`.
+The name `views::join` denotes a range adaptor object
+[[range.adaptor.object]]. Given a subexpression `E`, the expression
+`views::join(E)` is expression-equivalent to `join_view{E}`.
+[*Example 1*:
+``` cpp
+vector<string> ss{"hello", " ", "world", "!"};
+join_view greeting{ss};
+for (char ch : greeting)
+  cout << ch;                                   // prints: hello world!
+```
+— *end example*]
+#### Class template `join_view` <a id="range.join.view">[[range.join.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>> &&
+             (is_reference_v<range_reference_t<V>> ||
+              view<range_value_t<V>>)
+  class join_view : public view_interface<join_view<V>> {
+  private:
+    using InnerRng =                    // exposition only
+      range_reference_t<V>;
+    // [range.join.iterator], class template join_view::iterator
+    template<bool Const>
+      struct iterator;                  // exposition only
+    // [range.join.sentinel], class template join_view::sentinel
+    template<bool Const>
+      struct sentinel;                  // exposition only
+    V base_ = V();                      // exposition only
+    views::all_t<InnerRng> inner_ =     // exposition only, present only when !is_reference_v<InnerRng>
+      views::all_t<InnerRng>();
+  public:
+    join_view() = default;
+    constexpr explicit join_view(V base);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() {
+      constexpr bool use_const = simple-view<V> &&
+                                 is_reference_v<range_reference_t<V>>;
+      return iterator<use_const>{*this, ranges::begin(base_)};
+    }
+    constexpr auto begin() const
+    requires input_range<const V> &&
+             is_reference_v<range_reference_t<const V>> {
+      return iterator<true>{*this, ranges::begin(base_)};
+    }
+    constexpr auto end() {
+      if constexpr (forward_range<V> &&
+                    is_reference_v<InnerRng> && forward_range<InnerRng> &&
+                    common_range<V> && common_range<InnerRng>)
+        return iterator<simple-view<V>>{*this, ranges::end(base_)};
+      else
+        return sentinel<simple-view<V>>{*this};
+    }
+    constexpr auto end() const
+    requires input_range<const V> &&
+             is_reference_v<range_reference_t<const V>> {
+      if constexpr (forward_range<const V> &&
+                    is_reference_v<range_reference_t<const V>> &&
+                    forward_range<range_reference_t<const V>> &&
+                    common_range<const V> &&
+                    common_range<range_reference_t<const V>>)
+        return iterator<true>{*this, ranges::end(base_)};
+      else
+        return sentinel<true>{*this};
+    }
+  };
+  template<class R>
+    explicit join_view(R&&) -> join_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit join_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+#### Class template `join_view::iterator` <a id="range.join.iterator">[[range.join.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>> &&
+             (is_reference_v<range_reference_t<V>> ||
+              view<range_value_t<V>>)
+  template<bool Const>
+  struct join_view<V>::iterator {
+  private:
+    using Parent =                                              // exposition only
+      conditional_t<Const, const join_view, join_view>;
+    using Base   = conditional_t<Const, const V, V>;            // exposition only
+    static constexpr bool ref-is-glvalue =                      // exposition only
+      is_reference_v<range_reference_t<Base>>;
+    iterator_t<Base> outer_ = iterator_t<Base>();               // exposition only
+    iterator_t<range_reference_t<Base>> inner_ =                // exposition only
+      iterator_t<range_reference_t<Base>>();
+    Parent* parent_ = nullptr;                                  // exposition only
+    constexpr void satisfy();                                   // exposition only
+  public:
+    using iterator_concept  = see below;
+    using iterator_category = see below;
+    using value_type        = range_value_t<range_reference_t<Base>>;
+    using difference_type   = see below;
+    iterator() = default;
+    constexpr iterator(Parent& parent, iterator_t<Base> outer);
+    constexpr iterator(iterator<!Const> i)
+      requires Const &&
+               convertible_to<iterator_t<V>, iterator_t<Base>> &&
+               convertible_to<iterator_t<InnerRng>,
+                              iterator_t<range_reference_t<Base>>>;
+    constexpr decltype(auto) operator*() const { return *inner_; }
+    constexpr iterator_t<Base> operator->() const
+      requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int)
+      requires ref-is-glvalue && forward_range<Base> &&
+               forward_range<range_reference_t<Base>>;
+    constexpr iterator& operator--()
+      requires ref-is-glvalue && bidirectional_range<Base> &&
+               bidirectional_range<range_reference_t<Base>> &&
+               common_range<range_reference_t<Base>>;
+    constexpr iterator operator--(int)
+      requires ref-is-glvalue && bidirectional_range<Base> &&
+               bidirectional_range<range_reference_t<Base>> &&
+               common_range<range_reference_t<Base>>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires ref-is-glvalue && equality_comparable<iterator_t<Base>> &&
+               equality_comparable<iterator_t<range_reference_t<Base>>>;
+    friend constexpr decltype(auto) iter_move(const iterator& i)
+    noexcept(noexcept(ranges::iter_move(i.inner_))) {
+      return ranges::iter_move(i.inner_);
+    }
+    friend constexpr void iter_swap(const iterator& x, const iterator& y)
+      noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If *`ref-is-glvalue`* is `true` and *`Base`* and
+  `range_reference_t<Base>` each model `bidirectional_range`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if *`ref-is-glvalue`* is `true` and *`Base`* and
+  `range_reference_t<Base>` each model , then `iterator_concept` denotes
+  `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+`iterator::iterator_category` is defined as follows:
+- Let *OUTERC* denote
+  `iterator_traits<iterator_t<Base>>::iterator_category`, and let
+  *INNERC* denote
+  `iterator_traits<iterator_t<range_reference_t<Base>>>::iterator_category`.
+- If *`ref-is-glvalue`* is `true` and *OUTERC* and *INNERC* each model
+  `derived_from<bidirectional_iterator_tag>`, `iterator_category`
+  denotes `bidirectional_iterator_tag`.
+- Otherwise, if *`ref-is-glvalue`* is `true` and *OUTERC* and *INNERC*
+  each model `derived_from<forward_iterator_tag>`, `iterator_category`
+  denotes `forward_iterator_tag`.
+- Otherwise, if *OUTERC* and *INNERC* each model
+  `derived_from<input_iterator_tag>`, `iterator_category` denotes
+  `input_iterator_tag`.
+- Otherwise, `iterator_category` denotes `output_iterator_tag`.
+`iterator::difference_type` denotes the type:
+``` cpp
+common_type_t<
+  range_difference_t<Base>,
+  range_difference_t<range_reference_t<Base>>>
+```
+`join_view` iterators use the *`satisfy`* function to skip over empty
+inner ranges.
+``` cpp
+constexpr void satisfy();       // exposition only
+```
+*Effects:* Equivalent to:
+``` cpp
+auto update_inner = [this](range_reference_t<Base> x) -> auto& {
+  if constexpr (ref-is-glvalue) // x is a reference
+    return x;
+  else
+    return (parent_->inner_ = views::all(std::move(x)));
+};
+for (; outer_ != ranges::end(parent_->base_); ++outer_) {
+  auto& inner = update_inner(*outer_);
+  inner_ = ranges::begin(inner);
+  if (inner_ != ranges::end(inner))
+    return;
+}
+if constexpr (ref-is-glvalue)
+  inner_ = iterator_t<range_reference_t<Base>>();
+```
+``` cpp
+constexpr iterator(Parent& parent, iterator_t<Base> outer);
+```
+*Effects:* Initializes *outer\_* with `std::move(outer)` and *parent\_*
+with `addressof(parent)`; then calls *`satisfy`*`()`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const &&
+           convertible_to<iterator_t<V>, iterator_t<Base>> &&
+           convertible_to<iterator_t<InnerRng>,
+                          iterator_t<range_reference_t<Base>>>;
+```
+*Effects:* Initializes *outer\_* with `std::move(i.`*`outer_`*`)`,
+*inner\_* with `std::move(i.`*`inner_`*`)`, and *parent\_* with
+`i.`*`parent_`*.
+``` cpp
+constexpr iterator_t<Base> operator->() const
+  requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;
+```
+*Effects:* Equivalent to `return `*`inner_`*`;`
+``` cpp
+constexpr iterator& operator++();
+```
+Let *`inner-range`* be:
+- If *ref-is-glvalue* is `true`, `*`*`outer_`*.
+- Otherwise, *`parent_`*`->`*`inner_`*.
+*Effects:* Equivalent to:
+``` cpp
+auto&& inner_rng = inner-range;
+if (++inner_ == ranges::end(inner_rng)) {
+  ++outer_;
+  satisfy();
+}
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to: `++*this`.
+``` cpp
+constexpr iterator operator++(int)
+  requires ref-is-glvalue && forward_range<Base> &&
+           forward_range<range_reference_t<Base>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--()
+  requires ref-is-glvalue && bidirectional_range<Base> &&
+           bidirectional_range<range_reference_t<Base>> &&
+           common_range<range_reference_t<Base>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+if (outer_ == ranges::end(parent_->base_))
+  inner_ = ranges::end(*--outer_);
+while (inner_ == ranges::begin(*outer_))
+  inner_ = ranges::end(*--outer_);
+--inner_;
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int)
+  requires ref-is-glvalue && bidirectional_range<Base> &&
+           bidirectional_range<range_reference_t<Base>> &&
+           common_range<range_reference_t<Base>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires ref-is-glvalue && equality_comparable<iterator_t<Base>> &&
+           equality_comparable<iterator_t<range_reference_t<Base>>>;
+```
+*Effects:* Equivalent to:
+`return x.`*`outer_`*` == y.`*`outer_`*` && x.`*`inner_`*` == y.`*`inner_`*`;`
+``` cpp
+friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
+```
+*Effects:* Equivalent to:
+`return ranges::iter_swap(x.`*`inner_`*`, y.`*`inner_`*`);`
+#### Class template `join_view::sentinel` <a id="range.join.sentinel">[[range.join.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>> &&
+             (is_reference_v<range_reference_t<V>> ||
+              view<range_value_t<V>>)
+  template<bool Const>
+  struct join_view<V>::sentinel {
+  private:
+    using Parent =                                      // exposition only
+      conditional_t<Const, const join_view, join_view>;
+    using Base   = conditional_t<Const, const V, V>;    // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(Parent& parent);
+    constexpr sentinel(sentinel<!Const> s)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(Parent& parent);
+```
+*Effects:* Initializes *end\_* with `ranges::end(parent.`*`base_`*`)`.
+``` cpp
+constexpr sentinel(sentinel<!Const> s)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `std::move(s.`*`end_`*`)`.
+``` cpp
+friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
+```
+*Effects:* Equivalent to: `return x.`*`outer_`*` == y.`*`end_`*`;`

Diff to HTML by rtfpessoa