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

Files changed (1) hide show

tmp/tmp4rn0jxyv/{from.md → to.md} +251 -0

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

	@@ -0,0 +1,251 @@

+#### Class template `enumerate_view::iterator` <a id="range.enumerate.iterator">[[range.enumerate.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires range-with-movable-references<V>
+  template<bool Const>
+  class enumerate_view<V>::iterator {
+    using Base = maybe-const<Const, V>;                         // exposition only
+  public:
+    using iterator_category = input_iterator_tag;
+    using iterator_concept = see below;
+    using difference_type = range_difference_t<Base>;
+    using value_type = tuple<difference_type, range_value_t<Base>>;
+  private:
+    using reference-type =                                      // exposition only
+      tuple<difference_type, range_reference_t<Base>>;
+    iterator_t<Base> current_ = iterator_t<Base>();             // exposition only
+    difference_type pos_ = 0;                                   // exposition only
+    constexpr explicit
+      iterator(iterator_t<Base> current, difference_type pos);  // exposition only
+  public:
+    iterator() requires default_initializable<iterator_t<Base>> = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+    constexpr const iterator_t<Base>& base() const & noexcept;
+    constexpr iterator_t<Base> base() &&;
+    constexpr difference_type index() const noexcept;
+    constexpr auto operator*() const {
+      return reference-type(pos_, *current_);
+    }
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int) requires forward_range<Base>;
+    constexpr iterator& operator--() requires bidirectional_range<Base>;
+    constexpr iterator operator--(int) requires bidirectional_range<Base>;
+    constexpr iterator& operator+=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr iterator& operator-=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr auto operator[](difference_type n) const
+      requires random_access_range<Base>
+    { return reference-type(pos_ + n, current_[n]); }
+    friend constexpr bool operator==(const iterator& x, const iterator& y) noexcept;
+    friend constexpr strong_ordering operator<=>(const iterator& x, const iterator& y) noexcept;
+    friend constexpr iterator operator+(const iterator& x, difference_type y)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator+(difference_type x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator-(const iterator& x, difference_type y)
+      requires random_access_range<Base>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y);
+    friend constexpr auto iter_move(const iterator& i)
+      noexcept(noexcept(ranges::iter_move(i.current_)) &&
+               is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>) {
+      return tuple<difference_type,
+                   range_rvalue_reference_t<Base>>(i.pos_, ranges::iter_move(i.current_));
+    }
+  };
+}
+```
+The member *typedef-name* `iterator::iterator_concept` is defined as
+follows:
+- If *`Base`* models `random_access_range`, then `iterator_concept`
+  denotes `random_access_iterator_tag`.
+- Otherwise, if *`Base`* models `bidirectional_range`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if *`Base`* models `forward_range`, then `iterator_concept`
+  denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+``` cpp
+constexpr explicit iterator(iterator_t<Base> current, difference_type pos);
+```
+*Effects:* Initializes *current\_* with `std::move(current)` and *pos\_*
+with `pos`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+```
+*Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`
+and *pos\_* with `i.`*`pos_`*.
+``` cpp
+constexpr const iterator_t<Base>& base() const & noexcept;
+```
+*Effects:* Equivalent to: `return `*`current_`*`;`
+``` cpp
+constexpr iterator_t<Base> base() &&;
+```
+*Effects:* Equivalent to: `return std::move(`*`current_`*`);`
+``` cpp
+constexpr difference_type index() const noexcept;
+```
+*Effects:* Equivalent to: `return `*`pos_`*`;`
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+++pos_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to `++*this`.
+``` cpp
+constexpr iterator operator++(int) requires forward_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = *this;
+++*this;
+return temp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+--current_;
+--pos_;
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = *this;
+--*this;
+return temp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ += n;
+pos_ += n;
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ -= n;
+pos_ -= n;
+return *this;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y) noexcept;
+```
+*Effects:* Equivalent to: `return x.`*`pos_`*` == y.`*`pos_`*`;`
+``` cpp
+friend constexpr strong_ordering operator<=>(const iterator& x, const iterator& y) noexcept;
+```
+*Effects:* Equivalent to: `return x.`*`pos_`*` <=> y.`*`pos_`*`;`
+``` cpp
+friend constexpr iterator operator+(const iterator& x, difference_type y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = x;
+temp += y;
+return temp;
+```
+``` cpp
+friend constexpr iterator operator+(difference_type x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return y + x;`
+``` cpp
+friend constexpr iterator operator-(const iterator& x, difference_type y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = x;
+temp -= y;
+return temp;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y);
+```
+*Effects:* Equivalent to: `return x.`*`pos_`*` - y.`*`pos_`*`;`

Diff to HTML by rtfpessoa