33 Execution control library [exec]

33.13 Coroutine utilities [exec.coro.util]

33.13.6 execution​::​task [exec.task]

33.13.6.5 Class task​::​promise_type [task.promise]

namespace std::execution { template<class T, class Environment> class task<T, Environment>::promise_type { public: task get_return_object() noexcept; static constexpr suspend_always initial_suspend() noexcept { return {}; } auto final_suspend() noexcept; void unhandled_exception(); coroutine_handle<> unhandled_stopped() noexcept; void return_void(); // present only if is_void_v<T> is true template<class V = T> void return_value(V&& value); // present only if is_void_v<T> is false template<class E> unspecified yield_value(with_error<E> error); template<sender Sender> auto await_transform(Sender&& sndr); unspecified get_env() const noexcept; void* operator new(size_t size); template<class Alloc, class... Args> void* operator new(size_t size, allocator_arg_t, Alloc alloc, Args&&...); template<class This, class Alloc, class... Args> void* operator new(size_t size, const This&, allocator_arg_t, Alloc alloc, Args&&...); void operator delete(void* pointer, size_t size) noexcept; }; }
1
#
Let prom be an object of promise_type and let tsk be the task object created by prom.get_return_object().
The description below refers to objects STATE(prom), RCVR(prom), and SCHED(prom) associated with tsk during evaluation of task​::​state<Rcvr>​::​start for some receiver Rcvr.
🔗
task get_return_object() noexcept;
2
#
Returns: A task object whose member handle is coroutine_handle<promise_type>​::​​from_promise​(*this).
🔗
auto final_suspend() noexcept;
3
#
Returns: An awaitable object of unspecified type ([expr.await]) whose member functions arrange for the completion of the asynchronous operation associated with STATE(*this).
Let st be a reference to STATE(*this).
The asynchronous completion first destroys the coroutine frame using st.handle.destroy() and then invokes:
  • (3.1)
    set_error(std​::​move(st.rcvr), std​::​move(st.error)) if bool(st.error) is true, otherwise
  • (3.2)
    set_value(std​::​move(st.rcvr)) if is_void_v<T> is true, and otherwise
  • (3.3)
    set_value(std​::​move(st.rcvr), *std​::​move(st.result)).
🔗
template<class Err> auto yield_value(with_error<Err> err);
4
#
Mandates: std​::​move(err.error) is convertible to exactly one of the set_error_t argument types of error_types.
Let Cerr be that type.
5
#
Returns: An awaitable object of unspecified type ([expr.await]) whose member functions arrange for the calling coroutine to be suspended and then completes the asynchronous operation associated with STATE(*this).
Let st be a reference to STATE(*this).
Then the asynchronous operation completes by first destroying the coroutine frame using st.handle.destroy() and then invoking set_error(std​::​move(st.rcvr), Cerr(std​::​move(err.error))).
🔗
template<sender Sender> auto await_transform(Sender&& sndr);
6
#
Returns: If same_as<inline_scheduler, start_scheduler_type> is true, returns as_awaitable(​std​::​forward<Sender>(sndr), *this); otherwise returns as_awaitable(affine(std​::​forward<​Sender>(sndr)), *this).
🔗
void unhandled_exception();
7
#
Effects: If the signature set_error_t(exception_ptr) is not an element of error_types, calls terminate() ([except.terminate]).
Otherwise, stores current_exception() into STATE(*this).error.
🔗
coroutine_handle<> unhandled_stopped() noexcept;
8
#
Effects: Completes the asynchronous operation associated with STATE(*this).
Let st be a reference to STATE(*this).
The asynchronous operation is completed by first destroying the coroutine frame using st.handle.destroy() and then invoking set_stopped(std​::​move(st.rcvr)).
9
#
Returns: noop_coroutine().
🔗
void return_void();
10
#
Effects: Does nothing.
🔗
template<class V> void return_value(V&& v);
11
#
Effects: Equivalent to result.emplace(std​::​forward<V>(v)).
🔗
unspecified get_env() const noexcept;
12
#
Returns: An object env such that queries are forwarded as follows:
  • (12.1)
    env.query(get_start_scheduler) returns start_scheduler_type(SCHED(*this)).
  • (12.2)
    env.query(get_allocator) returns allocator_type(get_allocator(get_env(RCVR(*this))​)) if this expression is well-formed and allocator_type() otherwise.
  • (12.3)
    env.query(get_stop_token) returns STATE(*this).get-stop-token().
  • (12.4)
    For any other query q and arguments a... a call to env.query(q, a...) returns STATE(*this).
    environment.query(q, a...) if this expression is well-formed and forwarding_query(q) is well-formed and is true.
    Otherwise env.query(q, a...) is ill-formed.
🔗
void* operator new(size_t size);
13
#
Effects: Equivalent to: return operator new(size, allocator_arg, allocator_type());
🔗
template<class Alloc, class... Args> void* operator new(size_t size, allocator_arg_t, Alloc alloc, Args&&...); template<class This, class Alloc, class... Args> void* operator new(size_t size, const This&, allocator_arg_t, Alloc alloc, Args&&...);
14
#
Let PAlloc be allocator_traits<Alloc>​::​template rebind_alloc<U>, where U is an unspecified type whose size and alignment are both __STDCPP_DEFAULT_NEW_ALIGNMENT__.
15
#
Mandates: allocator_traits<PAlloc>​::​pointer is a pointer type.
16
#
Effects: Initializes an allocator palloc of type PAlloc with alloc.
Uses palloc to allocate storage for the smallest array of U sufficient to provide storage for a coroutine state of size size, and unspecified additional state necessary to ensure that operator delete can later deallocate this memory block with an allocator equal to palloc.
17
#
Returns: A pointer to the allocated storage.
🔗
void operator delete(void* pointer, size_t size) noexcept;
18
#
Preconditions: pointer was returned from an invocation of the above overload of operator new with a size argument equal to size.
19
#
Effects: Deallocates the storage pointed to by pointer using an allocator equal to that used to allocate it.