[range.zip.iterator] - C++20 → C++23

Files changed (1) hide show

tmp/tmpetmmoeox/{from.md → to.md} +301 -0

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

	@@ -0,0 +1,301 @@

+#### Class template `zip_view::iterator` <a id="range.zip.iterator">[[range.zip.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<bool Const, class... Views>
+    concept all-random-access =                 // exposition only
+      (random_access_range<maybe-const<Const, Views>> && ...);
+  template<bool Const, class... Views>
+    concept all-bidirectional =                 // exposition only
+      (bidirectional_range<maybe-const<Const, Views>> && ...);
+  template<bool Const, class... Views>
+    concept all-forward =                       // exposition only
+      (forward_range<maybe-const<Const, Views>> && ...);
+  template<input_range... Views>
+    requires (view<Views> && ...) && (sizeof...(Views) > 0)
+  template<bool Const>
+  class zip_view<Views...>::iterator {
+    tuple<iterator_t<maybe-const<Const, Views>>...> current_;       // exposition only
+    constexpr explicit iterator(tuple<iterator_t<maybe-const<Const, Views>>...>);
+                                                                            // exposition only
+  public:
+    using iterator_category = input_iterator_tag;                           // not always present
+    using iterator_concept  = see below;
+    using value_type = tuple<range_value_t<maybe-const<Const, Views>>...>;
+    using difference_type = common_type_t<range_difference_t<maybe-const<Const, Views>>...>;
+    iterator() = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+    constexpr auto operator*() const;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int) requires all-forward<Const, Views...>;
+    constexpr iterator& operator--() requires all-bidirectional<Const, Views...>;
+    constexpr iterator operator--(int) requires all-bidirectional<Const, Views...>;
+    constexpr iterator& operator+=(difference_type x)
+      requires all-random-access<Const, Views...>;
+    constexpr iterator& operator-=(difference_type x)
+      requires all-random-access<Const, Views...>;
+    constexpr auto operator[](difference_type n) const
+      requires all-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 auto operator<=>(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr iterator operator+(const iterator& i, difference_type n)
+      requires all-random-access<Const, Views...>;
+    friend constexpr iterator operator+(difference_type n, const iterator& i)
+      requires all-random-access<Const, Views...>;
+    friend constexpr iterator operator-(const iterator& i, difference_type n)
+      requires all-random-access<Const, Views...>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+      requires (sized_sentinel_for<iterator_t<maybe-const<Const, Views>>,
+                                   iterator_t<maybe-const<Const, Views>>> && ...);
+    friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+    friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+      requires (indirectly_swappable<iterator_t<maybe-const<Const, Views>>> && ...);
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If `all-random-access<Const, Views...>` is modeled, then
+  `iterator_concept` denotes `random_access_iterator_tag`.
+- Otherwise, if `all-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`.
+`iterator::iterator_category` is present if and only if
+`all-forward<Const, Views...>` is modeled.
+If the invocation of any non-const member function of *`iterator`* exits
+via an exception, the iterator acquires a singular value.
+``` cpp
+constexpr explicit iterator(tuple<iterator_t<maybe-const<Const, Views>>...> current);
+```
+*Effects:* Initializes *current\_* with `std::move(current)`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+```
+*Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`.
+``` cpp
+constexpr auto operator*() const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return tuple-transform([](auto& i) -> decltype(auto) { return *i; }, current_);
+```
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+tuple-for-each([](auto& i) { ++i; }, current_);
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to `++*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 all-bidirectional<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+tuple-for-each([](auto& i) { --i; }, current_);
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires all-bidirectional<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type x)
+  requires all-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+tuple-for-each([&]<class I>(I& i) { i += iter_difference_t<I>(x); }, current_);
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type x)
+  requires all-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+tuple-for-each([&]<class I>(I& i) { i -= iter_difference_t<I>(x); }, current_);
+return *this;
+```
+``` cpp
+constexpr auto operator[](difference_type n) const
+  requires all-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return tuple-transform([&]<class I>(I& i) -> decltype(auto) {
+  return i[iter_difference_t<I>(n)];
+}, current_);
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+```
+*Returns:*
+- `x.`*`current_`*` == y.`*`current_`* if
+  `all-bidirectional<Const, Views...>` is `true`.
+- Otherwise, `true` if there exists an integer
+  0 ≤ i < `sizeof...(Views)` such that
+  `bool(std::get<`i`>(x.`*`current_`*`) == std::get<`i`>(y.`*`current_`*`))`
+  is `true`. \[*Note 1*: This allows `zip_view` to model `common_range`
+  when all constituent views model `common_range`. — *end note*]
+- Otherwise, `false`.
+``` cpp
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+```
+*Returns:* `x.`*`current_`*` <=> y.`*`current_`*.
+``` cpp
+friend constexpr iterator operator+(const iterator& i, difference_type n)
+  requires all-random-access<Const, Views...>;
+friend constexpr iterator operator+(difference_type n, const iterator& i)
+  requires all-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto r = i;
+r += n;
+return r;
+```
+``` cpp
+friend constexpr iterator operator-(const iterator& i, difference_type n)
+  requires all-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto r = i;
+r -= n;
+return r;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires (sized_sentinel_for<iterator_t<maybe-const<Const, Views>>,
+                               iterator_t<maybe-const<Const, Views>>> && ...);
+```
+Let *`DIST`*`(`i`)` be
+`difference_type(std::get<`i`>(x.`*`current_`*`) - std::get<`i`>(y.`*`current_`*`))`.
+*Returns:* The value with the smallest absolute value among
+*`DIST`*`(`n`)` for all integers 0 ≤ n < `sizeof...(Views)`.
+``` cpp
+friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+```
+*Effects:* Equivalent to:
+``` cpp
+return tuple-transform(ranges::iter_move, i.current_);
+```
+*Remarks:* The exception specification is equivalent to:
+``` cpp
+(noexcept(ranges::iter_move(declval<const iterator_t<maybe-const<Const,
+                                                            Views>>&>())) && ...) &&
+(is_nothrow_move_constructible_v<range_rvalue_reference_t<maybe-const<Const,
+                                                                      Views>>> && ...)
+```
+``` cpp
+friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+  requires (indirectly_swappable<iterator_t<maybe-const<Const, Views>>> && ...);
+```
+*Effects:* For every integer 0 ≤ i < `sizeof...(Views)`, performs:
+``` cpp
+ranges::iter_swap(std::get<i>(l.current_), std::get<i>(r.current_))
+```
+*Remarks:* The exception specification is equivalent to the logical of
+the following expressions:
+``` cpp
+noexcept(ranges::iter_swap(std::get<i>(l.current_), std::get<i>(r.current_)))
+```
+for every integer 0 ≤ i < `sizeof...(Views)`.

Diff to HTML by rtfpessoa