[futures.task.members] - C++14 → C++17

Files changed (1) hide show

tmp/tmps7jxmaha/{from.md → to.md} +40 -38

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

@@ -2,73 +2,73 @@
 ``` cpp
 packaged_task() noexcept;
 ```
-*Effects:* constructs a `packaged_task` object with no shared state and
 no stored task.
 ``` cpp
 template <class F>
   packaged_task(F&& f);
-template <class F, class Allocator>
-  explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
 ```
-*Requires:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, where `t1, t2, ..., tN`
 are values of the corresponding types in `ArgTypes...`, shall be a valid
 expression. Invoking a copy of `f` shall behave the same as invoking
 `f`.
-*Remarks:* These constructors shall not participate in overload
-resolution if `decay_t<F>` is the same type as
-`std::packaged_task<R(ArgTypes...)>`.
-*Effects:* constructs a new `packaged_task` object with a shared state
-and initializes the object’s stored task with `std::forward<F>(f)`. The
-constructors that take an `Allocator` argument use it to allocate memory
-needed to store the internal data structures.
-*Throws:* any exceptions thrown by the copy or move constructor of `f`,
-or `std::bad_alloc` if memory for the internal data structures could not
-be allocated.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
-*Effects:* constructs a new `packaged_task` object and transfers
 ownership of `rhs`’s shared state to `*this`, leaving `rhs` with no
 shared state. Moves the stored task from `rhs` to `*this`.
-`rhs` has no shared state.
 ``` cpp
 packaged_task& operator=(packaged_task&& rhs) noexcept;
 ```
 *Effects:*
-- releases any shared state ([[futures.state]]).
-- `packaged_task(std::move(rhs)).swap(*this)`.
 ``` cpp
 ~packaged_task();
 ```
-*Effects:* Abandons any shared state. ([[futures.state]]).
 ``` cpp
 void swap(packaged_task& other) noexcept;
 ```
-*Effects:* exchanges the shared states and stored tasks of `*this` and
 `other`.
-`*this` has the same shared state and stored task (if any) as `other`
-prior to the call to `swap`. `other` has the same shared state and
-stored task (if any) as `*this` prior to the call to `swap`.
 ``` cpp
 bool valid() const noexcept;
 ```
@@ -91,14 +91,14 @@ future<R> get_future();
 ``` cpp
 void operator()(ArgTypes... args);
 ```
-*Effects:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, where `f` is the stored
-task of `*this` and `t1, t2, ..., tN` are the values in `args...`. If
-the task returns normally, the return value is stored as the
-asynchronous result in the shared state of `*this`, otherwise the
 exception thrown by the task is stored. The shared state of `*this` is
 made ready, and any threads blocked in a function waiting for the shared
 state of `*this` to become ready are unblocked.
 *Throws:* a `future_error` exception object if there is no shared state
@@ -112,18 +112,18 @@ or the stored task has already been invoked.
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
-*Effects:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, where `f` is the stored
-task and `t1, t2, ..., tN` are the values in `args...`. If the task
-returns normally, the return value is stored as the asynchronous result
-in the shared state of `*this`, otherwise the exception thrown by the
-task is stored. In either case, this shall be done without making that
-state ready ([[futures.state]]) immediately. Schedules the shared 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.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
@@ -134,13 +134,15 @@ destroyed.
 ``` cpp
 void reset();
 ```
-*Effects:* as if `*this = packaged_task(std::move(f))`, where `f` is the
-task stored in `*this`. This constructs a new shared state for `*this`.
-The old state is abandoned ([[futures.state]]).
 *Throws:*
 - `bad_alloc` if memory for the new shared state could not be allocated.
 - any exception thrown by the move constructor of the task stored in the

 ``` cpp
 packaged_task() noexcept;
 ```
+*Effects:* Constructs a `packaged_task` object with no shared state and
 no stored task.
 ``` cpp
 template <class F>
   packaged_task(F&& f);
 ```
+*Requires:* *INVOKE*\<R\>(f, t1, t2, ..., tN), where `t1, t2, ..., tN`
 are values of the corresponding types in `ArgTypes...`, shall be a valid
 expression. Invoking a copy of `f` shall behave the same as invoking
 `f`.
+*Remarks:* This constructor shall not participate in overload resolution
+if `decay_t<F>` is the same type as `packaged_task<R(ArgTypes...)>`.
+*Effects:* Constructs a new `packaged_task` object with a shared state
+and initializes the object’s stored task with `std::forward<F>(f)`.
+*Throws:*
+- Any exceptions thrown by the copy or move constructor of `f`.
+- For the first version, `bad_alloc` if memory for the internal data
+  structures could not be allocated.
+- For the second version, any exceptions thrown by
+  `allocator_traits<Allocator>::template`
+  `rebind_traits<`*`unspecified`*`>::allocate`.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
+*Effects:* Constructs a new `packaged_task` object and transfers
 ownership of `rhs`’s shared state to `*this`, leaving `rhs` with no
 shared state. Moves the stored task from `rhs` to `*this`.
+*Postconditions:* `rhs` has no shared state.
 ``` cpp
 packaged_task& operator=(packaged_task&& rhs) noexcept;
 ```
 *Effects:*
+- Releases any shared state ([[futures.state]]);
+- calls `packaged_task(std::move(rhs)).swap(*this)`.
 ``` cpp
 ~packaged_task();
 ```
+*Effects:* Abandons any shared state ([[futures.state]]).
 ``` cpp
 void swap(packaged_task& other) noexcept;
 ```
+*Effects:* Exchanges the shared states and stored tasks of `*this` and
 `other`.
+*Postconditions:* `*this` has the same shared state and stored task (if
+any) as `other` prior to the call to `swap`. `other` has the same shared
+state and stored task (if any) as `*this` prior to the call to `swap`.
 ``` cpp
 bool valid() const noexcept;
 ```
 ``` cpp
 void operator()(ArgTypes... args);
 ```
+*Effects:* As if by *INVOKE*\<R\>(f, t1, t2, ..., tN), where `f` is the
+stored task of `*this` and `t1, t2, ..., tN` are the values in
+`args...`. If the task returns normally, the return value is stored as
+the asynchronous result in the shared state of `*this`, otherwise the
 exception thrown by the task is stored. The shared state of `*this` is
 made ready, and any threads blocked in a function waiting for the shared
 state of `*this` to become ready are unblocked.
 *Throws:* a `future_error` exception object if there is no shared state
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
+*Effects:* As if by *INVOKE*\<R\>(f, t1, t2, ..., tN), where `f` is the
+stored task and `t1, t2, ..., tN` are the values in `args...`. If the
+task returns normally, the return value is stored as the asynchronous
+result in the shared state of `*this`, otherwise the exception thrown by
+the task is stored. In either case, this shall be done without making
+that state ready ([[futures.state]]) immediately. Schedules the shared
+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.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
 ``` cpp
 void reset();
 ```
+*Effects:* As if `*this = packaged_task(std::move(f))`, where `f` is the
+task stored in `*this`.
+[*Note 1*: This constructs a new shared state for `*this`. The old
+state is abandoned ([[futures.state]]). — *end note*]
 *Throws:*
 - `bad_alloc` if memory for the new shared state could not be allocated.
 - any exception thrown by the move constructor of the task stored in the

Diff to HTML by rtfpessoa