[iterator.cust] (original) (raw)

23 Iterators library [iterators]

23.3 Iterator requirements [iterator.requirements]

23.3.3 Customization points [iterator.cust]

23.3.3.1 ranges​::​iter_­move [iterator.cust.move]

The expression ranges​::​iter_­move(E) for a subexpression E is expression-equivalent to:

• iter_­move(E), ifE has class or enumeration type anditer_­move(E) is a well-formed expression when treated as an unevaluated operand, with overload resolution performed in a context that does not include a declaration of ranges​::​iter_­movebut does include the declaration
  void iter_move();
• Otherwise, if the expression *E is well-formed:
  • if *E is an lvalue, std​::​move(*E);
  • otherwise, *E.
• Otherwise, ranges​::​iter_­move(E) is ill-formed.
  [ Note
  :
  This case can result in substitution failure when ranges​::​iter_­move(E)appears in the immediate context of a template instantiation.
  — end note
  ]

If ranges​::​iter_­move(E) is not equal to *E, the program is ill-formed, no diagnostic required.

23.3.3.2 ranges​::​iter_­swap [iterator.cust.swap]

Let iter-exchange-move be the exposition-only function:

template<class X, class Y> constexpr iter_value_t<X> iter-exchange-move(X&& x, Y&& y) noexcept(noexcept(iter_value_t<X>(iter_move(x))) && noexcept(*x = iter_move(y)));

Effects:Equivalent to:

iter_value_t old_value(iter_move(x)); *x = iter_move(y); return old_value;

The expression ranges​::​iter_­swap(E1, E2) for subexpressionsE1 and E2 is expression-equivalent to:

• (void)iter_­swap(E1, E2), if eitherE1 or E2 has class or enumeration type anditer_­swap(E1, E2) is a well-formed expression with overload resolution performed in a context that includes the declaration
  template<class I1, class I2>
  void iter_swap(I1, I2) = delete;
  and does not include a declaration of ranges​::​iter_­swap. If the function selected by overload resolution does not exchange the values denoted by E1 and E2, the program is ill-formed, no diagnostic required.
• Otherwise, if the types of E1 and E2 each modelindirectly_­readable, and if the reference types of E1 and E2model swappable_­with ([concept.swappable]), then ranges​::​swap(*E1, *E2).
• Otherwise, if the types T1 and T2 of E1 andE2 model indirectly_­movable_­storable<T1, T2> andindirectly_­movable_­storable<T2, T1>, then(void)(*E1 = iter-exchange-move(E2, E1)), except that E1 is evaluated only once.
• Otherwise, ranges​::​iter_­swap(E1, E2) is ill-formed.
  [ Note
  : This case can result in substitution failure when ranges​::​iter_­swap(E1, E2)appears in the immediate context of a template instantiation. — end note
  ]