[futures.promise] - C++14 → C++17

Files changed (1) hide show

tmp/tmp6uyp_6ra/{from.md → to.md} +14 -11

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

@@ -23,11 +23,10 @@ namespace std {
     // setting the result
     void set_value(see below);
     void set_exception(exception_ptr p);
     // setting the result with deferred notification
-    void set_value_at_thread_exit(const R& r);
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
   template <class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
@@ -36,12 +35,12 @@ namespace std {
 }
 ```
 The implementation shall provide the template `promise` and two
 specializations, `promise<R&>` and `promise<{}void>`. These differ only
-in the argument type of the member function `set_value`, as set out in
-its description, below.
 The `set_value`, `set_exception`, `set_value_at_thread_exit`, and
 `set_exception_at_thread_exit` member functions behave as though they
 acquire a single mutex associated with the promise object while updating
 the promise object.
@@ -69,11 +68,11 @@ promise(promise&& rhs) noexcept;
 ```
 *Effects:* constructs a new `promise` object and transfers ownership of
 the shared state of `rhs` (if any) to the newly-constructed object.
-`rhs` has no shared state.
 ``` cpp
 ~promise();
 ```
@@ -92,13 +91,13 @@ promise& operator=(promise&& rhs) noexcept;
 void swap(promise& other) noexcept;
 ```
 *Effects:* Exchanges the shared state of `*this` and `other`.
-`*this` has the shared state (if any) that `other` had prior to the call
-to `swap`. `other` has the shared state (if any) that `*this` had prior
-to the call to `swap`.
 ``` cpp
 future<R> get_future();
 ```
@@ -119,11 +118,11 @@ void promise::set_value(const R& r);
 void promise::set_value(R&& r);
 void promise<R&>::set_value(R& r);
 void promise<void>::set_value();
 ```
-*Effects:* atomically stores the value `r` in the shared state and makes
 that state ready ([[futures.state]]).
 *Throws:*
 - `future_error` if its shared state already has a stored value or
@@ -141,11 +140,13 @@ that state ready ([[futures.state]]).
 ``` cpp
 void set_exception(exception_ptr p);
 ```
-*Effects:* atomically stores the exception pointer `p` in the shared
 state and makes that state ready ([[futures.state]]).
 *Throws:* `future_error` if its shared state already has a stored value
 or exception.
@@ -184,10 +185,12 @@ associated with the current thread have been destroyed.
 ``` cpp
 void set_exception_at_thread_exit(exception_ptr p);
 ```
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
 ready when the current thread exits, after all objects of thread storage
 duration associated with the current thread have been destroyed.
@@ -199,10 +202,10 @@ duration associated with the current thread have been destroyed.
   value or exception.
 - `no_state` if `*this` has no shared state.
 ``` cpp
 template <class R>
-  void swap(promise<R>& x, promise<R>& y);
 ```
-*Effects:* `x.swap(y)`.

     // setting the result
     void set_value(see below);
     void set_exception(exception_ptr p);
     // setting the result with deferred notification
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
   template <class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
 }
 ```
 The implementation shall provide the template `promise` and two
 specializations, `promise<R&>` and `promise<{}void>`. These differ only
+in the argument type of the member functions `set_value` and
+`set_value_at_thread_exit`, as set out in their descriptions, below.
 The `set_value`, `set_exception`, `set_value_at_thread_exit`, and
 `set_exception_at_thread_exit` member functions behave as though they
 acquire a single mutex associated with the promise object while updating
 the promise object.
 ```
 *Effects:* constructs a new `promise` object and transfers ownership of
 the shared state of `rhs` (if any) to the newly-constructed object.
+*Postconditions:* `rhs` has no shared state.
 ``` cpp
 ~promise();
 ```
 void swap(promise& other) noexcept;
 ```
 *Effects:* Exchanges the shared state of `*this` and `other`.
+*Postconditions:* `*this` has the shared state (if any) that `other` had
+prior to the call to `swap`. `other` has the shared state (if any) that
+`*this` had prior to the call to `swap`.
 ``` cpp
 future<R> get_future();
 ```
 void promise::set_value(R&& r);
 void promise<R&>::set_value(R& r);
 void promise<void>::set_value();
 ```
+*Effects:* Atomically stores the value `r` in the shared state and makes
 that state ready ([[futures.state]]).
 *Throws:*
 - `future_error` if its shared state already has a stored value or
 ``` cpp
 void set_exception(exception_ptr p);
 ```
+*Requires:* `p` is not null.
+*Effects:* Atomically stores the exception pointer `p` in the shared
 state and makes that state ready ([[futures.state]]).
 *Throws:* `future_error` if its shared state already has a stored value
 or exception.
 ``` cpp
 void set_exception_at_thread_exit(exception_ptr p);
 ```
+*Requires:* `p` is not null.
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
 ready when the current thread exits, after all objects of thread storage
 duration associated with the current thread have been destroyed.
   value or exception.
 - `no_state` if `*this` has no shared state.
 ``` cpp
 template <class R>
+  void swap(promise<R>& x, promise<R>& y) noexcept;
 ```
+*Effects:* As if by `x.swap(y)`.

Diff to HTML by rtfpessoa