[futures.task] - C++17 → C++20

Files changed (1) hide show

tmp/tmp8ufh6mgx/{from.md → to.md} +100 -72

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

@@ -40,86 +40,79 @@ namespace std {
     void operator()(ArgTypes... );
     void make_ready_at_thread_exit(ArgTypes...);
     void reset();
   };
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
-  template <class R, class Alloc>
-    struct uses_allocator<packaged_task<R>, Alloc>;
 }
 ```
-#### `packaged_task` member functions <a id="futures.task.members">[[futures.task.members]]</a>
 ``` 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;
 ```
@@ -130,11 +123,18 @@ future<R> get_future();
 ```
 *Returns:* A `future` object that shares the same shared state as
 `*this`.
-*Throws:* a `future_error` object if an error occurs.
 *Error conditions:*
 - `future_already_retrieved` if `get_future` has already been called on
   a `packaged_task` object with the same shared state as `*this`.
@@ -142,19 +142,19 @@ future<R> get_future();
 ``` 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
 or the stored task has already been invoked.
 *Error conditions:*
 - `promise_already_satisfied` if the stored task has already been
@@ -163,19 +163,19 @@ or the stored task has already been invoked.
 ``` 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:*
@@ -188,77 +188,99 @@ 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
   shared state.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
-#### `packaged_task` globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
-``` cpp
-template <class R, class Alloc>
-  struct uses_allocator<packaged_task<R>, Alloc>
-    : true_type { };
-```
-*Requires:* `Alloc` shall be an Allocator ([[allocator.requirements]]).
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
-[allocator.requirements]: library.md#allocator.requirements
 [atomics]: atomics.md#atomics
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
-[class]: class.md#class
-[condition_variable.syn]: #condition_variable.syn
 [except.terminate]: except.md#except.terminate
 [func.require]: utilities.md#func.require
 [future.syn]: #future.syn
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
-[futures.future_error]: #futures.future_error
 [futures.overview]: #futures.overview
 [futures.promise]: #futures.promise
-[futures.shared_future]: #futures.shared_future
 [futures.state]: #futures.state
 [futures.task]: #futures.task
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
-[futures.unique_future]: #futures.unique_future
-[intro.multithread]: intro.md#intro.multithread
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
-[shared_mutex.syn]: #shared_mutex.syn
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
-[tab:thread.lib.summary]: #tab:thread.lib.summary
 [thread]: #thread
 [thread.condition]: #thread.condition
 [thread.condition.condvar]: #thread.condition.condvar
 [thread.condition.condvarany]: #thread.condition.condvarany
 [thread.condition.nonmember]: #thread.condition.nonmember
-[thread.decaycopy]: #thread.decaycopy
 [thread.general]: #thread.general
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
 [thread.lock.guard]: #thread.lock.guard
 [thread.lock.scoped]: #thread.lock.scoped
 [thread.lock.shared]: #thread.lock.shared
@@ -288,14 +310,20 @@ template <class R, class Alloc>
 [thread.req.lockable.req]: #thread.req.lockable.req
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
 [thread.sharedmutex.class]: #thread.sharedmutex.class
 [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
 [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
 [thread.syn]: #thread.syn
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
 [thread.thread.constr]: #thread.thread.constr
@@ -306,15 +334,15 @@ template <class R, class Alloc>
 [thread.thread.this]: #thread.thread.this
 [thread.threads]: #thread.threads
 [thread.timedmutex.class]: #thread.timedmutex.class
 [thread.timedmutex.recursive]: #thread.timedmutex.recursive
 [thread.timedmutex.requirements]: #thread.timedmutex.requirements
-[time]: utilities.md#time
-[time.clock]: utilities.md#time.clock
-[time.clock.req]: utilities.md#time.clock.req
-[time.duration]: utilities.md#time.duration
-[time.point]: utilities.md#time.point
 [unord.hash]: utilities.md#unord.hash
 [^1]: All implementations for which standard time units are meaningful
     must necessarily have a steady clock within their hardware
     implementation.

     void operator()(ArgTypes... );
     void make_ready_at_thread_exit(ArgTypes...);
     void reset();
   };
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 }
 ```
+#### Member functions <a id="futures.task.members">[[futures.task.members]]</a>
 ``` cpp
 packaged_task() noexcept;
 ```
+*Effects:* The object has no shared state and no stored task.
 ``` cpp
 template<class F>
   packaged_task(F&& f);
 ```
+*Constraints:* `remove_cvref_t<F>` is not the same type as
+`packaged_task<R(ArgTypes...)>`.
+*Mandates:* `is_invocable_r_v<R, F&, ArgTypes...>` is `true`.
+*Preconditions:* Invoking a copy of `f` behaves the same as invoking
 `f`.
 *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`,
+or `bad_alloc` if memory for the internal data structures could not be
+allocated.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
+*Effects:* Transfers ownership of `rhs`’s shared state to `*this`,
+leaving `rhs` with no shared state. Moves the stored task from `rhs` to
+`*this`.
+*Ensures:* `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`.
+*Ensures:* `*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;
 ```
 ```
 *Returns:* A `future` object that shares the same shared state as
 `*this`.
+*Synchronization:* Calls to this function do not introduce data
+races  [[intro.multithread]] with calls to `operator()` or
+`make_ready_at_thread_exit`.
+[*Note 1*: Such calls need not synchronize with each
+other. — *end note*]
+*Throws:* A `future_error` object if an error occurs.
 *Error conditions:*
 - `future_already_retrieved` if `get_future` has already been called on
   a `packaged_task` object with the same shared state as `*this`.
 ``` cpp
 void operator()(ArgTypes... args);
 ```
+*Effects:* As if by *INVOKE*\<R\>(f, t₁, t₂, …, t$_N$) [[func.require]],
+where `f` is the stored task of `*this` and `t`₁`, t`₂`, `…`, t`$_N$ 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
 or the stored task has already been invoked.
 *Error conditions:*
 - `promise_already_satisfied` if the stored task has already been
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
+*Effects:* As if by *INVOKE*\<R\>(f, t₁, t₂, …, t$_N$) [[func.require]],
+where `f` is the stored task and `t`₁`, t`₂`, `…`, t`$_N$ 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 is 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:*
 ```
 *Effects:* As if `*this = packaged_task(std::move(f))`, where `f` is the
 task stored in `*this`.
+[*Note 2*: 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
   shared state.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
+#### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
 [atomics]: atomics.md#atomics
+[barrier.syn]: #barrier.syn
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
+[class.prop]: class.md#class.prop
+[condition.variable.syn]: #condition.variable.syn
+[cpp17.allocator]: #cpp17.allocator
+[cpp17.defaultconstructible]: #cpp17.defaultconstructible
+[cpp17.destructible]: #cpp17.destructible
+[cpp17.moveassignable]: #cpp17.moveassignable
+[cpp17.moveconstructible]: #cpp17.moveconstructible
+[defns.block]: intro.md#defns.block
 [except.terminate]: except.md#except.terminate
 [func.require]: utilities.md#func.require
 [future.syn]: #future.syn
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
+[futures.future.error]: #futures.future.error
 [futures.overview]: #futures.overview
 [futures.promise]: #futures.promise
+[futures.shared.future]: #futures.shared.future
 [futures.state]: #futures.state
 [futures.task]: #futures.task
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
+[futures.unique.future]: #futures.unique.future
+[intro.multithread]: basic.md#intro.multithread
+[intro.races]: basic.md#intro.races
+[latch.syn]: #latch.syn
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
+[semaphore.syn]: #semaphore.syn
+[shared.mutex.syn]: #shared.mutex.syn
+[stopcallback]: #stopcallback
+[stopcallback.cons]: #stopcallback.cons
+[stopsource]: #stopsource
+[stopsource.cons]: #stopsource.cons
+[stopsource.mem]: #stopsource.mem
+[stopsource.nonmembers]: #stopsource.nonmembers
+[stoptoken]: #stoptoken
+[stoptoken.cons]: #stoptoken.cons
+[stoptoken.mem]: #stoptoken.mem
+[stoptoken.nonmembers]: #stoptoken.nonmembers
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
 [thread]: #thread
+[thread.barrier]: #thread.barrier
+[thread.barrier.class]: #thread.barrier.class
 [thread.condition]: #thread.condition
 [thread.condition.condvar]: #thread.condition.condvar
 [thread.condition.condvarany]: #thread.condition.condvarany
 [thread.condition.nonmember]: #thread.condition.nonmember
+[thread.condvarany.intwait]: #thread.condvarany.intwait
+[thread.condvarany.wait]: #thread.condvarany.wait
+[thread.coord]: #thread.coord
 [thread.general]: #thread.general
+[thread.jthread.class]: #thread.jthread.class
+[thread.jthread.cons]: #thread.jthread.cons
+[thread.jthread.mem]: #thread.jthread.mem
+[thread.jthread.special]: #thread.jthread.special
+[thread.jthread.static]: #thread.jthread.static
+[thread.jthread.stop]: #thread.jthread.stop
+[thread.latch]: #thread.latch
+[thread.latch.class]: #thread.latch.class
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
 [thread.lock.guard]: #thread.lock.guard
 [thread.lock.scoped]: #thread.lock.scoped
 [thread.lock.shared]: #thread.lock.shared
 [thread.req.lockable.req]: #thread.req.lockable.req
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
+[thread.sema]: #thread.sema
+[thread.sema.cnt]: #thread.sema.cnt
 [thread.sharedmutex.class]: #thread.sharedmutex.class
 [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
 [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
+[thread.stoptoken]: #thread.stoptoken
+[thread.stoptoken.intro]: #thread.stoptoken.intro
+[thread.stoptoken.syn]: #thread.stoptoken.syn
+[thread.summary]: #thread.summary
 [thread.syn]: #thread.syn
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
 [thread.thread.constr]: #thread.thread.constr
 [thread.thread.this]: #thread.thread.this
 [thread.threads]: #thread.threads
 [thread.timedmutex.class]: #thread.timedmutex.class
 [thread.timedmutex.recursive]: #thread.timedmutex.recursive
 [thread.timedmutex.requirements]: #thread.timedmutex.requirements
+[time]: time.md#time
+[time.clock]: time.md#time.clock
+[time.clock.req]: time.md#time.clock.req
+[time.duration]: time.md#time.duration
+[time.point]: time.md#time.point
 [unord.hash]: utilities.md#unord.hash
 [^1]: All implementations for which standard time units are meaningful
     must necessarily have a steady clock within their hardware
     implementation.

Diff to HTML by rtfpessoa