20 General utilities library [utilities]

Effects:

• (1.1)

  If neither *this nor rhs holds a value, there is no effect. Otherwise,

• (1.2)

  if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value. Otherwise,

• (1.3)

  if index() == rhs.index(), assigns the value contained in rhs to the value contained in *this. Otherwise,

• (1.4)

  copies the value contained in rhs to a temporary, then destroys any value contained in *this. Sets *this to hold the same alternative index as rhs and initializes the value contained in *this as if direct-non-list-initializing an object of type T_j with std::forward<T_j>(TMP), with TMP being the temporary and j being rhs.index().

Returns: *this.

Postconditions: index() == rhs.index().

Remarks: This function shall not participate in overload resolution unless is_copy_constructible_v<T_i> && is_move_constructible_v<T_i> && is_copy_assignable_v<T_i> is true for all i.

• (4.1)

  If an exception is thrown during the call to T_j's copy assignment, the state of the contained value is as defined by the exception safety guarantee of T_j's copy assignment; index() will be j.

• (4.2)

  If an exception is thrown during the call to T_j's copy construction (with j being rhs.index()), *this will remain unchanged.

• (4.3)

  If an exception is thrown during the call to T_j's move construction, the variant will hold no value.

Effects:

• (5.1)

  If neither *this nor rhs holds a value, there is no effect. Otherwise,

• (5.2)

  if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value. Otherwise,

• (5.3)

  if index() == rhs.index(), assigns get<j>(std::move(rhs)) to the value contained in *this, with j being index(). Otherwise,

• (5.4)

  destroys any value contained in *this. Sets *this to hold the same alternative index as rhs and initializes the value contained in *this as if direct-non-list-initializing an object of type T_j with get<j>(std::move(rhs)) with j being rhs.index().

Returns: *this.

Remarks: This function shall not participate in overload resolution unless is_move_constructible_v<T_i> && is_move_assignable_v<T_i> is true for all i. The expression inside noexcept is equivalent to: is_nothrow_move_constructible_v<T_i> && is_nothrow_move_assignable_v<T_i> for all i.

• (7.1)

  If an exception is thrown during the call to T_j's move construction (with j being rhs.index()), the variant will hold no value.

• (7.2)

  If an exception is thrown during the call to T_j's move assignment, the state of the contained value is as defined by the exception safety guarantee of T_j's move assignment; index() will be j.

Let T_j be a type that is determined as follows: build an imaginary function FUN(T_i) for each alternative type T_i. The overload FUN(T_j) selected by overload resolution for the expression FUN(std::forward<T>(t)) defines the alternative T_j which is the type of the contained value after assignment.

Effects: If *this holds a T_j, assigns std::forward<T>(t) to the value contained in *this. Otherwise, destroys any value contained in *this, sets *this to hold the alternative type T_j as selected by the imaginary function overload resolution described above, and direct-initializes the contained value as if direct-non-list-initializing it with std::forward<T>(t).

Postconditions: holds_alternative<T_j>(*this) is true, with T_j selected by the imaginary function overload resolution described above.

Returns: *this.

Remarks: This function shall not participate in overload resolution unless is_same_v<decay_t<T>, variant> is false, unless is_assignable_v<T_j&, T> && is_constructible_v<T_j, T> is true, and unless the expression FUN(std::forward<T>(t)) (with FUN being the above-mentioned set of imaginary functions) is well formed.

[ Note:

variant<string, string> v;
v = "abc";

is ill-formed, as both alternative types have an equally viable constructor for the argument.  — end note ]

The expression inside noexcept is equivalent to: is_nothrow_assignable_v<T_j&, T> && is_nothrow_constructible_v<T_j, T>.

• (14.1)

  If an exception is thrown during the assignment of std::forward<T>(t) to the value contained in *this, the state of the contained value and t are as defined by the exception safety guarantee of the assignment expression; valueless_by_exception() will be false.

• (14.2)

  If an exception is thrown during the initialization of the contained value, the variant object might not hold a value.