[optional.optional] - C++14 → C++17

Files changed (1) hide show

tmp/tmpaitgm4fd/{from.md → to.md} +637 -0

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

	@@ -0,0 +1,637 @@

+### Class template `optional` <a id="optional.optional">[[optional.optional]]</a>
+``` cpp
+template <class T>
+  class optional {
+  public:
+    using value_type = T;
+    // [optional.ctor], constructors
+    constexpr optional() noexcept;
+    constexpr optional(nullopt_t) noexcept;
+    constexpr optional(const optional&);
+    constexpr optional(optional&&) noexcept(see below);
+    template <class... Args>
+      constexpr explicit optional(in_place_t, Args&&...);
+    template <class U, class... Args>
+      constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
+    template <class U = T>
+      \EXPLICIT constexpr optional(U&&);
+    template <class U>
+      \EXPLICIT optional(const optional<U>&);
+    template <class U>
+      \EXPLICIT optional(optional<U>&&);
+    // [optional.dtor], destructor
+    ~optional();
+    // [optional.assign], assignment
+    optional& operator=(nullopt_t) noexcept;
+    optional& operator=(const optional&);
+    optional& operator=(optional&&) noexcept(see below);
+    template <class U = T> optional& operator=(U&&);
+    template <class U> optional& operator=(const optional<U>&);
+    template <class U> optional& operator=(optional<U>&&);
+    template <class... Args> T& emplace(Args&&...);
+    template <class U, class... Args> T& emplace(initializer_list<U>, Args&&...);
+    // [optional.swap], swap
+    void swap(optional&) noexcept(see below);
+    // [optional.observe], observers
+    constexpr const T* operator->() const;
+    constexpr T* operator->();
+    constexpr const T& operator*() const&;
+    constexpr T& operator*() &;
+    constexpr T&& operator*() &&;
+    constexpr const T&& operator*() const&&;
+    constexpr explicit operator bool() const noexcept;
+    constexpr bool has_value() const noexcept;
+    constexpr const T& value() const&;
+    constexpr T& value() &;
+    constexpr T&& value() &&;
+    constexpr const T&& value() const&&;
+    template <class U> constexpr T value_or(U&&) const&;
+    template <class U> constexpr T value_or(U&&) &&;
+    // [optional.mod], modifiers
+    void reset() noexcept;
+  private:
+    T *val; // exposition only
+  };
+template<class T> optional(T) -> optional<T>;
+```
+Any instance of `optional<T>` at any given time either contains a value
+or does not contain a value. When an instance of `optional<T>` *contains
+a value*, it means that an object of type `T`, referred to as the
+optional object’s *contained value*, is allocated within the storage of
+the optional object. Implementations are not permitted to use additional
+storage, such as dynamic memory, to allocate its contained value. The
+contained value shall be allocated in a region of the `optional<T>`
+storage suitably aligned for the type `T`. When an object of type
+`optional<T>` is contextually converted to `bool`, the conversion
+returns `true` if the object contains a value; otherwise the conversion
+returns `false`.
+Member `val` is provided for exposition only. When an `optional<T>`
+object contains a value, `val` points to the contained value.
+`T` shall be an object type and shall satisfy the requirements of
+`Destructible` (Table  [[tab:destructible]]).
+#### Constructors <a id="optional.ctor">[[optional.ctor]]</a>
+``` cpp
+constexpr optional() noexcept;
+constexpr optional(nullopt_t) noexcept;
+```
+*Postconditions:* `*this` does not contain a value.
+*Remarks:* No contained value is initialized. For every object type `T`
+these constructors shall be constexpr constructors ([[dcl.constexpr]]).
+``` cpp
+constexpr optional(const optional& rhs);
+```
+*Effects:* If `rhs` contains a value, initializes the contained value as
+if direct-non-list-initializing an object of type `T` with the
+expression `*rhs`.
+*Postconditions:* `bool(rhs) == bool(*this)`.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* This constructor shall be defined as deleted unless
+`is_copy_constructible_v<T>` is `true`. If
+`is_trivially_copy_constructible_v<T>` is `true`, this constructor shall
+be a `constexpr` constructor.
+``` cpp
+constexpr optional(optional&& rhs) noexcept(see below);
+```
+*Effects:* If `rhs` contains a value, initializes the contained value as
+if direct-non-list-initializing an object of type `T` with the
+expression `std::move(*rhs)`. `bool(rhs)` is unchanged.
+*Postconditions:* `bool(rhs) == bool(*this)`.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* The expression inside `noexcept` is equivalent to
+`is_nothrow_move_constructible_v<T>`. This constructor shall not
+participate in overload resolution unless `is_move_constructible_v<T>`
+is `true`. If `is_trivially_move_constructible_v<T>` is `true`, this
+constructor shall be a `constexpr` constructor.
+``` cpp
+template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+```
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T` with the arguments
+`std::forward<Args>(args)...`.
+*Postconditions:* `*this` contains a value.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* If `T`’s constructor selected for the initialization is a
+constexpr constructor, this constructor shall be a constexpr
+constructor. This constructor shall not participate in overload
+resolution unless `is_constructible_v<T, Args...>` is `true`.
+``` cpp
+template <class U, class... Args>
+  constexpr explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
+```
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T` with the arguments
+`il, std::forward<Args>(args)...`.
+*Postconditions:* `*this` contains a value.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless `is_constructible_v<T, initializer_list<U>&, Args&&...>` is
+`true`. If `T`’s constructor selected for the initialization is a
+constexpr constructor, this constructor shall be a constexpr
+constructor.
+[*Note 1*: The following constructors are conditionally specified as
+explicit. This is typically implemented by declaring two such
+constructors, of which at most one participates in overload
+resolution. — *end note*]
+``` cpp
+template <class U = T> \EXPLICIT constexpr optional(U&& v);
+```
+*Effects:* Initializes the contained value as if
+direct-non-list-initializing an object of type `T` with the expression
+`std::forward<U>(v)`.
+*Postconditions:* `*this` contains a value.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* If `T`’s selected constructor is a constexpr constructor,
+this constructor shall be a constexpr constructor. This constructor
+shall not participate in overload resolution unless
+`is_constructible_v<T, U&&>` is `true`,
+`is_same_v<decay_t<U>, in_place_t>` is `false`, and
+`is_same_v<optional<T>, decay_t<U>>` is `false`. The constructor is
+explicit if and only if `is_convertible_v<U&&, T>` is `false`.
+``` cpp
+template <class U> \EXPLICIT optional(const optional<U>& rhs);
+```
+*Effects:* If `rhs` contains a value, initializes the contained value as
+if direct-non-list-initializing an object of type `T` with the
+expression `*rhs`.
+*Postconditions:* `bool(rhs)` == `bool(*this)`.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless
+- `is_constructible_v<T, const U&>` is `true`,
+- `is_constructible_v<T, optional<U>&>` is `false`,
+- `is_constructible_v<T, optional<U>&&>` is `false`,
+- `is_constructible_v<T, const optional<U>&>` is `false`,
+- `is_constructible_v<T, const optional<U>&&>` is `false`,
+- `is_convertible_v<optional<U>&, T>` is `false`,
+- `is_convertible_v<optional<U>&&, T>` is `false`,
+- `is_convertible_v<const optional<U>&, T>` is `false`, and
+- `is_convertible_v<const optional<U>&&, T>` is `false`.
+The constructor is explicit if and only if
+`is_convertible_v<const U&, T>` is `false`.
+``` cpp
+template <class U> \EXPLICIT optional(optional<U>&& rhs);
+```
+*Effects:* If `rhs` contains a value, initializes the contained value as
+if direct-non-list-initializing an object of type `T` with the
+expression `std::move(*rhs)`. `bool(rhs)` is unchanged.
+*Postconditions:* `bool(rhs)` == `bool(*this)`.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* This constructor shall not participate in overload resolution
+unless
+- `is_constructible_v<T, U&&>` is true,
+- `is_constructible_v<T, optional<U>&>` is `false`,
+- `is_constructible_v<T, optional<U>&&>` is `false`,
+- `is_constructible_v<T, const optional<U>&>` is `false`,
+- `is_constructible_v<T, const optional<U>&&>` is `false`,
+- `is_convertible_v<optional<U>&, T>` is `false`,
+- `is_convertible_v<optional<U>&&, T>` is `false`,
+- `is_convertible_v<const optional<U>&, T>` is `false`, and
+- `is_convertible_v<const optional<U>&&, T>` is `false`.
+The constructor is explicit if and only if `is_convertible_v<U&&, T>` is
+`false`.
+#### Destructor <a id="optional.dtor">[[optional.dtor]]</a>
+``` cpp
+~optional();
+```
+*Effects:* If `is_trivially_destructible_v<T> != true` and `*this`
+contains a value, calls
+``` cpp
+val->T::~T()
+```
+*Remarks:* If `is_trivially_destructible_v<T> == true` then this
+destructor shall be a trivial destructor.
+#### Assignment <a id="optional.assign">[[optional.assign]]</a>
+``` cpp
+optional<T>& operator=(nullopt_t) noexcept;
+```
+*Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
+the contained value; otherwise no effect.
+*Returns:* `*this`.
+*Postconditions:* `*this` does not contain a value.
+``` cpp
+optional<T>& operator=(const optional& rhs);
+```
+*Effects:* See Table  [[tab:optional.assign.copy]].
+**Table: `optional::operator=(const optional&)` effects** <a id="tab:optional.assign.copy">[tab:optional.assign.copy]</a>
+|                                | `*this` contains a value                               | `*this` does not contain a value                                                                     |
+| ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `*rhs` to the contained value                  | initializes the contained value as if direct-non-list-initializing an object of type `T` with `*rhs` |
+| `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                                                            |
+*Returns:* `*this`.
+*Postconditions:* `bool(rhs) == bool(*this)`.
+*Remarks:* If any exception is thrown, the result of the expression
+`bool(*this)` remains unchanged. If an exception is thrown during the
+call to `T`’s copy constructor, no effect. If an exception is thrown
+during the call to `T`’s copy assignment, the state of its contained
+value is as defined by the exception safety guarantee of `T`’s copy
+assignment. This operator shall be defined as deleted unless
+`is_copy_constructible_v<T>` is `true` and `is_copy_assignable_v<T>` is
+`true`.
+``` cpp
+optional<T>& operator=(optional&& rhs) noexcept(see below);
+```
+*Effects:* See Table  [[tab:optional.assign.move]]. The result of the
+expression `bool(rhs)` remains unchanged.
+**Table: `optional::operator=(optional&&)` effects** <a id="tab:optional.assign.move">[tab:optional.assign.move]</a>
+|                                | `*this` contains a value                               | `*this` does not contain a value                                                                                |
+| ------------------------------ | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | initializes the contained value as if direct-non-list-initializing an object of type `T` with `std::move(*rhs)` |
+| `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                                                                       |
+*Returns:* `*this`.
+*Postconditions:* `bool(rhs) == bool(*this)`.
+*Remarks:* The expression inside `noexcept` is equivalent to:
+``` cpp
+is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
+```
+If any exception is thrown, the result of the expression `bool(*this)`
+remains unchanged. If an exception is thrown during the call to `T`’s
+move constructor, the state of `*rhs.val` is determined by the exception
+safety guarantee of `T`’s move constructor. If an exception is thrown
+during the call to `T`’s move assignment, the state of `*val` and
+`*rhs.val` is determined by the exception safety guarantee of `T`’s move
+assignment. This operator shall not participate in overload resolution
+unless `is_move_constructible_v<T>` is `true` and
+`is_move_assignable_v<T>` is `true`.
+``` cpp
+template <class U = T> optional<T>& operator=(U&& v);
+```
+*Effects:* If `*this` contains a value, assigns `std::forward<U>(v)` to
+the contained value; otherwise initializes the contained value as if
+direct-non-list-initializing object of type `T` with
+`std::forward<U>(v)`.
+*Returns:* `*this`.
+*Postconditions:* `*this` contains a value.
+*Remarks:* If any exception is thrown, the result of the expression
+`bool(*this)` remains unchanged. If an exception is thrown during the
+call to `T`’s constructor, the state of `v` is determined by the
+exception safety guarantee of `T`’s constructor. If an exception is
+thrown during the call to `T`’s assignment, the state of `*val` and `v`
+is determined by the exception safety guarantee of `T`’s assignment.
+This function shall not participate in overload resolution unless
+`is_same_v<optional<T>, decay_t<U>>` is `false`,
+`conjunction_v<is_scalar<T>, is_same<T, decay_t<U>>>` is `false`,
+`is_constructible_v<T, U>` is `true`, and `is_assignable_v<T&, U>` is
+`true`.
+``` cpp
+template <class U> optional<T>& operator=(const optional<U>& rhs);
+```
+*Effects:* See Table  [[tab:optional.assign.copy.templ]].
+**Table: `optional::operator=(const optional<U>&)` effects** <a id="tab:optional.assign.copy.templ">[tab:optional.assign.copy.templ]</a>
+|                                | `*this` contains a value                               | `*this` does not contain a value                                                                     |
+| ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `*rhs` to the contained value                  | initializes the contained value as if direct-non-list-initializing an object of type `T` with `*rhs` |
+| `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                                                            |
+*Returns:* `*this`.
+*Postconditions:* `bool(rhs) == bool(*this)`.
+*Remarks:* If any exception is thrown, the result of the expression
+`bool(*this)` remains unchanged. If an exception is thrown during the
+call to `T`’s constructor, the state of `*rhs.val` is determined by the
+exception safety guarantee of `T`’s constructor. If an exception is
+thrown during the call to `T`’s assignment, the state of `*val` and
+`*rhs.val` is determined by the exception safety guarantee of `T`’s
+assignment. This function shall not participate in overload resolution
+unless
+- `is_constructible_v<T, const U&>` is `true`,
+- `is_assignable_v<T&, const U&>` is `true`,
+- `is_constructible_v<T, optional<U>&>` is `false`,
+- `is_constructible_v<T, optional<U>&&>` is `false`,
+- `is_constructible_v<T, const optional<U>&>` is `false`,
+- `is_constructible_v<T, const optional<U>&&>` is `false`,
+- `is_convertible_v<optional<U>&, T>` is `false`,
+- `is_convertible_v<optional<U>&&, T>` is `false`,
+- `is_convertible_v<const optional<U>&, T>` is `false`,
+- `is_convertible_v<const optional<U>&&, T>` is `false`,
+- `is_assignable_v<T&, optional<U>&>` is `false`,
+- `is_assignable_v<T&, optional<U>&&>` is `false`,
+- `is_assignable_v<T&, const optional<U>&>` is `false`, and
+- `is_assignable_v<T&, const optional<U>&&>` is `false`.
+``` cpp
+template <class U> optional<T>& operator=(optional<U>&& rhs);
+```
+*Effects:* See Table  [[tab:optional.assign.move.templ]]. The result of
+the expression `bool(rhs)` remains unchanged.
+**Table: `optional::operator=(optional<U>&&)` effects** <a id="tab:optional.assign.move.templ">[tab:optional.assign.move.templ]</a>
+|                                | `*this` contains a value                               | `*this` does not contain a value                                                                                |
+| ------------------------------ | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | initializes the contained value as if direct-non-list-initializing an object of type `T` with `std::move(*rhs)` |
+| `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                                                                       |
+*Returns:* `*this`.
+*Postconditions:* `bool(rhs) == bool(*this)`.
+*Remarks:* If any exception is thrown, the result of the expression
+`bool(*this)` remains unchanged. If an exception is thrown during the
+call to `T`’s constructor, the state of `*rhs.val` is determined by the
+exception safety guarantee of `T`’s constructor. If an exception is
+thrown during the call to `T`’s assignment, the state of `*val` and
+`*rhs.val` is determined by the exception safety guarantee of `T`’s
+assignment. This function shall not participate in overload resolution
+unless
+- `is_constructible_v<T, U>` is `true`,
+- `is_assignable_v<T&, U>` is `true`,
+- `is_constructible_v<T, optional<U>&>` is `false`,
+- `is_constructible_v<T, optional<U>&&>` is `false`,
+- `is_constructible_v<T, const optional<U>&>` is `false`,
+- `is_constructible_v<T, const optional<U>&&>` is `false`,
+- `is_convertible_v<optional<U>&, T>` is `false`,
+- `is_convertible_v<optional<U>&&, T>` is `false`,
+- `is_convertible_v<const optional<U>&, T>` is `false`,
+- `is_convertible_v<const optional<U>&&, T>` is `false`,
+- `is_assignable_v<T&, optional<U>&>` is `false`,
+- `is_assignable_v<T&, optional<U>&&>` is `false`,
+- `is_assignable_v<T&, const optional<U>&>` is `false`, and
+- `is_assignable_v<T&, const optional<U>&&>` is `false`.
+``` cpp
+template <class... Args> T& emplace(Args&&... args);
+```
+*Requires:* `is_constructible_v<T, Args&&...>` is `true`.
+*Effects:* Calls `*this = nullopt`. Then initializes the contained value
+as if direct-non-list-initializing an object of type `T` with the
+arguments `std::forward<Args>(args)...`.
+*Postconditions:* `*this` contains a value.
+*Returns:* A reference to the new contained value.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* If an exception is thrown during the call to `T`’s
+constructor, `*this` does not contain a value, and the previous `*val`
+(if any) has been destroyed.
+``` cpp
+template <class U, class... Args> T& emplace(initializer_list<U> il, Args&&... args);
+```
+*Effects:* Calls `*this = nullopt`. Then initializes the contained value
+as if direct-non-list-initializing an object of type `T` with the
+arguments `il, std::forward<Args>(args)...`.
+*Postconditions:* `*this` contains a value.
+*Returns:* A reference to the new contained value.
+*Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* If an exception is thrown during the call to `T`’s
+constructor, `*this` does not contain a value, and the previous `*val`
+(if any) has been destroyed. This function shall not participate in
+overload resolution unless
+`is_constructible_v<T, initializer_list<U>&, Args&&...>` is `true`.
+#### Swap <a id="optional.swap">[[optional.swap]]</a>
+``` cpp
+void swap(optional& rhs) noexcept(see below);
+```
+*Requires:* Lvalues of type `T` shall be swappable and
+`is_move_constructible_v<T>` is `true`.
+*Effects:* See Table  [[tab:optional.swap]].
+**Table: `optional::swap(optional&)` effects** <a id="tab:optional.swap">[tab:optional.swap]</a>
+|                                | `*this` contains a value                                                                                                                                                                                                                                   | `*this` does not contain a value                                                                                                                                                                                                                             |
+| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `rhs` contains a value         | calls `swap(*(*this), *rhs)`                                                                                                                                                                                                                               | initializes the contained value of `*this` as if direct-non-list-initializing an object of type `T` with the expression `std::move(*rhs)`, followed by `rhs.val->T::~T()`; postcondition is that `*this` contains a value and `rhs` does not contain a value |
+| `rhs` does not contain a value | initializes the contained value of `rhs` as if direct-non-list-initializing an object of type `T` with the expression `std::move(*(*this))`, followed by `val->T::~T()`; postcondition is that `*this` does not contain a value and `rhs` contains a value | no effect                                                                                                                                                                                                                                                    |
+*Throws:* Any exceptions thrown by the operations in the relevant part
+of Table  [[tab:optional.swap]].
+*Remarks:* The expression inside `noexcept` is equivalent to:
+``` cpp
+is_nothrow_move_constructible_v<T> && is_nothrow_swappable_v<T>
+```
+If any exception is thrown, the results of the expressions `bool(*this)`
+and `bool(rhs)` remain unchanged. If an exception is thrown during the
+call to function `swap`, the state of `*val` and `*rhs.val` is
+determined by the exception safety guarantee of `swap` for lvalues of
+`T`. If an exception is thrown during the call to `T`’s move
+constructor, the state of `*val` and `*rhs.val` is determined by the
+exception safety guarantee of `T`’s move constructor.
+#### Observers <a id="optional.observe">[[optional.observe]]</a>
+``` cpp
+constexpr const T* operator->() const;
+constexpr T* operator->();
+```
+*Requires:* `*this` contains a value.
+*Returns:* `val`.
+*Throws:* Nothing.
+*Remarks:* These functions shall be constexpr functions.
+``` cpp
+constexpr const T& operator*() const&;
+constexpr T& operator*() &;
+```
+*Requires:* `*this` contains a value.
+*Returns:* `*val`.
+*Throws:* Nothing.
+*Remarks:* These functions shall be constexpr functions.
+``` cpp
+constexpr T&& operator*() &&;
+constexpr const T&& operator*() const&&;
+```
+*Requires:* `*this` contains a value.
+*Effects:* Equivalent to: `return std::move(*val);`
+``` cpp
+constexpr explicit operator bool() const noexcept;
+```
+*Returns:* `true` if and only if `*this` contains a value.
+*Remarks:* This function shall be a constexpr function.
+``` cpp
+constexpr bool has_value() const noexcept;
+```
+*Returns:* `true` if and only if `*this` contains a value.
+*Remarks:* This function shall be a constexpr function.
+``` cpp
+constexpr const T& value() const&;
+constexpr T& value() &;
+```
+*Effects:* Equivalent to:
+``` cpp
+return bool(*this) ? *val : throw bad_optional_access();
+```
+``` cpp
+constexpr T&& value() &&;
+constexpr const T&& value() const&&;
+```
+*Effects:* Equivalent to:
+``` cpp
+return bool(*this) ? std::move(*val) : throw bad_optional_access();
+```
+``` cpp
+template <class U> constexpr T value_or(U&& v) const&;
+```
+*Effects:* Equivalent to:
+``` cpp
+return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
+```
+*Remarks:* If `is_copy_constructible_v<T> && is_convertible_v<U&&, T>`
+is `false`, the program is ill-formed.
+``` cpp
+template <class U> constexpr T value_or(U&& v) &&;
+```
+*Effects:* Equivalent to:
+``` cpp
+return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
+```
+*Remarks:* If `is_move_constructible_v<T> && is_convertible_v<U&&, T>`
+is `false`, the program is ill-formed.
+#### Modifiers <a id="optional.mod">[[optional.mod]]</a>
+``` cpp
+void reset() noexcept;
+```
+*Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
+the contained value; otherwise no effect.
+*Postconditions:* `*this` does not contain a value.

Diff to HTML by rtfpessoa