Subclause | Header | |
Schedulers | <execution> | |
Receivers | ||
Operation states | ||
Senders |
Customization point | Purpose | Examples |
object type | ||
core | provide core execution functionality, and connection between core components | |
completion functions | called by senders to announce the completion of the work (success, error, or cancellation) | |
senders | allow the specialization of the provided sender algorithms | |
queries | allow querying different properties of objects |
|
template<class Default = default_domain, class Sndr>
constexpr auto completion-domain(const Sndr& sndr) noexcept;
template<class Tag, class Env, class Default>
constexpr decltype(auto) query-with-default(
Tag, const Env& env, Default&& value) noexcept(see below);
template<class Sndr>
constexpr auto get-domain-early(const Sndr& sndr) noexcept;
template<class Sndr, class Env>
constexpr auto get-domain-late(const Sndr& sndr, const Env& env) noexcept;
template<size_t I, class Self>
constexpr decltype(auto) get(this Self&& self) noexcept;
template<class Tag, class Data = see below, class... Child>
constexpr auto make-sender(Tag tag, Data&& data, Child&&... child);
[]<class Sndr, class Rcvr, size_t... Is>(
basic-state<Sndr, Rcvr>* op, Sndr&& sndr, index_sequence<Is...>) noexcept(see below)
-> decltype(auto) {
auto& [_, data, ...child] = sndr;
return product-type{connect(
std::forward_like<Sndr>(child),
basic-receiver<Sndr, Rcvr, integral_constant<size_t, Is>>{op})...};
}
template<class Sndr, class... Env>
static consteval void default-impls::check-types();
template<class Tag, class Data, class... Child>
template<class Sndr, class... Env>
constexpr auto basic-sender<Tag, Data, Child...>::get_completion_signatures();
template<class T, class Context>
decltype(auto) allocator-aware-forward(T&& obj, Context&& context); // exposition only
template<class Sndr, class... Env>
consteval auto get_completion_signatures() -> valid-completion-signatures auto;
template<class Sndr, class Env>
static consteval void check-types();
template<class Sndr, class... Env>
static consteval void check-types();
template<class Sndr, class... Env>
static consteval void check-types();
template<class Sndr, class... Env>
static consteval void check-types();
template<class Sndr, class... Env>
static consteval void check-types();
template<class Sndr, class... Env>
static consteval void check-types();
associate-data(const associate-data& other)
noexcept(is_nothrow_copy_constructible_v<wrap-sender> &&
noexcept(other.token.try_associate()));
associate-data(associate-data&& other)
noexcept(is_nothrow_move_constructible_v<wrap-sender>);
~associate-data();
optional<pair<Token, wrap-sender>>
release() && noexcept(is_nothrow_move_constructible_v<wrap-sender>);
void complete() noexcept;
void abandon() noexcept;
void destroy() noexcept;
template<class... Args>
void set_value(Args&&... args) && noexcept;
template<class Error>
void set_error(Error&& err) && noexcept;
void set_stopped() && noexcept;
spawn-state(Alloc alloc, Sender&& sndr, Token token);
void run();
void complete() noexcept override;
void destroy() noexcept;
template<class QueryTag>
constexpr decltype(auto) query(QueryTag q) const noexcept(see below);
class run-loop-scheduler;
class run-loop-sender;
template<class Rcvr>
struct run-loop-opstate;
run_loop() noexcept;
~run_loop();
run-loop-opstate-base* pop-front();
void push-back(run-loop-opstate-base* item);
run-loop-scheduler get_scheduler();
void run();
void finish();
sender-awaitable(Sndr&& sndr, Promise& p);
value-type await_resume();
template<class Value>
call-result-t<as_awaitable_t, Value, Promise&> await_transform(Value&& value);
ts-sender schedule();
bool operator==(const task_scheduler& lhs, const task_scheduler& rhs) noexcept;
void start() & noexcept;
template<class R>
state(coroutine_handle<promise_type> h, R&& rr);
~state();
void start() & noexcept;
template<class... Args>
promise_type(const Args&... args);
task get_return_object() noexcept;
auto initial_suspend() noexcept;
auto final_suspend() noexcept;
template<class Err>
auto yield_value(with_error<Err> err);
template<class Sch>
auto await_transform(change_coroutine_scheduler<Sch> sch) noexcept;
void uncaught_exception();
coroutine_handle<> unhandled_stopped();
unspecified get_env() const noexcept;
template<class... Args>
void* operator new(size_t size, const Args&... args);
void operator delete(void* pointer, size_t size) noexcept;
simple_counting_scope() noexcept;
~simple_counting_scope();
token get_token() noexcept;
void close() noexcept;
bool try-associate() noexcept;
void disassociate() noexcept;
template<class State>
bool start-join-sender(State& st) noexcept;
bool try_associate() const noexcept;
void disassociate() const noexcept;
token get_token() noexcept;
void request_stop() noexcept;
parallel_scheduler get_parallel_scheduler();
shared_ptr<parallel_scheduler_backend> query_parallel_scheduler_backend();
template<class P, class-type Query>
optional<P> try_query(Query q) noexcept;
virtual void schedule(receiver_proxy& r, span<byte> s) noexcept = 0;
virtual void schedule_bulk_chunked(size_t n, bulk_item_receiver_proxy& r,
span<byte> s) noexcept = 0;
virtual void schedule_bulk_unchunked(size_t n, bulk_item_receiver_proxy& r,
span<byte> s) noexcept = 0;