[range.concat.iterator] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpoctr487i/{from.md → to.md} +577 -0

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

	@@ -0,0 +1,577 @@

+#### Class `concat_view::iterator` <a id="range.concat.iterator">[[range.concat.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range... Views>
+    requires (view<Views> && ...) && (sizeof...(Views) > 0) &&
+              concatable<Views...>
+  template<bool Const>
+  class concat_view<Views...>::iterator {
+  public:
+    using iterator_category = see below;                                // not always present
+    using iterator_concept = see below;
+    using value_type = concat-value-t<maybe-const<Const, Views>...>;
+    using difference_type = common_type_t<range_difference_t<maybe-const<Const, Views>>...>;
+  private:
+    using base-iter =                                                       // exposition only
+      variant<iterator_t<maybe-const<Const, Views>>...>;
+    maybe-const<Const, concat_view>* parent_ = nullptr;                     // exposition only
+    base-iter it_;                                                          // exposition only
+    template<size_t N>
+      constexpr void satisfy();                                             // exposition only
+    template<size_t N>
+      constexpr void prev();                                                // exposition only
+    template<size_t N>
+      constexpr void advance-fwd(difference_type offset,                    // exposition only
+                                 difference_type steps);
+    template<size_t N>
+      constexpr void advance-bwd(difference_type offset,                    // exposition only
+                                 difference_type steps);
+    template<class... Args>
+      constexpr explicit iterator(maybe-const<Const, concat_view>* parent,  // exposition only
+                                  Args&&... args)
+        requires constructible_from<base-iter, Args&&...>;
+  public:
+    iterator() = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+    constexpr decltype(auto) operator*() const;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int)
+      requires all-forward<Const, Views...>;
+    constexpr iterator& operator--()
+      requires concat-is-bidirectional<Const, Views...>;
+    constexpr iterator operator--(int)
+      requires concat-is-bidirectional<Const, Views...>;
+    constexpr iterator& operator+=(difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    constexpr iterator& operator-=(difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    constexpr decltype(auto) operator[](difference_type n) const
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+    friend constexpr bool operator==(const iterator& it, default_sentinel_t);
+    friend constexpr bool operator<(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator>(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator<=(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator>=(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires (all-random-access<Const, Views...> &&
+                (three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...));
+    friend constexpr iterator operator+(const iterator& it, difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr iterator operator+(difference_type n, const iterator& it)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr iterator operator-(const iterator& it, difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
+      requires see below;
+    friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
+      requires see below;
+    friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below);
+    friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)
+      requires see below;
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If `concat-is-random-access<Const, Views...>` is modeled, then
+  `iterator_concept` denotes `random_access_iterator_tag`.
+- Otherwise, if `concat-is-bidirectional<Const, Views...>` is modeled,
+  then `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `all-forward<Const, Views...>` is modeled, then
+  `iterator_concept` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+The member *typedef-name* `iterator_category` is defined if and only if
+`all-forward<Const, Views...>` is modeled. In that case,
+`iterator::iterator_category` is defined as follows:
+- If `is_reference_v<concat-reference-t<maybe-const<Const, Views>...>>`
+  is `false`, then `iterator_category` denotes `input_iterator_tag`.
+- Otherwise, let `Cs` denote the pack of types
+  `iterator_traits<iterator_t<maybe-const<Const, Views>>>::iterator_category...`.
+  - If
+    `(derived_from<Cs, random_access_iterator_tag> && ...) && concat-is-random-ac-{cess}<Const, Views...>`
+    is `true`, `iterator_category` denotes `random_access_iterator_tag`.
+  - Otherwise, if
+    `(derived_from<Cs, bidirectional_iterator_tag> && ...) && concat-is-{bidirectional}<Const, Views...>`
+    is `true`, `iterator_category` denotes `bidirectional_iterator_tag`.
+  - Otherwise, if `(derived_from<Cs, forward_iterator_tag> && ...)` is
+    `true`, `iterator_category` denotes `forward_iterator_tag`.
+  - Otherwise, `iterator_category` denotes `input_iterator_tag`.
+``` cpp
+template<size_t N>
+  constexpr void satisfy();
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (N < (sizeof...(Views) - 1)) {
+  if (std::get<N>(it_) == ranges::end(std::get<N>(parent_->views_))) {
+    it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_)));
+    satisfy<N + 1>();
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void prev();
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (N == 0) {
+  --std::get<0>(it_);
+} else {
+  if (std::get<N>(it_) == ranges::begin(std::get<N>(parent_->views_))) {
+    it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_)));
+    prev<N - 1>();
+  } else {
+    --std::get<N>(it_);
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void advance-fwd(difference_type offset, difference_type steps);
+```
+*Effects:* Equivalent to:
+``` cpp
+using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
+if constexpr (N == sizeof...(Views) - 1) {
+  std::get<N>(it_) += static_cast<underlying_diff_type>(steps);
+} else {
+  auto n_size = ranges::distance(std::get<N>(parent_->views_));
+  if (offset + steps < n_size) {
+    std::get<N>(it_) += static_cast<underlying_diff_type>(steps);
+  } else {
+    it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_)));
+    advance-fwd<N + 1>(0, offset + steps - n_size);
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void advance-bwd(difference_type offset, difference_type steps);
+```
+*Effects:* Equivalent to:
+``` cpp
+using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
+if constexpr (N == 0) {
+  std::get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+} else {
+  if (offset >= steps) {
+    std::get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+  } else {
+    auto prev_size = ranges::distance(std::get<N - 1>(parent_->views_));
+    it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_)));
+    advance-bwd<N - 1>(prev_size, steps - offset);
+  }
+}
+```
+``` cpp
+template<class... Args>
+  constexpr explicit iterator(maybe-const<Const, concat_view>* parent,
+                              Args&&... args)
+    requires constructible_from<base-iter, Args&&...>;
+```
+*Effects:* Initializes *parent\_* with `parent`, and initializes *it\_*
+with `std::forward<Args>(args)...`.
+``` cpp
+constexpr iterator(iterator<!Const> it)
+  requires Const &&
+           (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Initializes *parent\_* with `it.`*`parent_`*, and let i be
+`it.`*`it_`*`.index()`, initializes *it\_* with
+*`base-iter`*`(in_place_index<`i`>, std::get<`i`>(std::move(it.`*`it_`*`)))`.
+``` cpp
+constexpr decltype(auto) operator*() const;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+using reference = concat-reference-t<maybe-const<Const, Views>...>;
+return std::visit([](auto&& it) -> reference { return *it; },
+                  it_);
+```
+``` cpp
+constexpr iterator& operator++();
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+++std::get<i>(it_);
+satisfy<i>();
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+++*this;
+```
+``` cpp
+constexpr iterator operator++(int)
+  requires all-forward<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--()
+  requires concat-is-bidirectional<Const, Views...>;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+prev<i>();
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int)
+  requires concat-is-bidirectional<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+if (n > 0) {
+  advance-fwd<i>(std::get<i>(it_) - ranges::begin(std::get<i>(parent_->views_)), n);
+} else if (n < 0) {
+  advance-bwd<i>(std::get<i>(it_) - ranges::begin(std::get<i>(parent_->views_)), -n);
+}
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+*this += -n;
+return *this;
+```
+``` cpp
+constexpr decltype(auto) operator[](difference_type n) const
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return *((*this) + n);
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Equivalent to:
+``` cpp
+return x.it_ == y.it_;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& it, default_sentinel_t);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+constexpr auto last_idx = sizeof...(Views) - 1;
+return it.it_.index() == last_idx &&
+       std::get<last_idx>(it.it_) == ranges::end(std::get<last_idx>(it.parent_->views_));
+```
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires (all-random-access<Const, Views...> &&
+            (three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...));
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+Let op be the operator.
+*Effects:* Equivalent to:
+``` cpp
+return x.it_ op y.it_;
+```
+``` cpp
+friend constexpr iterator operator+(const iterator& it, difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = it;
+temp += n;
+return temp;
+```
+``` cpp
+friend constexpr iterator operator+(difference_type n, const iterator& it)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return it + n;
+```
+``` cpp
+friend constexpr iterator operator-(const iterator& it, difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = it;
+temp -= n;
+return temp;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Let i_`x` denote `x.`*`it_`*`.index()` and i_`y` denote
+`y.`*`it_`*`.index()`.
+- If i_`x`` > `i_`y`, let d_`y` be
+  `ranges::distance(std::get<`i_`y``>(y.`*`it_`*`), ranges::end(std::get<`i_`y``>(y.`*`parent_`*`->`*`views_`*`)))`,
+  d_`x` be
+  `ranges::distance(ranges::begin(std::get<`i_`x``>(x.`*`parent_`*`->`*`views_`*`)), std::get<`i_`x``>(x.`*`it_`*`))`.
+  Let s denote the sum of the sizes of all the ranges
+  `std::get<`i`>(x.`*`parent_`*`->`*`views_`*`)` for every integer i in
+  the range \[i_`y`` + 1`, i_`x`) if there is any, and `0` otherwise, of
+  type `difference_type`, equivalent to:
+  ``` cpp
+  return $d_y$ + s + $d_x$;
+  ```
+- otherwise, if i_`x`` < `i_`y` is `true`, equivalent to:
+  ``` cpp
+  return -(y - x);
+  ```
+- otherwise, equivalent to:
+  ``` cpp
+  return std::get<$i_x$>(x.it_) - std::get<$i_y$>(y.it_);
+  ```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
+  requires see below;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i_`x` denote `x.`*`it_`*`.index()`, d_`x` be
+`ranges::distance(std::get<`i_`x``>(x.`*`it_`*`), ranges::end(std::get<`i_`x``>(x.`*`parent_`*`->`*`views_`*`)))`.
+Let s denote the sum of the sizes of all the ranges
+`std::get<`i`>(x.`*`parent_`*`->`*`views_`*`)` for every integer i in
+the range \[i_`x`` + 1`, `sizeof...(Views)`) if there is any, and `0`
+otherwise, of type difference_type, equivalent to:
+``` cpp
+return -($d_x$ + s);
+```
+*Remarks:* Let `Fs` be the pack that consists of all elements of `Views`
+except the first element, the expression in the *requires-clause* is
+equivalent to:
+``` cpp
+(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+                    iterator_t<maybe-const<Const, Views>>> && ...) &&
+(sized_range<maybe-const<Const, Fs>> && ...)
+```
+``` cpp
+friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
+  requires see below;
+```
+*Effects:* Equivalent to:
+``` cpp
+return -(x - default_sentinel);
+```
+*Remarks:* Let `Fs` be the pack that consists of all elements of `Views`
+except the first element, the expression in the *requires-clause* is
+equivalent to:
+``` cpp
+(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+                    iterator_t<maybe-const<Const, Views>>> && ...) &&
+(sized_range<maybe-const<Const, Fs>> && ...)
+```
+``` cpp
+friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+return std::visit([](const auto& i)
+                  -> concat-rvalue-reference-t<maybe-const<Const, Views>...> {
+                    return ranges::iter_move(i);
+                  },
+                  it.it_);
+```
+*Remarks:* The exception specification is equivalent to:
+``` cpp
+((is_nothrow_invocable_v<decltype(ranges::iter_move),
+                         const iterator_t<maybe-const<Const, Views>>&> &&
+  is_nothrow_convertible_v<range_rvalue_reference_t<maybe-const<Const, Views>>,
+                           concat-rvalue-reference-t<maybe-const<Const, Views>...>>) &&
+ ...)
+```
+``` cpp
+friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)
+  requires see below;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Equivalent to:
+``` cpp
+std::visit([&](const auto& it1, const auto& it2) {
+             if constexpr (is_same_v<decltype(it1), decltype(it2)>) {
+               ranges::iter_swap(it1, it2);
+             } else {
+               ranges::swap(*x, *y);
+             }
+           },
+           x.it_, y.it_);
+```
+*Remarks:* The exception specification is equivalent to
+``` cpp
+(noexcept(ranges::swap(*x, *y)) && ... && noexcept(ranges::iter_swap(its, its)))
+```
+where `its` is a pack of lvalues of type
+`const iterator_t<`*`maybe-const`*`<Const, Views>>` respectively.
+The expression in the *requires-clause* is equivalent to
+``` cpp
+swappable_with<iter_reference_t<iterator>, iter_reference_t<iterator>> &&
+(... && indirectly_swappable<iterator_t<maybe-const<Const, Views>>>)
+```

Diff to HTML by rtfpessoa