cppdraft_translate/cppdraft/range/iota/view.md

[range.iota.view]

25 Ranges library [ranges]

25.6 Range factories [range.factories]

25.6.4 Iota view [range.iota]

25.6.4.2 Class template iota_view [range.iota.view]

🔗

namespace std::ranges {templateconcept decrementable = see below; // exposition onlytemplateconcept advanceable = see below; // exposition onlytemplate<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>requires weakly-equality-comparable-with<W, Bound> && copyableclass iota_view : public view_interface<iota_view<W, Bound>> {private:// [range.iota.iterator], class iota_view​::​iteratorstruct iterator; // exposition only// [range.iota.sentinel], class iota_view​::​sentinelstruct sentinel; // exposition only W value_ = W(); // exposition only Bound bound_ = Bound(); // exposition onlypublic: iota_view() requires default_initializable = default; constexpr explicit iota_view(W value); constexpr explicit iota_view(type_identity_t value, type_identity_t bound); constexpr explicit iota_view(iterator first, see below last); constexpr iterator begin() const; constexpr auto end() const; constexpr iterator end() const requires same_as<W, Bound>; constexpr bool empty() const; constexpr auto size() const requires see below; }; template<class W, class Bound>requires (!is-integer-like || !is-integer-like ||(is-signed-integer-like == is-signed-integer-like)) iota_view(W, Bound) -> iota_view<W, Bound>;}

1

#

Let IOTA-DIFF-T(W) be defined as follows:

• (1.1)

  If W is not an integral type, or if it is an integral type and sizeof(iter_difference_t) is greater than sizeof(W), then IOTA-DIFF-T(W) denotes iter_difference_t.

• (1.2)

  Otherwise, IOTA-DIFF-T(W) is a signed integer type of width greater than the width of W if such a type exists.

• (1.3)

  Otherwise, IOTA-DIFF-T(W) is an unspecified signed-integer-like type ([iterator.concept.winc]) of width not less than the width of W. [Note 1: It is unspecified whether this type satisfies weakly_incrementable. — end note]

2

#

The exposition-only decrementable concept is equivalent to:

🔗

template<class I> concept [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") = // exposition only [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<I> && requires(I i) { { --i } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>; { i-- } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I>; };

3

#

When an object is in the domain of both pre- and post-decrement, the object is said to be decrementable.

4

#

Let a and b be equal objects of type I.

I models decrementable only if

• (4.1)

  If a and b are decrementable, then the following are all true:

  • (4.1.1)

addressof(--a) == addressof(a)

• (4.1.2)

bool(a-- == b)

• (4.1.3)

bool(((void)a--, a) == --b)

• (4.1.4)

bool(++(--a) == b).

• (4.2)

  If a and b are incrementable, then bool(--(++a) == b).

5

#

The exposition-only advanceable concept is equivalent to:

🔗

template<class I> concept [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") = // exposition only [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<I> && [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<I> && requires(I i, const I j, const IOTA-DIFF-T(I) n) { { i += n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>; { i -= n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>; I(j + n); I(n + j); I(j - n); { j - j } -> [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<IOTA-DIFF-T(I)>; };

Let D be IOTA-DIFF-T(I).

Let a and b be objects of type I such thatb is reachable from a after n applications of ++a, for some value n of type D.

I models advanceable only if

• (a += n) is equal to b.

• addressof(a += n) is equal to addressof(a).

• I(a + n) is equal to (a += n).

• For any two positive values x and y of type D, if I(a + D(x + y)) is well-defined, then I(a + D(x + y)) is equal to I(I(a + x) + y).

• I(a + D(0)) is equal to a.

• If I(a + D(n - 1)) is well-defined, then I(a + n) is equal to [](I c) { return ++c; }(I(a + D(n - 1))).

• (b += -n) is equal to a.

• (b -= n) is equal to a.

• addressof(b -= n) is equal to addressof(b).

• I(b - n) is equal to (b -= n).

• D(b - a) is equal to n.

• D(a - b) is equal to D(-n).

• bool(a <= b) is true.

🔗

constexpr explicit iota_view(W value);

6

#

Preconditions: Bound denotes unreachable_sentinel_t orBound() is reachable from value.

When W and Bound model totally_ordered_with, then bool(value <= Bound()) is true.

7

#

Effects: Initializes value_ with value.

🔗

constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);

8

#

Preconditions: Bound denotes unreachable_sentinel_t orbound is reachable from value.

When W and Bound model totally_ordered_with, then bool(value <= bound) is true.

9

#

Effects: Initializes value_ with value andbound_ with bound.

🔗

constexpr explicit iota_view(iterator first, see below last);

10

#

Effects: Equivalent to:

• (10.1)

  If same_as<W, Bound> is true,iota_view(first.value_, last.value_).

• (10.2)

  Otherwise, if Bound denotes unreachable_sentinel_t,iota_view(first.value_, last).

• (10.3)

  Otherwise, iota_view(first.value_, last.bound_).

11

#

Remarks: The type of last is:

• (11.1)

  If same_as<W, Bound> is true, iterator.

• (11.2)

  Otherwise, if Bound denotes unreachable_sentinel_t,Bound.

• (11.3)

  Otherwise, sentinel.

🔗

constexpr iterator begin() const;

12

#

Effects: Equivalent to: return iterator{value_};

🔗

constexpr auto end() const;

13

#

Effects: Equivalent to:if constexpr (same_as<Bound, unreachable_sentinel_t>)return unreachable_sentinel;elsereturn sentinel{bound_};

🔗

constexpr iterator end() const requires [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound>;

14

#

Effects: Equivalent to: return iterator{bound_};

🔗

constexpr bool empty() const;

15

#

Effects: Equivalent to: return value_ == bound_;

🔗

constexpr auto size() const requires see below;

16

#

Effects: Equivalent to:if constexpr (is-integer-like && is-integer-like)return (value_ < 0)? ((bound_ < 0)? to-unsigned-like(-value_) - to-unsigned-like(-bound_): to-unsigned-like(bound_) + to-unsigned-like(-value_)): to-unsigned-like(bound_) - to-unsigned-like(value_);elsereturn to-unsigned-like(bound_ - value_);

17

#

Remarks: The expression in the requires-clause is equivalent to:(same_as<W, Bound> && advanceable) || (is-integer-like && is-integer-like) ||sized_sentinel_for<Bound, W>