stdexec: update to latest
* Add a .clang-format-ignore for the stdexec and stop running
clang-format on it. This makes it identical to the stdexec
source.
* Add a warning exception for -Wempty-body.
* Remove a requirement constraint on the spawn function. The
sender_of constraint can no longer analyze certain stdexec
generated classes and appears to be deprecated. In the future
I may be able to figure out a newer constraint for better
diagnostics, but this is only for diagnostic purposes.
Signed-off-by: Patrick Williams <patrick@stwcx.xyz>
Change-Id: Ic29b7052b1e3a1818fbbfbd42aefe2990f4295c7
diff --git a/.clang-format-ignore b/.clang-format-ignore
new file mode 100644
index 0000000..391761f
--- /dev/null
+++ b/.clang-format-ignore
@@ -0,0 +1 @@
+include/sdbusplus/async/stdexec/**
diff --git a/include/sdbusplus/async/context.hpp b/include/sdbusplus/async/context.hpp
index 9ba424d..1041014 100644
--- a/include/sdbusplus/async/context.hpp
+++ b/include/sdbusplus/async/context.hpp
@@ -17,6 +17,7 @@
{
struct wait_process_completion;
struct context_friend;
+
} // namespace details
/** @brief A run-loop context for handling asynchronous dbus operations.
@@ -56,7 +57,7 @@
*
* @param[in] sender - The Sender to run.
*/
- template <execution::sender_of<execution::set_value_t()> Snd>
+ template <typename Snd>
void spawn(Snd&& sender)
{
check_stop_requested();
diff --git a/include/sdbusplus/async/execution.hpp b/include/sdbusplus/async/execution.hpp
index 8f6cf58..a685d14 100644
--- a/include/sdbusplus/async/execution.hpp
+++ b/include/sdbusplus/async/execution.hpp
@@ -12,6 +12,7 @@
#else
#pragma GCC diagnostic ignored "-Wnon-template-friend"
#endif
+#pragma GCC diagnostic ignored "-Wempty-body"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include <sdbusplus/async/stdexec/async_scope.hpp>
diff --git a/include/sdbusplus/async/stdexec/__detail/__any_receiver_ref.hpp b/include/sdbusplus/async/stdexec/__detail/__any_receiver_ref.hpp
new file mode 100644
index 0000000..e33861f
--- /dev/null
+++ b/include/sdbusplus/async/stdexec/__detail/__any_receiver_ref.hpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2021-2024 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "__execution_fwd.hpp"
+
+#include "__completion_signatures.hpp"
+#include "__receivers.hpp"
+
+#include <functional>
+
+namespace stdexec::__any_ {
+ template <class _Sig>
+ struct __rcvr_vfun;
+
+ template <class _Tag, class... _Args>
+ struct __rcvr_vfun<_Tag(_Args...)> {
+ void (*__complete_)(void*, _Args...) noexcept;
+
+ void operator()(void* __obj, _Tag, _Args... __args) const noexcept {
+ __complete_(__obj, static_cast<_Args&&>(__args)...);
+ }
+ };
+
+ template <class _GetReceiver = std::identity, class _Obj, class _Tag, class... _Args>
+ constexpr auto __rcvr_vfun_fn(_Obj*, _Tag (*)(_Args...)) noexcept {
+ return +[](void* __ptr, _Args... __args) noexcept {
+ _Obj* __obj = static_cast<_Obj*>(__ptr);
+ _Tag()(std::move(_GetReceiver()(*__obj)), static_cast<_Args&&>(__args)...);
+ };
+ }
+
+ template <class _Sigs, class _Env>
+ struct __receiver_vtable_for;
+
+ template <class _Env, class... _Sigs>
+ struct __receiver_vtable_for<completion_signatures<_Sigs...>, _Env> : __rcvr_vfun<_Sigs>... {
+ _Env (*__do_get_env)(const void* __op_state) noexcept;
+
+ template <class _OpState, class _GetEnv>
+ static auto __s_get_env(const void* __ptr) noexcept -> _Env {
+ auto* __op_state = static_cast<const _OpState*>(__ptr);
+ return _GetEnv()(*__op_state);
+ }
+
+ template <class _OpState, class _GetEnv, class _GetReceiver = std::identity>
+ explicit constexpr __receiver_vtable_for(_OpState* __op, _GetEnv, _GetReceiver = {}) noexcept
+ : __rcvr_vfun<_Sigs>{__rcvr_vfun_fn<_GetReceiver>(__op, static_cast<_Sigs*>(nullptr))}...
+ , __do_get_env{&__s_get_env<_OpState, _GetEnv>} {
+ }
+
+ template <class _Tag, class... _Args>
+ requires __one_of<_Tag(_Args...), _Sigs...>
+ void operator()(void* __obj, _Tag, _Args&&... __args) const noexcept {
+ const __rcvr_vfun<_Tag(_Args...)>& __vfun = *this;
+ __vfun(__obj, _Tag{}, static_cast<_Args&&>(__args)...);
+ }
+
+ auto __get_env(const void* __op_state) const noexcept -> _Env {
+ return __do_get_env(__op_state);
+ }
+ };
+
+ template <class _OpState, class _GetEnv, class _GetReceiver, class _Env, class _Sigs>
+ inline constexpr __receiver_vtable_for<_Sigs, _Env>
+ __receiver_vtable_for_v{static_cast<_OpState*>(nullptr), _GetEnv{}, _GetReceiver{}};
+
+ template <class _Sigs, class _Env = env<>>
+ class __receiver_ref {
+ public:
+ using receiver_concept = receiver_t;
+ using __t = __receiver_ref;
+ using __id = __receiver_ref;
+
+ template <class _OpState, class _GetEnv, class _GetReceiver = std::identity>
+ __receiver_ref(_OpState& __op_state, _GetEnv, _GetReceiver = {}) noexcept
+ : __vtable_{&__any_::__receiver_vtable_for_v<_OpState, _GetEnv, _GetReceiver, _Env, _Sigs>}
+ , __op_state_{&__op_state} {
+ }
+
+ auto get_env() const noexcept -> decltype(auto) {
+ return __vtable_->__get_env(__op_state_);
+ }
+
+ template <class... _As>
+ requires __callable<__receiver_vtable_for<_Sigs, _Env>, void*, set_value_t, _As...>
+ void set_value(_As&&... __as) noexcept {
+ (*__vtable_)(__op_state_, set_value_t(), static_cast<_As&&>(__as)...);
+ }
+
+ template <class _Error>
+ requires __callable<__receiver_vtable_for<_Sigs, _Env>, void*, set_error_t, _Error>
+ void set_error(_Error&& __err) noexcept {
+ (*__vtable_)(__op_state_, set_error_t(), static_cast<_Error&&>(__err));
+ }
+
+ void set_stopped() noexcept
+ requires __callable<__receiver_vtable_for<_Sigs, _Env>, void*, set_stopped_t>
+ {
+ (*__vtable_)(__op_state_, set_stopped_t());
+ }
+
+ private:
+ const __receiver_vtable_for<_Sigs, _Env>* __vtable_;
+ void* __op_state_;
+ };
+} // namespace stdexec::__any_
diff --git a/include/sdbusplus/async/stdexec/__detail/__as_awaitable.hpp b/include/sdbusplus/async/stdexec/__detail/__as_awaitable.hpp
index e68ef30..2009084 100644
--- a/include/sdbusplus/async/stdexec/__detail/__as_awaitable.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__as_awaitable.hpp
@@ -15,11 +15,11 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__awaitable.hpp"
#include "__concepts.hpp"
#include "__config.hpp"
-#include "__cpo.hpp"
-#include "__execution_fwd.hpp"
#include "__meta.hpp"
#include "__receivers.hpp"
#include "__senders.hpp"
@@ -31,265 +31,233 @@
#include <system_error>
#include <variant>
-namespace stdexec
-{
+namespace stdexec {
#if !STDEXEC_STD_NO_COROUTINES()
-/////////////////////////////////////////////////////////////////////////////
-// stdexec::as_awaitable [execution.coro_utils.as_awaitable]
-namespace __as_awaitable
-{
-struct __void
-{};
+ /////////////////////////////////////////////////////////////////////////////
+ // stdexec::as_awaitable [execution.coro_utils.as_awaitable]
+ namespace __as_awaitable {
+ struct __void { };
-template <class _Value>
-using __value_or_void_t = __if_c<__same_as<_Value, void>, __void, _Value>;
+ template <class _Value>
+ using __value_or_void_t = __if_c<__same_as<_Value, void>, __void, _Value>;
-template <class _Value>
-using __expected_t =
- std::variant<std::monostate, __value_or_void_t<_Value>, std::exception_ptr>;
+ template <class _Value>
+ using __expected_t =
+ std::variant<std::monostate, __value_or_void_t<_Value>, std::exception_ptr>;
-template <class _Value>
-struct __receiver_base
-{
- using receiver_concept = receiver_t;
+ template <class _Value>
+ struct __receiver_base {
+ using receiver_concept = receiver_t;
- template <class... _Us>
+ template <class... _Us>
requires constructible_from<__value_or_void_t<_Value>, _Us...>
- void set_value(_Us&&... __us) noexcept
- {
- try
- {
- __result_->template emplace<1>(static_cast<_Us&&>(__us)...);
- __continuation_.resume();
+ void set_value(_Us&&... __us) noexcept {
+ STDEXEC_TRY {
+ __result_->template emplace<1>(static_cast<_Us&&>(__us)...);
+ __continuation_.resume();
}
- catch (...)
- {
- stdexec::set_error(static_cast<__receiver_base&&>(*this),
- std::current_exception());
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<__receiver_base&&>(*this), std::current_exception());
}
- }
+ }
- template <class _Error>
- void set_error(_Error&& __err) noexcept
- {
+ template <class _Error>
+ void set_error(_Error&& __err) noexcept {
if constexpr (__decays_to<_Error, std::exception_ptr>)
- __result_->template emplace<2>(static_cast<_Error&&>(__err));
+ __result_->template emplace<2>(static_cast<_Error&&>(__err));
else if constexpr (__decays_to<_Error, std::error_code>)
- __result_->template emplace<2>(
- std::make_exception_ptr(std::system_error(__err)));
+ __result_->template emplace<2>(std::make_exception_ptr(std::system_error(__err)));
else
- __result_->template emplace<2>(
- std::make_exception_ptr(static_cast<_Error&&>(__err)));
+ __result_->template emplace<2>(std::make_exception_ptr(static_cast<_Error&&>(__err)));
__continuation_.resume();
- }
+ }
- __expected_t<_Value>* __result_;
- __coro::coroutine_handle<> __continuation_;
-};
+ __expected_t<_Value>* __result_;
+ __coro::coroutine_handle<> __continuation_;
+ };
-template <class _PromiseId, class _Value>
-struct __receiver
-{
- using _Promise = stdexec::__t<_PromiseId>;
+ template <class _PromiseId, class _Value>
+ struct __receiver {
+ using _Promise = stdexec::__t<_PromiseId>;
- struct __t : __receiver_base<_Value>
- {
+ struct __t : __receiver_base<_Value> {
using __id = __receiver;
- void set_stopped() noexcept
- {
- auto __continuation =
- __coro::coroutine_handle<_Promise>::from_address(
- this->__continuation_.address());
- __coro::coroutine_handle<> __stopped_continuation =
- __continuation.promise().unhandled_stopped();
- __stopped_continuation.resume();
+ void set_stopped() noexcept {
+ auto __continuation = __coro::coroutine_handle<_Promise>::from_address(
+ this->__continuation_.address());
+ __coro::coroutine_handle<> __stopped_continuation = __continuation.promise()
+ .unhandled_stopped();
+ __stopped_continuation.resume();
}
// Forward get_env query to the coroutine promise
- auto get_env() const noexcept -> env_of_t<_Promise&>
- {
- auto __continuation =
- __coro::coroutine_handle<_Promise>::from_address(
- this->__continuation_.address());
- return stdexec::get_env(__continuation.promise());
+ auto get_env() const noexcept -> env_of_t<_Promise&> {
+ auto __continuation = __coro::coroutine_handle<_Promise>::from_address(
+ this->__continuation_.address());
+ return stdexec::get_env(__continuation.promise());
}
+ };
};
-};
-// BUGBUG NOT TO SPEC: make senders of more-than-one-value awaitable
-// by packaging the values into a tuple.
-// See: https://github.com/cplusplus/sender-receiver/issues/182
-template <std::size_t _Count>
-extern const __q<__decayed_std_tuple> __as_single;
+ // BUGBUG NOT TO SPEC: make senders of more-than-one-value awaitable
+ // by packaging the values into a tuple.
+ // See: https://github.com/cplusplus/sender-receiver/issues/182
+ template <std::size_t _Count>
+ extern const __q<__decayed_std_tuple> __as_single;
-template <>
-inline const __q<__midentity> __as_single<1>;
+ template <>
+ inline const __q<__midentity> __as_single<1>;
-template <>
-inline const __mconst<void> __as_single<0>;
+ template <>
+ inline const __mconst<void> __as_single<0>;
-template <class... _Values>
-using __single_value =
- __minvoke<decltype(__as_single<sizeof...(_Values)>), _Values...>;
+ template <class... _Values>
+ using __single_value = __minvoke<decltype(__as_single<sizeof...(_Values)>), _Values...>;
-template <class _Sender, class _Promise>
-using __value_t =
- __decay_t<__value_types_of_t<_Sender, env_of_t<_Promise&>,
- __q<__single_value>, __msingle_or<void>>>;
+ template <class _Sender, class _Promise>
+ using __value_t = __decay_t<
+ __value_types_of_t<_Sender, env_of_t<_Promise&>, __q<__single_value>, __msingle_or<void>>
+ >;
-template <class _Sender, class _Promise>
-using __receiver_t =
- __t<__receiver<__id<_Promise>, __value_t<_Sender, _Promise>>>;
+ template <class _Sender, class _Promise>
+ using __receiver_t = __t<__receiver<__id<_Promise>, __value_t<_Sender, _Promise>>>;
-template <class _Value>
-struct __sender_awaitable_base
-{
- [[nodiscard]] auto await_ready() const noexcept -> bool
- {
+ template <class _Value>
+ struct __sender_awaitable_base {
+ [[nodiscard]]
+ auto await_ready() const noexcept -> bool {
return false;
- }
+ }
- auto await_resume() -> _Value
- {
- switch (__result_.index())
- {
- case 0: // receiver contract not satisfied
- STDEXEC_ASSERT(false && +"_Should never get here" == nullptr);
- break;
- case 1: // set_value
- if constexpr (!__same_as<_Value, void>)
- return static_cast<_Value&&>(std::get<1>(__result_));
- else
- return;
- case 2: // set_error
- std::rethrow_exception(std::get<2>(__result_));
+ auto await_resume() -> _Value {
+ switch (__result_.index()) {
+ case 0: // receiver contract not satisfied
+ STDEXEC_ASSERT(false && +"_Should never get here" == nullptr);
+ break;
+ case 1: // set_value
+ if constexpr (!__same_as<_Value, void>)
+ return static_cast<_Value&&>(std::get<1>(__result_));
+ else
+ return;
+ case 2: // set_error
+ std::rethrow_exception(std::get<2>(__result_));
}
std::terminate();
- }
+ }
- protected:
- __expected_t<_Value> __result_;
-};
+ protected:
+ __expected_t<_Value> __result_;
+ };
-template <class _PromiseId, class _SenderId>
-struct __sender_awaitable
-{
- using _Promise = stdexec::__t<_PromiseId>;
- using _Sender = stdexec::__t<_SenderId>;
- using __value = __value_t<_Sender, _Promise>;
+ template <class _PromiseId, class _SenderId>
+ struct __sender_awaitable {
+ using _Promise = stdexec::__t<_PromiseId>;
+ using _Sender = stdexec::__t<_SenderId>;
+ using __value = __value_t<_Sender, _Promise>;
- struct __t : __sender_awaitable_base<__value>
- {
- __t(_Sender&& sndr, __coro::coroutine_handle<_Promise> __hcoro) //
- noexcept(__nothrow_connectable<_Sender, __receiver>) :
- __op_state_(connect(static_cast<_Sender&&>(sndr),
- __receiver{{&this->__result_, __hcoro}}))
- {}
-
- void await_suspend(__coro::coroutine_handle<_Promise>) noexcept
- {
- stdexec::start(__op_state_);
+ struct __t : __sender_awaitable_base<__value> {
+ __t(_Sender&& sndr, __coro::coroutine_handle<_Promise> __hcoro)
+ noexcept(__nothrow_connectable<_Sender, __receiver>)
+ : __op_state_(connect(
+ static_cast<_Sender&&>(sndr),
+ __receiver{
+ {&this->__result_, __hcoro}
+ })) {
}
- private:
+ void await_suspend(__coro::coroutine_handle<_Promise>) noexcept {
+ stdexec::start(__op_state_);
+ }
+
+ private:
using __receiver = __receiver_t<_Sender, _Promise>;
connect_result_t<_Sender, __receiver> __op_state_;
- };
-};
-
-template <class _Promise, class _Sender>
-using __sender_awaitable_t =
- __t<__sender_awaitable<__id<_Promise>, __id<_Sender>>>;
-
-template <class _Sender, class _Promise>
-concept __awaitable_sender =
- sender_in<_Sender, env_of_t<_Promise&>> && //
- __mvalid<__value_t, _Sender, _Promise> && //
- sender_to<_Sender, __receiver_t<_Sender, _Promise>> && //
- requires(_Promise& __promise) {
- {
- __promise.unhandled_stopped()
- } -> convertible_to<__coro::coroutine_handle<>>;
+ };
};
-struct __unspecified
-{
- auto get_return_object() noexcept -> __unspecified;
- auto initial_suspend() noexcept -> __unspecified;
- auto final_suspend() noexcept -> __unspecified;
- void unhandled_exception() noexcept;
- void return_void() noexcept;
- auto unhandled_stopped() noexcept -> __coro::coroutine_handle<>;
-};
+ template <class _Promise, class _Sender>
+ using __sender_awaitable_t = __t<__sender_awaitable<__id<_Promise>, __id<_Sender>>>;
-struct as_awaitable_t
-{
- template <class _Tp, class _Promise>
- static constexpr auto __select_impl_() noexcept
- {
- if constexpr (tag_invocable<as_awaitable_t, _Tp, _Promise&>)
- {
- using _Result = tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&>;
- constexpr bool _Nothrow =
- nothrow_tag_invocable<as_awaitable_t, _Tp, _Promise&>;
- return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
- // NOLINTNEXTLINE(bugprone-branch-clone)
- }
- else if constexpr (__awaitable<_Tp, __unspecified>)
- { // NOT __awaitable<_Tp, _Promise> !!
- using _Result = _Tp&&;
- return static_cast<_Result (*)() noexcept>(nullptr);
- }
- else if constexpr (__awaitable_sender<_Tp, _Promise>)
- {
- using _Result = __sender_awaitable_t<_Promise, _Tp>;
- constexpr bool _Nothrow = __nothrow_constructible_from<
- _Result, _Tp, __coro::coroutine_handle<_Promise>>;
- return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
- }
- else
- {
- using _Result = _Tp&&;
- return static_cast<_Result (*)() noexcept>(nullptr);
- }
- }
+ template <class _Sender, class _Promise>
+ concept __awaitable_sender = sender_in<_Sender, env_of_t<_Promise&>>
+ && __mvalid<__value_t, _Sender, _Promise>
+ && sender_to<_Sender, __receiver_t<_Sender, _Promise>>
+ && requires(_Promise& __promise) {
+ {
+ __promise.unhandled_stopped()
+ } -> convertible_to<__coro::coroutine_handle<>>;
+ };
+
+ struct __unspecified {
+ auto get_return_object() noexcept -> __unspecified;
+ auto initial_suspend() noexcept -> __unspecified;
+ auto final_suspend() noexcept -> __unspecified;
+ void unhandled_exception() noexcept;
+ void return_void() noexcept;
+ auto unhandled_stopped() noexcept -> __coro::coroutine_handle<>;
+ };
template <class _Tp, class _Promise>
- using __select_impl_t = decltype(__select_impl_<_Tp, _Promise>());
+ concept __has_as_awaitable_member = requires(_Tp&& __t, _Promise& __promise) {
+ static_cast<_Tp &&>(__t).as_awaitable(__promise);
+ };
- template <class _Tp, class _Promise>
- auto operator()(_Tp&& __t, _Promise& __promise) const
+ struct as_awaitable_t {
+ template <class _Tp, class _Promise>
+ static constexpr auto __select_impl_() noexcept {
+ if constexpr (__has_as_awaitable_member<_Tp, _Promise>) {
+ using _Result = decltype(__declval<_Tp>().as_awaitable(__declval<_Promise&>()));
+ constexpr bool _Nothrow = noexcept(__declval<_Tp>().as_awaitable(__declval<_Promise&>()));
+ return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (tag_invocable<as_awaitable_t, _Tp, _Promise&>) {
+ using _Result = tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&>;
+ constexpr bool _Nothrow = nothrow_tag_invocable<as_awaitable_t, _Tp, _Promise&>;
+ return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
+ // NOLINTNEXTLINE(bugprone-branch-clone)
+ } else if constexpr (__awaitable<_Tp, __unspecified>) { // NOT __awaitable<_Tp, _Promise> !!
+ using _Result = _Tp&&;
+ return static_cast<_Result (*)() noexcept>(nullptr);
+ } else if constexpr (__awaitable_sender<_Tp, _Promise>) {
+ using _Result = __sender_awaitable_t<_Promise, _Tp>;
+ constexpr bool _Nothrow =
+ __nothrow_constructible_from<_Result, _Tp, __coro::coroutine_handle<_Promise>>;
+ return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
+ } else {
+ using _Result = _Tp&&;
+ return static_cast<_Result (*)() noexcept>(nullptr);
+ }
+ }
+
+ template <class _Tp, class _Promise>
+ using __select_impl_t = decltype(__select_impl_<_Tp, _Promise>());
+
+ template <class _Tp, class _Promise>
+ auto operator()(_Tp&& __t, _Promise& __promise) const
noexcept(__nothrow_callable<__select_impl_t<_Tp, _Promise>>)
- -> __call_result_t<__select_impl_t<_Tp, _Promise>>
- {
- if constexpr (tag_invocable<as_awaitable_t, _Tp, _Promise&>)
- {
- using _Result = tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&>;
- static_assert(__awaitable<_Result, _Promise>);
- return tag_invoke(*this, static_cast<_Tp&&>(__t), __promise);
- // NOLINTNEXTLINE(bugprone-branch-clone)
+ -> __call_result_t<__select_impl_t<_Tp, _Promise>> {
+ if constexpr (__has_as_awaitable_member<_Tp, _Promise>) {
+ using _Result = decltype(static_cast<_Tp&&>(__t).as_awaitable(__promise));
+ static_assert(__awaitable<_Result, _Promise>);
+ return static_cast<_Tp&&>(__t).as_awaitable(__promise);
+ } else if constexpr (tag_invocable<as_awaitable_t, _Tp, _Promise&>) {
+ using _Result = tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&>;
+ static_assert(__awaitable<_Result, _Promise>);
+ return tag_invoke(*this, static_cast<_Tp&&>(__t), __promise);
+ // NOLINTNEXTLINE(bugprone-branch-clone)
+ } else if constexpr (__awaitable<_Tp, __unspecified>) { // NOT __awaitable<_Tp, _Promise> !!
+ return static_cast<_Tp&&>(__t);
+ } else if constexpr (__awaitable_sender<_Tp, _Promise>) {
+ auto __hcoro = __coro::coroutine_handle<_Promise>::from_promise(__promise);
+ return __sender_awaitable_t<_Promise, _Tp>{static_cast<_Tp&&>(__t), __hcoro};
+ } else {
+ return static_cast<_Tp&&>(__t);
}
- else if constexpr (__awaitable<_Tp, __unspecified>)
- { // NOT __awaitable<_Tp, _Promise> !!
- return static_cast<_Tp&&>(__t);
- }
- else if constexpr (__awaitable_sender<_Tp, _Promise>)
- {
- auto __hcoro =
- __coro::coroutine_handle<_Promise>::from_promise(__promise);
- return __sender_awaitable_t<_Promise, _Tp>{static_cast<_Tp&&>(__t),
- __hcoro};
- }
- else
- {
- return static_cast<_Tp&&>(__t);
- }
- }
-};
-} // namespace __as_awaitable
+ }
+ };
+ } // namespace __as_awaitable
-using __as_awaitable::as_awaitable_t;
-inline constexpr as_awaitable_t as_awaitable{};
+ using __as_awaitable::as_awaitable_t;
+ inline constexpr as_awaitable_t as_awaitable{};
#endif
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__awaitable.hpp b/include/sdbusplus/async/stdexec/__detail/__awaitable.hpp
index b61fbc4..5bd587a 100644
--- a/include/sdbusplus/async/stdexec/__detail/__awaitable.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__awaitable.hpp
@@ -15,137 +15,98 @@
*/
#pragma once
-#include "__concepts.hpp"
#include "__config.hpp"
+#include "__concepts.hpp"
#include "__utility.hpp"
-namespace stdexec
-{
+namespace stdexec {
#if !STDEXEC_STD_NO_COROUTINES()
-// Define some concepts and utilities for working with awaitables
-template <class _Tp>
-concept __await_suspend_result =
- __one_of<_Tp, void, bool> ||
- __is_instance_of<_Tp, __coro::coroutine_handle>;
+ // Define some concepts and utilities for working with awaitables
+ template <class _Tp>
+ concept __await_suspend_result = __one_of<_Tp, void, bool>
+ || __is_instance_of<_Tp, __coro::coroutine_handle>;
-template <class _Awaiter, class _Promise>
-concept __with_await_suspend =
- requires(_Awaiter& __awaiter, __coro::coroutine_handle<_Promise> __h) {
- { __awaiter.await_suspend(__h) } -> __await_suspend_result;
- };
+ template <class _Awaiter, class... _Promise>
+ concept __awaiter = requires(_Awaiter& __awaiter, __coro::coroutine_handle<_Promise...> __h) {
+ __awaiter.await_ready() ? 1 : 0;
+ { __awaiter.await_suspend(__h) } -> __await_suspend_result;
+ __awaiter.await_resume();
+ };
-template <class _Awaiter, class... _Promise>
-concept __awaiter = //
- requires(_Awaiter& __awaiter) {
- __awaiter.await_ready() ? 1 : 0;
- __awaiter.await_resume();
- } && //
- (__with_await_suspend<_Awaiter, _Promise> && ...);
+# if STDEXEC_MSVC()
+ // MSVCBUG https://developercommunity.visualstudio.com/t/operator-co_await-not-found-in-requires/10452721
-#if STDEXEC_MSVC()
-// MSVCBUG
-// https://developercommunity.visualstudio.com/t/operator-co_await-not-found-in-requires/10452721
+ template <class _Awaitable>
+ void __co_await_constraint(_Awaitable&& __awaitable)
+ requires requires { operator co_await(static_cast<_Awaitable &&>(__awaitable)); };
+# endif
-template <class _Awaitable>
-void __co_await_constraint(_Awaitable&& __awaitable)
- requires requires {
- operator co_await(static_cast<_Awaitable&&>(__awaitable));
- };
-#endif
-
-template <class _Awaitable>
-auto __get_awaiter(_Awaitable&& __awaitable, __ignore = {}) -> decltype(auto)
-{
- if constexpr (requires {
- static_cast<_Awaitable&&>(__awaitable)
- .operator co_await();
- })
- {
- return static_cast<_Awaitable&&>(__awaitable).operator co_await();
- }
- else if constexpr (requires {
-#if STDEXEC_MSVC()
- __co_await_constraint(
- static_cast<_Awaitable&&>(__awaitable));
-#else
+ template <class _Awaitable>
+ auto __get_awaiter(_Awaitable&& __awaitable, __ignore = {}) -> decltype(auto) {
+ if constexpr (requires { static_cast<_Awaitable &&>(__awaitable).operator co_await(); }) {
+ return static_cast<_Awaitable&&>(__awaitable).operator co_await();
+ } else if constexpr (requires {
+# if STDEXEC_MSVC()
+ __co_await_constraint(static_cast<_Awaitable &&>(__awaitable));
+# else
operator co_await(static_cast<_Awaitable&&>(__awaitable));
-#endif
- })
- {
- return operator co_await(static_cast<_Awaitable&&>(__awaitable));
+# endif
+ }) {
+ return operator co_await(static_cast<_Awaitable&&>(__awaitable));
+ } else {
+ return static_cast<_Awaitable&&>(__awaitable);
}
- else
- {
- return static_cast<_Awaitable&&>(__awaitable);
- }
-}
+ }
-template <class _Awaitable, class _Promise>
-auto __get_awaiter(_Awaitable&& __awaitable, _Promise* __promise)
- -> decltype(auto)
- requires requires {
- __promise->await_transform(
- static_cast<_Awaitable&&>(__awaitable));
- }
-{
+ template <class _Awaitable, class _Promise>
+ auto __get_awaiter(_Awaitable&& __awaitable, _Promise* __promise) -> decltype(auto)
+ requires requires { __promise->await_transform(static_cast<_Awaitable &&>(__awaitable)); }
+ {
if constexpr (requires {
- __promise
- ->await_transform(
- static_cast<_Awaitable&&>(__awaitable))
- .operator co_await();
- })
- {
- return __promise
- ->await_transform(static_cast<_Awaitable&&>(__awaitable))
- .operator co_await();
- }
- else if constexpr (requires {
-#if STDEXEC_MSVC()
- __co_await_constraint(__promise->await_transform(
- static_cast<_Awaitable&&>(__awaitable)));
-#else
+ __promise->await_transform(static_cast<_Awaitable &&>(__awaitable))
+ .operator co_await();
+ }) {
+ return __promise->await_transform(static_cast<_Awaitable&&>(__awaitable)).operator co_await();
+ } else if constexpr (requires {
+# if STDEXEC_MSVC()
+ __co_await_constraint(
+ __promise->await_transform(static_cast<_Awaitable &&>(__awaitable)));
+# else
operator co_await(__promise->await_transform(static_cast<_Awaitable&&>(__awaitable)));
-#endif
- })
- {
- return operator co_await(
- __promise->await_transform(static_cast<_Awaitable&&>(__awaitable)));
+# endif
+ }) {
+ return operator co_await(__promise->await_transform(static_cast<_Awaitable&&>(__awaitable)));
+ } else {
+ return __promise->await_transform(static_cast<_Awaitable&&>(__awaitable));
}
- else
+ }
+
+ template <class _Awaitable, class... _Promise>
+ concept __awaitable = requires(_Awaitable&& __awaitable, _Promise*... __promise) {
{
- return __promise->await_transform(
- static_cast<_Awaitable&&>(__awaitable));
- }
-}
+ stdexec::__get_awaiter(static_cast<_Awaitable &&>(__awaitable), __promise...)
+ } -> __awaiter<_Promise...>;
+ };
-template <class _Awaitable, class... _Promise>
-concept __awaitable = //
- requires(_Awaitable&& __awaitable, _Promise*... __promise) {
- {
- stdexec::__get_awaiter(static_cast<_Awaitable&&>(__awaitable),
- __promise...)
- } -> __awaiter<_Promise...>;
- };
+ template <class _Tp>
+ auto __as_lvalue(_Tp&&) -> _Tp&;
-template <class _Tp>
-auto __as_lvalue(_Tp&&) -> _Tp&;
-
-template <class _Awaitable, class... _Promise>
+ template <class _Awaitable, class... _Promise>
requires __awaitable<_Awaitable, _Promise...>
-using __await_result_t =
- decltype(stdexec::__as_lvalue(
- stdexec::__get_awaiter(std::declval<_Awaitable>(),
+ using __await_result_t = decltype(stdexec::__as_lvalue(
+ stdexec::__get_awaiter(
+ std::declval<_Awaitable>(),
static_cast<_Promise*>(nullptr)...))
- .await_resume());
+ .await_resume());
#else
-template <class _Awaitable, class... _Promise>
-concept __awaitable = false;
+ template <class _Awaitable, class... _Promise>
+ concept __awaitable = false;
-template <class _Awaitable, class... _Promise>
+ template <class _Awaitable, class... _Promise>
requires __awaitable<_Awaitable, _Promise...>
-using __await_result_t = void;
+ using __await_result_t = void;
#endif
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__basic_sender.hpp b/include/sdbusplus/async/stdexec/__detail/__basic_sender.hpp
index f900744..57a80b3 100644
--- a/include/sdbusplus/async/stdexec/__detail/__basic_sender.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__basic_sender.hpp
@@ -15,721 +15,617 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__concepts.hpp"
#include "__diagnostics.hpp"
#include "__env.hpp"
-#include "__execution_fwd.hpp"
-#include "__manual_lifetime.hpp"
#include "__meta.hpp"
-#include "__sender_introspection.hpp"
#include "__senders_core.hpp"
+#include "__sender_introspection.hpp"
#include "__tuple.hpp"
#include "__type_traits.hpp"
-#include <cstddef>
-#include <type_traits>
#include <utility> // for tuple_size/tuple_element
+#include <cstddef>
+#include <new> // IWYU pragma: keep for placement new
+#include <type_traits>
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// Generic __sender type
-namespace __detail
-{
-template <class _Sender>
-using __impl_of = decltype((__declval<_Sender>().__impl_));
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // Generic __sender type
+ namespace __detail {
+ template <class _Sender>
+ using __impl_of = decltype((__declval<_Sender>().__impl_));
+ } // namespace __detail
-struct __get_data
-{
- template <class _Data>
- STDEXEC_ATTRIBUTE((always_inline))
- _Data&& operator()(__ignore, _Data&& __data, auto&&...) const noexcept
- {
- return static_cast<_Data&&>(__data);
- }
-};
-} // namespace __detail
+ template <
+ class _Descriptor,
+ auto _DescriptorFn =
+ [] {
+ return _Descriptor();
+ }
+ >
+ inline constexpr auto __descriptor_fn_v = _DescriptorFn;
-namespace
-{
-template <class _Descriptor, auto _DescriptorFn = [] { return _Descriptor(); }>
-inline constexpr auto __descriptor_fn_v = _DescriptorFn;
-
-template <class _Tag, class _Data, class... _Child>
-inline constexpr auto __descriptor_fn()
-{
+ template <class _Tag, class _Data, class... _Child>
+ inline constexpr auto __descriptor_fn() {
return __descriptor_fn_v<__detail::__desc<_Tag, _Data, _Child...>>;
-}
-} // namespace
+ }
#if STDEXEC_EDG()
-#define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child) \
+# define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child) \
stdexec::__descriptor_fn<_Tag, _Data, _Child>()
#else
-#define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child) \
+# define STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child) \
stdexec::__descriptor_fn_v<stdexec::__detail::__desc<_Tag, _Data, _Child>>
#endif
-template <class _Tag>
-struct __sexpr_impl;
+ template <class _Tag>
+ struct __sexpr_impl;
-namespace __detail
-{
-template <class _Sexpr, class _Receiver>
-struct __op_state;
+ template <class _Sexpr, class _Receiver>
+ struct __op_state;
-template <class _Sexpr, class _Receiver>
-struct __connect_fn;
+ template <class _ReceiverId, class _Sexpr, std::size_t _Idx>
+ struct __rcvr;
-template <class _Tag, class _Sexpr, class _Receiver>
-using __state_type_t =
- __decay_t<__result_of<__sexpr_impl<_Tag>::get_state, _Sexpr, _Receiver&>>;
+ namespace __detail {
+ template <class _Sexpr, class _Receiver>
+ struct __connect_fn;
-template <class _Self, class _Tag, class _Index, class _Sexpr, class _Receiver>
-using __env_type_t = __result_of<
- __sexpr_impl<__meval<__msecond, _Self, _Tag>>::get_env, _Index,
- __state_type_t<__meval<__msecond, _Self, _Tag>, _Sexpr, _Receiver>&,
- _Receiver&>;
+ template <class _Tag, class _Sexpr, class _Receiver>
+ using __state_type_t =
+ __decay_t<__result_of<__sexpr_impl<_Tag>::get_state, _Sexpr, _Receiver&>>;
-template <class _Sexpr, class _Receiver>
-concept __connectable =
- __callable<__impl_of<_Sexpr>, __copy_cvref_fn<_Sexpr>,
- __connect_fn<_Sexpr, _Receiver>> &&
- __mvalid<__state_type_t, tag_of_t<_Sexpr>, _Sexpr, _Receiver>;
+ template <class _Self, class _Tag, class _Index, class _Sexpr, class _Receiver>
+ using __env_type_t = __result_of<
+ __sexpr_impl<__meval<__msecond, _Self, _Tag>>::get_env,
+ _Index,
+ __state_type_t<__meval<__msecond, _Self, _Tag>, _Sexpr, _Receiver>&,
+ _Receiver&
+ >;
-// // Note: This is UB. UBSAN allows it for now.
-// template <class _Parent, class _Child>
-// _Parent* __parent_from_child(_Child* __child, _Child _Parent::*__mbr_ptr)
-// noexcept {
-// alignas(_Parent) char __buf[sizeof(_Parent)];
-// _Parent* __parent = (_Parent*) &__buf;
-// const std::ptrdiff_t __offset = (char*) &(__parent->*__mbr_ptr) - __buf;
-// return (_Parent*) (static_cast<char*>(__child) - __offset);
-// }
+ template <class _Sexpr, class _Receiver>
+ concept __connectable =
+ __callable<__impl_of<_Sexpr>, __copy_cvref_fn<_Sexpr>, __connect_fn<_Sexpr, _Receiver>>
+ && __mvalid<__state_type_t, tag_of_t<_Sexpr>, _Sexpr, _Receiver>;
-inline constexpr auto __get_attrs = //
- [](__ignore, const auto&... __child) noexcept -> decltype(auto) {
- if constexpr (sizeof...(__child) == 1)
- {
- return stdexec::get_env(
- __child...); // BUGBUG: should be only the forwarding queries
- }
- else
- {
- return empty_env();
- }
-};
+ struct __defaults {
+ static constexpr auto get_attrs =
+ [](__ignore, const auto&... __child) noexcept -> decltype(auto) {
+ if constexpr (sizeof...(__child) == 1) {
+ return __env::__fwd_fn()(stdexec::get_env(__child...));
+ } else {
+ return env<>();
+ }
+ };
-inline constexpr auto __get_env = //
- []<class _Receiver>(__ignore, __ignore, const _Receiver& __rcvr) noexcept
- -> env_of_t<const _Receiver&> { return stdexec::get_env(__rcvr); };
+ static constexpr auto get_env =
+ []<class _Receiver>(__ignore, __ignore, const _Receiver& __rcvr) noexcept
+ -> env_of_t<const _Receiver&> {
+ return stdexec::get_env(__rcvr);
+ };
-inline constexpr auto __get_state = //
- []<class _Sender>(_Sender&& __sndr, __ignore) noexcept -> decltype(auto) {
- return __sndr.apply(static_cast<_Sender&&>(__sndr), __get_data());
-};
+ static constexpr auto get_state =
+ []<class _Sender>(_Sender&& __sndr, __ignore) noexcept -> decltype(auto) {
+ return __sndr.apply(static_cast<_Sender&&>(__sndr), __get_data());
+ };
-inline constexpr auto __connect = //
- []<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver __rcvr) //
- noexcept(__nothrow_constructible_from<__op_state<_Sender, _Receiver>,
- _Sender, _Receiver>)
- -> __op_state<_Sender, _Receiver>
- requires __connectable<_Sender, _Receiver>
-{
- return __op_state<_Sender, _Receiver>{static_cast<_Sender&&>(__sndr),
- static_cast<_Receiver&&>(__rcvr)};
-};
+ static constexpr auto connect =
+ []<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver __rcvr) noexcept(
+ __nothrow_constructible_from<__op_state<_Sender, _Receiver>, _Sender, _Receiver>)
+ -> __op_state<_Sender, _Receiver>
+ requires __connectable<_Sender, _Receiver>
+ {
+ return __op_state<_Sender, _Receiver>{
+ static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr)};
+ };
-inline constexpr auto __start = //
- []<class _StartTag = start_t, class... _ChildOps>(
- __ignore, __ignore, _ChildOps&... __ops) noexcept {
+ static constexpr auto start = []<class _StartTag = start_t, class... _ChildOps>(
+ __ignore,
+ __ignore,
+ _ChildOps&... __ops) noexcept {
(_StartTag()(__ops), ...);
- };
+ };
-inline constexpr auto __complete = //
- []<class _Index, class _Receiver, class _SetTag, class... _Args>(
- _Index, __ignore, _Receiver& __rcvr, _SetTag,
- _Args&&... __args) noexcept {
- static_assert(__v<_Index> == 0,
- "I don't know how to complete this operation.");
- _SetTag()(std::move(__rcvr), static_cast<_Args&&>(__args)...);
- };
+ static constexpr auto complete =
+ []<class _Index, class _Receiver, class _SetTag, class... _Args>(
+ _Index,
+ __ignore,
+ _Receiver& __rcvr,
+ _SetTag,
+ _Args&&... __args) noexcept {
+ static_assert(__v<_Index> == 0, "I don't know how to complete this operation.");
+ _SetTag()(std::move(__rcvr), static_cast<_Args&&>(__args)...);
+ };
-inline constexpr auto __sigs = //
- []<class _Sender>(_Sender&& __sndr, __ignore = {}) noexcept {
- static_assert(
+ static constexpr auto get_completion_signatures =
+ []<class _Sender>(_Sender&&, auto&&...) noexcept {
+ static_assert(
__mnever<tag_of_t<_Sender>>,
"No customization of get_completion_signatures for this sender tag type.");
+ };
};
-template <class _ReceiverId, class _Sexpr, class _Idx>
-struct __receiver
-{
- struct __t
- {
- using receiver_concept = receiver_t;
- using _Receiver = stdexec::__t<_ReceiverId>;
- using __sexpr = _Sexpr;
- using __index = _Idx;
- using __id = __receiver;
- using __parent_op_t = __op_state<_Sexpr, _Receiver>;
- using __tag_t = tag_of_t<_Sexpr>;
+ template <class _Sexpr, class _Receiver>
+ using __state_t = __state_type_t<typename __decay_t<_Sexpr>::__tag_t, _Sexpr, _Receiver>;
- // A pointer to the parent operation state, which contains the one
- // created with this receiver.
- __parent_op_t* __op_;
+ template <class _Sexpr, class _Receiver>
+ struct __op_base;
- // template <class _ChildSexpr, class _ChildReceiver>
- // static __t __from_op_state(__op_state<_ChildSexpr, _ChildReceiver>*
- // __child) noexcept {
- // using __parent_op_t = __op_state<_Sexpr, _Receiver>;
- // std::ptrdiff_t __offset = __parent_op_t::template
- // __get_child_op_offset<__v<_Idx>>();
- // __parent_op_t* __parent = (__parent_op_t*)
- // (static_cast<char*>(__child) - __offset); return __t{__parent};
- // }
+ template <class _Receiver>
+ struct __receiver_box {
+ _Receiver __rcvr_;
- template <class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- void set_value(_Args&&... __args) noexcept
- {
- __op_->__complete(_Idx(), stdexec::set_value,
- static_cast<_Args&&>(__args)...);
- }
+ STDEXEC_ATTRIBUTE(always_inline) auto __rcvr() & noexcept -> _Receiver& {
+ return this->__rcvr_;
+ }
- template <class _Error>
- STDEXEC_ATTRIBUTE((always_inline))
- void set_error(_Error&& __err) noexcept
- {
- __op_->__complete(_Idx(), stdexec::set_error,
- static_cast<_Error&&>(__err));
- }
-
- STDEXEC_ATTRIBUTE((always_inline))
- void set_stopped() noexcept
- {
- __op_->__complete(_Idx(), stdexec::set_stopped);
- }
-
- template <__same_as<__t> _Self = __t>
- STDEXEC_ATTRIBUTE((always_inline))
- auto get_env() const noexcept
- -> __env_type_t<_Self, __tag_t, _Idx, _Sexpr, _Receiver>
- {
- return __op_->__get_env(_Idx());
- }
+ STDEXEC_ATTRIBUTE(always_inline) auto __rcvr() const & noexcept -> const _Receiver& {
+ return this->__rcvr_;
+ }
};
-};
-// template <class _Receiver>
-// using __sexpr_connected_with = __mapply<
-// __mbind_front_q<__m_at, typename _Receiver::__index>,
-// typename __call_result_t<__impl_of<typename _Receiver::__sexpr>, __cp,
-// __get_desc>::__children>;
+ template <class _Sexpr, class _Receiver>
+ struct __state_box : __immovable {
+ using __tag_t = __decay_t<_Sexpr>::__tag_t;
+ using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
-template <class _Sexpr, class _Receiver>
-using __state_t = //
- __state_type_t<typename __decay_t<_Sexpr>::__tag_t, _Sexpr, _Receiver>;
+ __state_box(_Sexpr&& __sndr, _Receiver& __rcvr)
+ noexcept(__noexcept_of<__sexpr_impl<__tag_t>::get_state, _Sexpr, _Receiver&>) {
+ ::new (static_cast<void*>(__buf_)) auto(
+ __sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr));
+ }
-template <class _Sexpr, class _Receiver>
-struct __op_base;
+ ~__state_box() {
+ reinterpret_cast<__state_t*>(__buf_)->~__state_t();
+ }
-template <class _Receiver>
-struct __receiver_box
-{
- _Receiver __rcvr_;
+ STDEXEC_ATTRIBUTE(always_inline) auto __state() & noexcept -> __state_t& {
+ return *reinterpret_cast<__state_t*>(__buf_);
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- auto __rcvr() & noexcept -> _Receiver&
- {
- return this->__rcvr_;
- }
+ STDEXEC_ATTRIBUTE(always_inline) auto __state() const & noexcept -> const __state_t& {
+ return *reinterpret_cast<const __state_t*>(__buf_);
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- auto __rcvr() const& noexcept -> const _Receiver&
- {
- return this->__rcvr_;
- }
-};
+ // We use a buffer to store the state object to make __state_box a standard-layout type
+ // regardless of whether __state_t is standard-layout or not.
+ alignas(__state_t) std::byte __buf_[sizeof(__state_t)]; // NOLINT(modernize-avoid-c-arrays)
+ };
-template <class _Sexpr, class _Receiver>
-struct __state_box
-{
- using __tag_t = typename __decay_t<_Sexpr>::__tag_t;
- using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
-
- __state_box(_Sexpr&& __sndr, _Receiver& __rcvr) //
- noexcept(__nothrow_callable<decltype(__sexpr_impl<__tag_t>::get_state),
- _Sexpr, _Receiver>) :
- __state_(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr),
- __rcvr))
- {}
-
- __state_t __state_;
-};
-
-template <class _Sexpr, class _Receiver, class _State>
-struct __enable_receiver_from_this
-{
+ template <class _Sexpr, class _Receiver, class _State>
+ struct __enable_receiver_from_this {
#if STDEXEC_HAS_FEATURE(undefined_behavior_sanitizer) && STDEXEC_CLANG()
- // See https://github.com/llvm/llvm-project/issues/101276
- [[clang::noinline]]
+ // See https://github.com/llvm/llvm-project/issues/101276
+ [[clang::noinline]]
#endif
- auto __receiver() noexcept -> decltype(auto)
- {
+ auto __receiver() noexcept -> decltype(auto) {
void* __state = static_cast<_State*>(this);
+ // The following cast use the pointer-interconvertibility between the __state_box::__buf_
+ // member and the containing __state_box object itself.
auto* __sbox = static_cast<__state_box<_Sexpr, _Receiver>*>(__state);
return (static_cast<__op_base<_Sexpr, _Receiver>*>(__sbox)->__rcvr_);
- }
-};
+ }
+ };
-template <class _Sexpr, class _Receiver>
-concept __state_uses_receiver = //
- derived_from<__state_t<_Sexpr, _Receiver>,
- __enable_receiver_from_this<_Sexpr, _Receiver,
- __state_t<_Sexpr, _Receiver>>>;
+ template <class _Sexpr, class _Receiver>
+ concept __state_uses_receiver = derived_from<
+ __state_t<_Sexpr, _Receiver>,
+ __enable_receiver_from_this<_Sexpr, _Receiver, __state_t<_Sexpr, _Receiver>>
+ >;
-template <class _Sexpr, class _Receiver>
-struct __op_base : __immovable
-{
- using __tag_t = typename __decay_t<_Sexpr>::__tag_t;
- using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
+ template <class _Sexpr, class _Receiver>
+ struct __op_base : __immovable {
+ using __tag_t = __decay_t<_Sexpr>::__tag_t;
+ using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
- STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
- _Receiver __rcvr_;
- STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
- __state_t __state_;
+ STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
+ _Receiver __rcvr_;
+ STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
+ __state_t __state_;
- __op_base(_Sexpr&& __sndr, _Receiver&& __rcvr) //
- noexcept(__nothrow_decay_copyable<_Receiver> &&
- __nothrow_callable<decltype(__sexpr_impl<__tag_t>::get_state),
- _Sexpr, _Receiver>) :
- __rcvr_(static_cast<_Receiver&&>(__rcvr)),
- __state_(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr),
- __rcvr_))
- {}
+ __op_base(_Sexpr&& __sndr, _Receiver&& __rcvr) noexcept(
+ __nothrow_decay_copyable<_Receiver>
+ && noexcept(
+ __state_t(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr_))))
+ : __rcvr_(static_cast<_Receiver&&>(__rcvr))
+ , __state_(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr_)) {
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- auto __rcvr() & noexcept -> _Receiver&
- {
+ STDEXEC_ATTRIBUTE(always_inline) auto __state() & noexcept -> __state_t& {
+ return __state_;
+ }
+
+ STDEXEC_ATTRIBUTE(always_inline) auto __state() const & noexcept -> const __state_t& {
+ return __state_;
+ }
+
+ STDEXEC_ATTRIBUTE(always_inline) auto __rcvr() & noexcept -> _Receiver& {
return __rcvr_;
- }
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- auto __rcvr() const& noexcept -> const _Receiver&
- {
+ STDEXEC_ATTRIBUTE(always_inline) auto __rcvr() const & noexcept -> const _Receiver& {
return __rcvr_;
- }
-};
+ }
+ };
-template <class _Sexpr, class _Receiver>
- requires __state_uses_receiver<_Sexpr, _Receiver>
-struct __op_base<_Sexpr, _Receiver> :
- __receiver_box<_Receiver>,
- __state_box<_Sexpr, _Receiver>
-{
- using __tag_t = typename __decay_t<_Sexpr>::__tag_t;
- using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
+ template <class _Sexpr, class _Receiver>
+ requires __state_uses_receiver<_Sexpr, _Receiver>
+ struct __op_base<_Sexpr, _Receiver>
+ : __receiver_box<_Receiver>
+ , __state_box<_Sexpr, _Receiver> {
+ using __tag_t = __decay_t<_Sexpr>::__tag_t;
+ using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
- STDEXEC_IMMOVABLE(__op_base);
+ STDEXEC_IMMOVABLE(__op_base);
- __op_base(_Sexpr&& __sndr, _Receiver&& __rcvr) //
- noexcept(__nothrow_decay_copyable<_Receiver> &&
- __nothrow_move_constructible<__state_t>) :
- __receiver_box<_Receiver>{static_cast<_Receiver&&>(__rcvr)},
- __state_box<_Sexpr, _Receiver>{static_cast<_Sexpr&&>(__sndr),
- this->__rcvr_}
- {}
-};
+ __op_base(_Sexpr&& __sndr, _Receiver&& __rcvr)
+ noexcept(__nothrow_decay_copyable<_Receiver> && __nothrow_move_constructible<__state_t>)
+ : __receiver_box<_Receiver>{static_cast<_Receiver&&>(__rcvr)}
+ , __state_box<_Sexpr, _Receiver>{static_cast<_Sexpr&&>(__sndr), this->__rcvr_} {
+ // This is necessary to ensure that the state object is pointer-interconvertible
+ // with the __state_box object for the sake of __enable_receiver_from_this.
+ static_assert(std::is_standard_layout_v<__state_box<_Sexpr, _Receiver>>);
+ }
+ };
-// template <class _Sexpr, class _Receiver>
-// requires __is_instance_of<__id<_Receiver>, __receiver>
-// && __decays_to<_Sexpr, __sexpr_connected_with<_Receiver>>
-// struct __op_base<_Sexpr, _Receiver> : __immovable {
-// using __tag_t = typename __decay_t<_Sexpr>::__tag_t;
-// using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
+ STDEXEC_PRAGMA_PUSH()
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
-// STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS __state_t __state_;
+ template <class _Sexpr, class _Receiver>
+ struct __connect_fn {
+ template <std::size_t _Idx>
+ using __receiver_t = __t<__rcvr<__id<_Receiver>, _Sexpr, _Idx>>;
-// __op_base(_Sexpr&& __sndr, _Receiver&& __rcvr)
-// :
-// __state_(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr),
-// __rcvr)) { STDEXEC_ASSERT(this->__rcvr().__op_ == __rcvr.__op_);
-// }
+ __op_state<_Sexpr, _Receiver>* __op_;
-// _Receiver __rcvr() const noexcept {
-// return _Receiver::__from_op_state( //
-// static_cast<__op_state<_Sexpr, _Receiver>*>( //
-// const_cast<__op_base*>(this)));
-// }
-// };
-
-STDEXEC_PRAGMA_PUSH()
-STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
-
-template <class _Sexpr, class _Receiver>
-struct __connect_fn
-{
- template <std::size_t _Idx>
- using __receiver_t =
- __t<__receiver<__id<_Receiver>, _Sexpr, __msize_t<_Idx>>>;
-
- __op_state<_Sexpr, _Receiver>* __op_;
-
- struct __impl
- {
+ struct __impl {
__op_state<_Sexpr, _Receiver>* __op_;
template <std::size_t... _Is, class... _Child>
auto operator()(__indices<_Is...>, _Child&&... __child) const
- noexcept((__nothrow_connectable<_Child, __receiver_t<_Is>> && ...))
- -> __tuple_for<connect_result_t<_Child, __receiver_t<_Is>>...>
- {
- return __tuple{connect(static_cast<_Child&&>(__child),
- __receiver_t<_Is>{__op_})...};
+ noexcept((__nothrow_connectable<_Child, __receiver_t<_Is>> && ...))
+ -> __tuple_for<connect_result_t<_Child, __receiver_t<_Is>>...> {
+ return __tuple{connect(static_cast<_Child&&>(__child), __receiver_t<_Is>{__op_})...};
}
+ };
+
+ template <class... _Child>
+ auto operator()(__ignore, __ignore, _Child&&... __child) const
+ noexcept(__nothrow_callable<__impl, __indices_for<_Child...>, _Child...>)
+ -> __call_result_t<__impl, __indices_for<_Child...>, _Child...> {
+ return __impl{__op_}(__indices_for<_Child...>(), static_cast<_Child&&>(__child)...);
+ }
+
+ auto operator()(__ignore, __ignore) const noexcept -> __tuple_for<> {
+ return {};
+ }
};
- template <class... _Child>
- auto operator()(__ignore, __ignore, _Child&&... __child) const noexcept(
- __nothrow_callable<__impl, __indices_for<_Child...>, _Child...>)
- -> __call_result_t<__impl, __indices_for<_Child...>, _Child...>
- {
- return __impl{__op_}(__indices_for<_Child...>(),
- static_cast<_Child&&>(__child)...);
+ STDEXEC_PRAGMA_POP()
+
+ inline constexpr auto __drop_front = []<class _Fn>(_Fn __fn) noexcept {
+ return [__fn = std::move(__fn)]<class... _Rest>(auto&&, _Rest&&... __rest) noexcept(
+ __nothrow_callable<const _Fn&, _Rest...>) -> __call_result_t<const _Fn&, _Rest...> {
+ return __fn(static_cast<_Rest&&>(__rest)...);
+ };
+ };
+
+ template <class _Tag, class... _Captures>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto __captures(_Tag, _Captures&&... __captures2) {
+ return
+ [... __captures3 = static_cast<_Captures&&>(__captures2)]<class _Cvref, class _Fun>(
+ _Cvref,
+ _Fun&&
+ __fun) mutable noexcept(__nothrow_callable<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>)
+ -> __call_result_t<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>
+ requires __callable<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>
+ {
+ // The use of decltype(__captures3) here instead of _Captures is a workaround for
+ // a codegen bug in nvc++.
+ return static_cast<_Fun&&>(
+ __fun)(_Tag(), const_cast<__minvoke<_Cvref, decltype(__captures3)>&&>(__captures3)...);
+ };
}
- auto operator()(__ignore, __ignore) const noexcept -> __tuple_for<>
- {
- return {};
- }
-};
-STDEXEC_PRAGMA_POP()
+ template <class _Tag, class _Data, class... _Child>
+ using __captures_t =
+ decltype(__detail::__captures(_Tag(), __declval<_Data>(), __declval<_Child>()...));
-template <class _Sexpr, class _Receiver>
-struct __op_state : __op_base<_Sexpr, _Receiver>
-{
- using __desc_t = typename __decay_t<_Sexpr>::__desc_t;
- using __tag_t = typename __desc_t::__tag;
- using __data_t = typename __desc_t::__data;
- // using __children_t = typename __desc_t::__children;
- using __state_t = typename __op_state::__state_t;
+ template <class, class, class... _Child>
+ using __tuple_size_t = char[sizeof...(_Child) + 2]; // NOLINT(modernize-avoid-c-arrays)
+
+ template <std::size_t _Idx, class _Descriptor>
+ concept __in_range = (_Idx < sizeof(__minvoke<_Descriptor, __q<__tuple_size_t>>));
+
+ } // namespace __detail
+
+ using __sexpr_defaults = __detail::__defaults;
+
+ template <class _ReceiverId, class _Sexpr, std::size_t _Idx>
+ struct __rcvr {
+ using _Receiver = stdexec::__t<_ReceiverId>;
+
+ struct __t {
+ using receiver_concept = receiver_t;
+ using __id = __rcvr;
+
+ using __index = __msize_t<_Idx>;
+ using __parent_op_t = __op_state<_Sexpr, _Receiver>;
+ using __tag_t = tag_of_t<_Sexpr>;
+
+ // A pointer to the parent operation state, which contains the one created with
+ // this receiver.
+ __parent_op_t* __op_;
+
+ template <class... _Args>
+ STDEXEC_ATTRIBUTE(always_inline)
+ void set_value(_Args&&... __args) noexcept {
+ __op_->__complete(__index(), stdexec::set_value, static_cast<_Args&&>(__args)...);
+ }
+
+ template <class _Error>
+ STDEXEC_ATTRIBUTE(always_inline)
+ void set_error(_Error&& __err) noexcept {
+ __op_->__complete(__index(), stdexec::set_error, static_cast<_Error&&>(__err));
+ }
+
+ STDEXEC_ATTRIBUTE(always_inline) void set_stopped() noexcept {
+ __op_->__complete(__index(), stdexec::set_stopped);
+ }
+
+ template <__same_as<__t> _Self = __t>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto get_env() const noexcept
+ -> __detail::__env_type_t<_Self, __tag_t, __index, _Sexpr, _Receiver> {
+ return __op_->__get_env(__index());
+ }
+ };
+ };
+
+ template <class _Sexpr, class _Receiver>
+ struct __op_state : __detail::__op_base<_Sexpr, _Receiver> {
+ using __desc_t = __decay_t<_Sexpr>::__desc_t;
+ using __tag_t = __desc_t::__tag;
+ using __data_t = __desc_t::__data;
+ using __state_t = __op_state::__op_base::__state_t;
using __inner_ops_t =
- __result_of<__sexpr_apply, _Sexpr, __connect_fn<_Sexpr, _Receiver>>;
+ __result_of<__sexpr_apply, _Sexpr, __detail::__connect_fn<_Sexpr, _Receiver>>;
__inner_ops_t __inner_ops_;
- // template <std::size_t _Idx>
- // static std::ptrdiff_t __get_child_op_offset() noexcept {
- // __op_state* __self = (__op_state*) &__self;
- // return (std::ptrdiff_t)((char*) &__tup::get<_Idx>(__self->__inner_ops_)
- // - static_cast<char*>(__self));
- // }
+ __op_state(_Sexpr&& __sexpr, _Receiver __rcvr) noexcept(
+ __nothrow_constructible_from<__detail::__op_base<_Sexpr, _Receiver>, _Sexpr, _Receiver>
+ && __noexcept_of<__sexpr_apply, _Sexpr, __detail::__connect_fn<_Sexpr, _Receiver>>)
+ : __op_state::__op_base{static_cast<_Sexpr&&>(__sexpr), static_cast<_Receiver&&>(__rcvr)}
+ , __inner_ops_(__sexpr_apply(
+ static_cast<_Sexpr&&>(__sexpr),
+ __detail::__connect_fn<_Sexpr, _Receiver>{this})) {
+ }
- __op_state(_Sexpr&& __sexpr, _Receiver __rcvr) //
- noexcept(__nothrow_constructible_from<__op_base<_Sexpr, _Receiver>,
- _Sexpr&&, _Receiver&&> &&
- __nothrow_callable<__sexpr_apply_t, _Sexpr&&,
- __connect_fn<_Sexpr, _Receiver>>) :
- __op_state::__op_base{static_cast<_Sexpr&&>(__sexpr),
- static_cast<_Receiver&&>(__rcvr)},
- __inner_ops_(__sexpr_apply(static_cast<_Sexpr&&>(__sexpr),
- __connect_fn<_Sexpr, _Receiver>{this}))
- {}
-
- STDEXEC_ATTRIBUTE((always_inline))
- void start() & noexcept
- {
- using __tag_t = typename __op_state::__tag_t;
- auto&& __rcvr = this->__rcvr();
- __inner_ops_.apply(
- [&](auto&... __ops) noexcept {
- __sexpr_impl<__tag_t>::start(this->__state_, __rcvr, __ops...);
- },
- __inner_ops_);
+ STDEXEC_ATTRIBUTE(always_inline) void start() & noexcept {
+ using __tag_t = __op_state::__tag_t;
+ auto&& __rcvr = this->__rcvr();
+ __inner_ops_.apply(
+ [&](auto&... __ops) noexcept {
+ __sexpr_impl<__tag_t>::start(this->__state(), __rcvr, __ops...);
+ },
+ __inner_ops_);
}
template <class _Index, class _Tag2, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- void __complete(_Index, _Tag2, _Args&&... __args) noexcept
- {
- using __tag_t = typename __op_state::__tag_t;
- auto&& __rcvr = this->__rcvr();
- using _CompleteFn = __mtypeof<__sexpr_impl<__tag_t>::complete>;
- if constexpr (__callable<_CompleteFn, _Index, __op_state&, _Tag2,
- _Args...>)
- {
- __sexpr_impl<__tag_t>::complete(_Index(), *this, _Tag2(),
- static_cast<_Args&&>(__args)...);
- }
- else
- {
- __sexpr_impl<__tag_t>::complete(_Index(), this->__state_, __rcvr,
- _Tag2(),
- static_cast<_Args&&>(__args)...);
- }
+ STDEXEC_ATTRIBUTE(always_inline)
+ void __complete(_Index, _Tag2, _Args&&... __args) noexcept {
+ using __tag_t = __op_state::__tag_t;
+ auto&& __rcvr = this->__rcvr();
+ using _CompleteFn = __mtypeof<__sexpr_impl<__tag_t>::complete>;
+ if constexpr (__callable<_CompleteFn, _Index, __op_state&, _Tag2, _Args...>) {
+ __sexpr_impl<__tag_t>::complete(_Index(), *this, _Tag2(), static_cast<_Args&&>(__args)...);
+ } else {
+ __sexpr_impl<__tag_t>::complete(
+ _Index(), this->__state(), __rcvr, _Tag2(), static_cast<_Args&&>(__args)...);
+ }
}
template <class _Index>
- STDEXEC_ATTRIBUTE((always_inline))
+ STDEXEC_ATTRIBUTE(always_inline)
auto __get_env(_Index) const noexcept
- -> __env_type_t<_Index, __tag_t, _Index, _Sexpr, _Receiver>
- {
- const auto& __rcvr = this->__rcvr();
- return __sexpr_impl<__tag_t>::get_env(_Index(), this->__state_, __rcvr);
+ -> __detail::__env_type_t<_Index, __tag_t, _Index, _Sexpr, _Receiver> {
+ const auto& __rcvr = this->__rcvr();
+ return __sexpr_impl<__tag_t>::get_env(_Index(), this->__state(), __rcvr);
}
-};
+ };
-inline constexpr auto __drop_front = //
- []<class _Fn>(_Fn __fn) noexcept {
- return [__fn = std::move(__fn)]<class... _Rest>(auto&&,
- _Rest&&... __rest) //
- noexcept(__nothrow_callable<const _Fn&, _Rest...>)
- -> __call_result_t<const _Fn&, _Rest...> {
- return __fn(static_cast<_Rest&&>(__rest)...);
- };
- };
-
-template <class _Tag, class... _Captures>
-STDEXEC_ATTRIBUTE((host, device, always_inline))
-constexpr auto __captures(_Tag, _Captures&&... __captures2)
-{
- return
- [... __captures3 =
- static_cast<_Captures&&>(__captures2)]<class _Cvref, class _Fun>(
- _Cvref, _Fun&& __fun) mutable //
- noexcept(
- __nothrow_callable<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>) //
- -> __call_result_t<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>
- requires __callable<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>
- {
- // The use of decltype(__captures3) here instead of _Captures is a
- // workaround for a codegen bug in nvc++.
- return static_cast<_Fun&&>(__fun)(
- _Tag(), const_cast<__minvoke<_Cvref, decltype(__captures3)>&&>(
- __captures3)...);
- };
-}
-
-template <class _Tag, class _Data, class... _Child>
-using __captures_t = decltype(__detail::__captures(_Tag(), __declval<_Data>(),
- __declval<_Child>()...));
-
-template <class, class, class... _Child>
-using __tuple_size_t = char[sizeof...(_Child) + 2];
-
-template <std::size_t _Idx, class _Descriptor>
-concept __in_range =
- (_Idx < sizeof(__minvoke<_Descriptor, __q<__tuple_size_t>>));
-
-} // namespace __detail
-
-struct __sexpr_defaults
-{
- static constexpr auto get_attrs = __detail::__get_attrs;
- static constexpr auto get_env = __detail::__get_env;
- static constexpr auto get_state = __detail::__get_state;
- static constexpr auto connect = __detail::__connect;
- static constexpr auto start = __detail::__start;
- static constexpr auto complete = __detail::__complete;
- static constexpr auto get_completion_signatures = __detail::__sigs;
-};
-
-template <class _Tag>
-struct __sexpr_impl : __sexpr_defaults
-{
+ template <class _Tag>
+ struct __sexpr_impl : __detail::__defaults {
using not_specialized = void;
-};
+ };
-using __detail::__enable_receiver_from_this;
+ using __detail::__enable_receiver_from_this;
-template <class _Tag>
-using __get_attrs_fn = __result_of<__detail::__drop_front,
- __mtypeof<__sexpr_impl<_Tag>::get_attrs>>;
+ template <class _Tag>
+ using __get_attrs_fn =
+ __result_of<__detail::__drop_front, __mtypeof<__sexpr_impl<_Tag>::get_attrs>>;
-//! A dummy type used only for diagnostic purposes.
-//! See `__sexpr` for the implementation of P2300's _`basic-sender`_.
-template <class...>
-struct __basic_sender
-{
+ //! A dummy type used only for diagnostic purposes.
+ //! See `__sexpr` for the implementation of P2300's _`basic-sender`_.
+ template <class...>
+ struct __basic_sender {
// See MAINTAINERS.md#class-template-parameters for `__id` and `__t`.
using __id = __basic_sender;
using __t = __basic_sender;
-};
+ };
-//! A struct template to aid in creating senders.
-//! This struct closely resembles P2300's
-//! [_`basic-sender`_](https://eel.is/c++draft/exec#snd.expos-24), but is not an
-//! exact implementation. Note: The struct named `__basic_sender` is just a
-//! dummy type and is also not _`basic-sender`_.
-template <auto _DescriptorFn, class = __anon>
-struct __sexpr
-{
- using sender_concept = sender_t;
+ namespace {
+ //! A struct template to aid in creating senders.
+ //! This struct closely resembles P2300's [_`basic-sender`_](https://eel.is/c++draft/exec#snd.expos-24),
+ //! but is not an exact implementation.
+ //! Note: The struct named `__basic_sender` is just a dummy type and is also not _`basic-sender`_.
+ template <auto _DescriptorFn>
+ struct __sexpr {
+ using sender_concept = sender_t;
- // See MAINTAINERS.md#class-template-parameters for `__id` and `__t`.
- using __id = __sexpr;
- using __t = __sexpr;
- using __desc_t = decltype(_DescriptorFn());
- using __tag_t = typename __desc_t::__tag;
- using __captures_t = __minvoke<__desc_t, __q<__detail::__captures_t>>;
+ // See MAINTAINERS.md#class-template-parameters for `__id` and `__t`.
+ using __id = __sexpr;
+ using __t = __sexpr;
+ using __desc_t = decltype(_DescriptorFn());
+ using __tag_t = __desc_t::__tag;
+ using __captures_t = __minvoke<__desc_t, __q<__detail::__captures_t>>;
- mutable __captures_t __impl_;
+ mutable __captures_t __impl_;
- template <class _Tag, class _Data, class... _Child>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- explicit __sexpr(_Tag, _Data&& __data, _Child&&... __child) :
- __impl_(__detail::__captures(_Tag(), static_cast<_Data&&>(__data),
- static_cast<_Child&&>(__child)...))
- {}
+ template <class _Tag, class _Data, class... _Child>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ explicit __sexpr(_Tag, _Data&& __data, _Child&&... __child)
+ : __impl_(
+ __detail::__captures(
+ _Tag(),
+ static_cast<_Data&&>(__data),
+ static_cast<_Child&&>(__child)...)) {
+ }
- template <class _Self>
- using __impl = __sexpr_impl<__meval<__msecond, _Self, __tag_t>>;
+ template <class _Self>
+ using __impl = __sexpr_impl<__meval<__msecond, _Self, __tag_t>>;
- template <class _Self = __sexpr>
- STDEXEC_ATTRIBUTE((always_inline))
- auto get_env() const noexcept
- -> __result_of<__sexpr_apply, const _Self&, __get_attrs_fn<__tag_t>>
- {
- return __sexpr_apply(*this,
- __detail::__drop_front(__impl<_Self>::get_attrs));
- }
+ template <class _Self = __sexpr>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto get_env() const noexcept
+ -> __result_of<__sexpr_apply, const _Self&, __get_attrs_fn<__tag_t>> {
+ return __sexpr_apply(*this, __detail::__drop_front(__impl<_Self>::get_attrs));
+ }
- template <__decays_to<__sexpr> _Self, class... _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto get_completion_signatures(_Self&&, _Env&&...) noexcept //
- -> __msecond<__if_c<__decays_to<_Self, __sexpr>>,
- __result_of<__impl<_Self>::get_completion_signatures,
- _Self, _Env...>>
- {
+ template <__decays_to<__sexpr> _Self, class... _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto get_completion_signatures(_Self&&, _Env&&...) noexcept -> __msecond<
+ __if_c<__decays_to<_Self, __sexpr>>,
+ __result_of<__impl<_Self>::get_completion_signatures, _Self, _Env...>
+ > {
return {};
- }
+ }
- // BUGBUG fix receiver constraint here:
- template <__decays_to<__sexpr> _Self, /*receiver*/ class _Receiver>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto connect(_Self&& __self, _Receiver&& __rcvr) //
- noexcept(__noexcept_of<__impl<_Self>::connect, _Self, _Receiver>) //
- -> __msecond<__if_c<__decays_to<_Self, __sexpr>>,
- __result_of<__impl<_Self>::connect, _Self, _Receiver>>
- {
- return __impl<_Self>::connect(static_cast<_Self&&>(__self),
- static_cast<_Receiver&&>(__rcvr));
- }
+ // BUGBUG fix receiver constraint here:
+ template <__decays_to<__sexpr> _Self, /*receiver*/ class _Receiver>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto connect(_Self&& __self, _Receiver&& __rcvr)
+ noexcept(__noexcept_of<__impl<_Self>::connect, _Self, _Receiver>) -> __msecond<
+ __if_c<__decays_to<_Self, __sexpr>>,
+ __result_of<__impl<_Self>::connect, _Self, _Receiver>
+ > {
+ return __impl<_Self>::connect(
+ static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
+ }
- template <class _Sender, class _ApplyFn>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto apply(_Sender&& __sndr, _ApplyFn&& __fun) //
- noexcept(__nothrow_callable<__detail::__impl_of<_Sender>,
- __copy_cvref_fn<_Sender>, _ApplyFn>) //
- -> __call_result_t<__detail::__impl_of<_Sender>,
- __copy_cvref_fn<_Sender>, _ApplyFn>
- { //
- return static_cast<_Sender&&>(__sndr).__impl_(
- __copy_cvref_fn<_Sender>(), static_cast<_ApplyFn&&>(__fun)); //
- }
+ template <__decays_to<__sexpr> _Self, /*receiver*/ class _Receiver>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto submit(_Self&& __self, _Receiver&& __rcvr)
+ noexcept(__noexcept_of<__impl<_Self>::submit, _Self, _Receiver>) -> __msecond<
+ __if_c<__decays_to<_Self, __sexpr>>,
+ __result_of<__impl<_Self>::submit, _Self, _Receiver>
+ > {
+ return __impl<_Self>::submit(
+ static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
+ }
- template <std::size_t _Idx, __decays_to_derived_from<__sexpr> _Self>
- STDEXEC_ATTRIBUTE((always_inline))
- friend auto get(_Self&& __self) noexcept -> decltype(auto)
+ template <class _Sender, class _ApplyFn>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto apply(_Sender&& __sndr, _ApplyFn&& __fun) noexcept(
+ __nothrow_callable<__detail::__impl_of<_Sender>, __copy_cvref_fn<_Sender>, _ApplyFn>)
+ -> __call_result_t<__detail::__impl_of<_Sender>, __copy_cvref_fn<_Sender>, _ApplyFn> {
+ return static_cast<_Sender&&>(__sndr)
+ .__impl_(__copy_cvref_fn<_Sender>(), static_cast<_ApplyFn&&>(__fun));
+ }
+
+ template <std::size_t _Idx, __decays_to_derived_from<__sexpr> _Self>
+ STDEXEC_ATTRIBUTE(always_inline)
+ friend auto get(_Self&& __self) noexcept -> decltype(auto)
requires __detail::__in_range<_Idx, __desc_t>
- {
- if constexpr (_Idx == 0)
- {
- return __tag_t();
+ {
+ if constexpr (_Idx == 0) {
+ return __tag_t();
+ } else {
+ return __self.__impl_(__copy_cvref_fn<_Self>(), __nth_pack_element<_Idx>);
}
- else
- {
- return __self.__impl_(__copy_cvref_fn<_Self>(),
- __nth_pack_element<_Idx>);
- }
- }
-};
+ }
+ };
-template <class _Tag, class _Data, class... _Child>
-STDEXEC_ATTRIBUTE((host, device))
-__sexpr(_Tag, _Data, _Child...)
- -> __sexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;
-
-template <class _Tag, class _Data, class... _Child>
-using __sexpr_t = __sexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// __make_sexpr
-//! A tagged function-object
-//! Takes data and children and
-//! returns `__sexpr_t<_Tag, _Data, _Child...>{_Tag(), data, children...}`.
-namespace __detail
-{
-template <class _Tag>
-struct __make_sexpr_t
-{
- template <class _Data = __, class... _Child>
- constexpr auto operator()(_Data __data = {}, _Child... __child) const
- {
- return __sexpr_t<_Tag, _Data, _Child...>{
- _Tag(), static_cast<_Data&&>(__data),
- static_cast<_Child&&>(__child)...};
- }
-};
-} // namespace __detail
-
-template <class _Tag>
-inline constexpr __detail::__make_sexpr_t<_Tag> __make_sexpr{};
-
-// The __name_of utility defined below is used to pretty-print the type names of
-// senders in compiler diagnostics.
-namespace __detail
-{
-struct __basic_sender_name
-{
template <class _Tag, class _Data, class... _Child>
- using __result = __basic_sender<_Tag, _Data, __name_of<_Child>...>;
+ STDEXEC_ATTRIBUTE(host, device)
+ __sexpr(_Tag, _Data, _Child...) -> __sexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;
+ } // namespace
+
+ template <class _Tag, class _Data, class... _Child>
+ using __sexpr_t = __sexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // __make_sexpr
+ //! A tagged function-object
+ //! Takes data and children and
+ //! returns `__sexpr_t<_Tag, _Data, _Child...>{_Tag(), data, children...}`.
+ namespace __detail {
+ template <class _Tag>
+ struct __make_sexpr_t {
+ template <class _Data = __, class... _Child>
+ constexpr auto operator()(_Data __data = {}, _Child... __child) const {
+ return __sexpr_t<_Tag, _Data, _Child...>{
+ _Tag(), static_cast<_Data&&>(__data), static_cast<_Child&&>(__child)...};
+ }
+ };
+ } // namespace __detail
+
+ template <class _Tag>
+ inline constexpr __detail::__make_sexpr_t<_Tag> __make_sexpr{};
+
+ // The __name_of utility defined below is used to pretty-print the type names of
+ // senders in compiler diagnostics.
+ namespace __detail {
+ struct __basic_sender_name {
+ template <class _Tag, class _Data, class... _Child>
+ using __result = __basic_sender<_Tag, _Data, __name_of<_Child>...>;
+
+ template <class _Sender>
+ using __f = __minvoke<typename __decay_t<_Sender>::__desc_t, __q<__result>>;
+ };
+
+ struct __id_name {
+ template <class _Sender>
+ using __f = __name_of<__id<_Sender>>;
+ };
template <class _Sender>
- using __f = __minvoke<typename __decay_t<_Sender>::__desc_t, __q<__result>>;
-};
+ extern __mcompose<__cplr, __name_of_fn<_Sender>> __name_of_v<_Sender&>;
-struct __id_name
-{
template <class _Sender>
- using __f = __name_of<__id<_Sender>>;
-};
+ extern __mcompose<__cprr, __name_of_fn<_Sender>> __name_of_v<_Sender&&>;
-template <class _Sender>
-extern __mcompose<__cplr, __name_of_fn<_Sender>> __name_of_v<_Sender&>;
+ template <class _Sender>
+ extern __mcompose<__cpclr, __name_of_fn<_Sender>> __name_of_v<const _Sender&>;
-template <class _Sender>
-extern __mcompose<__cprr, __name_of_fn<_Sender>> __name_of_v<_Sender&&>;
+ template <auto _Descriptor>
+ extern __basic_sender_name __name_of_v<__sexpr<_Descriptor>>;
-template <class _Sender>
-extern __mcompose<__cpclr, __name_of_fn<_Sender>> __name_of_v<const _Sender&>;
-
-template <auto _Descriptor>
-extern __basic_sender_name __name_of_v<__sexpr<_Descriptor>>;
-
-template <__has_id _Sender>
- requires(!same_as<__id<_Sender>, _Sender>)
-extern __id_name __name_of_v<_Sender>;
-} // namespace __detail
+ template <__has_id _Sender>
+ requires(!same_as<__id<_Sender>, _Sender>)
+ extern __id_name __name_of_v<_Sender>;
+ } // namespace __detail
} // namespace stdexec
-namespace std
-{
-template <auto _Descriptor>
-struct tuple_size<stdexec::__sexpr<_Descriptor>> :
- integral_constant<size_t,
- stdexec::__v<stdexec::__minvoke<
- stdexec::__result_of<_Descriptor>, stdexec::__msize>>>
-{};
+namespace std {
+ template <auto _Descriptor>
+ struct tuple_size<stdexec::__sexpr<_Descriptor>>
+ : integral_constant<
+ size_t,
+ stdexec::__v<stdexec::__minvoke<stdexec::__result_of<_Descriptor>, stdexec::__msize>>
+ > { };
-template <size_t _Idx, auto _Descriptor>
-struct tuple_element<_Idx, stdexec::__sexpr<_Descriptor>>
-{
- using type = //
- stdexec::__remove_rvalue_reference_t< //
- stdexec::__call_result_t< //
- stdexec::__detail::__impl_of<stdexec::__sexpr<_Descriptor>>,
- stdexec::__cp, stdexec::__nth_pack_element_t<_Idx>>>;
-};
+ template <size_t _Idx, auto _Descriptor>
+ struct tuple_element<_Idx, stdexec::__sexpr<_Descriptor>> {
+ using type = stdexec::__remove_rvalue_reference_t<stdexec::__call_result_t<
+ stdexec::__detail::__impl_of<stdexec::__sexpr<_Descriptor>>,
+ stdexec::__cp,
+ stdexec::__nth_pack_element_t<_Idx>
+ >>;
+ };
} // namespace std
diff --git a/include/sdbusplus/async/stdexec/__detail/__bulk.hpp b/include/sdbusplus/async/stdexec/__detail/__bulk.hpp
index c8ca584..8e1f381 100644
--- a/include/sdbusplus/async/stdexec/__detail/__bulk.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__bulk.hpp
@@ -15,6 +15,7 @@
*/
#pragma once
+#include "__execution_legacy.hpp"
#include "__execution_fwd.hpp"
// include these after __execution_fwd.hpp
@@ -22,167 +23,353 @@
#include "__diagnostics.hpp"
#include "__domain.hpp"
#include "__meta.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
#include "__senders_core.hpp"
+#include "__sender_adaptor_closure.hpp"
#include "__transform_completion_signatures.hpp"
#include "__transform_sender.hpp"
+#include "__senders.hpp" // IWYU pragma: keep for __well_formed_sender
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.bulk]
-namespace __bulk
-{
-inline constexpr __mstring __bulk_context =
- "In stdexec::bulk(Sender, Shape, Function)..."_mstr;
-using __on_not_callable = __callable_error<__bulk_context>;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.bulk]
+ namespace __bulk {
+ struct bulk_t;
+ struct bulk_chunked_t;
+ struct bulk_unchunked_t;
-template <class _Shape, class _Fun>
-struct __data
-{
- _Shape __shape_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fun __fun_;
- static constexpr auto __mbrs_ =
- __mliterals<&__data::__shape_, &__data::__fun_>();
-};
-template <class _Shape, class _Fun>
-__data(_Shape, _Fun) -> __data<_Shape, _Fun>;
+ //! Wrapper for a policy object.
+ //!
+ //! If we wrap a standard execution policy, we don't store anything, as we know the type.
+ //! Stores the execution policy object if it's a non-standard one.
+ //! Provides a way to query the execution policy object.
+ template <class _Pol>
+ struct __policy_wrapper {
+ _Pol __pol_;
-template <class _Ty>
-using __decay_ref = __decay_t<_Ty>&;
+ /*implicit*/ __policy_wrapper(_Pol __pol)
+ : __pol_{__pol} {
+ }
-template <class _Catch, class _Fun, class _Shape, class _CvrefSender,
- class... _Env>
-using __with_error_invoke_t = //
- __if<__value_types_t<
- __completion_signatures_of_t<_CvrefSender, _Env...>,
- __mtransform<
- __q<__decay_ref>,
- __mbind_front<__mtry_catch_q<__nothrow_invocable_t, _Catch>,
- _Fun, _Shape>>,
- __q<__mand>>,
- completion_signatures<>, __eptr_completion>;
+ const _Pol& __get() const noexcept {
+ return __pol_;
+ }
+ };
-template <class _Fun, class _Shape, class _CvrefSender, class... _Env>
-using __completion_signatures = //
- transform_completion_signatures<
+ template <>
+ struct __policy_wrapper<sequenced_policy> {
+ /*implicit*/ __policy_wrapper(const sequenced_policy&) {
+ }
+
+ const sequenced_policy& __get() const noexcept {
+ return seq;
+ }
+ };
+
+ template <>
+ struct __policy_wrapper<parallel_policy> {
+ /*implicit*/ __policy_wrapper(const parallel_policy&) {
+ }
+
+ const parallel_policy& __get() const noexcept {
+ return par;
+ }
+ };
+
+ template <>
+ struct __policy_wrapper<parallel_unsequenced_policy> {
+ /*implicit*/ __policy_wrapper(const parallel_unsequenced_policy&) {
+ }
+
+ const parallel_unsequenced_policy& __get() const noexcept {
+ return par_unseq;
+ }
+ };
+
+ template <>
+ struct __policy_wrapper<unsequenced_policy> {
+ /*implicit*/ __policy_wrapper(const unsequenced_policy&) {
+ }
+
+ const unsequenced_policy& __get() const noexcept {
+ return unseq;
+ }
+ };
+
+ template <class _Pol, class _Shape, class _Fun>
+ struct __data {
+ STDEXEC_ATTRIBUTE(no_unique_address) __policy_wrapper<_Pol> __pol_;
+ _Shape __shape_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fun __fun_;
+ static constexpr auto __mbrs_ =
+ __mliterals<&__data::__pol_, &__data::__shape_, &__data::__fun_>();
+ };
+ template <class _Pol, class _Shape, class _Fun>
+ __data(const _Pol&, _Shape, _Fun) -> __data<_Pol, _Shape, _Fun>;
+
+ template <class _AlgoTag>
+ struct __bulk_traits;
+
+ template <>
+ struct __bulk_traits<bulk_t> {
+ using __on_not_callable =
+ __callable_error<"In stdexec::bulk(Sender, Policy, Shape, Function)..."_mstr>;
+
+ // Curried function, after passing the required indices.
+ template <class _Fun, class _Shape>
+ using __fun_curried =
+ __mbind_front<__mtry_catch_q<__nothrow_invocable_t, __on_not_callable>, _Fun, _Shape>;
+ };
+
+ template <>
+ struct __bulk_traits<bulk_chunked_t> {
+ using __on_not_callable =
+ __callable_error<"In stdexec::bulk_chunked(Sender, Policy, Shape, Function)..."_mstr>;
+
+ // Curried function, after passing the required indices.
+ template <class _Fun, class _Shape>
+ using __fun_curried = __mbind_front<
+ __mtry_catch_q<__nothrow_invocable_t, __on_not_callable>,
+ _Fun,
+ _Shape,
+ _Shape
+ >;
+ };
+
+ template <>
+ struct __bulk_traits<bulk_unchunked_t> {
+ using __on_not_callable =
+ __callable_error<"In stdexec::bulk_unchunked(Sender, Policy, Shape, Function)..."_mstr>;
+
+ // Curried function, after passing the required indices.
+ template <class _Fun, class _Shape>
+ using __fun_curried =
+ __mbind_front<__mtry_catch_q<__nothrow_invocable_t, __on_not_callable>, _Fun, _Shape>;
+ };
+
+ template <class _Ty>
+ using __decay_ref = __decay_t<_Ty>&;
+
+ template <class _AlgoTag, class _Fun, class _Shape, class _CvrefSender, class... _Env>
+ using __with_error_invoke_t = __if<
+ __value_types_t<
__completion_signatures_of_t<_CvrefSender, _Env...>,
- __with_error_invoke_t<__on_not_callable, _Fun, _Shape, _CvrefSender,
- _Env...>>;
+ __mtransform<
+ __q<__decay_ref>,
+ typename __bulk_traits<_AlgoTag>::template __fun_curried<_Fun, _Shape>
+ >,
+ __q<__mand>
+ >,
+ completion_signatures<>,
+ __eptr_completion
+ >;
-struct bulk_t
-{
- template <sender _Sender, integral _Shape, __movable_value _Fun>
- STDEXEC_ATTRIBUTE((host, device))
- auto operator()(_Sender&& __sndr, _Shape __shape, _Fun __fun) const
- -> __well_formed_sender auto
- {
+
+ template <class _AlgoTag, class _Fun, class _Shape, class _CvrefSender, class... _Env>
+ using __completion_signatures = transform_completion_signatures<
+ __completion_signatures_of_t<_CvrefSender, _Env...>,
+ __with_error_invoke_t<_AlgoTag, _Fun, _Shape, _CvrefSender, _Env...>
+ >;
+
+ template <class _AlgoTag>
+ struct __generic_bulk_t { // NOLINT(bugprone-crtp-constructor-accessibility)
+ template <sender _Sender, typename _Policy, integral _Shape, copy_constructible _Fun>
+ requires is_execution_policy_v<std::remove_cvref_t<_Policy>>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto operator()(_Sender&& __sndr, _Policy&& __pol, _Shape __shape, _Fun __fun) const
+ -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain,
- __make_sexpr<bulk_t>(__data{__shape, static_cast<_Fun&&>(__fun)},
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<_AlgoTag>(
+ __data{__pol, __shape, static_cast<_Fun&&>(__fun)}, static_cast<_Sender&&>(__sndr)));
+ }
- template <integral _Shape, class _Fun>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Shape __shape, _Fun __fun) const
- -> __binder_back<bulk_t, _Shape, _Fun>
- {
- return {{static_cast<_Shape&&>(__shape), static_cast<_Fun&&>(__fun)},
- {},
- {}};
- }
+ template <typename _Policy, integral _Shape, copy_constructible _Fun>
+ requires is_execution_policy_v<std::remove_cvref_t<_Policy>>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Policy&& __pol, _Shape __shape, _Fun __fun) const
+ -> __binder_back<_AlgoTag, _Policy, _Shape, _Fun> {
+ return {
+ {static_cast<_Policy&&>(__pol),
+ static_cast<_Shape&&>(__shape),
+ static_cast<_Fun&&>(__fun)},
+ {},
+ {}
+ };
+ }
- // This describes how to use the pieces of a bulk sender to find
- // legacy customizations of the bulk algorithm.
- using _Sender = __1;
- using _Shape = __nth_member<0>(__0);
- using _Fun = __nth_member<1>(__0);
- using __legacy_customizations_t =
- __types<tag_invoke_t(bulk_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(_Sender&)),
- _Sender, _Shape, _Fun),
- tag_invoke_t(bulk_t, _Sender, _Shape, _Fun)>;
-};
+ template <sender _Sender, integral _Shape, copy_constructible _Fun>
+ [[deprecated(
+ "The bulk algorithm now requires an execution policy such as stdexec::par as an "
+ "argument.")]]
+ STDEXEC_ATTRIBUTE(host, device) auto
+ operator()(_Sender&& __sndr, _Shape __shape, _Fun __fun) const {
+ return (*this)(
+ static_cast<_Sender&&>(__sndr),
+ par,
+ static_cast<_Shape&&>(__shape),
+ static_cast<_Fun&&>(__fun));
+ }
-struct __bulk_impl : __sexpr_defaults
-{
- template <class _Sender>
- using __fun_t = decltype(__decay_t<__data_of<_Sender>>::__fun_);
+ template <integral _Shape, copy_constructible _Fun>
+ [[deprecated(
+ "The bulk algorithm now requires an execution policy such as stdexec::par as an "
+ "argument.")]]
+ STDEXEC_ATTRIBUTE(always_inline) auto operator()(_Shape __shape, _Fun __fun) const {
+ return (*this)(par, static_cast<_Shape&&>(__shape), static_cast<_Fun&&>(__fun));
+ }
+ };
- template <class _Sender>
- using __shape_t = decltype(__decay_t<__data_of<_Sender>>::__shape_);
+ struct bulk_t : __generic_bulk_t<bulk_t> {
+ template <class _Env>
+ static auto __transform_sender_fn(const _Env&) {
+ return [&]<class _Data, class _Child>(__ignore, _Data&& __data, _Child&& __child) {
+ using __shape_t = std::remove_cvref_t<decltype(__data.__shape_)>;
+ auto __new_f =
+ [__func = std::move(
+ __data.__fun_)](__shape_t __begin, __shape_t __end, auto&&... __vs) mutable
+#if !STDEXEC_MSVC()
+ // MSVCBUG https://developercommunity.visualstudio.com/t/noexcept-expression-in-lambda-template-n/10718680
+ noexcept(noexcept(__data.__fun_(__begin++, __vs...)))
+#endif
+ {
+ while (__begin != __end)
+ __func(__begin++, __vs...);
+ };
- static constexpr auto get_completion_signatures = //
- []<class _Sender, class... _Env>(_Sender&&, _Env&&...) noexcept
- -> __completion_signatures<__fun_t<_Sender>, __shape_t<_Sender>,
- __child_of<_Sender>, _Env...> {
+ // Lower `bulk` to `bulk_chunked`. If `bulk_chunked` is customized, we will see the customization.
+ return bulk_chunked(
+ static_cast<_Child&&>(__child),
+ __data.__pol_.__get(),
+ __data.__shape_,
+ std::move(__new_f));
+ };
+ }
+
+ template <class _Sender, class _Env>
+ static auto transform_sender(_Sender&& __sndr, const _Env& __env) {
+ return __sexpr_apply(static_cast<_Sender&&>(__sndr), __transform_sender_fn(__env));
+ }
+ };
+
+ struct bulk_chunked_t : __generic_bulk_t<bulk_chunked_t> { };
+
+ struct bulk_unchunked_t : __generic_bulk_t<bulk_unchunked_t> { };
+
+ template <class _AlgoTag>
+ struct __bulk_impl_base : __sexpr_defaults {
+ template <class _Sender>
+ using __fun_t = decltype(__decay_t<__data_of<_Sender>>::__fun_);
+
+ template <class _Sender>
+ using __shape_t = decltype(__decay_t<__data_of<_Sender>>::__shape_);
+
+ static constexpr auto get_completion_signatures =
+ []<class _Sender, class... _Env>(_Sender&&, _Env&&...) noexcept -> __completion_signatures<
+ _AlgoTag,
+ __fun_t<_Sender>,
+ __shape_t<_Sender>,
+ __child_of<_Sender>,
+ _Env...
+ > {
static_assert(sender_expr_for<_Sender, bulk_t>);
return {};
+ };
};
- //! This implements the core default behavior for `bulk`:
- //! When setting value, it loops over the shape and invokes the function.
- //! Note: This is not done in parallel. That is customized by the scheduler.
- //! See, e.g., static_thread_pool::bulk_receiver::__t.
- static constexpr auto complete = //
+ struct __bulk_chunked_impl : __bulk_impl_base<bulk_chunked_t> {
+ //! This implements the core default behavior for `bulk_chunked`:
+ //! When setting value, it calls the function with the entire range.
+ //! Note: This is not done in parallel. That is customized by the scheduler.
+ //! See, e.g., static_thread_pool::bulk_receiver::__t.
+ static constexpr auto complete =
[]<class _Tag, class _State, class _Receiver, class... _Args>(
- __ignore, _State& __state, _Receiver& __rcvr, _Tag,
- _Args&&... __args) noexcept -> void {
- if constexpr (std::same_as<_Tag, set_value_t>)
- {
- // Intercept set_value and dispatch to the bulk operation.
- using __shape_t = decltype(__state.__shape_);
- if constexpr (noexcept(__state.__fun_(__shape_t{}, __args...)))
- {
- // The noexcept version that doesn't need try/catch:
- for (__shape_t __i{}; __i != __state.__shape_; ++__i)
- {
- __state.__fun_(__i, __args...);
- }
- _Tag()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
+ __ignore,
+ _State& __state,
+ _Receiver& __rcvr,
+ _Tag,
+ _Args&&... __args) noexcept -> void {
+ if constexpr (same_as<_Tag, set_value_t>) {
+ // Intercept set_value and dispatch to the bulk operation.
+ using __shape_t = decltype(__state.__shape_);
+ if constexpr (noexcept(__state.__fun_(__shape_t{}, __shape_t{}, __args...))) {
+ // The noexcept version that doesn't need try/catch:
+ __state.__fun_(static_cast<__shape_t>(0), __state.__shape_, __args...);
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
+ } else {
+ STDEXEC_TRY {
+ __state.__fun_(static_cast<__shape_t>(0), __state.__shape_, __args...);
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
}
- else
- {
- try
- {
- for (__shape_t __i{}; __i != __state.__shape_; ++__i)
- {
- __state.__fun_(__i, __args...);
- }
- _Tag()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
- }
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- std::current_exception());
- }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
}
+ }
+ } else {
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
}
- else
- {
- _Tag()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
- }
+ };
};
-};
-} // namespace __bulk
-using __bulk::bulk_t;
-inline constexpr bulk_t bulk{};
+ struct __bulk_unchunked_impl : __bulk_impl_base<bulk_unchunked_t> {
+ //! This implements the core default behavior for `bulk_unchunked`:
+ //! When setting value, it loops over the shape and invokes the function.
+ //! Note: This is not done in concurrently. That is customized by the scheduler.
+ static constexpr auto complete =
+ []<class _Tag, class _State, class _Receiver, class... _Args>(
+ __ignore,
+ _State& __state,
+ _Receiver& __rcvr,
+ _Tag,
+ _Args&&... __args) noexcept -> void {
+ if constexpr (std::same_as<_Tag, set_value_t>) {
+ using __shape_t = decltype(__state.__shape_);
+ if constexpr (noexcept(__state.__fun_(__shape_t{}, __args...))) {
+ // The noexcept version that doesn't need try/catch:
+ for (__shape_t __i{}; __i != __state.__shape_; ++__i) {
+ __state.__fun_(__i, __args...);
+ }
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
+ } else {
+ STDEXEC_TRY {
+ for (__shape_t __i{}; __i != __state.__shape_; ++__i) {
+ __state.__fun_(__i, __args...);
+ }
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
+ }
+ }
+ } else {
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
+ }
+ };
+ };
-template <>
-struct __sexpr_impl<bulk_t> : __bulk::__bulk_impl
-{};
+ struct __bulk_impl : __bulk_impl_base<bulk_t> {
+ // Implementation is handled by lowering to `bulk_chunked` in `transform_sender`.
+ };
+ } // namespace __bulk
+
+ using __bulk::bulk_t;
+ using __bulk::bulk_chunked_t;
+ using __bulk::bulk_unchunked_t;
+ inline constexpr bulk_t bulk{};
+ inline constexpr bulk_chunked_t bulk_chunked{};
+ inline constexpr bulk_unchunked_t bulk_unchunked{};
+
+ template <>
+ struct __sexpr_impl<bulk_t> : __bulk::__bulk_impl { };
+
+ template <>
+ struct __sexpr_impl<bulk_chunked_t> : __bulk::__bulk_chunked_impl { };
+
+ template <>
+ struct __sexpr_impl<bulk_unchunked_t> : __bulk::__bulk_unchunked_impl { };
} // namespace stdexec
STDEXEC_PRAGMA_POP()
diff --git a/include/sdbusplus/async/stdexec/__detail/__completion_behavior.hpp b/include/sdbusplus/async/stdexec/__detail/__completion_behavior.hpp
new file mode 100644
index 0000000..11db2e5
--- /dev/null
+++ b/include/sdbusplus/async/stdexec/__detail/__completion_behavior.hpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2025 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <compare>
+#include <type_traits>
+#include <initializer_list>
+
+#include "__config.hpp"
+#include "__concepts.hpp"
+#include "__query.hpp"
+#include "__meta.hpp"
+#include "__execution_fwd.hpp"
+#include "__type_traits.hpp"
+
+namespace stdexec {
+ //////////////////////////////////////////////////////////////////////////////////////////
+ // get_completion_behavior
+ namespace __completion_behavior {
+ enum class completion_behavior : int {
+ unknown, ///< The completion behavior is unknown.
+ asynchronous, ///< The operation's completion will not happen on the calling thread before `start()`
+ ///< returns.
+ synchronous, ///< The operation's completion happens-before the return of `start()`.
+ inline_completion ///< The operation completes synchronously within `start()` on the same thread that called
+ ///< `start()`.
+ };
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator<=>(completion_behavior __a, completion_behavior __b) noexcept
+ -> std::strong_ordering {
+ return static_cast<int>(__a) <=> static_cast<int>(__b);
+ }
+
+ template <completion_behavior _CB>
+ using __constant_t = std::integral_constant<completion_behavior, _CB>;
+
+ using __unknown_t = __constant_t<completion_behavior::unknown>;
+ using __asynchronous_t = __constant_t<completion_behavior::asynchronous>;
+ using __synchronous_t = __constant_t<completion_behavior::synchronous>;
+ using __inline_completion_t = __constant_t<completion_behavior::inline_completion>;
+ } // namespace __completion_behavior
+
+ struct min_t;
+
+ struct completion_behavior {
+ private:
+ template <__completion_behavior::completion_behavior _CB>
+ using __constant_t = std::integral_constant<__completion_behavior::completion_behavior, _CB>;
+
+ friend struct min_t;
+
+ public:
+ struct unknown_t : __completion_behavior::__unknown_t { };
+ struct asynchronous_t : __completion_behavior::__asynchronous_t { };
+ struct synchronous_t : __completion_behavior::__synchronous_t { };
+ struct inline_completion_t : __completion_behavior::__inline_completion_t { };
+
+ static constexpr unknown_t unknown{};
+ static constexpr asynchronous_t asynchronous{};
+ static constexpr synchronous_t synchronous{};
+ static constexpr inline_completion_t inline_completion{};
+ };
+
+ //////////////////////////////////////////////////////////////////////////////////////////
+ // get_completion_behavior: A sender can define this attribute to describe the sender's
+ // completion behavior
+ struct get_completion_behavior_t
+ : __query<get_completion_behavior_t, completion_behavior::unknown, __q1<__decay_t>> {
+ template <class _Attrs, class... _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept {
+ static_assert(
+ __nothrow_queryable_with<_Attrs, get_completion_behavior_t, _Env...>,
+ "The get_completion_behavior query must be noexcept.");
+ static_assert(
+ convertible_to<
+ __query_result_t<_Attrs, get_completion_behavior_t, _Env...>,
+ __completion_behavior::completion_behavior
+ >,
+ "The get_completion_behavior query must return one of the static member variables in "
+ "execution::completion_behavior.");
+ }
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static constexpr auto query(forwarding_query_t) noexcept -> bool {
+ return true;
+ }
+ };
+
+ struct min_t {
+ using __completion_behavior_t = __completion_behavior::completion_behavior;
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static constexpr auto __minimum(std::initializer_list<__completion_behavior_t> __cbs) noexcept
+ -> __completion_behavior_t {
+ auto __result = __completion_behavior::completion_behavior::inline_completion;
+ for (auto __cb: __cbs) {
+ if (__cb < __result) {
+ __result = __cb;
+ }
+ }
+ return __result;
+ }
+
+ template <__completion_behavior_t... _CBs>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(completion_behavior::__constant_t<_CBs>...) const noexcept {
+ constexpr auto __behavior = __minimum({_CBs...});
+
+ if constexpr (__behavior == completion_behavior::unknown) {
+ return completion_behavior::unknown;
+ } else if constexpr (__behavior == completion_behavior::asynchronous) {
+ return completion_behavior::asynchronous;
+ } else if constexpr (__behavior == completion_behavior::synchronous) {
+ return completion_behavior::synchronous;
+ } else if constexpr (__behavior == completion_behavior::inline_completion) {
+ return completion_behavior::inline_completion;
+ }
+ STDEXEC_UNREACHABLE();
+ }
+ };
+
+ constexpr min_t min{};
+
+ template <class _Attrs, class... _Env>
+ concept __completes_inline =
+ (__call_result_t<get_completion_behavior_t, const _Attrs&, const _Env&...>{}
+ == completion_behavior::inline_completion);
+
+ template <class _Sndr, class... _Env>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ consteval auto get_completion_behavior() noexcept {
+ using __behavior_t =
+ __call_result_t<get_completion_behavior_t, env_of_t<_Sndr>, const _Env&...>;
+ return __behavior_t{};
+ }
+
+} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__completion_signatures.hpp b/include/sdbusplus/async/stdexec/__detail/__completion_signatures.hpp
index dd16858..dfe13c5 100644
--- a/include/sdbusplus/async/stdexec/__detail/__completion_signatures.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__completion_signatures.hpp
@@ -22,37 +22,31 @@
#include "__diagnostics.hpp"
#include "__meta.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// completion_signatures
-namespace __sigs
-{
-template <class... _Args>
-inline constexpr bool __is_compl_sig<set_value_t(_Args...)> = true;
-template <class _Error>
-inline constexpr bool __is_compl_sig<set_error_t(_Error)> = true;
-template <>
-inline constexpr bool __is_compl_sig<set_stopped_t()> = true;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // completion_signatures
+ namespace __sigs {
+ template <class... _Args>
+ inline constexpr bool __is_compl_sig<set_value_t(_Args...)> = true;
+ template <class _Error>
+ inline constexpr bool __is_compl_sig<set_error_t(_Error)> = true;
+ template <>
+ inline constexpr bool __is_compl_sig<set_stopped_t()> = true;
-template <class>
-inline constexpr bool __is_completion_signatures = false;
-template <class... _Sigs>
-inline constexpr bool
- __is_completion_signatures<completion_signatures<_Sigs...>> = true;
-} // namespace __sigs
+ template <class>
+ inline constexpr bool __is_completion_signatures = false;
+ template <class... _Sigs>
+ inline constexpr bool __is_completion_signatures<completion_signatures<_Sigs...>> = true;
+ } // namespace __sigs
-template <class... _Sigs>
-struct completion_signatures
-{};
+ template <class... _Sigs>
+ struct completion_signatures { };
-template <class _Completions>
-concept __valid_completion_signatures = //
- __same_as<__ok_t<_Completions>, __msuccess> &&
- __sigs::__is_completion_signatures<_Completions>;
+ template <class _Completions>
+ concept __valid_completion_signatures = __same_as<__ok_t<_Completions>, __msuccess>
+ && __sigs::__is_completion_signatures<_Completions>;
-template <class _Sender, class _Env>
-using __unrecognized_sender_error = //
- __mexception<_UNRECOGNIZED_SENDER_TYPE_<>, _WITH_SENDER_<_Sender>,
- _WITH_ENVIRONMENT_<_Env>>;
+ template <class _Sender, class... _Env>
+ using __unrecognized_sender_error =
+ __mexception<_UNRECOGNIZED_SENDER_TYPE_<>, _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>...>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__concepts.hpp b/include/sdbusplus/async/stdexec/__detail/__concepts.hpp
index e31f7ba..dd01cfd 100644
--- a/include/sdbusplus/async/stdexec/__detail/__concepts.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__concepts.hpp
@@ -15,8 +15,8 @@
*/
#pragma once
-#if __cpp_concepts < 201907L
-#error This library requires support for C++20 concepts
+#if __cpp_concepts < 2019'07L
+# error This library requires support for C++20 concepts
#endif
#include "__config.hpp"
@@ -25,276 +25,243 @@
#include <version>
// Perhaps the stdlib lacks support for concepts though:
-#if __has_include(<concepts>) && __cpp_lib_concepts >= 202002
-#define STDEXEC_HAS_STD_CONCEPTS_HEADER() 1
+#if __has_include(<concepts>) && __cpp_lib_concepts >= 2020'02L
+# define STDEXEC_HAS_STD_CONCEPTS_HEADER() 1
#else
-#define STDEXEC_HAS_STD_CONCEPTS_HEADER() 0
+# define STDEXEC_HAS_STD_CONCEPTS_HEADER() 0
#endif
#if STDEXEC_HAS_STD_CONCEPTS_HEADER()
-#include <concepts>
+# include <concepts>
#else
-#include <type_traits>
+# include <type_traits>
#endif
-namespace stdexec
-{
-//////////////////////////////////////////////////////////////////////////////////////////////////
-template <class _Fun, class... _As>
-concept __callable = //
- requires(_Fun&& __fun, _As&&... __as) { //
- static_cast<_Fun&&>(__fun)(static_cast<_As&&>(__as)...); //
- };
-template <class _Fun, class... _As>
-concept __nothrow_callable = //
- __callable<_Fun, _As...> && //
- requires(_Fun&& __fun, _As&&... __as) {
- { static_cast<_Fun&&>(__fun)(static_cast<_As&&>(__as)...) } noexcept;
- };
+namespace stdexec {
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ template <class _Fun, class... _As>
+ concept __callable = requires(_Fun&& __fun, _As&&... __as) {
+ static_cast<_Fun &&>(__fun)(static_cast<_As &&>(__as)...);
+ };
+ template <class _Fun, class... _As>
+ concept __nothrow_callable = __callable<_Fun, _As...> && requires(_Fun&& __fun, _As&&... __as) {
+ { static_cast<_Fun &&>(__fun)(static_cast<_As &&>(__as)...) } noexcept;
+ };
-//////////////////////////////////////////////////////////////////////////////////////////////////
-template <class...>
-struct __types;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ template <class...>
+ struct __types;
-template <class... _Ts>
-concept __typename = requires { typename __types<_Ts...>; };
+ template <class... _Ts>
+ concept __typename = requires {
+ typename __types<_Ts...>; // NOLINT
+ };
-//////////////////////////////////////////////////////////////////////////////////////////////////
-template <class _Ap, class _Bp>
-concept __same_as = STDEXEC_IS_SAME(_Ap, _Bp);
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ template <class _Ap, class _Bp>
+ concept __same_as = STDEXEC_IS_SAME(_Ap, _Bp);
-// Handy concepts
-template <class _Ty, class _Up>
-concept __decays_to = __same_as<__decay_t<_Ty>, _Up>;
+ // Handy concepts
+ template <class _Ty, class _Up>
+ concept __decays_to = __same_as<__decay_t<_Ty>, _Up>;
-template <class _Ty, class _Up>
-concept __not_decays_to = !__decays_to<_Ty, _Up>;
+ template <class _Ty, class _Up>
+ concept __not_decays_to = !__decays_to<_Ty, _Up>;
-template <bool _TrueOrFalse>
-concept __satisfies = _TrueOrFalse;
+ template <bool _TrueOrFalse>
+ concept __satisfies = _TrueOrFalse;
-template <class...>
-concept __true = true;
+ template <class...>
+ concept __true = true;
-template <class _Cp>
-concept __class = __true<int _Cp::*> && (!__same_as<const _Cp, _Cp>);
+ template <class _Cp>
+ concept __class = __true<int _Cp::*> && (!__same_as<const _Cp, _Cp>);
-template <class _Ty, class... _As>
-concept __one_of = (__same_as<_Ty, _As> || ...);
+ template <class _Ty, class... _As>
+ concept __one_of = (__same_as<_Ty, _As> || ...);
-template <class _Ty, class... _Us>
-concept __all_of = (__same_as<_Ty, _Us> && ...);
+ template <class _Ty, class... _Us>
+ concept __all_of = (__same_as<_Ty, _Us> && ...);
-template <class _Ty, class... _Us>
-concept __none_of = ((!__same_as<_Ty, _Us>) && ...);
+ template <class _Ty, class... _Us>
+ concept __none_of = ((!__same_as<_Ty, _Us>) && ...);
-template <class, template <class...> class>
-constexpr bool __is_instance_of_ = false;
-template <class... _As, template <class...> class _Ty>
-constexpr bool __is_instance_of_<_Ty<_As...>, _Ty> = true;
+ template <class, template <class...> class>
+ constexpr bool __is_instance_of_ = false;
+ template <class... _As, template <class...> class _Ty>
+ constexpr bool __is_instance_of_<_Ty<_As...>, _Ty> = true;
-template <class _Ay, template <class...> class _Ty>
-concept __is_instance_of = __is_instance_of_<_Ay, _Ty>;
+ template <class _Ay, template <class...> class _Ty>
+ concept __is_instance_of = __is_instance_of_<_Ay, _Ty>;
-template <class _Ay, template <class...> class _Ty>
-concept __is_not_instance_of = !__is_instance_of<_Ay, _Ty>;
+ template <class _Ay, template <class...> class _Ty>
+ concept __is_not_instance_of = !__is_instance_of<_Ay, _Ty>;
} // namespace stdexec
-namespace stdexec::__std_concepts
-{
-// Make sure we're using a same_as concept that doesn't instantiate std::is_same
-template <class _Ap, class _Bp>
-concept same_as = __same_as<_Ap, _Bp> && __same_as<_Bp, _Ap>;
+namespace stdexec::__std_concepts {
+ // Make sure we're using a same_as concept that doesn't instantiate std::is_same
+ template <class _Ap, class _Bp>
+ concept same_as = __same_as<_Ap, _Bp> && __same_as<_Bp, _Ap>;
#if STDEXEC_HAS_STD_CONCEPTS_HEADER()
-using std::convertible_to;
-using std::derived_from;
-using std::equality_comparable;
-using std::integral;
+ using std::integral;
+ using std::derived_from;
+ using std::convertible_to;
+ using std::equality_comparable;
#else
-template <class T>
-concept integral = std::is_integral_v<T>;
+ template <class T>
+ concept integral = std::is_integral_v<T>;
-template <class _Ap, class _Bp>
-concept derived_from = //
- STDEXEC_IS_BASE_OF(_Bp, _Ap) && //
- STDEXEC_IS_CONVERTIBLE_TO(const volatile _Ap*, const volatile _Bp*);
+ template <class _Ap, class _Bp>
+ concept derived_from = STDEXEC_IS_BASE_OF(_Bp, _Ap)
+ && STDEXEC_IS_CONVERTIBLE_TO(const volatile _Ap*, const volatile _Bp*);
-template <class _From, class _To>
-concept convertible_to = //
- STDEXEC_IS_CONVERTIBLE_TO(_From, _To) && //
- requires(_From (&__fun)()) { static_cast<_To>(__fun()); };
+ template <class _From, class _To>
+ concept convertible_to = STDEXEC_IS_CONVERTIBLE_TO(_From, _To)
+ && requires(_From (&__fun)()) { static_cast<_To>(__fun()); };
-template <class _Ty>
-concept equality_comparable = //
- requires(__cref_t<_Ty> __t) {
- { __t == __t } -> convertible_to<bool>;
- { __t != __t } -> convertible_to<bool>;
- };
+ template <class _Ty>
+ concept equality_comparable = requires(__cref_t<_Ty> __t) {
+ { __t == __t } -> convertible_to<bool>;
+ { __t != __t } -> convertible_to<bool>;
+ };
#endif
} // namespace stdexec::__std_concepts
-namespace stdexec
-{
-using namespace __std_concepts;
+namespace stdexec {
+ using namespace __std_concepts;
-// Avoid using libstdc++'s object concepts because they instantiate a
-// lot of templates.
+ // Avoid using libstdc++'s object concepts because they instantiate a
+ // lot of templates.
#if STDEXEC_HAS_BUILTIN(__is_nothrow_destructible) || STDEXEC_MSVC()
-template <class _Ty>
-concept destructible = __is_nothrow_destructible(_Ty);
+ template <class _Ty>
+ concept destructible = __is_nothrow_destructible(_Ty);
#else
-template <class _Ty>
-inline constexpr bool __destructible_ = //
- requires(_Ty && (&__fn)() noexcept) {
- { __fn().~_Ty() } noexcept;
- };
-template <class _Ty>
-inline constexpr bool __destructible_<_Ty&> = true;
-template <class _Ty>
-inline constexpr bool __destructible_<_Ty&&> = true;
-template <class _Ty, std::size_t _Np>
-inline constexpr bool __destructible_<_Ty[_Np]> = __destructible_<_Ty>;
+ template <class _Ty>
+ inline constexpr bool __destructible_ = requires(_Ty && (&__fn)() noexcept) {
+ { __fn().~_Ty() } noexcept;
+ };
+ template <class _Ty>
+ inline constexpr bool __destructible_<_Ty&> = true;
+ template <class _Ty>
+ inline constexpr bool __destructible_<_Ty&&> = true;
+ template <class _Ty, std::size_t _Np>
+ inline constexpr bool __destructible_<_Ty[_Np]> = __destructible_<_Ty>;
-template <class T>
-concept destructible = __destructible_<T>;
+ template <class T>
+ concept destructible = __destructible_<T>;
#endif
-template <class _Ty, class... _As>
-concept constructible_from = //
- destructible<_Ty> && //
- STDEXEC_IS_CONSTRUCTIBLE(_Ty, _As...);
+ template <class _Ty, class... _As>
+ concept constructible_from = destructible<_Ty> && STDEXEC_IS_CONSTRUCTIBLE(_Ty, _As...);
-template <class _Ty>
-concept default_initializable = //
- constructible_from<_Ty> && //
- requires { _Ty{}; } && //
- requires { ::new _Ty; };
+ template <class _Ty>
+ concept default_initializable = constructible_from<_Ty> && requires { _Ty{}; }
+ && requires { ::new _Ty; };
-template <class _Ty>
-concept move_constructible = //
- constructible_from<_Ty, _Ty>;
+ template <class _Ty>
+ concept move_constructible = constructible_from<_Ty, _Ty>;
-template <class _Ty>
-concept copy_constructible = //
- move_constructible<_Ty> //
- && constructible_from<_Ty, const _Ty&>;
+ template <class _Ty>
+ concept copy_constructible = move_constructible<_Ty> && constructible_from<_Ty, _Ty const &>;
-template <class _LHS, class _RHS>
-concept assignable_from = //
- same_as<_LHS, _LHS&> && //
- // std::common_reference_with<
- // const std::remove_reference_t<_LHS>&,
- // const std::remove_reference_t<_RHS>&> &&
- requires(_LHS __lhs, _RHS&& __rhs) {
- { __lhs = static_cast<_RHS&&>(__rhs) } -> same_as<_LHS>;
+ template <class _LHS, class _RHS>
+ concept assignable_from = same_as<_LHS, _LHS&> &&
+ // std::common_reference_with<
+ // const std::remove_reference_t<_LHS>&,
+ // const std::remove_reference_t<_RHS>&> &&
+ requires(_LHS __lhs, _RHS&& __rhs) {
+ { __lhs = static_cast<_RHS &&>(__rhs) } -> same_as<_LHS>;
+ };
+
+ namespace __swap {
+ using std::swap;
+
+ template <class _Ty, class _Uy>
+ concept swappable_with = requires(_Ty&& __t, _Uy&& __u) {
+ swap(static_cast<_Ty &&>(__t), static_cast<_Uy &&>(__u));
};
-namespace __swap
-{
-using std::swap;
-
-template <class _Ty, class _Uy>
-concept swappable_with = //
- requires(_Ty&& __t, _Uy&& __u) { //
+ inline constexpr auto const __fn =
+ []<class _Ty, swappable_with<_Ty> _Uy>(_Ty&& __t, _Uy&& __u) noexcept(
+ noexcept(swap(static_cast<_Ty&&>(__t), static_cast<_Uy&&>(__u)))) {
swap(static_cast<_Ty&&>(__t), static_cast<_Uy&&>(__u));
- };
+ };
+ } // namespace __swap
-inline constexpr const auto __fn = //
- []<class _Ty, swappable_with<_Ty> _Uy>(_Ty&& __t, _Uy&& __u) //
- noexcept(noexcept(swap(static_cast<_Ty&&>(__t), static_cast<_Uy&&>(__u)))) {
- swap(static_cast<_Ty&&>(__t), static_cast<_Uy&&>(__u));
- };
-} // namespace __swap
+ using __swap::swappable_with;
+ inline constexpr auto const & swap = __swap::__fn;
-using __swap::swappable_with;
-inline constexpr const auto& swap = __swap::__fn;
+ template <class _Ty>
+ concept swappable = requires(_Ty& a, _Ty& b) { swap(a, b); };
-template <class _Ty>
-concept swappable = //
- requires(_Ty& a, _Ty& b) { swap(a, b); };
+ template <class _Ty>
+ concept movable = std::is_object_v<_Ty> && move_constructible<_Ty> && assignable_from<_Ty&, _Ty>
+ && swappable<_Ty>;
-template <class _Ty>
-concept movable = //
- std::is_object_v<_Ty> && //
- move_constructible<_Ty> && //
- assignable_from<_Ty&, _Ty> && //
- swappable<_Ty>;
+ template <class _Ty>
+ concept copyable = copy_constructible<_Ty> && movable<_Ty> && assignable_from<_Ty&, _Ty&>
+ && assignable_from<_Ty&, const _Ty&> && assignable_from<_Ty&, const _Ty>;
-template <class _Ty>
-concept copyable = //
- copy_constructible<_Ty> && //
- movable<_Ty> && //
- assignable_from<_Ty&, _Ty&> && //
- assignable_from<_Ty&, const _Ty&> && //
- assignable_from<_Ty&, const _Ty>;
+ template <class _Ty>
+ concept semiregular = copyable<_Ty> && default_initializable<_Ty>;
-template <class _Ty>
-concept semiregular = //
- copyable<_Ty> && //
- default_initializable<_Ty>;
+ template <class _Ty>
+ concept regular = semiregular<_Ty> && equality_comparable<_Ty>;
-template <class _Ty>
-concept regular = //
- semiregular<_Ty> && //
- equality_comparable<_Ty>;
+ // Not exactly right, but close.
+ template <class _Ty>
+ concept __boolean_testable_ = convertible_to<_Ty, bool>;
-// Not exactly right, but close.
-template <class _Ty>
-concept __boolean_testable_ = convertible_to<_Ty, bool>;
+ template <class T, class U>
+ concept __partially_ordered_with = requires(__cref_t<T> t, __cref_t<U> u) {
+ { t < u } -> __boolean_testable_;
+ { t > u } -> __boolean_testable_;
+ { t <= u } -> __boolean_testable_;
+ { t >= u } -> __boolean_testable_;
+ { u < t } -> __boolean_testable_;
+ { u > t } -> __boolean_testable_;
+ { u <= t } -> __boolean_testable_;
+ { u >= t } -> __boolean_testable_;
+ };
-template <class T, class U>
-concept __partially_ordered_with = //
- requires(__cref_t<T> t, __cref_t<U> u) {
- { t < u } -> __boolean_testable_;
- { t > u } -> __boolean_testable_;
- { t <= u } -> __boolean_testable_;
- { t >= u } -> __boolean_testable_;
- { u < t } -> __boolean_testable_;
- { u > t } -> __boolean_testable_;
- { u <= t } -> __boolean_testable_;
- { u >= t } -> __boolean_testable_;
- };
+ template <class _Ty>
+ concept totally_ordered = equality_comparable<_Ty> && __partially_ordered_with<_Ty, _Ty>;
-template <class _Ty>
-concept totally_ordered = //
- equality_comparable<_Ty> && //
- __partially_ordered_with<_Ty, _Ty>;
+ template <class _Ty>
+ concept __movable_value = move_constructible<__decay_t<_Ty>>
+ && constructible_from<__decay_t<_Ty>, _Ty>;
-template <class _Ty>
-concept __movable_value = //
- move_constructible<__decay_t<_Ty>> && //
- constructible_from<__decay_t<_Ty>, _Ty>;
+ template <class _Ty>
+ concept __nothrow_movable_value = __movable_value<_Ty> && requires(_Ty&& __t) {
+ { __decay_t<_Ty>{__decay_t<_Ty>{static_cast<_Ty &&>(__t)}} } noexcept;
+ };
-template <class _Ty>
-concept __nothrow_movable_value = //
- __movable_value<_Ty> && //
- requires(_Ty&& __t) {
- { __decay_t<_Ty>{__decay_t<_Ty>{static_cast<_Ty&&>(__t)}} } noexcept;
- };
+ template <class _Ty, class... _As>
+ concept __nothrow_constructible_from = constructible_from<_Ty, _As...>
+ && STDEXEC_IS_NOTHROW_CONSTRUCTIBLE(_Ty, _As...);
-template <class _Ty, class... _As>
-concept __nothrow_constructible_from =
- constructible_from<_Ty, _As...> &&
- STDEXEC_IS_NOTHROW_CONSTRUCTIBLE(_Ty, _As...);
+ template <class _Ty>
+ concept __nothrow_move_constructible = __nothrow_constructible_from<_Ty, _Ty>;
-template <class _Ty>
-concept __nothrow_move_constructible = __nothrow_constructible_from<_Ty, _Ty>;
+ template <class _Ty>
+ concept __nothrow_copy_constructible = __nothrow_constructible_from<_Ty, const _Ty&>;
-template <class _Ty>
-concept __nothrow_copy_constructible =
- __nothrow_constructible_from<_Ty, const _Ty&>;
+ template <class... _Ts>
+ concept __decay_copyable = (constructible_from<__decay_t<_Ts>, _Ts> && ...);
-template <class... _Ts>
-concept __decay_copyable = (constructible_from<__decay_t<_Ts>, _Ts> && ...);
+ template <class... _Ts>
+ using __decay_copyable_t = __mbool<__decay_copyable<_Ts...>>;
-template <class... _Ts>
-concept __nothrow_decay_copyable =
- (__nothrow_constructible_from<__decay_t<_Ts>, _Ts> && ...);
+ template <class... _Ts>
+ concept __nothrow_decay_copyable = (__nothrow_constructible_from<__decay_t<_Ts>, _Ts> && ...);
-template <class _Ty, class _Up>
-concept __decays_to_derived_from = derived_from<__decay_t<_Ty>, _Up>;
+ template <class... _Ts>
+ using __nothrow_decay_copyable_t = __mbool<__nothrow_decay_copyable<_Ts...>>;
+
+ template <class _Ty, class _Up>
+ concept __decays_to_derived_from = derived_from<__decay_t<_Ty>, _Up>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__config.hpp b/include/sdbusplus/async/stdexec/__detail/__config.hpp
index 479bf9e..6c08602 100644
--- a/include/sdbusplus/async/stdexec/__detail/__config.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__config.hpp
@@ -15,546 +15,603 @@
*/
#pragma once
-#if __cplusplus < 202002L
-#if defined(_MSC_VER) && !defined(__clang__)
+// IWYU pragma: always_keep
+
+#if __cplusplus < 2020'02L
+# if defined(_MSC_VER) && !defined(__clang__)
# error This library requires the use of C++20. Use /Zc:__cplusplus to enable __cplusplus conformance.
-#else
-#error This library requires the use of C++20.
-#endif
+# else
+# error This library requires the use of C++20.
+# endif
#endif
-#if defined(_MSC_VER) && !defined(__clang__) && \
- (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
+#if defined(_MSC_VER) && !defined(__clang__) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
# error This library requires the use of the new conforming preprocessor enabled by /Zc:preprocessor.
#endif
+#include "__preprocessor.hpp"
+
#if __has_include(<version>)
-#include <version>
+# include <version>
#else
-#include <ciso646> // For stdlib feature-test macros when <version> is not available
+# include <ciso646> // For stdlib feature-test macros when <version> is not available
#endif
#include <cassert>
-#include <type_traits>
-
-#define STDEXEC_STRINGIZE(_ARG) #_ARG
-
-#define STDEXEC_CAT_(_XP, ...) _XP##__VA_ARGS__
-#define STDEXEC_CAT(_XP, ...) STDEXEC_CAT_(_XP, __VA_ARGS__)
-
-#define STDEXEC_EXPAND(...) __VA_ARGS__
-#define STDEXEC_EVAL(_MACRO, ...) _MACRO(__VA_ARGS__)
-#define STDEXEC_EAT(...)
-
-#define STDEXEC_IIF(_XP, _YP, ...) \
- STDEXEC_IIF_EVAL(STDEXEC_CAT(STDEXEC_IIF_, _XP), _YP, __VA_ARGS__)
-#define STDEXEC_IIF_0(_YP, ...) __VA_ARGS__
-#define STDEXEC_IIF_1(_YP, ...) _YP
-#define STDEXEC_IIF_EVAL(_MACRO, ...) _MACRO(__VA_ARGS__)
-
-#define STDEXEC_COMPL(_B) STDEXEC_COMPL_CAT(STDEXEC_COMPL_, _B)
-#define STDEXEC_COMPL_0 1
-#define STDEXEC_COMPL_1 0
-#define STDEXEC_COMPL_CAT(_XP, ...) _XP##__VA_ARGS__
-
-#define STDEXEC_COUNT(...) \
- STDEXEC_EXPAND(STDEXEC_COUNT_(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1))
-#define STDEXEC_COUNT_(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _NP, ...) _NP
-
-#define STDEXEC_CHECK(...) STDEXEC_EXPAND(STDEXEC_CHECK_(__VA_ARGS__, 0, ))
-#define STDEXEC_CHECK_(_XP, _NP, ...) _NP
-#define STDEXEC_PROBE(...) STDEXEC_PROBE_(__VA_ARGS__, 1)
-#define STDEXEC_PROBE_(_XP, _NP, ...) _XP, _NP,
-
-#define STDEXEC_NOT(_XP) STDEXEC_CHECK(STDEXEC_CAT(STDEXEC_NOT_, _XP))
-#define STDEXEC_NOT_0 STDEXEC_PROBE(~, 1)
-
-#define STDEXEC_BOOL(_XP) STDEXEC_COMPL(STDEXEC_NOT(_XP))
-#define STDEXEC_IF(_XP, _YP, ...) \
- STDEXEC_IIF(STDEXEC_BOOL(_XP), _YP, __VA_ARGS__)
-
-#define STDEXEC_WHEN(_XP, ...) \
- STDEXEC_IF(_XP, STDEXEC_EXPAND, STDEXEC_EAT)(__VA_ARGS__)
-
-////////////////////////////////////////////////////////////////////////////////
-// STDEXEC_FOR_EACH
-// Inspired by "Recursive macros with C++20 __VA_OPT__", by David Mazières
-// https://www.scs.stanford.edu/~dm/blog/va-opt.html
-#define STDEXEC_EXPAND_R(...) \
- STDEXEC_EXPAND_R1( \
- STDEXEC_EXPAND_R1(STDEXEC_EXPAND_R1(STDEXEC_EXPAND_R1(__VA_ARGS__)))) \
- /**/
-#define STDEXEC_EXPAND_R1(...) \
- STDEXEC_EXPAND_R2( \
- STDEXEC_EXPAND_R2(STDEXEC_EXPAND_R2(STDEXEC_EXPAND_R2(__VA_ARGS__)))) \
- /**/
-#define STDEXEC_EXPAND_R2(...) \
- STDEXEC_EXPAND_R3( \
- STDEXEC_EXPAND_R3(STDEXEC_EXPAND_R3(STDEXEC_EXPAND_R3(__VA_ARGS__)))) \
- /**/
-#define STDEXEC_EXPAND_R3(...) \
- STDEXEC_EXPAND( \
- STDEXEC_EXPAND(STDEXEC_EXPAND(STDEXEC_EXPAND(__VA_ARGS__)))) \
- /**/
-
-#define STDEXEC_PARENS ()
-#define STDEXEC_FOR_EACH(_MACRO, ...) \
- __VA_OPT__(STDEXEC_EXPAND_R(STDEXEC_FOR_EACH_HELPER(_MACRO, __VA_ARGS__))) \
- /**/
-#define STDEXEC_FOR_EACH_HELPER(_MACRO, _A1, ...) \
- _MACRO(_A1) \
- __VA_OPT__(STDEXEC_FOR_EACH_AGAIN STDEXEC_PARENS(_MACRO, __VA_ARGS__)) /**/
-#define STDEXEC_FOR_EACH_AGAIN() STDEXEC_FOR_EACH_HELPER
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#define STDEXEC_FRONT(...) __VA_OPT__(STDEXEC_FRONT_HELPER(__VA_ARGS__))
-#define STDEXEC_FRONT_HELPER(_A1, ...) _A1
-#define STDEXEC_BACK(...) \
- __VA_OPT__(STDEXEC_EXPAND_R(STDEXEC_BACK_HELPER(__VA_ARGS__)))
-#define STDEXEC_BACK_HELPER(_A1, ...) \
- STDEXEC_FRONT(__VA_OPT__(, ) _A1, ) \
- __VA_OPT__(STDEXEC_BACK_AGAIN STDEXEC_PARENS(__VA_ARGS__))
-#define STDEXEC_BACK_AGAIN() STDEXEC_BACK_HELPER
-
-// If tail is non-empty, expand to the tail. Otherwise, expand to the head
-#define STDEXEC_HEAD_OR_TAIL(_XP, ...) \
- STDEXEC_EXPAND __VA_OPT__((__VA_ARGS__)STDEXEC_EAT)(_XP)
-
-// If tail is non-empty, expand to nothing. Otherwise, expand to the head
-#define STDEXEC_HEAD_OR_NULL(_XP, ...) \
- STDEXEC_EXPAND __VA_OPT__(() STDEXEC_EAT)(_XP)
+#include <cstdlib>
+#include <type_traits> // IWYU pragma: keep
+#include <utility> // IWYU pragma: keep for std::unreachable
// When used with no arguments, these macros expand to 1 if the current
-// compiler corresponds to the macro name; 0, otherwise. When used with
-// arguments, they expand to the arguments if if the current compiler
-// corresponds to the macro name; nothing, otherwise.
+// compiler corresponds to the macro name; 0, otherwise. When used with arguments,
+// they expand to the arguments if if the current compiler corresponds to the
+// macro name; nothing, otherwise.
#if defined(__NVCC__)
-#define STDEXEC_NVCC(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
+# define STDEXEC_NVCC() 1
+# define STDEXEC_NVCC_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
#elif defined(__EDG__)
-#define STDEXEC_EDG(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#if defined(__NVCOMPILER)
-#define STDEXEC_NVHPC(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#endif
-#if defined(__INTELLISENSE__)
-#define STDEXEC_INTELLISENSE(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#define STDEXEC_MSVC_HEADERS(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#endif
+# define STDEXEC_EDG() 1
+# define STDEXEC_EDG_VERSION __EDG_VERSION__
+# if defined(__NVCOMPILER)
+# define STDEXEC_NVHPC() 1
+# define STDEXEC_NVHPC_VERSION (__NVCOMPILER_MAJOR__ * 100 + __NVCOMPILER_MINOR__)
+# endif
+# if defined(__INTELLISENSE__)
+# define STDEXEC_INTELLISENSE() 1
+# define STDEXEC_MSVC_HEADERS() 1
+# endif
#elif defined(__clang__)
-#define STDEXEC_CLANG(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#if defined(_MSC_VER)
-#define STDEXEC_CLANG_CL(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#endif
-#if defined(__apple_build_version__)
-#define STDEXEC_APPLE_CLANG(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#endif
+# define STDEXEC_CLANG() 1
+# define STDEXEC_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+# if defined(_MSC_VER)
+# define STDEXEC_CLANG_CL() 1
+# endif
+# if defined(__apple_build_version__)
+# define STDEXEC_APPLE_CLANG() 1
+// Apple clang version is encoded as major * 1000000 + minor * 1000 + patch. We ignore the patch
+// version here, as it is not relevant for the purposes of this library.
+# define STDEXEC_APPLE_CLANG_VERSION (__apple_build_version__ / 1000)
+# endif
#elif defined(__GNUC__)
-#define STDEXEC_GCC(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
+# define STDEXEC_GCC() 1
+# define STDEXEC_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#elif defined(_MSC_VER)
-#define STDEXEC_MSVC(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
-#define STDEXEC_MSVC_HEADERS(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
+# define STDEXEC_MSVC() 1
+# define STDEXEC_MSVC_HEADERS() 1
+# define STDEXEC_MSVC_VERSION _MSC_VER
#endif
#ifndef STDEXEC_NVCC
-#define STDEXEC_NVCC(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_NVCC() 0
#endif
#ifndef STDEXEC_NVHPC
-#define STDEXEC_NVHPC(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_NVHPC() 0
#endif
#ifndef STDEXEC_EDG
-#define STDEXEC_EDG(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_EDG() 0
#endif
#ifndef STDEXEC_CLANG
-#define STDEXEC_CLANG(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_CLANG() 0
#endif
#ifndef STDEXEC_CLANG_CL
-#define STDEXEC_CLANG_CL(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_CLANG_CL() 0
#endif
#ifndef STDEXEC_APPLE_CLANG
-#define STDEXEC_APPLE_CLANG(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_APPLE_CLANG() 0
#endif
#ifndef STDEXEC_GCC
-#define STDEXEC_GCC(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_GCC() 0
#endif
#ifndef STDEXEC_MSVC
-#define STDEXEC_MSVC(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_MSVC() 0
#endif
#ifndef STDEXEC_MSVC_HEADERS
-#define STDEXEC_MSVC_HEADERS(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_MSVC_HEADERS() 0
#endif
#ifndef STDEXEC_INTELLISENSE
-#define STDEXEC_INTELLISENSE(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
-#endif
-
-#if STDEXEC_NVHPC()
-#define STDEXEC_NVHPC_VERSION() \
- (__NVCOMPILER_MAJOR__ * 100 + __NVCOMPILER_MINOR__)
+# define STDEXEC_INTELLISENSE() 0
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
-#ifdef __CUDACC__
-#define STDEXEC_CUDA(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
+#if defined(__CUDACC__) || STDEXEC_NVHPC()
+# define STDEXEC_CUDA_COMPILATION() 1
#else
-#define STDEXEC_CUDA(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_CUDA_COMPILATION() 0
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
-#if __cpp_impl_coroutine >= 201902 && __cpp_lib_coroutine >= 201902
-#include <coroutine>
-#define STDEXEC_STD_NO_COROUTINES() 0
-namespace __coro = std;
+#if defined(__has_attribute)
+# define STDEXEC_HAS_ATTRIBUTE(...) __has_attribute(__VA_ARGS__)
+#else
+# define STDEXEC_HAS_ATTRIBUTE(...) 0
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+#if STDEXEC_CLANG() && STDEXEC_CUDA_COMPILATION()
+# define STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __host__ __device__
+#else
+# define STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+#if __cpp_impl_coroutine >= 2019'02 && __cpp_lib_coroutine >= 2019'02
+# include <coroutine> // IWYU pragma: keep
+# define STDEXEC_STD_NO_COROUTINES() 0
+namespace __coro = std; // NOLINT(misc-unused-alias-decls)
#elif defined(__cpp_coroutines) && __has_include(<experimental/coroutine>)
-#include <experimental/coroutine>
-#define STDEXEC_STD_NO_COROUTINES() 0
+# include <experimental/coroutine>
+# define STDEXEC_STD_NO_COROUTINES() 0
namespace __coro = std::experimental;
#else
-#define STDEXEC_STD_NO_COROUTINES() 1
+# define STDEXEC_STD_NO_COROUTINES() 1
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
// For portably declaring attributes on functions and types
// Usage:
//
-// STDEXEC_ATTRIBUTE((attr1, attr2, ...))
+// STDEXEC_ATTRIBUTE(attr1, attr2, ...)
// void foo() { ... }
-#define STDEXEC_ATTRIBUTE(_XP) \
- STDEXEC_FOR_EACH(STDEXEC_ATTR, STDEXEC_EXPAND _XP)
-#define STDEXEC_ATTR(_ATTR) \
- STDEXEC_CAT(STDEXEC_ATTR_WHICH_, \
- STDEXEC_CHECK(STDEXEC_CAT(STDEXEC_ATTR_, _ATTR))) \
- (_ATTR)
+#define STDEXEC_ATTRIBUTE(...) STDEXEC_FOR_EACH(STDEXEC__ATTRIBUTE_DETAIL, __VA_ARGS__)
+#define STDEXEC__ATTRIBUTE_DETAIL(_ATTR) \
+ STDEXEC_CAT(STDEXEC_ATTR_WHICH_, STDEXEC_CHECK(STDEXEC_CAT(STDEXEC_ATTR_, _ATTR)))(_ATTR)
// unknown attributes are treated like C++-style attributes
#define STDEXEC_ATTR_WHICH_0(_ATTR) [[_ATTR]]
// custom handling for specific attribute types
#ifdef __CUDACC__
-#define STDEXEC_ATTR_WHICH_1(_ATTR) __host__
+# define STDEXEC_ATTR_WHICH_1(_ATTR) __host__
#else
-#define STDEXEC_ATTR_WHICH_1(_ATTR)
+# define STDEXEC_ATTR_WHICH_1(_ATTR)
#endif
-#define STDEXEC_ATTR_host STDEXEC_PROBE(~, 1)
+#define STDEXEC_ATTR_host STDEXEC_PROBE(~, 1)
#define STDEXEC_ATTR___host__ STDEXEC_PROBE(~, 1)
#ifdef __CUDACC__
-#define STDEXEC_ATTR_WHICH_2(_ATTR) __device__
+# define STDEXEC_ATTR_WHICH_2(_ATTR) __device__
#else
-#define STDEXEC_ATTR_WHICH_2(_ATTR)
+# define STDEXEC_ATTR_WHICH_2(_ATTR)
#endif
-#define STDEXEC_ATTR_device STDEXEC_PROBE(~, 2)
+#define STDEXEC_ATTR_device STDEXEC_PROBE(~, 2)
#define STDEXEC_ATTR___device__ STDEXEC_PROBE(~, 2)
#if STDEXEC_NVHPC()
// NVBUG #4067067: NVHPC does not fully support [[no_unique_address]]
-#define STDEXEC_ATTR_WHICH_3(_ATTR) /*nothing*/
-#elif STDEXEC_MSVC()
-// MSVCBUG
-// https://developercommunity.visualstudio.com/t/Incorrect-codegen-when-using-msvc::no_/10452874
-#define STDEXEC_ATTR_WHICH_3(_ATTR) // [[msvc::no_unique_address]]
+# if STDEXEC_NVHPC_VERSION < 23'05
+# define STDEXEC_ATTR_WHICH_3(_ATTR) /*nothing*/
+# else
+# define STDEXEC_ATTR_WHICH_3(_ATTR) [[no_unique_address]]
+# endif
#elif STDEXEC_CLANG_CL()
-// clang-cl does not support: https://reviews.llvm.org/D110485
-#define STDEXEC_ATTR_WHICH_3(_ATTR) // [[msvc::no_unique_address]]
+// clang-cl does not support [[no_unique_address]]: https://reviews.llvm.org/D110485
+// TODO: Find the version that started supporting [[msvc::no_unique_address]]
+# if STDEXEC_CLANG_VERSION < 18'01
+# define STDEXEC_ATTR_WHICH_3(_ATTR) /*nothing*/
+# else
+# define STDEXEC_ATTR_WHICH_3(_ATTR) [[msvc::no_unique_address]]
+# endif
+#elif STDEXEC_MSVC()
+// MSVCBUG https://developercommunity.visualstudio.com/t/Incorrect-codegen-when-using-msvc::no_/10452874
+# if STDEXEC_MSVC_VERSION < 19'43
+# define STDEXEC_ATTR_WHICH_3(_ATTR) /*nothing*/
+# else
+# define STDEXEC_ATTR_WHICH_3(_ATTR) [[msvc::no_unique_address]]
+# endif
#else
-#define STDEXEC_ATTR_WHICH_3(_ATTR) [[no_unique_address]]
+# define STDEXEC_ATTR_WHICH_3(_ATTR) [[no_unique_address]]
#endif
#define STDEXEC_ATTR_no_unique_address STDEXEC_PROBE(~, 3)
#if STDEXEC_MSVC()
-#define STDEXEC_ATTR_WHICH_4(_ATTR) __forceinline
+# define STDEXEC_ATTR_WHICH_4(_ATTR) __forceinline
#elif STDEXEC_CLANG()
-#define STDEXEC_ATTR_WHICH_4(_ATTR) \
+# define STDEXEC_ATTR_WHICH_4(_ATTR) \
__attribute__((__always_inline__, __artificial__, __nodebug__)) inline
-#elif defined(__GNUC__)
-#define STDEXEC_ATTR_WHICH_4(_ATTR) \
- __attribute__((__always_inline__, __artificial__)) inline
+#elif STDEXEC_GCC()
+# define STDEXEC_ATTR_WHICH_4(_ATTR) __attribute__((__always_inline__, __artificial__)) inline
#else
-#define STDEXEC_ATTR_WHICH_4(_ATTR) /*nothing*/
+# define STDEXEC_ATTR_WHICH_4(_ATTR) /*nothing*/
#endif
#define STDEXEC_ATTR_always_inline STDEXEC_PROBE(~, 4)
#if STDEXEC_CLANG() || STDEXEC_GCC()
-#define STDEXEC_ATTR_WHICH_5(_ATTR) __attribute__((__weak__))
+# define STDEXEC_ATTR_WHICH_5(_ATTR) __attribute__((__weak__))
#else
-#define STDEXEC_ATTR_WHICH_5(_ATTR) /*nothing*/
+# define STDEXEC_ATTR_WHICH_5(_ATTR) /*nothing*/
#endif
-#define STDEXEC_ATTR_weak STDEXEC_PROBE(~, 5)
+#define STDEXEC_ATTR_weak STDEXEC_PROBE(~, 5)
#define STDEXEC_ATTR___weak__ STDEXEC_PROBE(~, 5)
+#if STDEXEC_HAS_ATTRIBUTE(__preferred_name__)
+# define STDEXEC_ATTR_WHICH_6(_ATTR) __attribute__((_ATTR))
+#else
+# define STDEXEC_ATTR_WHICH_6(_ATTR) /*nothing*/
+#endif
+#define STDEXEC_ATTR_preferred_name STDEXEC_PROBE(~, 6)
+#define STDEXEC_ATTR___preferred_name__ STDEXEC_PROBE(~, 6)
+
////////////////////////////////////////////////////////////////////////////////////////////////////
// warning push/pop portability macros
#if STDEXEC_NVCC()
-#define STDEXEC_PRAGMA_PUSH() _Pragma("nv_diagnostic push")
-#define STDEXEC_PRAGMA_POP() _Pragma("nv_diagnostic pop")
-#define STDEXEC_PRAGMA_IGNORE_EDG(...) \
- _Pragma(STDEXEC_STRINGIZE(nv_diag_suppress __VA_ARGS__))
+# define STDEXEC_PRAGMA_PUSH() _Pragma("nv_diagnostic push")
+# define STDEXEC_PRAGMA_POP() _Pragma("nv_diagnostic pop")
+# define STDEXEC_PRAGMA_IGNORE_EDG(...) _Pragma(STDEXEC_STRINGIZE(nv_diag_suppress __VA_ARGS__))
#elif STDEXEC_EDG()
-#define STDEXEC_PRAGMA_PUSH() \
- _Pragma("diagnostic push") STDEXEC_PRAGMA_IGNORE_EDG(invalid_error_number)
-#define STDEXEC_PRAGMA_POP() _Pragma("diagnostic pop")
-#define STDEXEC_PRAGMA_IGNORE_EDG(...) \
- _Pragma(STDEXEC_STRINGIZE(diag_suppress __VA_ARGS__))
+# define STDEXEC_PRAGMA_PUSH() \
+ _Pragma("diagnostic push") STDEXEC_PRAGMA_IGNORE_EDG(invalid_error_number) \
+ STDEXEC_PRAGMA_IGNORE_EDG(invalid_error_tag)
+# define STDEXEC_PRAGMA_POP() _Pragma("diagnostic pop")
+# define STDEXEC_PRAGMA_IGNORE_EDG(...) _Pragma(STDEXEC_STRINGIZE(diag_suppress __VA_ARGS__))
#elif STDEXEC_CLANG() || STDEXEC_GCC()
-#define STDEXEC_PRAGMA_PUSH() \
- _Pragma("GCC diagnostic push") STDEXEC_PRAGMA_IGNORE_GNU("-Wpragmas") \
- STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-pragmas") \
- STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-warning-option") \
- STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-attributes") \
- STDEXEC_PRAGMA_IGNORE_GNU("-Wattributes")
-#define STDEXEC_PRAGMA_POP() _Pragma("GCC diagnostic pop")
-#define STDEXEC_PRAGMA_IGNORE_GNU(...) \
+# define STDEXEC_PRAGMA_PUSH() \
+ _Pragma("GCC diagnostic push") STDEXEC_PRAGMA_IGNORE_GNU("-Wpragmas") \
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-pragmas") \
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-warning-option") \
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-attributes") \
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wattributes")
+# define STDEXEC_PRAGMA_POP() _Pragma("GCC diagnostic pop")
+# define STDEXEC_PRAGMA_IGNORE_GNU(...) \
_Pragma(STDEXEC_STRINGIZE(GCC diagnostic ignored __VA_ARGS__))
#elif STDEXEC_MSVC()
-#define STDEXEC_PRAGMA_PUSH() __pragma(warning(push))
-#define STDEXEC_PRAGMA_POP() __pragma(warning(pop))
-#define STDEXEC_PRAGMA_IGNORE_MSVC(...) __pragma(warning(disable : __VA_ARGS__))
+# define STDEXEC_PRAGMA_PUSH() __pragma(warning(push))
+# define STDEXEC_PRAGMA_POP() __pragma(warning(pop))
+# define STDEXEC_PRAGMA_IGNORE_MSVC(...) __pragma(warning(disable : __VA_ARGS__))
#else
-#define STDEXEC_PRAGMA_PUSH()
-#define STDEXEC_PRAGMA_POP()
+# define STDEXEC_PRAGMA_PUSH()
+# define STDEXEC_PRAGMA_POP()
#endif
#ifndef STDEXEC_PRAGMA_IGNORE_GNU
-#define STDEXEC_PRAGMA_IGNORE_GNU(...)
+# define STDEXEC_PRAGMA_IGNORE_GNU(...)
#endif
#ifndef STDEXEC_PRAGMA_IGNORE_EDG
-#define STDEXEC_PRAGMA_IGNORE_EDG(...)
+# define STDEXEC_PRAGMA_IGNORE_EDG(...)
#endif
#ifndef STDEXEC_PRAGMA_IGNORE_MSVC
-#define STDEXEC_PRAGMA_IGNORE_MSVC(...)
+# define STDEXEC_PRAGMA_IGNORE_MSVC(...)
#endif
#if !STDEXEC_MSVC() && defined(__has_builtin)
-#define STDEXEC_HAS_BUILTIN __has_builtin
+# define STDEXEC_HAS_BUILTIN __has_builtin
#else
-#define STDEXEC_HAS_BUILTIN(...) 0
+# define STDEXEC_HAS_BUILTIN(...) 0
#endif
#if !STDEXEC_MSVC() && defined(__has_feature)
-#define STDEXEC_HAS_FEATURE __has_feature
+# define STDEXEC_HAS_FEATURE __has_feature
#else
-#define STDEXEC_HAS_FEATURE(...) 0
+# define STDEXEC_HAS_FEATURE(...) 0
#endif
#if STDEXEC_HAS_BUILTIN(__is_trivially_copyable) || STDEXEC_MSVC()
-#define STDEXEC_IS_TRIVIALLY_COPYABLE(...) __is_trivially_copyable(__VA_ARGS__)
+# define STDEXEC_IS_TRIVIALLY_COPYABLE(...) __is_trivially_copyable(__VA_ARGS__)
#else
-#define STDEXEC_IS_TRIVIALLY_COPYABLE(...) \
- std::is_trivially_copyable_v<__VA_ARGS__>
+# define STDEXEC_IS_TRIVIALLY_COPYABLE(...) std::is_trivially_copyable_v<__VA_ARGS__>
#endif
-#if STDEXEC_HAS_BUILTIN(__is_base_of) || (_MSC_VER >= 1914)
-#define STDEXEC_IS_BASE_OF(...) __is_base_of(__VA_ARGS__)
+#if STDEXEC_HAS_BUILTIN(__is_base_of) || (STDEXEC_MSVC_VERSION >= 19'14)
+# define STDEXEC_IS_BASE_OF(...) __is_base_of(__VA_ARGS__)
#else
-#define STDEXEC_IS_BASE_OF(...) std::is_base_of_v<__VA_ARGS__>
+# define STDEXEC_IS_BASE_OF(...) std::is_base_of_v<__VA_ARGS__>
#endif
#if STDEXEC_HAS_BUILTIN(__is_convertible_to) || STDEXEC_MSVC()
-#define STDEXEC_IS_CONVERTIBLE_TO(...) __is_convertible_to(__VA_ARGS__)
+# define STDEXEC_IS_CONVERTIBLE_TO(...) __is_convertible_to(__VA_ARGS__)
#elif STDEXEC_HAS_BUILTIN(__is_convertible)
-#define STDEXEC_IS_CONVERTIBLE_TO(...) __is_convertible(__VA_ARGS__)
+# define STDEXEC_IS_CONVERTIBLE_TO(...) __is_convertible(__VA_ARGS__)
#else
-#define STDEXEC_IS_CONVERTIBLE_TO(...) std::is_convertible_v<__VA_ARGS__>
+# define STDEXEC_IS_CONVERTIBLE_TO(...) std::is_convertible_v<__VA_ARGS__>
#endif
#if STDEXEC_HAS_BUILTIN(__is_const)
-#define STDEXEC_IS_CONST(...) __is_const(__VA_ARGS__)
+# define STDEXEC_IS_CONST(...) __is_const(__VA_ARGS__)
#else
-#define STDEXEC_IS_CONST(...) stdexec::__is_const_<__VA_ARGS__>
+# define STDEXEC_IS_CONST(...) stdexec::__is_const_<__VA_ARGS__>
+#endif
+
+#if STDEXEC_HAS_BUILTIN(__is_function)
+# define STDEXEC_IS_FUNCTION(...) __is_function(__VA_ARGS__)
+#else
+# define STDEXEC_IS_FUNCTION(...) \
+ (!STDEXEC_IS_CONST(__VA_ARGS__) && !STDEXEC_IS_CONST(const __VA_ARGS__))
#endif
#if STDEXEC_HAS_BUILTIN(__is_same)
-#define STDEXEC_IS_SAME(...) __is_same(__VA_ARGS__)
+# define STDEXEC_IS_SAME(...) __is_same(__VA_ARGS__)
#elif STDEXEC_HAS_BUILTIN(__is_same_as)
-#define STDEXEC_IS_SAME(...) __is_same_as(__VA_ARGS__)
+# define STDEXEC_IS_SAME(...) __is_same_as(__VA_ARGS__)
#elif STDEXEC_MSVC()
// msvc replaces std::is_same_v with a compile-time constant
-#define STDEXEC_IS_SAME(...) std::is_same_v<__VA_ARGS__>
+# define STDEXEC_IS_SAME(...) std::is_same_v<__VA_ARGS__>
#else
-#define STDEXEC_IS_SAME(...) stdexec::__same_as_v<__VA_ARGS__>
+# define STDEXEC_IS_SAME(...) stdexec::__same_as_v<__VA_ARGS__>
#endif
#if STDEXEC_HAS_BUILTIN(__is_constructible) || STDEXEC_MSVC()
-#define STDEXEC_IS_CONSTRUCTIBLE(...) __is_constructible(__VA_ARGS__)
+# define STDEXEC_IS_CONSTRUCTIBLE(...) __is_constructible(__VA_ARGS__)
#else
-#define STDEXEC_IS_CONSTRUCTIBLE(...) std::is_constructible_v<__VA_ARGS__>
+# define STDEXEC_IS_CONSTRUCTIBLE(...) std::is_constructible_v<__VA_ARGS__>
#endif
#if STDEXEC_HAS_BUILTIN(__is_nothrow_constructible) || STDEXEC_MSVC()
-#define STDEXEC_IS_NOTHROW_CONSTRUCTIBLE(...) \
- __is_nothrow_constructible(__VA_ARGS__)
+# define STDEXEC_IS_NOTHROW_CONSTRUCTIBLE(...) __is_nothrow_constructible(__VA_ARGS__)
#else
-#define STDEXEC_IS_NOTHROW_CONSTRUCTIBLE(...) \
- std::is_nothrow_constructible_v<__VA_ARGS__>
+# define STDEXEC_IS_NOTHROW_CONSTRUCTIBLE(...) std::is_nothrow_constructible_v<__VA_ARGS__>
#endif
#if STDEXEC_HAS_BUILTIN(__is_trivially_constructible) || STDEXEC_MSVC()
-#define STDEXEC_IS_TRIVIALLY_CONSTRUCTIBLE(...) \
- __is_trivially_constructible(__VA_ARGS__)
+# define STDEXEC_IS_TRIVIALLY_CONSTRUCTIBLE(...) __is_trivially_constructible(__VA_ARGS__)
#else
-#define STDEXEC_IS_TRIVIALLY_CONSTRUCTIBLE(...) \
- std::is_trivially_constructible_v<__VA_ARGS__>
+# define STDEXEC_IS_TRIVIALLY_CONSTRUCTIBLE(...) std::is_trivially_constructible_v<__VA_ARGS__>
#endif
#if STDEXEC_HAS_BUILTIN(__is_empty) || STDEXEC_MSVC()
-#define STDEXEC_IS_EMPTY(...) __is_empty(__VA_ARGS__)
+# define STDEXEC_IS_EMPTY(...) __is_empty(__VA_ARGS__)
#else
-#define STDEXEC_IS_EMPTY(...) std::is_empty_v<__VA_ARGS__>
+# define STDEXEC_IS_EMPTY(...) std::is_empty_v<__VA_ARGS__>
#endif
#if STDEXEC_HAS_BUILTIN(__remove_reference)
-namespace stdexec
-{
-template <class Ty>
-using _remove_reference_t = __remove_reference(Ty);
+namespace stdexec {
+ template <class Ty>
+ using _remove_reference_t = __remove_reference(Ty);
} // namespace stdexec
-#define STDEXEC_REMOVE_REFERENCE(...) stdexec::_remove_reference_t<__VA_ARGS__>
+# define STDEXEC_REMOVE_REFERENCE(...) stdexec::_remove_reference_t<__VA_ARGS__>
#elif STDEXEC_HAS_BUILTIN(__remove_reference_t)
-namespace stdexec
-{
-template <class Ty>
-using _remove_reference_t = __remove_reference_t(Ty);
+namespace stdexec {
+ template <class Ty>
+ using _remove_reference_t = __remove_reference_t(Ty);
} // namespace stdexec
-#define STDEXEC_REMOVE_REFERENCE(...) stdexec::_remove_reference_t<__VA_ARGS__>
+# define STDEXEC_REMOVE_REFERENCE(...) stdexec::_remove_reference_t<__VA_ARGS__>
#else
-#define STDEXEC_REMOVE_REFERENCE(...) ::std::remove_reference_t<__VA_ARGS__>
+# define STDEXEC_REMOVE_REFERENCE(...) ::std::remove_reference_t<__VA_ARGS__>
#endif
-namespace stdexec
-{
-template <class _Ap, class _Bp>
-inline constexpr bool __same_as_v = false;
+namespace stdexec {
+ template <class _Ap, class _Bp>
+ inline constexpr bool __same_as_v = false;
-template <class _Ap>
-inline constexpr bool __same_as_v<_Ap, _Ap> = true;
+ template <class _Ap>
+ inline constexpr bool __same_as_v<_Ap, _Ap> = true;
} // namespace stdexec
-#if defined(__cpp_lib_unreachable) && __cpp_lib_unreachable >= 202202L
-#define STDEXEC_UNREACHABLE() std::unreachable()
+#if defined(__cpp_lib_unreachable) && __cpp_lib_unreachable >= 2022'02L
+# define STDEXEC_UNREACHABLE() std::unreachable()
#elif STDEXEC_HAS_BUILTIN(__builtin_unreachable)
-#define STDEXEC_UNREACHABLE() __builtin_unreachable()
+# define STDEXEC_UNREACHABLE() __builtin_unreachable()
#elif STDEXEC_MSVC()
-#define STDEXEC_UNREACHABLE(...) __assume(false)
+# define STDEXEC_UNREACHABLE(...) __assume(false)
#else
-#define STDEXEC_UNREACHABLE(...) std::terminate()
+# define STDEXEC_UNREACHABLE(...) std::terminate()
#endif
// Before gcc-12, gcc really didn't like tuples or variants of immovable types
-#if STDEXEC_GCC() && (__GNUC__ < 12)
-#define STDEXEC_IMMOVABLE(_XP) _XP(_XP&&)
+#if STDEXEC_GCC() && (STDEXEC_GCC_VERSION < 12'00)
+# define STDEXEC_IMMOVABLE(_XP) _XP(_XP&&)
#else
-#define STDEXEC_IMMOVABLE(_XP) _XP(_XP&&) = delete
+# define STDEXEC_IMMOVABLE(_XP) _XP(_XP&&) = delete
#endif
-// BUG (gcc PR93711): copy elision fails when initializing a
-// [[no_unique_address]] field from a function returning an object
-// of class type by value
#if STDEXEC_GCC()
-#define STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
+// BUG (gcc#98995): copy elision fails when initializing a [[no_unique_address]] field
+// from a function returning an object of class type by value.
+// See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98995
+# define STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
+#elif STDEXEC_CLANG() && (__clang_major__ >= 15 && __clang_major__ < 19)
+// See https://github.com/llvm/llvm-project/issues/93563
+# define STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
#else
-#define STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS \
- STDEXEC_ATTRIBUTE((no_unique_address))
+# define STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS STDEXEC_ATTRIBUTE(no_unique_address)
#endif
#if STDEXEC_NVHPC()
-#include <nv/target>
-#define STDEXEC_TERMINATE() \
- NV_IF_TARGET(NV_IS_HOST, (std::terminate();), (__trap();)) void()
-#elif STDEXEC_CLANG() && STDEXEC_CUDA() && defined(__CUDA_ARCH__)
-#define STDEXEC_TERMINATE() \
- __trap(); \
+# include <nv/target>
+# define STDEXEC_TERMINATE() NV_IF_TARGET(NV_IS_HOST, (std::terminate();), (__trap();)) void()
+#elif STDEXEC_CLANG() && STDEXEC_CUDA_COMPILATION() && defined(__CUDA_ARCH__)
+# define STDEXEC_TERMINATE() \
+ __trap(); \
__builtin_unreachable()
#else
-#define STDEXEC_TERMINATE() std::terminate()
+# define STDEXEC_TERMINATE() std::terminate()
#endif
+// Some compilers turn on pack indexing in pre-C++26 code. We want to use it if it is
+// available. Pack indexing is disabled for clang < 20 because of:
+// https://github.com/llvm/llvm-project/issues/116105
+#if defined(__cpp_pack_indexing) && !STDEXEC_NVCC() \
+ && !(STDEXEC_CLANG() && STDEXEC_CLANG_VERSION < 20'00)
+# define STDEXEC_STD_NO_PACK_INDEXING() 0
+#else // ^^^ has pack indexing ^^^ / vvv no pack indexing vvv
+# define STDEXEC_STD_NO_PACK_INDEXING() 1
+#endif // no pack indexing
+
#if STDEXEC_HAS_FEATURE(thread_sanitizer) || defined(__SANITIZE_THREAD__)
-#define STDEXEC_TSAN(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
+# define STDEXEC_TSAN() 1
#else
-#define STDEXEC_TSAN(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_TSAN() 0
#endif
// Before clang-16, clang did not like libstdc++'s ranges implementation
#if __has_include(<ranges>) && \
- (defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L) && \
- (!STDEXEC_CLANG() || __clang_major__ >= 16 || defined(_LIBCPP_VERSION))
-#define STDEXEC_HAS_STD_RANGES() 1
+ (defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 2019'11L) && \
+ (!STDEXEC_CLANG() || STDEXEC_CLANG_VERSION >= 16'00 || defined(_LIBCPP_VERSION))
+# define STDEXEC_HAS_STD_RANGES() 1
#else
-#define STDEXEC_HAS_STD_RANGES() 0
+# define STDEXEC_HAS_STD_RANGES() 0
#endif
#if __has_include(<memory_resource>) && \
- (defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L)
-#define STDEXEC_HAS_STD_MEMORY_RESOURCE() 1
+ (defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 2016'03L)
+# define STDEXEC_HAS_STD_MEMORY_RESOURCE() 1
#else
-#define STDEXEC_HAS_STD_MEMORY_RESOURCE() 0
+# define STDEXEC_HAS_STD_MEMORY_RESOURCE() 0
+#endif
+
+#if defined(__cpp_lib_execution) && __cpp_lib_execution >= 2016'03L
+# define STDEXEC_HAS_EXECUTION_POLICY() 1
+#else
+# define STDEXEC_HAS_EXECUTION_POLICY() 0
+#endif
+
+#if defined(__cpp_lib_execution) && __cpp_lib_execution >= 2019'02L
+# define STDEXEC_HAS_UNSEQUENCED_EXECUTION_POLICY() 1
+#else
+# define STDEXEC_HAS_UNSEQUENCED_EXECUTION_POLICY() 0
#endif
#ifdef STDEXEC_ASSERT
-#error \
- "Redefinition of STDEXEC_ASSERT is not permitted. Define STDEXEC_ASSERT_FN instead."
+# error "Redefinition of STDEXEC_ASSERT is not permitted. Define STDEXEC_ASSERT_FN instead."
#endif
-#define STDEXEC_ASSERT(_XP) \
- do \
- { \
- static_assert(noexcept(_XP)); \
- STDEXEC_ASSERT_FN(_XP); \
- } while (false)
+#define STDEXEC_ASSERT(_XP) \
+ do { \
+ static_assert(noexcept(_XP)); \
+ STDEXEC_ASSERT_FN(_XP); \
+ } while (false)
#ifndef STDEXEC_ASSERT_FN
-#define STDEXEC_ASSERT_FN assert
+# define STDEXEC_ASSERT_FN assert
#endif
-#define STDEXEC_AUTO_RETURN(...) \
- noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) \
- { \
- return __VA_ARGS__; \
- }
+#define STDEXEC_AUTO_RETURN(...) \
+ noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
+ return __VA_ARGS__; \
+ }
-// GCC 13 implements lexical friendship, but it is incomplete. See
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111018
-#if STDEXEC_CLANG() // || (STDEXEC_GCC() && __GNUC__ >= 13)
-#define STDEXEC_FRIENDSHIP_IS_LEXICAL() 1
+// GCC 13 implements lexical friendship, but it is incomplete. See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111018
+#if STDEXEC_CLANG() // || (STDEXEC_GCC() && STDEXEC_GCC_VERSION >= 13'00)
+# define STDEXEC_FRIENDSHIP_IS_LEXICAL() 1
#else
-#define STDEXEC_FRIENDSHIP_IS_LEXICAL() 0
+# define STDEXEC_FRIENDSHIP_IS_LEXICAL() 0
#endif
-#if defined(__cpp_explicit_this_parameter) && \
- (__cpp_explicit_this_parameter >= 202110)
-#define STDEXEC_EXPLICIT_THIS(...) STDEXEC_HEAD_OR_TAIL(1, __VA_ARGS__)
+#if defined(__cpp_explicit_this_parameter) && (__cpp_explicit_this_parameter >= 2021'10L)
+# define STDEXEC_EXPLICIT_THIS() 1
#else
-#define STDEXEC_EXPLICIT_THIS(...) STDEXEC_HEAD_OR_NULL(0, __VA_ARGS__)
+# define STDEXEC_EXPLICIT_THIS() 0
#endif
-// Configure extra type checking
-#define STDEXEC_TYPE_CHECKING_ZERO() 0
-#define STDEXEC_TYPE_CHECKING_ONE() 1
-#define STDEXEC_TYPE_CHECKING_TWO() 2
-
-#define STDEXEC_PROBE_TYPE_CHECKING_ STDEXEC_TYPE_CHECKING_ONE
-#define STDEXEC_PROBE_TYPE_CHECKING_0 STDEXEC_TYPE_CHECKING_ZERO
-#define STDEXEC_PROBE_TYPE_CHECKING_1 STDEXEC_TYPE_CHECKING_ONE
-#define STDEXEC_PROBE_TYPE_CHECKING_STDEXEC_ENABLE_EXTRA_TYPE_CHECKING \
- STDEXEC_TYPE_CHECKING_TWO
-
-#define STDEXEC_TYPE_CHECKING_WHICH3(...) \
- STDEXEC_PROBE_TYPE_CHECKING_##__VA_ARGS__
-#define STDEXEC_TYPE_CHECKING_WHICH2(...) \
- STDEXEC_TYPE_CHECKING_WHICH3(__VA_ARGS__)
-#define STDEXEC_TYPE_CHECKING_WHICH \
- STDEXEC_TYPE_CHECKING_WHICH2(STDEXEC_ENABLE_EXTRA_TYPE_CHECKING)
-
-#ifndef STDEXEC_ENABLE_EXTRA_TYPE_CHECKING
-#define STDEXEC_ENABLE_EXTRA_TYPE_CHECKING() 0
-#elif STDEXEC_TYPE_CHECKING_WHICH() == 2
-// do nothing
-#elif STDEXEC_TYPE_CHECKING_WHICH() == 0
-#undef STDEXEC_ENABLE_EXTRA_TYPE_CHECKING
-#define STDEXEC_ENABLE_EXTRA_TYPE_CHECKING() 0
+#if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING == 0
+# undef STDEXEC_ENABLE_EXTRA_TYPE_CHECKING
+# define STDEXEC_ENABLE_EXTRA_TYPE_CHECKING() 0
#else
-#undef STDEXEC_ENABLE_EXTRA_TYPE_CHECKING
-#define STDEXEC_ENABLE_EXTRA_TYPE_CHECKING() 1
+# undef STDEXEC_ENABLE_EXTRA_TYPE_CHECKING
+# define STDEXEC_ENABLE_EXTRA_TYPE_CHECKING() 1
#endif
-namespace stdexec
-{}
+#if STDEXEC_CUDA_COMPILATION() && defined(__CUDA_ARCH__)
+# define STDEXEC_STD_NO_EXCEPTIONS() 1
+#elif STDEXEC_MSVC() || STDEXEC_CLANG_CL()
+# define STDEXEC_STD_NO_EXCEPTIONS() (_HAS_EXCEPTIONS == 0) || (_CPPUNWIND == 0)
+#else
+# define STDEXEC_STD_NO_EXCEPTIONS() (__EXCEPTIONS == 0)
+#endif
+
+// We need to treat host and device separately
+#if STDEXEC_CUDA_COMPILATION() && defined(__CUDA_ARCH__) && !STDEXEC_NVHPC()
+# define STDEXEC_GLOBAL_CONSTANT STDEXEC_ATTRIBUTE(device) constexpr
+#else
+# define STDEXEC_GLOBAL_CONSTANT inline constexpr
+#endif
+
+#if STDEXEC_CUDA_COMPILATION() || __has_include(<cuda_runtime_api.h>)
+# define STDEXEC_HAS_CTK() 1
+#else
+# define STDEXEC_HAS_CTK() 0
+#endif
+
+// clang-format off
+#if STDEXEC_HAS_CTK() && __has_include(<nv/target>)
+# include <nv/target>
+# define STDEXEC_IF_HOST(...) NV_IF_TARGET(NV_IS_HOST, (__VA_ARGS__;))
+# define STDEXEC_IF_DEVICE(...) NV_IF_TARGET(NV_IS_DEVICE, (__VA_ARGS__;))
+#else
+# define STDEXEC_IF_HOST(...) {__VA_ARGS__;}
+# define STDEXEC_IF_DEVICE(...)
+#endif
+// clang-format on
+
+// CUDA compilers preinclude cuda_runtime.h, but if we're not compiling for CUDA then we
+// need to include it ourselves.
+#if STDEXEC_HAS_CTK() && !STDEXEC_CUDA_COMPILATION()
+# include <cuda_runtime_api.h>
+#endif
+
+// clang-format off
+
+// The following macros are used to conditionally compile exception handling code. They
+// are used in the same way as `try` and `catch`, but they allow for different behavior
+// based on whether exceptions are enabled or not, and whether the code is being compiled
+// for device or not.
+//
+// Usage:
+// STDEXEC_TRY
+// {
+// can_throw(); // Code that may throw an exception
+// }
+// STDEXEC_CATCH (cuda_error& e) // Handle CUDA exceptions
+// {
+// printf("CUDA error: %s\n", e.what());
+// }
+// STDEXEC_CATCH_ALL // Handle any other exceptions
+// {
+// printf("unknown error\n");
+// }
+#if STDEXEC_STD_NO_EXCEPTIONS()
+# define STDEXEC_TRY if constexpr (true) {
+# define STDEXEC_CATCH(...) } else if constexpr (__VA_ARGS__ = ::stdexec::__catch_any_lvalue; false) {
+# define STDEXEC_CATCH_ALL } else if constexpr (true) {} else
+# define STDEXEC_THROW(...) ::stdexec::__terminate()
+# define STDEXEC_CATCH_FALLTHROUGH } else {}
+#else
+# define STDEXEC_TRY try
+# define STDEXEC_CATCH catch
+# define STDEXEC_CATCH_ALL catch(...)
+# define STDEXEC_THROW(...) throw __VA_ARGS__
+# define STDEXEC_CATCH_FALLTHROUGH
+#endif
+
+// clang-format on
+
+namespace stdexec {
+ // Used by the STDEXEC_CATCH macro to provide a stub initialization of the exception object.
+ constexpr struct __catch_any_lvalue_t {
+ template <class _Tp>
+ STDEXEC_ATTRIBUTE(host, device)
+ operator _Tp&() const noexcept;
+ } __catch_any_lvalue{};
+
+ STDEXEC_ATTRIBUTE(noreturn, host, device)
+ inline void __terminate() noexcept {
+ STDEXEC_IF_HOST(::exit(-1))
+ STDEXEC_IF_DEVICE(__trap())
+ STDEXEC_UNREACHABLE();
+ }
+} // namespace stdexec
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// clang-tidy struggles with the CUDA function annotations
+#if STDEXEC_CLANG() && STDEXEC_CUDA_COMPILATION() && defined(STDEXEC_CLANG_TIDY_INVOKED)
+# include <cuda_runtime_api.h> // IWYU pragma: keep
+# if !defined(__launch_bounds__)
+# define __launch_bounds__(...)
+# endif
+
+# if !defined(__host__)
+# define __host__
+# endif
+
+# if !defined(__device__)
+# define __device__
+# endif
+
+# if !defined(__global__)
+# define __global__
+# endif
+#endif
+
+namespace stdexec {
+}
diff --git a/include/sdbusplus/async/stdexec/__detail/__connect_awaitable.hpp b/include/sdbusplus/async/stdexec/__detail/__connect_awaitable.hpp
index a38dcb5..7191050 100644
--- a/include/sdbusplus/async/stdexec/__detail/__connect_awaitable.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__connect_awaitable.hpp
@@ -15,247 +15,210 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__awaitable.hpp"
#include "__completion_signatures.hpp"
#include "__concepts.hpp"
#include "__config.hpp"
-#include "__execution_fwd.hpp"
+#include "__env.hpp"
#include "__meta.hpp"
#include "__receivers.hpp"
-#include "__tag_invoke.hpp"
#include <exception>
#include <utility>
-namespace stdexec
-{
+namespace stdexec {
#if !STDEXEC_STD_NO_COROUTINES()
-/////////////////////////////////////////////////////////////////////////////
-// __connect_awaitable_
-namespace __connect_awaitable_
-{
-struct __promise_base
-{
- auto initial_suspend() noexcept -> __coro::suspend_always
- {
+ /////////////////////////////////////////////////////////////////////////////
+ // __connect_awaitable_
+ namespace __connect_awaitable_ {
+ struct __promise_base {
+ auto initial_suspend() noexcept -> __coro::suspend_always {
return {};
- }
+ }
- [[noreturn]] auto final_suspend() noexcept -> __coro::suspend_always
- {
+ [[noreturn]]
+ auto final_suspend() noexcept -> __coro::suspend_always {
std::terminate();
- }
+ }
- [[noreturn]] void unhandled_exception() noexcept
- {
+ [[noreturn]]
+ void unhandled_exception() noexcept {
std::terminate();
- }
+ }
- [[noreturn]] void return_void() noexcept
- {
+ [[noreturn]]
+ void return_void() noexcept {
std::terminate();
- }
-};
+ }
+ };
-struct __operation_base
-{
- __coro::coroutine_handle<> __coro_;
+ struct __operation_base {
+ __coro::coroutine_handle<> __coro_;
- explicit __operation_base(__coro::coroutine_handle<> __hcoro) noexcept :
- __coro_(__hcoro)
- {}
+ explicit __operation_base(__coro::coroutine_handle<> __hcoro) noexcept
+ : __coro_(__hcoro) {
+ }
- __operation_base(__operation_base&& __other) noexcept :
- __coro_(std::exchange(__other.__coro_, {}))
- {}
+ __operation_base(__operation_base&& __other) noexcept
+ : __coro_(std::exchange(__other.__coro_, {})) {
+ }
- ~__operation_base()
- {
- if (__coro_)
- {
-#if STDEXEC_MSVC()
- // MSVCBUG
- // https://developercommunity.visualstudio.com/t/Double-destroy-of-a-local-in-coroutine-d/10456428
+ ~__operation_base() {
+ if (__coro_) {
+# if STDEXEC_MSVC()
+ // MSVCBUG https://developercommunity.visualstudio.com/t/Double-destroy-of-a-local-in-coroutine-d/10456428
- // Reassign __coro_ before calling destroy to make the mutation
- // observable and to hopefully ensure that the compiler does not
- // eliminate it.
- auto __coro = __coro_;
- __coro_ = {};
- __coro.destroy();
-#else
- __coro_.destroy();
-#endif
+ // Reassign __coro_ before calling destroy to make the mutation
+ // observable and to hopefully ensure that the compiler does not eliminate it.
+ auto __coro = __coro_;
+ __coro_ = {};
+ __coro.destroy();
+# else
+ __coro_.destroy();
+# endif
}
- }
+ }
- void start() & noexcept
- {
+ void start() & noexcept {
__coro_.resume();
- }
-};
+ }
+ };
-template <class _ReceiverId>
-struct __promise;
+ template <class _ReceiverId>
+ struct __promise;
-template <class _ReceiverId>
-struct __operation
-{
- struct __t : __operation_base
- {
+ template <class _ReceiverId>
+ struct __operation {
+ struct __t : __operation_base {
using promise_type = stdexec::__t<__promise<_ReceiverId>>;
using __operation_base::__operation_base;
+ };
};
-};
-template <class _ReceiverId>
-struct __promise
-{
- using _Receiver = stdexec::__t<_ReceiverId>;
+ template <class _ReceiverId>
+ struct __promise {
+ using _Receiver = stdexec::__t<_ReceiverId>;
- struct __t : __promise_base
- {
+ struct __t
+ : __promise_base
+ , __env::__with_await_transform<__t> {
using __id = __promise;
-#if STDEXEC_EDG()
- __t(auto&&, _Receiver&& __rcvr) noexcept : __rcvr_(__rcvr) {}
-#else
- explicit __t(auto&, _Receiver& __rcvr) noexcept : __rcvr_(__rcvr) {}
-#endif
+# if STDEXEC_EDG()
+ __t(auto&&, _Receiver&& __rcvr) noexcept
+ : __rcvr_(__rcvr) {
+ }
+# else
+ explicit __t(auto&, _Receiver& __rcvr) noexcept
+ : __rcvr_(__rcvr) {
+ }
+# endif
- auto unhandled_stopped() noexcept -> __coro::coroutine_handle<>
- {
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
- // Returning noop_coroutine here causes the __connect_awaitable
- // coroutine to never resume past the point where it co_await's
- // the awaitable.
- return __coro::noop_coroutine();
+ auto unhandled_stopped() noexcept -> __coro::coroutine_handle<> {
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
+ // Returning noop_coroutine here causes the __connect_awaitable
+ // coroutine to never resume past the point where it co_await's
+ // the awaitable.
+ return __coro::noop_coroutine();
}
- auto get_return_object() noexcept
- -> stdexec::__t<__operation<_ReceiverId>>
- {
- return stdexec::__t<__operation<_ReceiverId>>{
- __coro::coroutine_handle<__t>::from_promise(*this)};
- }
-
- template <class _Awaitable>
- auto await_transform(_Awaitable&& __awaitable) noexcept -> _Awaitable&&
- {
- return static_cast<_Awaitable&&>(__awaitable);
- }
-
- template <class _Awaitable>
- requires tag_invocable<as_awaitable_t, _Awaitable, __t&>
- auto await_transform(_Awaitable&& __awaitable) //
- noexcept(nothrow_tag_invocable<as_awaitable_t, _Awaitable, __t&>)
- -> tag_invoke_result_t<as_awaitable_t, _Awaitable, __t&>
- {
- return tag_invoke(as_awaitable,
- static_cast<_Awaitable&&>(__awaitable), *this);
+ auto get_return_object() noexcept -> stdexec::__t<__operation<_ReceiverId>> {
+ return stdexec::__t<__operation<_ReceiverId>>{
+ __coro::coroutine_handle<__t>::from_promise(*this)};
}
// Pass through the get_env receiver query
- auto get_env() const noexcept -> env_of_t<_Receiver>
- {
- return stdexec::get_env(__rcvr_);
+ auto get_env() const noexcept -> env_of_t<_Receiver> {
+ return stdexec::get_env(__rcvr_);
}
_Receiver& __rcvr_;
+ };
};
-};
-template <receiver _Receiver>
-using __promise_t = __t<__promise<__id<_Receiver>>>;
+ template <receiver _Receiver>
+ using __promise_t = __t<__promise<__id<_Receiver>>>;
-template <receiver _Receiver>
-using __operation_t = __t<__operation<__id<_Receiver>>>;
+ template <receiver _Receiver>
+ using __operation_t = __t<__operation<__id<_Receiver>>>;
-struct __connect_awaitable_t
-{
- private:
- template <class _Fun, class... _Ts>
- static auto __co_call(_Fun __fun, _Ts&&... __as) noexcept
- {
+ struct __connect_awaitable_t {
+ private:
+ template <class _Fun, class... _Ts>
+ static auto __co_call(_Fun __fun, _Ts&&... __as) noexcept {
auto __fn = [&, __fun]() noexcept {
- __fun(static_cast<_Ts&&>(__as)...);
+ __fun(static_cast<_Ts&&>(__as)...);
};
- struct __awaiter
- {
- decltype(__fn) __fn_;
+ struct __awaiter {
+ decltype(__fn) __fn_;
- static constexpr auto await_ready() noexcept -> bool
- {
- return false;
- }
+ static constexpr auto await_ready() noexcept -> bool {
+ return false;
+ }
- void await_suspend(__coro::coroutine_handle<>) noexcept
- {
- __fn_();
- }
+ void await_suspend(__coro::coroutine_handle<>) noexcept {
+ __fn_();
+ }
- [[noreturn]] void await_resume() noexcept
- {
- std::terminate();
- }
+ [[noreturn]]
+ void await_resume() noexcept {
+ std::terminate();
+ }
};
return __awaiter{__fn};
- }
+ }
- template <class _Awaitable, class _Receiver>
-#if STDEXEC_GCC() && (__GNUC__ > 11)
- __attribute__((__used__))
-#endif
- static auto __co_impl(_Awaitable __awaitable, _Receiver __rcvr)
- -> __operation_t<_Receiver>
- {
+ template <class _Awaitable, class _Receiver>
+# if STDEXEC_GCC() && (STDEXEC_GCC_VERSION >= 12'00)
+ __attribute__((__used__))
+# endif
+ static auto __co_impl(_Awaitable __awaitable, _Receiver __rcvr) -> __operation_t<_Receiver> {
using __result_t = __await_result_t<_Awaitable, __promise_t<_Receiver>>;
std::exception_ptr __eptr;
- try
- {
- if constexpr (same_as<__result_t, void>)
- co_await (co_await static_cast<_Awaitable&&>(__awaitable),
- __co_call(set_value,
- static_cast<_Receiver&&>(__rcvr)));
- else
- co_await __co_call(
- set_value, static_cast<_Receiver&&>(__rcvr),
- co_await static_cast<_Awaitable&&>(__awaitable));
+ STDEXEC_TRY {
+ if constexpr (same_as<__result_t, void>)
+ co_await (
+ co_await static_cast<_Awaitable&&>(__awaitable),
+ __co_call(set_value, static_cast<_Receiver&&>(__rcvr)));
+ else
+ co_await __co_call(
+ set_value,
+ static_cast<_Receiver&&>(__rcvr),
+ co_await static_cast<_Awaitable&&>(__awaitable));
}
- catch (...)
- {
- __eptr = std::current_exception();
+ STDEXEC_CATCH_ALL {
+ __eptr = std::current_exception();
}
- co_await __co_call(set_error, static_cast<_Receiver&&>(__rcvr),
- static_cast<std::exception_ptr&&>(__eptr));
- }
+ co_await __co_call(
+ set_error, static_cast<_Receiver&&>(__rcvr), static_cast<std::exception_ptr&&>(__eptr));
+ }
- template <receiver _Receiver, class _Awaitable>
- using __completions_t = //
+ template <receiver _Receiver, class _Awaitable>
+ using __completions_t =
completion_signatures<
- __minvoke< // set_value_t() or set_value_t(T)
- __mremove<void, __qf<set_value_t>>,
- __await_result_t<_Awaitable, __promise_t<_Receiver>>>,
- set_error_t(std::exception_ptr), set_stopped_t()>;
+ __minvoke< // set_value_t() or set_value_t(T)
+ __mremove<void, __qf<set_value_t>>,
+ __await_result_t<_Awaitable, __promise_t<_Receiver>>>,
+ set_error_t(std::exception_ptr),
+ set_stopped_t()>;
- public:
- template <class _Receiver, __awaitable<__promise_t<_Receiver>> _Awaitable>
+ public:
+ template <class _Receiver, __awaitable<__promise_t<_Receiver>> _Awaitable>
requires receiver_of<_Receiver, __completions_t<_Receiver, _Awaitable>>
- auto operator()(_Awaitable&& __awaitable, _Receiver __rcvr) const
- -> __operation_t<_Receiver>
- {
- return __co_impl(static_cast<_Awaitable&&>(__awaitable),
- static_cast<_Receiver&&>(__rcvr));
- }
-};
-} // namespace __connect_awaitable_
+ auto
+ operator()(_Awaitable&& __awaitable, _Receiver __rcvr) const -> __operation_t<_Receiver> {
+ return __co_impl(static_cast<_Awaitable&&>(__awaitable), static_cast<_Receiver&&>(__rcvr));
+ }
+ };
+ } // namespace __connect_awaitable_
-using __connect_awaitable_::__connect_awaitable_t;
+ using __connect_awaitable_::__connect_awaitable_t;
#else
-struct __connect_awaitable_t
-{};
+ struct __connect_awaitable_t { };
#endif
-inline constexpr __connect_awaitable_t __connect_awaitable{};
+ inline constexpr __connect_awaitable_t __connect_awaitable{};
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__continues_on.hpp b/include/sdbusplus/async/stdexec/__detail/__continues_on.hpp
index c9d1f60..06ee3e7 100644
--- a/include/sdbusplus/async/stdexec/__detail/__continues_on.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__continues_on.hpp
@@ -19,115 +19,87 @@
// include these after __execution_fwd.hpp
#include "__basic_sender.hpp"
-#include "__concepts.hpp"
#include "__env.hpp"
#include "__meta.hpp"
#include "__schedule_from.hpp"
#include "__schedulers.hpp"
-#include "__sender_adaptor_closure.hpp"
#include "__sender_introspection.hpp"
-#include "__senders.hpp"
-#include "__tag_invoke.hpp"
+#include "__sender_adaptor_closure.hpp"
+#include "__senders_core.hpp"
#include "__transform_sender.hpp"
-#include "__type_traits.hpp"
-#include <utility>
-
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.continues_on]
-namespace __continues_on
-{
-using __schfr::__environ;
-
-template <class _Env>
-using __scheduler_t = __result_of<get_completion_scheduler<set_value_t>, _Env>;
-
-template <class _Sender>
-using __lowered_t = //
- __result_of<schedule_from, __scheduler_t<__data_of<_Sender>>,
- __child_of<_Sender>>;
-
-struct continues_on_t
-{
- template <sender _Sender, scheduler _Scheduler>
- auto operator()(_Sender&& __sndr, _Scheduler&& __sched) const
- -> __well_formed_sender auto
- {
- auto __domain = __get_early_domain(__sndr);
- using _Env = __t<__environ<__id<__decay_t<_Scheduler>>>>;
- return stdexec::transform_sender(
- __domain, __make_sexpr<continues_on_t>(
- _Env{{static_cast<_Scheduler&&>(__sched)}},
- static_cast<_Sender&&>(__sndr)));
- }
-
- template <scheduler _Scheduler>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Scheduler&& __sched) const
- -> __binder_back<continues_on_t, __decay_t<_Scheduler>>
- {
- return {{static_cast<_Scheduler&&>(__sched)}, {}, {}};
- }
-
- //////////////////////////////////////////////////////////////////////////////////////////////
- using _Env = __0;
- using _Sender = __1;
- using __legacy_customizations_t = //
- __types<tag_invoke_t(continues_on_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(const _Sender&)),
- _Sender,
- get_completion_scheduler_t<set_value_t>(_Env)),
- tag_invoke_t(continues_on_t, _Sender,
- get_completion_scheduler_t<set_value_t>(_Env))>;
-
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.continues_on]
+ namespace __continues_on {
template <class _Env>
- static auto __transform_sender_fn(const _Env&)
- {
- return [&]<class _Data, class _Child>(__ignore, _Data&& __data,
- _Child&& __child) {
- auto __sched = get_completion_scheduler<set_value_t>(__data);
- return schedule_from(std::move(__sched),
- static_cast<_Child&&>(__child));
+ using __scheduler_t = __result_of<get_completion_scheduler<set_value_t>, _Env>;
+
+ template <class _Sender>
+ using __lowered_t =
+ __result_of<schedule_from, __scheduler_t<__data_of<_Sender>>, __child_of<_Sender>>;
+
+ struct continues_on_t {
+ template <sender _Sender, scheduler _Scheduler>
+ auto operator()(_Sender&& __sndr, _Scheduler __sched) const -> __well_formed_sender auto {
+ auto __domain = __get_early_domain(__sndr);
+ return stdexec::transform_sender(
+ __domain,
+ __make_sexpr<continues_on_t>(
+ static_cast<_Scheduler&&>(__sched), static_cast<_Sender&&>(__sndr)));
+ }
+
+ template <scheduler _Scheduler>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Scheduler __sched) const -> __binder_back<continues_on_t, _Scheduler> {
+ return {{static_cast<_Scheduler&&>(__sched)}, {}, {}};
+ }
+
+ static auto __transform_sender_fn() {
+ return [&]<class _Data, class _Child>(__ignore, _Data&& __data, _Child&& __child) {
+ return schedule_from(static_cast<_Data&&>(__data), static_cast<_Child&&>(__child));
};
- }
+ }
- template <class _Sender, class _Env>
- static auto transform_sender(_Sender&& __sndr, const _Env& __env)
- {
- return __sexpr_apply(static_cast<_Sender&&>(__sndr),
- __transform_sender_fn(__env));
- }
-};
-
-struct __continues_on_impl : __sexpr_defaults
-{
- static constexpr auto get_attrs = //
- []<class _Data, class _Child>(
- const _Data& __data,
- const _Child& __child) noexcept -> decltype(auto) {
- return __env::__join(__data, stdexec::get_env(__child));
+ template <class _Sender, class _Env>
+ static auto transform_sender(_Sender&& __sndr, const _Env&) {
+ return __sexpr_apply(static_cast<_Sender&&>(__sndr), __transform_sender_fn());
+ }
};
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {};
-};
-} // namespace __continues_on
+ struct __continues_on_impl : __sexpr_defaults {
+ static constexpr auto get_attrs = []<class _Data, class _Child>(
+ const _Data& __data,
+ const _Child& __child) noexcept -> decltype(auto) {
+ using __domain_t = __detail::__early_domain_of_t<_Child, __none_such>;
+ return __env::__join(
+ __sched_attrs{std::cref(__data), __domain_t{}}, stdexec::get_env(__child));
+ };
-using __continues_on::continues_on_t;
-inline constexpr continues_on_t continues_on{};
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
+ return {};
+ };
+ };
+ } // namespace __continues_on
-using transfer_t = continues_on_t;
-inline constexpr continues_on_t transfer{};
+ using __continues_on::continues_on_t;
+ inline constexpr continues_on_t continues_on{};
-using continue_on_t = continues_on_t;
-inline constexpr continues_on_t continue_on{};
+ // Backward compatibility:
+ using transfer_t = continues_on_t;
+ inline constexpr continues_on_t transfer{};
-template <>
-struct __sexpr_impl<continues_on_t> : __continues_on::__continues_on_impl
-{};
+ using continue_on_t = continues_on_t;
+ inline constexpr continues_on_t continue_on{};
+
+ namespace v2 {
+ using continue_on_t
+ [[deprecated("use stdexec::continues_on_t instead")]] = stdexec::continues_on_t;
+ [[deprecated("use stdexec::continues_on instead")]]
+ inline constexpr stdexec::continues_on_t const & continue_on = stdexec::continues_on;
+ } // namespace v2
+
+ template <>
+ struct __sexpr_impl<continues_on_t> : __continues_on::__continues_on_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__cpo.hpp b/include/sdbusplus/async/stdexec/__detail/__cpo.hpp
index b5fb859..22b214d 100644
--- a/include/sdbusplus/async/stdexec/__detail/__cpo.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__cpo.hpp
@@ -33,107 +33,97 @@
/// return ...;
/// }
/// @endcode
-#define STDEXEC_MEMFN_DECL(...) \
- friend STDEXEC_EVAL(STDEXEC_MEMFN_DECL_TAG_INVOKE, \
- STDEXEC_MEMFN_DECL_WHICH(__VA_ARGS__), __VA_ARGS__)
+#define STDEXEC_MEMFN_DECL(...) \
+ friend STDEXEC_EVAL( \
+ STDEXEC_MEMFN_DECL_TAG_INVOKE, STDEXEC_MEMFN_DECL_WHICH(__VA_ARGS__), __VA_ARGS__)
-#define STDEXEC_MEMFN_DECL_WHICH(_A1, ...) \
- STDEXEC_CAT(STDEXEC_MEMFN_DECL_WHICH_, STDEXEC_FRONT(__VA_OPT__(1, ) 0)) \
- (_A1, __VA_ARGS__)
-#define STDEXEC_MEMFN_DECL_WHICH_0(_A1, ...) \
- STDEXEC_CHECK(STDEXEC_MEMFN_DECL_PROBE_##_A1), \
- STDEXEC_CHECK(_A1##_STDEXEC_MEMFN_DECL_PROBE)
-#define STDEXEC_MEMFN_DECL_WHICH_1(_A1, ...) \
- 0, STDEXEC_CHECK( \
- STDEXEC_CAT(STDEXEC_BACK(__VA_ARGS__), _STDEXEC_MEMFN_DECL_PROBE))
+#define STDEXEC_MEMFN_DECL_WHICH(_A1, ...) \
+ STDEXEC_CAT(STDEXEC_MEMFN_DECL_WHICH_, STDEXEC_FRONT(__VA_OPT__(1, ) 0))(_A1, __VA_ARGS__)
+#define STDEXEC_MEMFN_DECL_WHICH_0(_A1, ...) \
+ STDEXEC_CHECK(STDEXEC_MEMFN_DECL_PROBE_##_A1), STDEXEC_CHECK(_A1##_STDEXEC_MEMFN_DECL_PROBE)
+#define STDEXEC_MEMFN_DECL_WHICH_1(_A1, ...) \
+ 0, STDEXEC_CHECK(STDEXEC_CAT(STDEXEC_BACK(__VA_ARGS__), _STDEXEC_MEMFN_DECL_PROBE))
-#define STDEXEC_MEMFN_DECL_TAG_INVOKE(_WHICH, _QUERY, ...) \
+#define STDEXEC_MEMFN_DECL_TAG_INVOKE(_WHICH, _QUERY, ...) \
STDEXEC_MEMFN_DECL_RETURN_ ## _WHICH(__VA_ARGS__) \
tag_invoke(STDEXEC_MEMFN_DECL_TAG_ ## _WHICH ## _QUERY(__VA_ARGS__)
-#define STDEXEC_MEMFN_DECL_ARGS(...) \
+#define STDEXEC_MEMFN_DECL_ARGS(...) \
STDEXEC_CAT(STDEXEC_EAT_THIS_, __VA_ARGS__))
-#define STDEXEC_MEMFN_DECL_QUERY(_SELF, _TAG, ...) \
+#define STDEXEC_MEMFN_DECL_QUERY(_SELF, _TAG, ...) \
_TAG, STDEXEC_CAT(STDEXEC_EAT_THIS_, _SELF) __VA_OPT__(, __VA_ARGS__))
#define STDEXEC_EAT_THIS_this
#define STDEXEC_EAT_AUTO_auto
#define STDEXEC_EAT_VOID_void
-#define query_STDEXEC_MEMFN_DECL_PROBE STDEXEC_PROBE(~, 1)
-#define STDEXEC_MEMFN_DECL_PROBE_auto STDEXEC_PROBE(~, 1)
-#define STDEXEC_MEMFN_DECL_PROBE_void STDEXEC_PROBE(~, 2)
+#define query_STDEXEC_MEMFN_DECL_PROBE STDEXEC_PROBE(~, 1)
+#define STDEXEC_MEMFN_DECL_PROBE_auto STDEXEC_PROBE(~, 1)
+#define STDEXEC_MEMFN_DECL_PROBE_void STDEXEC_PROBE(~, 2)
-#define STDEXEC_MEMFN_DECL_RETURN_0(...) \
- ::stdexec::__arg_type_t<void(__VA_ARGS__())>
+#define STDEXEC_MEMFN_DECL_RETURN_0(...) ::stdexec::__arg_type_t<void(__VA_ARGS__())>
#define STDEXEC_MEMFN_DECL_RETURN_1(...) auto
#define STDEXEC_MEMFN_DECL_RETURN_2(...) void
-#define STDEXEC_MEMFN_DECL_TAG_00(...) \
- const ::stdexec::__tag_type_t<__VA_ARGS__##_t::*>&, STDEXEC_MEMFN_DECL_ARGS
-#define STDEXEC_MEMFN_DECL_TAG_10(...) \
- const STDEXEC_EAT_AUTO_##__VA_ARGS__##_t&, STDEXEC_MEMFN_DECL_ARGS
-#define STDEXEC_MEMFN_DECL_TAG_20(...) \
- const STDEXEC_EAT_VOID_##__VA_ARGS__##_t&, STDEXEC_MEMFN_DECL_ARGS
+#define STDEXEC_MEMFN_DECL_TAG_00(...) \
+ const ::stdexec::__tag_type_t<__VA_ARGS__##_t::*>&, STDEXEC_MEMFN_DECL_ARGS
+#define STDEXEC_MEMFN_DECL_TAG_10(...) \
+ const STDEXEC_EAT_AUTO_##__VA_ARGS__##_t&, STDEXEC_MEMFN_DECL_ARGS
+#define STDEXEC_MEMFN_DECL_TAG_20(...) \
+ const STDEXEC_EAT_VOID_##__VA_ARGS__##_t&, STDEXEC_MEMFN_DECL_ARGS
#define STDEXEC_MEMFN_DECL_TAG_01(...) STDEXEC_MEMFN_DECL_QUERY
#define STDEXEC_MEMFN_DECL_TAG_11(...) STDEXEC_MEMFN_DECL_QUERY
#define STDEXEC_MEMFN_DECL_TAG_21(...) STDEXEC_MEMFN_DECL_QUERY
-#define STDEXEC_MEMFN_FRIEND(_TAG) \
- using STDEXEC_CAT(_TAG, _t) = STDEXEC_CAT(stdexec::_TAG, _t)
+#define STDEXEC_MEMFN_FRIEND(_TAG) using STDEXEC_CAT(_TAG, _t) = STDEXEC_CAT(stdexec::_TAG, _t)
#if STDEXEC_MSVC()
-#pragma deprecated(STDEXEC_CUSTOM)
+# pragma deprecated(STDEXEC_CUSTOM)
#endif
-#if STDEXEC_GCC() || (STDEXEC_CLANG() && __clang_major__ < 14)
-#define STDEXEC_CUSTOM \
- _Pragma( \
- "GCC warning \"STDEXEC_CUSTOM is deprecated; use STDEXEC_MEMFN_DECL instead.\"") \
- STDEXEC_MEMFN_DECL
+#if STDEXEC_GCC() || (STDEXEC_CLANG() && STDEXEC_CLANG_VERSION < 14'00)
+# define STDEXEC_CUSTOM \
+ _Pragma("GCC warning \"STDEXEC_CUSTOM is deprecated; use STDEXEC_MEMFN_DECL instead.\"") \
+ STDEXEC_MEMFN_DECL
#else
-#define STDEXEC_CUSTOM STDEXEC_MEMFN_DECL
+# define STDEXEC_CUSTOM STDEXEC_MEMFN_DECL
#endif
-#if STDEXEC_CLANG() && __clang_major__ >= 14
-#pragma clang deprecated(STDEXEC_CUSTOM, "use STDEXEC_MEMFN_DECL instead.")
+#if STDEXEC_CLANG() && STDEXEC_CLANG_VERSION >= 14'00
+# pragma clang deprecated(STDEXEC_CUSTOM, "use STDEXEC_MEMFN_DECL instead.")
#endif
-namespace stdexec
-{
-template <class>
-struct __arg_type;
+namespace stdexec {
+ template <class>
+ struct __arg_type;
-template <class _Arg>
-struct __arg_type<void(_Arg (*)())>
-{
+ template <class _Arg>
+ struct __arg_type<void(_Arg (*)())> {
using type = _Arg;
-};
+ };
-template <class _Fn>
-using __arg_type_t = typename __arg_type<_Fn>::type;
+ template <class _Fn>
+ using __arg_type_t = __arg_type<_Fn>::type;
-template <class>
-struct __tag_type;
+ template <class>
+ struct __tag_type;
-template <class _Ret, class _Tag>
-struct __tag_type<_Ret _Tag::*>
-{
+ template <class _Ret, class _Tag>
+ struct __tag_type<_Ret _Tag::*> {
using type = _Tag;
-};
+ };
-template <class _Fn>
-using __tag_type_t = typename __tag_type<_Fn>::type;
+ template <class _Fn>
+ using __tag_type_t = __tag_type<_Fn>::type;
-namespace tags
-{
-using stdexec::connect_t;
-using stdexec::get_completion_signatures_t;
-using stdexec::get_env_t;
-using stdexec::set_error_t;
-using stdexec::set_stopped_t;
-using stdexec::set_value_t;
-using stdexec::start_t;
-} // namespace tags
+ namespace tags {
+ using stdexec::set_value_t;
+ using stdexec::set_error_t;
+ using stdexec::set_stopped_t;
+ using stdexec::connect_t;
+ using stdexec::start_t;
+ using stdexec::get_env_t;
+ using stdexec::get_completion_signatures_t;
+ } // namespace tags
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__debug.hpp b/include/sdbusplus/async/stdexec/__detail/__debug.hpp
index 825ef07..9a283ce 100644
--- a/include/sdbusplus/async/stdexec/__detail/__debug.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__debug.hpp
@@ -15,270 +15,237 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__concepts.hpp"
-#include "__cpo.hpp"
+#include "__completion_signatures.hpp"
#include "__diagnostics.hpp"
#include "__env.hpp"
-#include "__execution_fwd.hpp"
#include "__meta.hpp"
-#include "__tag_invoke.hpp"
+#include "__senders_core.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// Some utilities for debugging senders
-namespace __debug
-{
-struct __is_debug_env_t
-{
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
+#include <exception> // IWYU pragma: keep for std::terminate
+
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // Some utilities for debugging senders
+ namespace __debug {
+ struct __is_debug_env_t : __query<__is_debug_env_t> {
+ static constexpr auto query(forwarding_query_t) noexcept -> bool {
return true;
- }
+ }
+ };
+
template <class _Env>
- requires tag_invocable<__is_debug_env_t, const _Env&>
- auto operator()(const _Env&) const noexcept
- -> tag_invoke_result_t<__is_debug_env_t, const _Env&>;
-};
+ using __debug_env_t = env<prop<__is_debug_env_t, bool>, _Env>;
-template <class _Env>
-using __debug_env_t = env<prop<__is_debug_env_t, bool>, _Env>;
+ template <class _Env>
+ concept __is_debug_env = __callable<__is_debug_env_t, _Env>;
-template <class _Env>
-concept __is_debug_env = tag_invocable<__is_debug_env_t, _Env>;
-
-struct __completion_signatures
-{};
+ struct __completion_signatures { };
#if STDEXEC_MSVC()
-// MSVCBUG
-// https://developercommunity.visualstudio.com/t/Explicit-variable-template-specialisatio/10360032
-// MSVCBUG
-// https://developercommunity.visualstudio.com/t/Non-function-type-interpreted-as-functio/10447831
+ // MSVCBUG https://developercommunity.visualstudio.com/t/Explicit-variable-template-specialisatio/10360032
+ // MSVCBUG https://developercommunity.visualstudio.com/t/Non-function-type-interpreted-as-functio/10447831
-template <class _Sig>
-struct __normalize_sig;
+ template <class _Sig>
+ struct __normalize_sig;
-template <class _Tag, class... _Args>
-struct __normalize_sig<_Tag(_Args...)>
-{
- using __type = _Tag (*)(_Args&&...);
-};
+ template <class _Tag, class... _Args>
+ struct __normalize_sig<_Tag(_Args...)> {
+ using __type = _Tag (*)(_Args&&...);
+ };
-template <class _Sig>
-using __normalize_sig_t = typename __normalize_sig<_Sig>::__type;
+ template <class _Sig>
+ using __normalize_sig_t = __normalize_sig<_Sig>::__type;
#else
-template <class _Sig>
-extern int __normalize_sig;
+ template <class _Sig>
+ extern int __normalize_sig;
-template <class _Tag, class... _Args>
-extern _Tag (*__normalize_sig<_Tag(_Args...)>)(_Args&&...);
+ template <class _Tag, class... _Args>
+ extern _Tag (*__normalize_sig<_Tag(_Args...)>)(_Args&&...);
-template <class _Sig>
-using __normalize_sig_t = decltype(__normalize_sig<_Sig>);
+ template <class _Sig>
+ using __normalize_sig_t = decltype(__normalize_sig<_Sig>);
#endif
-template <class... _Sigs>
-struct __valid_completions
-{
- template <class... _Args>
+ template <class... _Sigs>
+ struct __valid_completions {
+ template <class... _Args>
requires __one_of<set_value_t (*)(_Args&&...), _Sigs...>
- STDEXEC_ATTRIBUTE((host, device))
- void set_value(_Args&&...) noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_value(_Args&&...) noexcept {
STDEXEC_TERMINATE();
- }
+ }
- template <class _Error>
+ template <class _Error>
requires __one_of<set_error_t (*)(_Error&&), _Sigs...>
- STDEXEC_ATTRIBUTE((host, device))
- void set_error(_Error&&) noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_error(_Error&&) noexcept {
STDEXEC_TERMINATE();
- }
+ }
- STDEXEC_ATTRIBUTE((host, device))
- void set_stopped() noexcept
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_stopped() noexcept
requires __one_of<set_stopped_t (*)(), _Sigs...>
- {
+ {
STDEXEC_TERMINATE();
- }
-};
-
-template <class _CvrefSenderId, class _Env, class _Completions>
-struct __debug_receiver
-{
- using __t = __debug_receiver;
- using __id = __debug_receiver;
- using receiver_concept = receiver_t;
-};
-
-template <class _CvrefSenderId, class _Env, class... _Sigs>
-struct __debug_receiver<_CvrefSenderId, _Env,
- completion_signatures<_Sigs...>> //
- : __valid_completions<__normalize_sig_t<_Sigs>...>
-{
- using __t = __debug_receiver;
- using __id = __debug_receiver;
- using receiver_concept = receiver_t;
-
- STDEXEC_ATTRIBUTE((host, device))
- auto get_env() const noexcept -> __debug_env_t<_Env>
- {
- STDEXEC_TERMINATE();
- }
-};
-
-struct _COMPLETION_SIGNATURES_MISMATCH_
-{};
-
-template <class _Sig>
-struct _COMPLETION_SIGNATURE_
-{};
-
-template <class... _Sigs>
-struct _IS_NOT_ONE_OF_
-{};
-
-template <class _Sender>
-struct _SIGNAL_SENT_BY_SENDER_
-{};
-
-template <class _Warning>
-[[deprecated(
- "The sender claims to send a particular set of completions,"
- " but in actual fact it completes with a result that is not"
- " one of the declared completion signatures.")]] STDEXEC_ATTRIBUTE((host,
- device)) void _ATTENTION_() noexcept
-{}
-
-template <class _Sig>
-struct __invalid_completion
-{
- struct __t
- {
- template <class _CvrefSenderId, class _Env, class... _Sigs>
- // BUGBUG this works around a recently (aug 2023) introduced regression
- // in nvc++
- requires(!__one_of<_Sig, _Sigs...>)
- __t(__debug_receiver<_CvrefSenderId, _Env,
- completion_signatures<_Sigs...>>&&) noexcept
- {
- using _SenderId = __decay_t<_CvrefSenderId>;
- using _Sender = stdexec::__t<_SenderId>;
- using _What = //
- _WARNING_< //
- _COMPLETION_SIGNATURES_MISMATCH_,
- _COMPLETION_SIGNATURE_<_Sig>, _IS_NOT_ONE_OF_<_Sigs...>,
- _SIGNAL_SENT_BY_SENDER_<__name_of<_Sender>>>;
- __debug::_ATTENTION_<_What>();
- }
+ }
};
-};
-template <__completion_tag _Tag, class... _Args>
-STDEXEC_ATTRIBUTE((host, device))
-void tag_invoke(_Tag, __t<__invalid_completion<_Tag(_Args...)>>,
- _Args&&...) noexcept
-{}
+ template <class _CvrefSenderId, class _Env, class _Completions>
+ struct __debug_receiver {
+ using __t = __debug_receiver;
+ using __id = __debug_receiver;
+ using receiver_concept = receiver_t;
+ };
-struct __debug_operation
-{
- void start() & noexcept {}
-};
+ template <class _CvrefSenderId, class _Env, class... _Sigs>
+ struct __debug_receiver<_CvrefSenderId, _Env, completion_signatures<_Sigs...>>
+ : __valid_completions<__normalize_sig_t<_Sigs>...> {
+ using __t = __debug_receiver;
+ using __id = __debug_receiver;
+ using receiver_concept = receiver_t;
-////////////////////////////////////////////////////////////////////////////
-// `__debug_sender`
-// ===============
-//
-// Understanding why a particular sender doesn't connect to a particular
-// receiver is nigh impossible in the current design due to limitations in
-// how the compiler reports overload resolution failure in the presence of
-// constraints. `__debug_sender` is a utility to assist with the process. It
-// gives you the deep template instantiation backtrace that you need to
-// understand where in a chain of senders the problem is occurring.
-//
-// ```c++
-// template <class _Sigs, class _Env = empty_env, class _Sender>
-// void __debug_sender(_Sender&& __sndr, _Env = {});
-//
-// template <class _Env = empty_env, class _Sender>
-// void __debug_sender(_Sender&& __sndr, _Env = {});
-// ```
-//
-// **Usage:**
-//
-// To find out where in a chain of senders a sender is failing to connect
-// to a receiver, pass it to `__debug_sender`, optionally with an
-// environment argument; e.g. `__debug_sender(sndr [, env])`
-//
-// To find out why a sender will not connect to a receiver of a particular
-// signature, specify the set of completion signatures as an explicit template
-// argument that names an instantiation of `completion_signatures`; e.g.:
-// `__debug_sender<completion_signatures<set_value_t(int)>>(sndr [, env])`.
-//
-// **How it works:**
-//
-// The `__debug_sender` function `connect`'s the sender to a
-// `__debug_receiver`, whose environment is augmented with a special
-// `__is_debug_env_t` query. An additional fall-back overload is added to
-// the `connect` CPO that recognizes receivers whose environments respond to
-// that query and lets them through. Then in a non-immediate context, it
-// looks for a `tag_invoke(connect_t...)` overload for the input sender and
-// receiver. This will recurse until it hits the `tag_invoke` call that is
-// causing the failure.
-//
-// At least with clang, this gives me a nice backtrace, at the bottom of
-// which is the faulty `tag_invoke` overload with a mention of the
-// constraint that failed.
-template <class _Sigs, class _Env = empty_env, class _Sender>
-void __debug_sender(_Sender&& __sndr, const _Env& = {})
-{
- if constexpr (!__is_debug_env<_Env>)
- {
- if (sizeof(_Sender) == ~0u)
- { // never true
- using _Receiver =
- __debug_receiver<__cvref_id<_Sender>, _Env, _Sigs>;
+ STDEXEC_ATTRIBUTE(host, device) auto get_env() const noexcept -> __debug_env_t<_Env> {
+ STDEXEC_TERMINATE();
+ }
+ };
+
+ struct _COMPLETION_SIGNATURES_MISMATCH_ { };
+
+ template <class _Sig>
+ struct _COMPLETION_SIGNATURE_ { };
+
+ template <class... _Sigs>
+ struct _IS_NOT_ONE_OF_ { };
+
+ template <class _Sender>
+ struct _SIGNAL_SENT_BY_SENDER_ { };
+
+ template <class _Warning>
+ [[deprecated(
+ "The sender claims to send a particular set of completions,"
+ " but in actual fact it completes with a result that is not"
+ " one of the declared completion signatures.")]] STDEXEC_ATTRIBUTE(host, device) void _ATTENTION_() noexcept {
+ }
+
+ template <class _Sig>
+ struct __invalid_completion {
+ struct __t {
+ template <class _CvrefSenderId, class _Env, class... _Sigs>
+ // BUGBUG this works around a recently (aug 2023) introduced regression in nvc++
+ requires(!__one_of<_Sig, _Sigs...>)
+ __t(__debug_receiver<_CvrefSenderId, _Env, completion_signatures<_Sigs...>>&&) noexcept {
+ using _SenderId = __decay_t<_CvrefSenderId>;
+ using _Sender = stdexec::__t<_SenderId>;
+ using _What = _WARNING_<
+ _COMPLETION_SIGNATURES_MISMATCH_,
+ _COMPLETION_SIGNATURE_<_Sig>,
+ _IS_NOT_ONE_OF_<_Sigs...>,
+ _SIGNAL_SENT_BY_SENDER_<__name_of<_Sender>>
+ >;
+ __debug::_ATTENTION_<_What>();
+ }
+ };
+ };
+
+ template <__completion_tag _Tag, class... _Args>
+ STDEXEC_ATTRIBUTE(host, device)
+ void tag_invoke(_Tag, __t<__invalid_completion<_Tag(_Args...)>>, _Args&&...) noexcept {
+ }
+
+ struct __debug_operation {
+ void start() & noexcept {
+ }
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ // `__debug_sender`
+ // ===============
+
+ // Understanding why a particular sender doesn't connect to a particular
+ // receiver is nigh impossible in the current design due to limitations in
+ // how the compiler reports overload resolution failure in the presence of
+ // constraints. `__debug_sender` is a utility to assist with the process. It
+ // gives you the deep template instantiation backtrace that you need to
+ // understand where in a chain of senders the problem is occurring.
+
+ // ```c++
+ // template <class _Sigs, class _Env = env<>, class _Sender>
+ // void __debug_sender(_Sender&& __sndr, _Env = {});
+
+ // template <class _Env = env<>, class _Sender>
+ // void __debug_sender(_Sender&& __sndr, _Env = {});
+ // ```
+
+ // **Usage:**
+
+ // To find out where in a chain of senders a sender is failing to connect
+ // to a receiver, pass it to `__debug_sender`, optionally with an
+ // environment argument; e.g. `__debug_sender(sndr [, env])`
+
+ // To find out why a sender will not connect to a receiver of a particular
+ // signature, specify the set of completion signatures as an explicit template
+ // argument that names an instantiation of `completion_signatures`; e.g.:
+ // `__debug_sender<completion_signatures<set_value_t(int)>>(sndr [, env])`.
+
+ // **How it works:**
+
+ // The `__debug_sender` function `connect`'s the sender to a
+ // `__debug_receiver`, whose environment is augmented with a special
+ // `__is_debug_env_t` query. An additional fall-back overload is added to
+ // the `connect` CPO that recognizes receivers whose environments respond to
+ // that query and lets them through. Then in a non-immediate context, it
+ // looks for a `tag_invoke(connect_t...)` overload for the input sender and
+ // receiver. This will recurse until it hits the `tag_invoke` call that is
+ // causing the failure.
+
+ // At least with clang, this gives me a nice backtrace, at the bottom of
+ // which is the faulty `tag_invoke` overload with a mention of the
+ // constraint that failed.
+ template <class _Sigs, class _Env = env<>, class _Sender>
+ void __debug_sender(_Sender&& __sndr, const _Env& = {}) {
+ if constexpr (!__is_debug_env<_Env>) {
+ if constexpr (sender_in<_Sender, _Env>) {
+ using _Receiver = __debug_receiver<__cvref_id<_Sender>, _Env, _Sigs>;
+ using _Operation = connect_result_t<_Sender, _Receiver>;
+ //static_assert(receiver_of<_Receiver, _Sigs>);
+ if constexpr (!same_as<_Operation, __debug_operation>) {
+ if (sizeof(_Sender) == ~0u) { // never true
+ auto __op = connect(static_cast<_Sender&&>(__sndr), _Receiver{});
+ stdexec::start(__op);
+ }
+ }
+ } else {
+ stdexec::__diagnose_sender_concept_failure<_Sender, _Env>();
+ }
+ }
+ }
+
+ template <class _Env = env<>, class _Sender>
+ void __debug_sender(_Sender&& __sndr, const _Env& = {}) {
+ if constexpr (!__is_debug_env<_Env>) {
+ if constexpr (sender_in<_Sender, _Env>) {
+ using _Sigs = __completion_signatures_of_t<_Sender, __debug_env_t<_Env>>;
+ using _Receiver = __debug_receiver<__cvref_id<_Sender>, _Env, _Sigs>;
+ if constexpr (!same_as<_Sigs, __debug::__completion_signatures>) {
using _Operation = connect_result_t<_Sender, _Receiver>;
- // static_assert(receiver_of<_Receiver, _Sigs>);
- if constexpr (!same_as<_Operation, __debug_operation>)
- {
- auto __op =
- connect(static_cast<_Sender&&>(__sndr), _Receiver{});
+ //static_assert(receiver_of<_Receiver, _Sigs>);
+ if constexpr (!same_as<_Operation, __debug_operation>) {
+ if (sizeof(_Sender) == ~0ul) { // never true
+ auto __op = connect(static_cast<_Sender&&>(__sndr), _Receiver{});
stdexec::start(__op);
+ }
}
+ }
+ } else {
+ __diagnose_sender_concept_failure<_Sender, _Env>();
}
+ }
}
-}
+ } // namespace __debug
-template <class _Env = empty_env, class _Sender>
-void __debug_sender(_Sender&& __sndr, const _Env& = {})
-{
- if constexpr (!__is_debug_env<_Env>)
- {
- if (sizeof(_Sender) == ~0ul)
- { // never true
- using _Sigs =
- __completion_signatures_of_t<_Sender, __debug_env_t<_Env>>;
- if constexpr (!same_as<_Sigs, __debug::__completion_signatures>)
- {
- using _Receiver =
- __debug_receiver<__cvref_id<_Sender>, _Env, _Sigs>;
- using _Operation = connect_result_t<_Sender, _Receiver>;
- // static_assert(receiver_of<_Receiver, _Sigs>);
- if constexpr (!same_as<_Operation, __debug_operation>)
- {
- auto __op =
- connect(static_cast<_Sender&&>(__sndr), _Receiver{});
- stdexec::start(__op);
- }
- }
- }
- }
-}
-} // namespace __debug
-
-using __debug::__debug_sender;
-using __debug::__is_debug_env;
+ using __debug::__is_debug_env;
+ using __debug::__debug_sender;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__diagnostics.hpp b/include/sdbusplus/async/stdexec/__detail/__diagnostics.hpp
index 9180cf3..fddba2f 100644
--- a/include/sdbusplus/async/stdexec/__detail/__diagnostics.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__diagnostics.hpp
@@ -17,97 +17,241 @@
#include "__meta.hpp"
-namespace stdexec
-{
-namespace __detail
-{
-template <class _Ty>
-extern __q<__midentity> __name_of_v;
+namespace stdexec {
+ namespace __detail {
+ template <class _Ty>
+ extern __q<__midentity> __name_of_v;
-template <class _Ty>
-using __name_of_fn = decltype(__name_of_v<_Ty>);
+ template <class _Ty>
+ using __name_of_fn = decltype(__name_of_v<_Ty>);
-template <class _Ty>
-using __name_of = __minvoke<__name_of_fn<_Ty>, _Ty>;
-} // namespace __detail
+ template <class _Ty>
+ using __name_of = __minvoke<__name_of_fn<_Ty>, _Ty>;
+ } // namespace __detail
-// A utility for pretty-printing type names in diagnostics
-template <class _Ty>
-using __name_of = __detail::__name_of<_Ty>;
+ // A utility for pretty-printing type names in diagnostics
+ template <class _Ty>
+ using __name_of = __detail::__name_of<_Ty>;
-namespace __errs
-{
-inline constexpr __mstring __unrecognized_sender_type_diagnostic =
- "The given type cannot be used as a sender with the given environment "
- "because the attempt to compute the completion signatures failed."_mstr;
+ namespace __errs {
+ inline constexpr __mstring __unrecognized_sender_type_diagnostic =
+ "The given type cannot be used as a sender with the given environment "
+ "because the attempt to compute the completion signatures failed."_mstr;
-template <class _Sender>
-struct _WITH_SENDER_;
+ template <class _Sender>
+ struct _WITH_SENDER_;
-template <class... _Senders>
-struct _WITH_SENDERS_;
-} // namespace __errs
+ template <class... _Senders>
+ struct _WITH_SENDERS_;
+ } // namespace __errs
-struct _WHERE_;
+ struct _WHERE_;
-struct _IN_ALGORITHM_;
+ struct _IN_ALGORITHM_;
-template <__mstring _Diagnostic = __errs::__unrecognized_sender_type_diagnostic>
-struct _UNRECOGNIZED_SENDER_TYPE_;
+ template <__mstring _Diagnostic = __errs::__unrecognized_sender_type_diagnostic>
+ struct _UNRECOGNIZED_SENDER_TYPE_;
-template <class _Sender>
-using _WITH_SENDER_ = __errs::_WITH_SENDER_<__name_of<_Sender>>;
+ template <class _Sender>
+ using _WITH_SENDER_ = __errs::_WITH_SENDER_<__name_of<_Sender>>;
-template <class... _Senders>
-using _WITH_SENDERS_ = __errs::_WITH_SENDERS_<__name_of<_Senders>...>;
+ template <class... _Senders>
+ using _WITH_SENDERS_ = __errs::_WITH_SENDERS_<__name_of<_Senders>...>;
-template <class _Env>
-struct _WITH_ENVIRONMENT_;
+ template <class _Env>
+ struct _WITH_ENVIRONMENT_;
-template <class _Ty>
-struct _WITH_TYPE_;
+ template <class _Ty>
+ struct _WITH_TYPE_;
-template <class _Receiver>
-struct _WITH_RECEIVER_;
+ template <class _Receiver>
+ struct _WITH_RECEIVER_;
-template <class _Sig>
-struct _MISSING_COMPLETION_SIGNAL_;
+ template <class _Sig>
+ struct _MISSING_COMPLETION_SIGNAL_;
-template <class _Sig>
-struct _WITH_COMPLETION_SIGNATURE_;
+ template <class _Sig>
+ struct _WITH_COMPLETION_SIGNATURE_;
-template <class _Fun>
-struct _WITH_FUNCTION_;
+ template <class _Fun>
+ struct _WITH_FUNCTION_;
-template <class... _Args>
-struct _WITH_ARGUMENTS_;
+ template <class... _Args>
+ struct _WITH_ARGUMENTS_;
-template <class _Tag>
-struct _WITH_QUERY_;
+ template <class _Tag>
+ struct _WITH_QUERY_;
-struct _SENDER_TYPE_IS_NOT_COPYABLE_;
+ struct _SENDER_TYPE_IS_NOT_COPYABLE_;
-inline constexpr __mstring __not_callable_diag =
+ inline constexpr __mstring __not_callable_diag =
"The specified function is not callable with the arguments provided."_mstr;
-template <__mstring _Context, __mstring _Diagnostic = __not_callable_diag>
-struct _NOT_CALLABLE_;
+ template <__mstring _Context, __mstring _Diagnostic = __not_callable_diag>
+ struct _NOT_CALLABLE_;
-template <auto _Reason = "You cannot pipe one sender into another."_mstr>
-struct _CANNOT_PIPE_INTO_A_SENDER_
-{};
+ template <auto _Reason = "You cannot pipe one sender into another."_mstr>
+ struct _CANNOT_PIPE_INTO_A_SENDER_ { };
-template <class _Sender>
-using __bad_pipe_sink_t =
- __mexception<_CANNOT_PIPE_INTO_A_SENDER_<>, _WITH_SENDER_<_Sender>>;
+ template <class _Sender>
+ using __bad_pipe_sink_t = __mexception<_CANNOT_PIPE_INTO_A_SENDER_<>, _WITH_SENDER_<_Sender>>;
-template <__mstring _Context>
-struct __callable_error
-{
+ template <__mstring _Context>
+ struct __callable_error {
template <class _Fun, class... _Args>
- using __f = //
- __mexception< //
- _NOT_CALLABLE_<_Context>, _WITH_FUNCTION_<_Fun>,
- _WITH_ARGUMENTS_<_Args...>>;
-};
+ using __f =
+ __mexception<_NOT_CALLABLE_<_Context>, _WITH_FUNCTION_<_Fun>, _WITH_ARGUMENTS_<_Args...>>;
+ };
} // namespace stdexec
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_ENABLE_SENDER_IS_FALSE \
+ "\n" \
+ "\n" \
+ "The given type is not a sender because stdexec::enable_sender<Sender> is false. Either:\n" \
+ "\n" \
+ "1. Give the type a nested `::sender_concept` type that is an alias for `stdexec::sender_t`,\n" \
+ " as in:\n" \
+ "\n" \
+ " class MySender\n" \
+ " {\n" \
+ " public:\n" \
+ " using sender_concept = stdexec::sender_t;\n" \
+ " ...\n" \
+ " };\n" \
+ "\n" \
+ " or,\n" \
+ "\n" \
+ "2. Specialize the `stdexec::enable_sender` boolean trait for this type to true, as follows:\n" \
+ "\n" \
+ " class MySender\n" \
+ " {\n" \
+ " ...\n" \
+ " };\n" \
+ "\n" \
+ " template <>\n" \
+ " inline constexpr bool stdexec::enable_sender<MySender> = true;\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_CANNOT_COMPUTE_COMPLETION_SIGNATURES \
+ "\n" \
+ "\n" \
+ "The sender type was not able to report its completion signatures when asked.\n" \
+ "This is either because it lacks the necessary member function, or because the\n" \
+ "member function was ill-formed.\n" \
+ "\n" \
+ "A sender can declare its completion signatures in one of two ways:\n" \
+ "\n" \
+ "1. By defining a nested type alias named `completion_signatures` that is a\n" \
+ " specialization of `stdexec::completion_signatures<...>`, as follows:\n" \
+ "\n" \
+ " class MySender\n" \
+ " {\n" \
+ " public:\n" \
+ " using sender_concept = stdexec::sender_t;\n" \
+ " using completion_signatures = stdexec::completion_signatures<\n" \
+ " // This sender can complete successfully with an int and a float...\n" \
+ " stdexec::set_value_t(int, float),\n" \
+ " // ... or in error with an exception_ptr\n" \
+ " stdexec::set_error_t(std::exception_ptr)>;\n" \
+ " ...\n" \
+ " };\n" \
+ "\n" \
+ " or,\n" \
+ "\n" \
+ "2. By defining a member function named `get_completion_signatures` that returns\n" \
+ " a specialization of `stdexec::completion_signatures<...>`, as follows:\n" \
+ "\n" \
+ " class MySender\n" \
+ " {\n" \
+ " public:\n" \
+ " using sender_concept = stdexec::sender_t;\n" \
+ "\n" \
+ " template <class... _Env>\n" \
+ " auto get_completion_signatures(_Env&&...) -> stdexec::completion_signatures<\n" \
+ " // This sender can complete successfully with an int and a float...\n" \
+ " stdexec::set_value_t(int, float),\n" \
+ " // ... or in error with a std::exception_ptr.\n" \
+ " stdexec::set_error_t(std::exception_ptr)>\n" \
+ " {\n" \
+ " return {};\n" \
+ " }\n" \
+ " ...\n" \
+ " };\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_RETURNED_AN_ERROR \
+ "\n" \
+ "\n" \
+ "Trying to compute the sender's completion signatures resulted in an error. See\n" \
+ "the rest of the compiler diagnostic for clues. Look for the string \"_ERROR_\".\n"
+
+#define STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_HAS_INVALID_RETURN_TYPE \
+ "\n" \
+ "\n" \
+ "The member function `get_completion_signatures` of the sender returned an\n" \
+ "invalid type.\n" \
+ "\n" \
+ "A sender's `get_completion_signatures` function must return a specialization of\n" \
+ "`stdexec::completion_signatures<...>`, as follows:\n" \
+ "\n" \
+ " class MySender\n" \
+ " {\n" \
+ " public:\n" \
+ " using sender_concept = stdexec::sender_t;\n" \
+ "\n" \
+ " template <class... _Env>\n" \
+ " auto get_completion_signatures(_Env&&...) -> stdexec::completion_signatures<\n" \
+ " // This sender can complete successfully with an int and a float...\n" \
+ " stdexec::set_value_t(int, float),\n" \
+ " // ... or in error with a std::exception_ptr.\n" \
+ " stdexec::set_error_t(std::exception_ptr)>\n" \
+ " {\n" \
+ " return {};\n" \
+ " }\n" \
+ " ...\n" \
+ " };\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_CANNOT_CONNECT_SENDER_TO_RECEIVER \
+ "\n" \
+ "A sender must provide a `connect` member function that takes a receiver as an\n" \
+ "argument and returns an object whose type satisfies `stdexec::operation_state`,\n" \
+ "as shown below:\n" \
+ "\n" \
+ " class MySender\n" \
+ " {\n" \
+ " public:\n" \
+ " using sender_concept = stdexec::sender_t;\n" \
+ " using completion_signatures = stdexec::completion_signatures<stdexec::set_value_t()>;\n" \
+ "\n" \
+ " template <class Receiver>\n" \
+ " struct MyOpState\n" \
+ " {\n" \
+ " using operation_state_concept = stdexec::operation_state_t;\n" \
+ "\n" \
+ " void start() noexcept\n" \
+ " {\n" \
+ " // Start the operation, which will eventually complete and send its\n" \
+ " // result to rcvr_;\n" \
+ " }\n" \
+ "\n" \
+ " Receiver rcvr_;\n" \
+ " };\n" \
+ "\n" \
+ " template <stdexec::receiver Receiver>\n" \
+ " auto connect(Receiver rcvr) -> MyOpState<Receiver>\n" \
+ " {\n" \
+ " return MyOpState<Receiver>{std::move(rcvr)};\n" \
+ " }\n" \
+ "\n" \
+ " ...\n" \
+ " };\n"
+
+////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_SYNC_WAIT_CANNOT_CONNECT_SENDER_TO_RECEIVER \
+ "\n" \
+ "\n" \
+ "The sender passed to `stdexec::sync_wait()` does not have a `connect`\n" \
+ "member function that accepts sync_wait's " \
+ "receiver.\n" STDEXEC_ERROR_CANNOT_CONNECT_SENDER_TO_RECEIVER
diff --git a/include/sdbusplus/async/stdexec/__detail/__domain.hpp b/include/sdbusplus/async/stdexec/__detail/__domain.hpp
index 0798479..bc05eda 100644
--- a/include/sdbusplus/async/stdexec/__detail/__domain.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__domain.hpp
@@ -15,349 +15,236 @@
*/
#pragma once
-#include "../functional.hpp"
-#include "__concepts.hpp"
-#include "__config.hpp"
-#include "__env.hpp"
#include "__execution_fwd.hpp"
-#include "__meta.hpp"
+
+#include "__config.hpp"
+#include "__concepts.hpp"
+#include "__env.hpp"
#include "__sender_introspection.hpp"
+#include "__meta.hpp"
-namespace stdexec
-{
+#include "../functional.hpp"
+#include "__utility.hpp"
-struct default_domain;
-struct dependent_domain;
+namespace stdexec {
-namespace __domain
-{
-template <class _Tag>
-using __legacy_c11n_for = typename _Tag::__legacy_customizations_t;
+ struct default_domain;
+ struct dependent_domain;
-template <class _Tag, class... _Args>
-using __legacy_c11n_fn = //
- __make_dispatcher<__legacy_c11n_for<_Tag>, __none_such, _Args...>;
+ namespace __detail {
+ template <class _DomainOrTag, class _Sender, class... _Env>
+ concept __has_transform_sender =
+ requires(_DomainOrTag __tag, _Sender&& __sender, const _Env&... __env) {
+ __tag.transform_sender(static_cast<_Sender &&>(__sender), __env...);
+ };
-template <class _Tag, class... _Args>
-concept __has_legacy_c11n = //
- __callable<__legacy_c11n_fn<_Tag, _Args...>, _Args...>;
+ template <class _DomainOrTag, class _Sender, class... _Env>
+ concept __has_nothrow_transform_sender =
+ requires(_DomainOrTag __tag, _Sender&& __sender, const _Env&... __env) {
+ { __tag.transform_sender(static_cast<_Sender &&>(__sender), __env...) } noexcept;
+ };
-struct __legacy_customization
-{
- template <class _Tag, class _Data, class... _Children>
- requires __has_legacy_c11n<_Tag, _Data, _Children...>
- auto operator()(_Tag, _Data&& __data, _Children&&... __children) const
- -> decltype(auto)
- {
- return __legacy_c11n_fn<_Tag, _Data, _Children...>()(
- static_cast<_Data&&>(__data),
- static_cast<_Children&&>(__children)...);
- }
-};
+ template <class _Sender, class... _Env>
+ concept __has_default_transform_sender =
+ sender_expr<_Sender> && __has_transform_sender<tag_of_t<_Sender>, _Sender, _Env...>;
-template <class _DomainOrTag, class _Sender, class... _Env>
-concept __has_transform_sender =
- requires(_DomainOrTag __tag, _Sender&& __sender, const _Env&... __env) {
- __tag.transform_sender(static_cast<_Sender&&>(__sender), __env...);
+ template <class _DomainOrTag, class _Sender, class... _Env>
+ using __transform_sender_result_t =
+ decltype(_DomainOrTag{}.transform_sender(__declval<_Sender>(), __declval<const _Env&>()...));
+
+ template <class _DomainOrTag, class _Sender, class _Env>
+ concept __has_transform_env = requires(_DomainOrTag __tag, _Sender&& __sender, _Env&& __env) {
+ __tag.transform_env(static_cast<_Sender &&>(__sender), static_cast<_Env &&>(__env));
};
-template <class _Sender, class... _Env>
-concept __has_default_transform_sender = //
- sender_expr<_Sender> //
- && __has_transform_sender<tag_of_t<_Sender>, _Sender, _Env...>;
+ template <class _Sender, class _Env>
+ concept __has_default_transform_env = sender_expr<_Sender>
+ && __has_transform_env<tag_of_t<_Sender>, _Sender, _Env>;
-template <class _Type, class _Sender, class _Env>
-concept __has_transform_env =
- requires(_Type __obj, _Sender&& __sender, _Env&& __env) {
- __obj.transform_env(static_cast<_Sender&&>(__sender),
- static_cast<_Env&&>(__env));
+ template <class _DomainOrTag, class _Sender, class _Env>
+ using __transform_env_result_t =
+ decltype(_DomainOrTag{}.transform_env(__declval<_Sender>(), __declval<_Env>()));
+
+ template <class _DomainOrTag, class... _Args>
+ concept __has_apply_sender = requires(_DomainOrTag __tag, _Args&&... __args) {
+ __tag.apply_sender(static_cast<_Args &&>(__args)...);
};
-template <class _Sender, class _Env>
-concept __has_default_transform_env = //
- sender_expr<_Sender> //
- && __has_transform_env<tag_of_t<_Sender>, _Sender, _Env>;
+ template <class _Tag, class... _Args>
+ using __apply_sender_result_t = decltype(_Tag{}.apply_sender(__declval<_Args>()...));
-template <class _DomainOrTag, class... _Args>
-concept __has_apply_sender =
- requires(_DomainOrTag __tag, _Args&&... __args) {
- __tag.apply_sender(static_cast<_Args&&>(__args)...);
- };
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ template <class _Env, class _Tag>
+ using __completion_scheduler_for =
+ __meval_or<__call_result_t, __none_such, get_completion_scheduler_t<_Tag>, _Env>;
-template <class _Sender>
-constexpr bool __is_nothrow_transform_sender()
-{
- if constexpr (__callable<__sexpr_apply_t, _Sender,
- __domain::__legacy_customization>)
- {
- return __nothrow_callable<__sexpr_apply_t, _Sender,
- __domain::__legacy_customization>;
- }
- else if constexpr (__domain::__has_default_transform_sender<_Sender>)
- {
- return noexcept(
- tag_of_t<_Sender>().transform_sender(__declval<_Sender>()));
- }
- else
- {
- return __nothrow_constructible_from<_Sender, _Sender>;
- }
-}
+ template <class _Env, class _Tag>
+ using __completion_domain_for =
+ __meval_or<__call_result_t, __none_such, get_domain_t, __completion_scheduler_for<_Env, _Tag>>;
-template <class _Sender, class _Env>
-constexpr bool __is_nothrow_transform_sender() noexcept
-{
- if constexpr (__domain::__has_default_transform_sender<_Sender, _Env>)
- {
- return //
- noexcept(tag_of_t<_Sender>().transform_sender(
- __declval<_Sender>(), __declval<const _Env&>()));
- }
- else
- {
- return __nothrow_constructible_from<_Sender, _Sender>;
- }
-}
-} // namespace __domain
+ // Check the value, error, and stopped channels for completion schedulers.
+ // Of the completion schedulers that are known, they must all have compatible
+ // domains. This computes that domain, or else returns __none_such if there
+ // are no completion schedulers or if they don't specify a domain.
+ template <class _Env>
+ struct __completion_domain_or_none_
+ : __mdefer_<
+ __mtransform<
+ __mbind_front_q<__completion_domain_for, _Env>,
+ __mremove<__none_such, __munique<__msingle_or<__none_such>>>
+ >,
+ set_value_t,
+ set_error_t,
+ set_stopped_t
+ > { };
-struct default_domain
-{
- default_domain() = default;
-
- // Called without the environment during eager customization
template <class _Sender>
- STDEXEC_ATTRIBUTE((always_inline))
- decltype(auto) transform_sender(_Sender&& __sndr) const
- noexcept(__domain::__is_nothrow_transform_sender<_Sender>())
- {
- // Look for a legacy customization for the given tag, and if found,
- // apply it.
- if constexpr (__callable<__sexpr_apply_t, _Sender,
- __domain::__legacy_customization>)
- {
- return stdexec::__sexpr_apply(static_cast<_Sender&&>(__sndr),
- __domain::__legacy_customization());
+ using __completion_domain_or_none = __t<__completion_domain_or_none_<env_of_t<_Sender>>>;
+
+ template <class _Sender>
+ concept __consistent_completion_domains = __mvalid<__completion_domain_or_none, _Sender>;
+
+ template <class _Sender>
+ concept __has_completion_domain = (!same_as<__completion_domain_or_none<_Sender>, __none_such>);
+
+ template <__has_completion_domain _Sender>
+ using __completion_domain_of = __completion_domain_or_none<_Sender>;
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ //! Function object implementing `get-domain-early(snd)`
+ //! from [exec.snd.general] item 3.9. It is the first well-formed expression of
+ //! a) `get_domain(get_env(sndr))`
+ //! b) `completion-domain(sndr)`
+ //! c) `default_domain()`
+ struct __get_early_domain_t {
+ template <class _Sender, class _Default = default_domain>
+ auto operator()(const _Sender&, _Default = {}) const noexcept {
+ if constexpr (__callable<get_domain_t, env_of_t<_Sender>>) {
+ return __domain_of_t<env_of_t<_Sender>>();
+ } else if constexpr (__has_completion_domain<_Sender>) {
+ return __completion_domain_of<_Sender>();
+ } else {
+ return _Default();
}
- else if constexpr (__domain::__has_default_transform_sender<_Sender>)
- {
- return tag_of_t<_Sender>().transform_sender(
- static_cast<_Sender&&>(__sndr));
- }
- else
- {
- return static_cast<_Sender>(static_cast<_Sender&&>(__sndr));
- }
- }
+ }
+ };
- // Called with an environment during lazy customization
- template <class _Sender, class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- decltype(auto) transform_sender(_Sender&& __sndr, const _Env& __env) const
- noexcept(__domain::__is_nothrow_transform_sender<_Sender, _Env>())
- {
- if constexpr (__domain::__has_default_transform_sender<_Sender, _Env>)
- {
- return tag_of_t<_Sender>().transform_sender(
- static_cast<_Sender&&>(__sndr), __env);
- }
- else
- {
- return static_cast<_Sender>(static_cast<_Sender&&>(__sndr));
- }
- }
-
- template <class _Tag, class _Sender, class... _Args>
- requires __domain::__has_legacy_c11n<_Tag, _Sender, _Args...> ||
- __domain::__has_apply_sender<_Tag, _Sender, _Args...>
- STDEXEC_ATTRIBUTE((always_inline))
- decltype(auto) apply_sender(_Tag, _Sender&& __sndr, _Args&&... __args) const
- {
- // Look for a legacy customization for the given tag, and if found,
- // apply it.
- if constexpr (__domain::__has_legacy_c11n<_Tag, _Sender, _Args...>)
- {
- return __domain::__legacy_c11n_fn<_Tag, _Sender, _Args...>()(
- static_cast<_Sender&&>(__sndr),
- static_cast<_Args&&>(__args)...);
- }
- else
- {
- return _Tag().apply_sender(static_cast<_Sender&&>(__sndr),
- static_cast<_Args&&>(__args)...);
- }
- }
-
- template <class _Sender, class _Env>
- auto transform_env(_Sender&& __sndr, _Env&& __env) const noexcept
- -> decltype(auto)
- {
- if constexpr (__domain::__has_default_transform_env<_Sender, _Env>)
- {
- return tag_of_t<_Sender>().transform_env(
- static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env));
- }
- else
- {
- return static_cast<_Env>(static_cast<_Env&&>(__env));
- }
- }
-};
-
-/////////////////////////////////////////////////////////////////////////////
-namespace __detail
-{
-template <class _Env, class _Tag>
-using __completion_scheduler_for =
- __meval_or<__call_result_t, __none_such, get_completion_scheduler_t<_Tag>,
- _Env>;
-
-template <class _Env, class _Tag>
-using __completion_domain_for =
- __meval_or<__call_result_t, __none_such, get_domain_t,
- __completion_scheduler_for<_Env, _Tag>>;
-
-// Check the value, error, and stopped channels for completion schedulers.
-// Of the completion schedulers that are known, they must all have compatible
-// domains. This computes that domain, or else returns __none_such if there
-// are no completion schedulers or if they don't specify a domain.
-template <class _Env>
-struct __completion_domain_or_none_ :
- __mdefer_<__mtransform<
- __mbind_front_q<__completion_domain_for, _Env>,
- __mremove<__none_such, __munique<__msingle_or<__none_such>>>>,
- set_value_t, set_error_t, set_stopped_t>
-{};
-
-template <class _Sender>
-using __completion_domain_or_none =
- __t<__completion_domain_or_none_<env_of_t<_Sender>>>;
-
-template <class _Sender>
-concept __consistent_completion_domains =
- __mvalid<__completion_domain_or_none, _Sender>;
-
-template <class _Sender>
-concept __has_completion_domain =
- (!same_as<__completion_domain_or_none<_Sender>, __none_such>);
-
-template <__has_completion_domain _Sender>
-using __completion_domain_of = __completion_domain_or_none<_Sender>;
-} // namespace __detail
-
-/////////////////////////////////////////////////////////////////////////////
-//! Function object implementing `get-domain-early(snd)`
-//! from [exec.snd.general] item 3.9. It is the first well-formed expression of
-//! a) `get_domain(get_env(sndr))`
-//! b) `completion-domain(sndr)`
-//! c) `default_domain()`
-inline constexpr struct __get_early_domain_t
-{
template <class _Sender, class _Default = default_domain>
- auto operator()(const _Sender&, _Default __def = {}) const noexcept
- {
- if constexpr (__callable<get_domain_t, env_of_t<_Sender>>)
- {
- return __domain_of_t<env_of_t<_Sender>>();
+ using __early_domain_of_t = __call_result_t<__get_early_domain_t, _Sender, _Default>;
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ //! Function object implementing `get-domain-late(snd)`
+ struct __get_late_domain_t {
+ // When connect is looking for a customization, it first checks if the sender has a
+ // late domain override. If so, that is the domain that is used to transform the
+ // sender. Otherwise, look to the receiver for information about where the resulting
+ // operation state will be started.
+ template <class _Sender, class _Env, class _Default = default_domain>
+ auto operator()(const _Sender& __sndr, const _Env& __env, _Default = {}) const noexcept {
+ // The schedule_from algorithm is the exception to the rule. It ignores the domain
+ // of the predecessor, and dispatches based on the domain of the scheduler to
+ // which execution is being transferred.
+ if constexpr (__callable<get_domain_override_t, env_of_t<_Sender>>) {
+ return get_domain_override(get_env(__sndr));
+ } else if constexpr (__callable<get_domain_t, const _Env&>) {
+ return get_domain(__env);
+ } else if constexpr (__callable<__composed<get_domain_t, get_scheduler_t>, const _Env&>) {
+ return get_domain(get_scheduler(__env));
+ } else {
+ return _Default();
}
- else if constexpr (__detail::__has_completion_domain<_Sender>)
- {
- return __detail::__completion_domain_of<_Sender>();
+ }
+ };
+
+ template <class _Sender, class _Env, class _Default = default_domain>
+ using __late_domain_of_t = __call_result_t<__get_late_domain_t, _Sender, _Env, _Default>;
+
+ struct __common_domain_fn {
+ template <
+ class _Default = default_domain,
+ class _Dependent = dependent_domain,
+ class... _Domains
+ >
+ static auto __common_domain(_Domains...) noexcept {
+ if constexpr (sizeof...(_Domains) == 0) {
+ return _Default();
+ } else if constexpr (__one_of<_Dependent, _Domains...>) {
+ return _Dependent();
+ } else if constexpr (stdexec::__mvalid<std::common_type_t, _Domains...>) {
+ return std::common_type_t<_Domains...>();
+ } else {
+ return __none_such();
}
- else
- {
- return __def;
- }
+ }
+
+ auto operator()(__ignore, __ignore, const auto&... __sndrs) const noexcept {
+ return __common_domain(__get_early_domain_t{}(__sndrs)...);
+ }
+ };
+ } // namespace __detail
+
+ struct default_domain {
+ template <class _Sender, class... _Env>
+ requires __detail::__has_default_transform_sender<_Sender, _Env...>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto transform_sender(_Sender&& __sndr, _Env&&... __env) const
+ noexcept(__detail::__has_nothrow_transform_sender<tag_of_t<_Sender>, _Sender, _Env...>)
+ -> __detail::__transform_sender_result_t<tag_of_t<_Sender>, _Sender, _Env...> {
+ return tag_of_t<_Sender>().transform_sender(static_cast<_Sender&&>(__sndr), __env...);
}
-} __get_early_domain{};
-template <class _Sender, class _Default = default_domain>
-using __early_domain_of_t =
- __call_result_t<__get_early_domain_t, _Sender, _Default>;
+ template <class _Sender, class... _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto transform_sender(_Sender&& __sndr, _Env&&...) const
+ noexcept(__nothrow_constructible_from<_Sender, _Sender>) -> _Sender {
+ return static_cast<_Sender>(static_cast<_Sender&&>(__sndr));
+ }
-/////////////////////////////////////////////////////////////////////////////
-inline constexpr struct __get_late_domain_t
-{
- // When connect is looking for a customization, it first checks the sender's
- // domain. If the sender knows the domain in which it completes, then that
- // is where the subsequent task will execute. Otherwise, look to the
- // receiver for late-bound information about the current execution context.
template <class _Sender, class _Env>
- auto operator()(const _Sender& __sndr, const _Env& __env) const noexcept
- {
- if constexpr (!same_as<dependent_domain,
- __early_domain_of_t<_Sender, dependent_domain>>)
- {
- return __get_early_domain(__sndr);
- }
- else if constexpr (__callable<get_domain_t, const _Env&>)
- {
- return get_domain(__env);
- }
- else if constexpr (__callable<__composed<get_domain_t, get_scheduler_t>,
- const _Env&>)
- {
- return get_domain(get_scheduler(__env));
- }
- else
- {
- return default_domain();
- }
+ requires __detail::__has_default_transform_env<_Sender, _Env>
+ auto transform_env(_Sender&& __sndr, _Env&& __env) const noexcept
+ -> __detail::__transform_env_result_t<tag_of_t<_Sender>, _Sender, _Env> {
+ return tag_of_t<_Sender>()
+ .transform_env(static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env));
}
- // The continues_on algorithm is the exception to the rule. It ignores the
- // domain of the predecessor, and dispatches based on the domain of the
- // scheduler to which execution is being transferred.
- template <sender_expr_for<continues_on_t> _Sender, class _Env>
- auto operator()(const _Sender& __sndr, const _Env&) const noexcept
- {
- return __sexpr_apply(__sndr, [](__ignore, auto& __data,
- __ignore) noexcept {
- auto __sched = get_completion_scheduler<set_value_t>(__data);
- return query_or(get_domain, __sched, default_domain());
- });
- }
-} __get_late_domain{};
-
-template <class _Sender, class _Env>
-using __late_domain_of_t = __call_result_t<__get_late_domain_t, _Sender, _Env>;
-
-namespace __domain
-{
-struct __common_domain_fn
-{
- static auto __common_domain() noexcept -> default_domain
- {
- return {};
+ template <class _Env>
+ auto transform_env(__ignore, _Env&& __env) const noexcept -> _Env {
+ return static_cast<_Env>(static_cast<_Env&&>(__env));
}
- template <class _Domain, class... _OtherDomains>
- requires __all_of<_Domain, _OtherDomains...>
- static auto __common_domain(_Domain __domain, _OtherDomains...) noexcept
- -> _Domain
- {
- return static_cast<_Domain&&>(__domain);
+ template <class _Tag, class... _Args>
+ requires __detail::__has_apply_sender<_Tag, _Args...>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto apply_sender(_Tag, _Args&&... __args) const
+ -> __detail::__apply_sender_result_t<_Tag, _Args...> {
+ return _Tag().apply_sender(static_cast<_Args&&>(__args)...);
}
+ };
- template <class... _Domains>
- static auto __common_domain(_Domains...) noexcept //
- -> __if_c<__one_of<dependent_domain, _Domains...>, dependent_domain,
- __none_such>
- {
- return {};
- }
+ inline constexpr __detail::__get_early_domain_t __get_early_domain{};
+ inline constexpr __detail::__get_late_domain_t __get_late_domain{};
+ using __detail::__early_domain_of_t;
+ using __detail::__late_domain_of_t;
- auto operator()(__ignore, __ignore, const auto&... __sndrs) const noexcept
- {
- return __common_domain(__get_early_domain(__sndrs)...);
- }
-};
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // dependent_domain
+ struct dependent_domain {
+ // defined in __transform_sender.hpp
+ template <class _Sender, class _Env>
+ static constexpr auto __is_nothrow_transform_sender() noexcept -> bool;
-template <class... _Senders>
-using __common_domain_t = //
- __call_result_t<__common_domain_fn, int, int, _Senders...>;
+ // defined in __transform_sender.hpp
+ template <sender_expr _Sender, class _Env>
+ requires same_as<__early_domain_of_t<_Sender>, dependent_domain>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto transform_sender(_Sender&& __sndr, const _Env& __env) const
+ noexcept(__is_nothrow_transform_sender<_Sender, _Env>()) -> decltype(auto);
+ };
-template <class... _Senders>
-concept __has_common_domain = //
- __none_of<__none_such, __common_domain_t<_Senders...>>;
-} // namespace __domain
+ template <class... _Senders>
+ using __common_domain_t = __call_result_t<__detail::__common_domain_fn, int, int, _Senders...>;
+
+ template <class... _Senders>
+ concept __has_common_domain = __none_of<__none_such, __common_domain_t<_Senders...>>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__ensure_started.hpp b/include/sdbusplus/async/stdexec/__detail/__ensure_started.hpp
index 2afb8cd..130b05e 100644
--- a/include/sdbusplus/async/stdexec/__detail/__ensure_started.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__ensure_started.hpp
@@ -20,7 +20,6 @@
// include these after __execution_fwd.hpp
#include "__basic_sender.hpp"
#include "__concepts.hpp"
-#include "__intrusive_ptr.hpp"
#include "__meta.hpp"
#include "__sender_adaptor_closure.hpp"
#include "__senders.hpp"
@@ -28,99 +27,71 @@
#include "__transform_sender.hpp"
#include "__type_traits.hpp"
-#include <utility>
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.ensure_started]
+ namespace __ensure_started {
+ using namespace __shared;
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.ensure_started]
-namespace __ensure_started
-{
-using namespace __shared;
+ struct __ensure_started_t { };
-struct __ensure_started_t
-{};
-
-struct ensure_started_t
-{
- template <sender _Sender, class _Env = empty_env>
+ struct ensure_started_t {
+ template <sender _Sender, class _Env = env<>>
requires sender_in<_Sender, _Env> && __decay_copyable<env_of_t<_Sender>>
- [[nodiscard]] auto operator()(_Sender&& __sndr, _Env&& __env = {}) const
- -> __well_formed_sender auto
- {
- if constexpr (sender_expr_for<_Sender, __ensure_started_t>)
- {
- return static_cast<_Sender&&>(__sndr);
+ [[nodiscard]]
+ auto operator()(_Sender&& __sndr, _Env&& __env = {}) const -> __well_formed_sender auto {
+ if constexpr (sender_expr_for<_Sender, __ensure_started_t>) {
+ return static_cast<_Sender&&>(__sndr);
+ } else {
+ auto __early_domain = __get_early_domain(__sndr);
+ auto __domain = __get_late_domain(__sndr, __env, __early_domain);
+ return stdexec::transform_sender(
+ __domain,
+ __make_sexpr<ensure_started_t>(
+ static_cast<_Env&&>(__env), static_cast<_Sender&&>(__sndr)));
}
- else
- {
- auto __domain = __get_late_domain(__sndr, __env);
- return stdexec::transform_sender(
- __domain,
- __make_sexpr<ensure_started_t>(static_cast<_Env&&>(__env),
- static_cast<_Sender&&>(__sndr)));
- }
- }
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()() const noexcept -> __binder_back<ensure_started_t>
- {
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()() const noexcept -> __binder_back<ensure_started_t> {
return {{}, {}, {}};
- }
+ }
- using _Sender = __1;
- using __legacy_customizations_t = //
- __types<tag_invoke_t(ensure_started_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(const _Sender&)),
- _Sender),
- tag_invoke_t(ensure_started_t, _Sender)>;
+ template <class _CvrefSender, class _Env>
+ using __receiver_t = __t<__meval<__receiver, __cvref_id<_CvrefSender>, __id<_Env>>>;
- template <class _CvrefSender, class _Env>
- using __receiver_t =
- __t<__meval<__receiver, __cvref_id<_CvrefSender>, __id<_Env>>>;
-
- template <class _Sender>
- static auto transform_sender(_Sender&& __sndr)
- {
- using _Receiver =
- __receiver_t<__child_of<_Sender>, __decay_t<__data_of<_Sender>>>;
+ template <class _Sender>
+ static auto transform_sender(_Sender&& __sndr) {
+ using _Receiver = __receiver_t<__child_of<_Sender>, __decay_t<__data_of<_Sender>>>;
static_assert(sender_to<__child_of<_Sender>, _Receiver>);
return __sexpr_apply(
- static_cast<_Sender&&>(__sndr),
- [&]<class _Env, class _Child>(__ignore, _Env&& __env,
- _Child&& __child) {
- // The shared state starts life with a ref-count of one.
- auto __sh_state =
- __make_intrusive<__shared_state<_Child, __decay_t<_Env>>,
- 2>(static_cast<_Child&&>(__child),
- static_cast<_Env&&>(__env));
+ static_cast<_Sender&&>(__sndr),
+ [&]<class _Env, class _Child>(__ignore, _Env&& __env, _Child&& __child) {
+ // The shared state starts life with a ref-count of one.
+ auto* __sh_state =
+ new __shared_state{static_cast<_Child&&>(__child), static_cast<_Env&&>(__env)};
- // Eagerly start the work:
- __sh_state->__try_start();
+ // Eagerly start the work:
+ __sh_state->__try_start(); // cannot throw
- return __make_sexpr<__ensure_started_t>(
- __box{__ensure_started_t(), std::move(__sh_state)});
- });
- }
-};
-} // namespace __ensure_started
+ return __make_sexpr<__ensure_started_t>(__box{__ensure_started_t(), __sh_state});
+ });
+ }
+ };
+ } // namespace __ensure_started
-using __ensure_started::ensure_started_t;
-inline constexpr ensure_started_t ensure_started{};
+ using __ensure_started::ensure_started_t;
+ inline constexpr ensure_started_t ensure_started{};
-template <>
-struct __sexpr_impl<__ensure_started::__ensure_started_t> :
- __shared::__shared_impl<__ensure_started::__ensure_started_t>
-{};
+ template <>
+ struct __sexpr_impl<__ensure_started::__ensure_started_t>
+ : __shared::__shared_impl<__ensure_started::__ensure_started_t> { };
-template <>
-struct __sexpr_impl<ensure_started_t> : __sexpr_defaults
-{
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {};
-};
+ template <>
+ struct __sexpr_impl<ensure_started_t> : __sexpr_defaults {
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
+ };
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__env.hpp b/include/sdbusplus/async/stdexec/__detail/__env.hpp
index adbcb7b..45ecf68 100644
--- a/include/sdbusplus/async/stdexec/__detail/__env.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__env.hpp
@@ -15,815 +15,726 @@
*/
#pragma once
-#include "__concepts.hpp"
-#include "__cpo.hpp"
#include "__execution_fwd.hpp"
+
+#include "__concepts.hpp"
+#include "__completion_behavior.hpp"
#include "__meta.hpp"
+#include "__query.hpp"
#include "__stop_token.hpp"
#include "__tag_invoke.hpp"
-#include "__tuple.hpp"
+// #include "__tuple.hpp"
-#include <exception>
-#include <functional>
+#include <exception> // IWYU pragma: keep for std::terminate
+#include <functional> // IWYU pragma: keep for unwrap_reference_t
#include <type_traits>
+#include <utility>
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_EDG(probable_guiding_friend)
STDEXEC_PRAGMA_IGNORE_EDG(type_qualifiers_ignored_on_reference)
-namespace stdexec
-{
-// [exec.queries.queryable]
-template <class T>
-concept queryable = destructible<T>;
-
-template <class Tag>
-struct __query
-{
- template <class Sig>
- static inline constexpr Tag (*signature)(Sig) = nullptr;
-};
-
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// [exec.queries]
-namespace __queries
-{
-template <class _Tp>
-concept __is_bool_constant = //
- requires { //
- typename __mbool<_Tp::value>;
+namespace stdexec {
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // [exec.queries]
+ namespace __queries {
+ struct execute_may_block_caller_t : __query<execute_may_block_caller_t, true> {
+ template <class _Attrs>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept {
+ static_assert(same_as<bool, __call_result_t<execute_may_block_caller_t, const _Attrs&>>);
+ static_assert(__nothrow_callable<execute_may_block_caller_t, const _Attrs&>);
+ }
};
-struct forwarding_query_t
-{
- template <class _Query>
- consteval auto operator()(_Query __query) const noexcept -> bool
- {
- if constexpr (tag_invocable<forwarding_query_t, _Query>)
- {
- using __result_t = tag_invoke_result_t<forwarding_query_t, _Query>;
- // If this a integral type wrapper, unpack it and return the value.
- // Otherwise, return the result of the tag_invoke call expression.
- if constexpr (__is_bool_constant<__result_t>)
- {
- return __result_t::value;
- }
- else
- {
- return tag_invoke(*this, static_cast<_Query&&>(__query));
- }
- }
- else if constexpr (derived_from<_Query, forwarding_query_t>)
- {
- return true;
- }
- else
- {
- return false;
- }
- }
-};
+ struct get_forward_progress_guarantee_t
+ : __query<
+ get_forward_progress_guarantee_t,
+ forward_progress_guarantee::weakly_parallel,
+ __q1<__decay_t>
+ > {
+ template <class _Attrs>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept {
+ using __result_t = __call_result_t<get_forward_progress_guarantee_t, const _Attrs&>;
+ static_assert(same_as<forward_progress_guarantee, __result_t>);
+ static_assert(__nothrow_callable<get_forward_progress_guarantee_t, const _Attrs&>);
+ }
+ };
-struct query_or_t
-{
- template <class _Query, class _Queryable, class _Default>
- constexpr auto operator()(_Query, _Queryable&&, _Default&& __default) const
- noexcept(__nothrow_constructible_from<_Default, _Default&&>) -> _Default
- {
- return static_cast<_Default&&>(__default);
- }
+ // TODO: implement allocator concept
+ template <class _T0>
+ concept __allocator_c = true;
- template <class _Query, class _Queryable, class _Default>
- requires __callable<_Query, _Queryable>
- constexpr auto operator()(_Query __query, _Queryable&& __queryable,
- _Default&&) const
- noexcept(__nothrow_callable<_Query, _Queryable>)
- -> __call_result_t<_Query, _Queryable>
- {
- return static_cast<_Query&&>(__query)(
- static_cast<_Queryable&&>(__queryable));
- }
-};
+ struct get_scheduler_t : __query<get_scheduler_t> {
+ using __query<get_scheduler_t>::operator();
-struct execute_may_block_caller_t : __query<execute_may_block_caller_t>
-{
- template <class _Tp>
- requires tag_invocable<execute_may_block_caller_t, __cref_t<_Tp>>
- constexpr auto operator()(_Tp&& __t) const noexcept -> bool
- {
+ template <class _Query = get_scheduler_t>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto
+ operator()() const noexcept; // defined in __read_env.hpp // defined in __read_env.hpp
+
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept; // defined in __schedulers.hpp
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
+ return true;
+ }
+ };
+
+ //! The type for `get_delegation_scheduler` [exec.get.delegation.scheduler]
+ //! A query object that asks for a scheduler that can be used to delegate
+ //! work to for the purpose of forward progress delegation ([intro.progress]).
+ struct get_delegation_scheduler_t : __query<get_delegation_scheduler_t> {
+ using __query<get_delegation_scheduler_t>::operator();
+
+ template <class _Query = get_delegation_scheduler_t>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()() const noexcept; // defined in __read_env.hpp
+
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept; // defined in __schedulers.hpp
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
+ return true;
+ }
+ };
+
+ struct get_allocator_t : __query<get_allocator_t> {
+ using __query<get_allocator_t>::operator();
+
+ template <class _Query = get_allocator_t>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()() const noexcept; // defined in __read_env.hpp
+
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept {
+ static_assert(__nothrow_callable<get_allocator_t, const _Env&>);
+ static_assert(__allocator_c<__call_result_t<get_allocator_t, const _Env&>>);
+ }
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
+ return true;
+ }
+ };
+
+ using __get_stop_token_t = __query<get_stop_token_t, never_stop_token{}, __q1<__decay_t>>;
+
+ struct get_stop_token_t : __get_stop_token_t {
+ using __get_stop_token_t::operator();
+
+ template <class _Query = get_stop_token_t>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()() const noexcept; // defined in __read_env.hpp
+
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept {
+ static_assert(__nothrow_callable<get_stop_token_t, const _Env&>);
+ static_assert(stoppable_token<__call_result_t<get_stop_token_t, const _Env&>>);
+ }
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
+ return true;
+ }
+ };
+
+ template <__completion_tag _Query>
+ struct get_completion_scheduler_t : __query<get_completion_scheduler_t<_Query>> {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept; // defined in __schedulers.hpp
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
+ return true;
+ }
+ };
+
+ struct get_domain_t : __query<get_domain_t, __no_default, __q1<__decay_t>> {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept {
static_assert(
- same_as<bool, tag_invoke_result_t<execute_may_block_caller_t,
- __cref_t<_Tp>>>);
+ __nothrow_callable<get_domain_t, const _Env&>,
+ "Customizations of get_domain must be noexcept.");
static_assert(
- nothrow_tag_invocable<execute_may_block_caller_t, __cref_t<_Tp>>);
- return tag_invoke(execute_may_block_caller_t{}, std::as_const(__t));
- }
+ __class<__call_result_t<get_domain_t, const _Env&>>,
+ "Customizations of get_domain must return a class type.");
+ }
- constexpr auto operator()(auto&&) const noexcept -> bool
- {
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
return true;
- }
-};
+ }
+ };
-struct get_forward_progress_guarantee_t :
- __query<get_forward_progress_guarantee_t>
-{
- template <class _Tp>
- requires tag_invocable<get_forward_progress_guarantee_t, __cref_t<_Tp>>
- constexpr auto operator()(_Tp&& __t) const noexcept(
- nothrow_tag_invocable<get_forward_progress_guarantee_t, __cref_t<_Tp>>)
- -> __decay_t<tag_invoke_result_t<get_forward_progress_guarantee_t,
- __cref_t<_Tp>>>
- {
- return tag_invoke(get_forward_progress_guarantee_t{},
- std::as_const(__t));
- }
-
- constexpr auto operator()(auto&&) const noexcept
- -> stdexec::forward_progress_guarantee
- {
- return stdexec::forward_progress_guarantee::weakly_parallel;
- }
-};
-
-struct __has_algorithm_customizations_t :
- __query<__has_algorithm_customizations_t>
-{
- template <class _Tp>
- using __result_t =
- tag_invoke_result_t<__has_algorithm_customizations_t, __cref_t<_Tp>>;
-
- template <class _Tp>
- requires tag_invocable<__has_algorithm_customizations_t, __cref_t<_Tp>>
- constexpr auto operator()(_Tp&&) const noexcept(noexcept(__result_t<_Tp>{}))
- -> __result_t<_Tp>
- {
- using _Boolean = tag_invoke_result_t<__has_algorithm_customizations_t,
- __cref_t<_Tp>>;
- static_assert(_Boolean{}
- ? true
- : false); // must be contextually convertible to bool
- return _Boolean{};
- }
-
- constexpr auto operator()(auto&&) const noexcept -> std::false_type
- {
- return {};
- }
-};
-
-// TODO: implement allocator concept
-template <class _T0>
-concept __allocator_c = true;
-
-struct get_scheduler_t : __query<get_scheduler_t>
-{
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
- return true;
- }
-
- template <class _Env>
- requires tag_invocable<get_scheduler_t, const _Env&>
- auto operator()(const _Env& __env) const noexcept
- -> tag_invoke_result_t<get_scheduler_t, const _Env&>;
-
- template <class _Tag = get_scheduler_t>
- auto operator()() const noexcept;
-};
-
-//! The type for `get_delegation_scheduler` [exec.get.delegation.scheduler]
-//! A query object that asks for a scheduler that can be used to delegate
-//! work to for the purpose of forward progress delegation ([intro.progress]).
-struct get_delegation_scheduler_t : __query<get_delegation_scheduler_t>
-{
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
- return true;
- }
-
- template <class _Env>
- requires tag_invocable<get_delegation_scheduler_t, const _Env&>
- auto operator()(const _Env& __t) const noexcept
- -> tag_invoke_result_t<get_delegation_scheduler_t, const _Env&>;
-
- template <class _Tag = get_delegation_scheduler_t>
- auto operator()() const noexcept;
-};
-
-struct get_allocator_t : __query<get_allocator_t>
-{
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
- return true;
- }
-
- template <class _Env>
- requires tag_invocable<get_allocator_t, const _Env&>
- auto operator()(const _Env& __env) const noexcept
- -> tag_invoke_result_t<get_allocator_t, const _Env&>
- {
- static_assert(nothrow_tag_invocable<get_allocator_t, const _Env&>);
+ struct get_domain_override_t : __query<get_domain_override_t, __no_default, __q1<__decay_t>> {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ static constexpr void __validate() noexcept {
static_assert(
- __allocator_c<tag_invoke_result_t<get_allocator_t, const _Env&>>);
- return tag_invoke(get_allocator_t{}, __env);
- }
-
- template <class _Tag = get_allocator_t>
- auto operator()() const noexcept;
-};
-
-struct get_stop_token_t : __query<get_stop_token_t>
-{
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
- return true;
- }
-
- template <class _Env, class _Token = never_stop_token>
- auto operator()(const _Env&) const noexcept -> _Token
- {
- return {};
- }
-
- template <class _Env, class = void>
- requires tag_invocable<get_stop_token_t, const _Env&>
- auto operator()(const _Env& __env) const noexcept
- -> tag_invoke_result_t<get_stop_token_t, const _Env&>
- {
- static_assert(nothrow_tag_invocable<get_stop_token_t, const _Env&>);
+ __nothrow_callable<get_domain_override_t, const _Env&>,
+ "Customizations of get_domain_override must be noexcept.");
static_assert(
- stoppable_token<
- __decay_t<tag_invoke_result_t<get_stop_token_t, const _Env&>>>);
- return tag_invoke(get_stop_token_t{}, __env);
- }
+ __class<__call_result_t<get_domain_override_t, const _Env&>>,
+ "Customizations of get_domain_override must return a class type.");
+ }
- template <class _Tag = get_stop_token_t>
- auto operator()() const noexcept;
-};
-
-template <class _Queryable, class _Tag>
-concept __has_completion_scheduler_for =
- queryable<_Queryable> && //
- tag_invocable<get_completion_scheduler_t<_Tag>, const _Queryable&>;
-
-template <__completion_tag _Tag>
-struct get_completion_scheduler_t : __query<get_completion_scheduler_t<_Tag>>
-{
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
- return true;
- }
-
- template <__has_completion_scheduler_for<_Tag> _Queryable>
- auto operator()(const _Queryable& __queryable) const noexcept
- -> tag_invoke_result_t<get_completion_scheduler_t<_Tag>,
- const _Queryable&>;
-};
-
-struct get_domain_t
-{
- template <class _Ty>
- requires tag_invocable<get_domain_t, const _Ty&>
- constexpr auto operator()(const _Ty& __ty) const noexcept
- -> __decay_t<tag_invoke_result_t<get_domain_t, const _Ty&>>
- {
- static_assert(nothrow_tag_invocable<get_domain_t, const _Ty&>,
- "Customizations of get_domain must be noexcept.");
- static_assert(
- __class<__decay_t<tag_invoke_result_t<get_domain_t, const _Ty&>>>,
- "Customizations of get_domain must return a class type.");
- return {};
- }
-
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
- return true;
- }
-};
-
-struct __is_scheduler_affine_t
-{
- template <class _Env>
- constexpr auto operator()(const _Env&) const noexcept
- {
- if constexpr (tag_invocable<__is_scheduler_affine_t, const _Env&>)
- {
- using _Result =
- tag_invoke_result_t<__is_scheduler_affine_t, const _Env&>;
- static_assert(__same_as<decltype(__v<_Result>), const bool>);
- return _Result();
- }
- else
- {
- return std::false_type();
- }
- }
-
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
return false;
- }
-};
+ }
+ };
-struct __root_t
-{
- template <class _Env>
- requires tag_invocable<__root_t, const _Env&>
- constexpr auto operator()(const _Env& __env) const noexcept -> bool
- {
- STDEXEC_ASSERT(tag_invoke(__root_t{}, __env) == true);
- return true;
- }
+ struct __is_scheduler_affine_t {
+ template <class _Result>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto __ensure_bool_constant() noexcept {
+ if constexpr (__is_bool_constant<_Result>) {
+ return static_cast<bool>(_Result::value);
+ } else {
+ static_assert(
+ __is_bool_constant<_Result>,
+ "The __is_scheduler_affine query must be one of the following forms:\n"
+ " static constexpr bool query(__is_scheduler_affine_t) noexcept;\n"
+ " bool_constant<Bool> query(__is_scheduler_affine_t) const noexcept;\n"
+ " bool_constant<Bool> query(__is_scheduler_affine_t, const Env&) const noexcept;\n");
+ }
+ }
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
+ template <class _Attrs, class... _Env>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ consteval auto operator()() const noexcept -> bool {
+ return __completes_inline<_Attrs, const _Env&...>;
+ }
+
+ template <__queryable_with<__is_scheduler_affine_t> _Attrs, class... _Env>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ consteval auto operator()() const noexcept -> bool {
+ if constexpr (__statically_queryable_with<_Attrs, __is_scheduler_affine_t>) {
+ return _Attrs::query(__is_scheduler_affine_t());
+ } else {
+ return __ensure_bool_constant<__query_result_t<_Attrs, __is_scheduler_affine_t>>();
+ }
+ }
+
+ template <class _Attrs, class _Env>
+ requires __queryable_with<_Attrs, __is_scheduler_affine_t, const _Env&>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ consteval auto operator()() const noexcept -> bool {
+ using __result_t = __query_result_t<_Attrs, __is_scheduler_affine_t, const _Env&>;
+ return __ensure_bool_constant<__result_t>();
+ }
+
+ template <class _Attrs, class... _Env>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ consteval auto operator()(const _Attrs&, const _Env&...) const noexcept -> bool {
+ return operator()<_Attrs, _Env...>();
+ }
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
return false;
- }
-};
+ }
+ };
-struct __root_env
-{
- using __t = __root_env;
- using __id = __root_env;
+ struct __root_t : __query<__root_t> {
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static consteval auto query(forwarding_query_t) noexcept -> bool {
+ return false;
+ }
+ };
- constexpr STDEXEC_MEMFN_DECL(auto __root)(this const __root_env&) noexcept
- -> bool
- {
+ struct __root_env {
+ using __t = __root_env;
+ using __id = __root_env;
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static constexpr auto query(__root_t) noexcept -> bool {
return true;
- }
-};
-} // namespace __queries
+ }
+ };
+ } // namespace __queries
-using __queries::__has_algorithm_customizations_t;
-using __queries::execute_may_block_caller_t;
-using __queries::forwarding_query_t;
-using __queries::get_allocator_t;
-using __queries::get_delegation_scheduler_t;
-using __queries::get_forward_progress_guarantee_t;
-using __queries::get_scheduler_t;
-using __queries::query_or_t;
-using get_delegatee_scheduler_t [[deprecated(
- "get_delegatee_scheduler_t has been renamed get_delegation_scheduler_t")]] =
- get_delegation_scheduler_t;
-using __queries::__is_scheduler_affine_t;
-using __queries::__root_env;
-using __queries::__root_t;
-using __queries::get_completion_scheduler_t;
-using __queries::get_domain_t;
-using __queries::get_stop_token_t;
+ using __queries::execute_may_block_caller_t;
+ using __queries::get_forward_progress_guarantee_t;
+ using __queries::get_allocator_t;
+ using __queries::get_scheduler_t;
+ using __queries::get_delegation_scheduler_t;
+ using get_delegatee_scheduler_t
+ [[deprecated("get_delegatee_scheduler_t has been renamed get_delegation_scheduler_t")]] =
+ get_delegation_scheduler_t;
+ using __queries::get_stop_token_t;
+ using __queries::get_completion_scheduler_t;
+ using __queries::get_domain_t;
+ using __queries::get_domain_override_t;
+ using __queries::__is_scheduler_affine_t;
+ using __queries::__root_t;
+ using __queries::__root_env;
-inline constexpr forwarding_query_t forwarding_query{};
-inline constexpr query_or_t query_or{}; // NOT TO SPEC
-inline constexpr execute_may_block_caller_t execute_may_block_caller{};
-inline constexpr __has_algorithm_customizations_t
- __has_algorithm_customizations{};
-inline constexpr get_forward_progress_guarantee_t
- get_forward_progress_guarantee{};
-inline constexpr get_scheduler_t get_scheduler{};
-inline constexpr get_delegation_scheduler_t get_delegation_scheduler{};
-inline constexpr auto& get_delegatee_scheduler [[deprecated(
- "get_delegatee_scheduler has been renamed get_delegation_scheduler")]] =
- get_delegation_scheduler;
-inline constexpr get_allocator_t get_allocator{};
-inline constexpr get_stop_token_t get_stop_token{};
+ inline constexpr execute_may_block_caller_t execute_may_block_caller{};
+ inline constexpr get_forward_progress_guarantee_t get_forward_progress_guarantee{};
+ inline constexpr get_scheduler_t get_scheduler{};
+ inline constexpr get_delegation_scheduler_t get_delegation_scheduler{};
+ inline constexpr auto& get_delegatee_scheduler
+ [[deprecated("get_delegatee_scheduler has been renamed get_delegation_scheduler")]]
+ = get_delegation_scheduler;
+ inline constexpr get_allocator_t get_allocator{};
+ inline constexpr get_stop_token_t get_stop_token{};
#if !STDEXEC_GCC() || defined(__OPTIMIZE_SIZE__)
-template <__completion_tag _Tag>
-inline constexpr get_completion_scheduler_t<_Tag> get_completion_scheduler{};
+ template <__completion_tag _Query>
+ inline constexpr get_completion_scheduler_t<_Query> get_completion_scheduler{};
#else
-template <>
-inline constexpr get_completion_scheduler_t<set_value_t>
- get_completion_scheduler<set_value_t>{};
-template <>
-inline constexpr get_completion_scheduler_t<set_error_t>
- get_completion_scheduler<set_error_t>{};
-template <>
-inline constexpr get_completion_scheduler_t<set_stopped_t>
+ template <>
+ inline constexpr get_completion_scheduler_t<set_value_t> get_completion_scheduler<set_value_t>{};
+ template <>
+ inline constexpr get_completion_scheduler_t<set_error_t> get_completion_scheduler<set_error_t>{};
+ template <>
+ inline constexpr get_completion_scheduler_t<set_stopped_t>
get_completion_scheduler<set_stopped_t>{};
#endif
-template <class _Tag>
-concept __forwarding_query = forwarding_query(_Tag{});
+ inline constexpr get_domain_t get_domain{};
+ inline constexpr get_domain_override_t get_domain_override{};
-inline constexpr get_domain_t get_domain{};
+ template <class _Query, class _Queryable, class _Default>
+ using __query_result_or_t = __call_result_t<query_or_t, _Query, _Queryable, _Default>;
-template <class _Env>
-using __domain_of_t = __decay_t<__call_result_t<get_domain_t, _Env>>;
+ namespace __env {
+ template <class _Tp, class _Promise>
+ concept __has_as_awaitable_member = requires(_Tp&& __t, _Promise& __promise) {
+ static_cast<_Tp &&>(__t).as_awaitable(__promise);
+ };
-template <class _Tag, class _Queryable, class _Default>
-using __query_result_or_t =
- __call_result_t<query_or_t, _Tag, _Queryable, _Default>;
-
-namespace __env
-{
-// To be kept in sync with the promise type used in __connect_awaitable
-template <class _Env>
-struct __promise
-{
- template <class _Ty>
- auto await_transform(_Ty&& __value) noexcept -> _Ty&&
- {
+ template <class _Promise>
+ struct __with_await_transform {
+ template <class _Ty>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ auto await_transform(_Ty&& __value) noexcept -> _Ty&& {
return static_cast<_Ty&&>(__value);
- }
+ }
- template <class _Ty>
- requires tag_invocable<as_awaitable_t, _Ty, __promise&>
- auto await_transform(_Ty&& __value) //
- noexcept(nothrow_tag_invocable<as_awaitable_t, _Ty, __promise&>)
- -> tag_invoke_result_t<as_awaitable_t, _Ty, __promise&>
- {
- return tag_invoke(as_awaitable, static_cast<_Ty&&>(__value), *this);
- }
+ template <class _Ty>
+ requires __has_as_awaitable_member<_Ty, _Promise&>
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ auto await_transform(_Ty&& __value)
+ noexcept(noexcept(__declval<_Ty>().as_awaitable(__declval<_Promise&>())))
+ -> decltype(__declval<_Ty>().as_awaitable(__declval<_Promise&>())) {
+ return static_cast<_Ty&&>(__value).as_awaitable(static_cast<_Promise&>(*this));
+ }
- auto get_env() const noexcept -> const _Env&;
-};
+ template <class _Ty>
+ requires(!__has_as_awaitable_member<_Ty, _Promise&>)
+ && tag_invocable<as_awaitable_t, _Ty, _Promise&>
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ auto await_transform(_Ty&& __value)
+ noexcept(nothrow_tag_invocable<as_awaitable_t, _Ty, _Promise&>)
+ -> tag_invoke_result_t<as_awaitable_t, _Ty, _Promise&> {
+ return tag_invoke(as_awaitable, static_cast<_Ty&&>(__value), static_cast<_Promise&>(*this));
+ }
+ };
-template <class _Env, class _Query, class... _Args>
-concept __queryable = //
- tag_invocable<_Query, const _Env&, _Args...>;
+ template <class _Env>
+ struct __promise : __with_await_transform<__promise<_Env>> {
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ auto get_env() const noexcept -> const _Env&;
+ };
-template <class _Env, class _Query, class... _Args>
-concept __nothrow_queryable = //
- nothrow_tag_invocable<_Query, const _Env&, _Args...>;
+ template <class ValueType>
+ struct __prop_like {
+ template <class _Query>
+ STDEXEC_ATTRIBUTE(noreturn, nodiscard, host, device)
+ constexpr auto query(_Query) const noexcept -> const ValueType& {
+ STDEXEC_TERMINATE();
+ }
+ };
-template <class _Env, class _Query, class... _Args>
-using __query_result_t = //
- tag_invoke_result_t<_Query, const _Env&, _Args...>;
+ // A singleton environment from a query/value pair
+ template <class _Query, class _Value>
+ struct prop {
+ using __t = prop;
+ using __id = prop;
-// A singleton environment from a query/value pair
-template <class _Query, class _Value>
-struct prop
-{
- using __t = prop;
- using __id = prop;
+ static_assert(__callable<_Query, __prop_like<_Value>>);
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Query __query;
-
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Value __value;
-
- STDEXEC_ATTRIBUTE((nodiscard))
- constexpr const _Value& query(_Query) const noexcept
- {
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(_Query) const noexcept -> const _Value& {
return __value;
- }
+ }
- prop& operator=(const prop&) = delete;
-};
+ STDEXEC_ATTRIBUTE(no_unique_address) _Query __query;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Value __value;
+ };
-template <class _Query, class _Value>
-prop(_Query, _Value) -> prop<_Query, std::unwrap_reference_t<_Value>>;
+ template <class _Query, class _Value>
+ STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
+ prop(_Query, _Value) -> prop<_Query, std::unwrap_reference_t<_Value>>;
-// utility for joining multiple environments
-template <class... _Envs>
-struct env
-{
- using __t = env;
- using __id = env;
+ template <class _Query, auto _Value>
+ struct cprop {
+ using __t = cprop;
+ using __id = cprop;
- __tuple_for<_Envs...> __tup_;
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ static constexpr auto query(_Query) noexcept {
+ return _Value;
+ }
+ };
- // return a reference to the first child env for which
- // __queryable<_Envs, _Query, _Args...> is true.
- template <class _Query, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr decltype(auto) __get_1st() const noexcept
- {
- constexpr bool __flags[] = {__queryable<_Envs, _Query, _Args...>...};
- constexpr std::size_t __idx =
- __pos_of(__flags, __flags + sizeof...(_Envs));
- return __tup::get<__idx>(__tup_);
- }
+ //////////////////////////////////////////////////////////////////////
+ // env
+ template <class... Envs>
+ struct env;
- template <class _Query, class... _Args>
- requires(__queryable<_Envs, _Query, _Args...> || ...)
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr decltype(auto) query(_Query __q, _Args&&... __args) const
- noexcept(__nothrow_queryable<decltype(__get_1st<_Query, _Args...>()),
- _Query, _Args...>)
- {
- return tag_invoke(__q, __get_1st<_Query, _Args...>(),
- static_cast<_Args&&>(__args)...);
- }
+ template <>
+ struct env<> {
+ using __t = env;
+ using __id = env;
- env& operator=(const env&) = delete;
-};
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ auto query() const = delete;
+ };
-// specialization for two envs to avoid warnings about elided braces
-template <class _Env0, class _Env1>
-struct env<_Env0, _Env1>
-{
- using __t = env;
- using __id = env;
+ template <class Env>
+ struct env<Env> : Env {
+ using __t = env;
+ using __id = env;
+ };
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Env0 __env0_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Env1 __env1_;
+ template <class Env>
+ struct env<Env&> {
+ using __t = env;
+ using __id = env;
- // return a reference to the first child env for which
- // __queryable<_Envs, _Query, _Args...> is true.
- template <class _Query, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr decltype(auto) __get_1st() const noexcept
- {
- if constexpr (__queryable<_Env0, _Query, _Args...>)
- {
- return (__env0_);
- }
- else
- {
- return (__env1_);
- }
- }
+ template <class Query, class... _Args>
+ requires __queryable_with<Env, Query, _Args...>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(Query, _Args&&... __args) const
+ noexcept(__nothrow_queryable_with<Env, Query, _Args...>)
+ -> __query_result_t<Env, Query, _Args...> {
+ return __query<Query>()(env_, static_cast<_Args&&>(__args)...);
+ }
- template <class _Query, class... _Args>
- requires __queryable<_Env0, _Query, _Args...> ||
- __queryable<_Env1, _Query, _Args...>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr decltype(auto) query(_Query __q, _Args&&... __args) const
- noexcept(__nothrow_queryable<decltype(__get_1st<_Query, _Args...>()),
- _Query, _Args...>)
- {
- return tag_invoke(__q, __get_1st<_Query, _Args...>(),
- static_cast<_Args&&>(__args)...);
- }
+ Env& env_;
+ };
- env& operator=(const env&) = delete;
-};
+ template <class Env>
+ using __env_base = __if_c<std::is_reference_v<Env>, env<Env>, Env>;
-template <class... _Envs>
-env(_Envs...) -> env<std::unwrap_reference_t<_Envs>...>;
+ template <class Env1, class Env2>
+ struct env<Env1, Env2> : __env_base<Env1> {
+ using __t = env;
+ using __id = env;
-template <class _Value, class _Tag, class... _Tags>
-struct __with
-{
- using __t = __with;
- using __id = __with;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Value __value_;
+ using __env_base<Env1>::query;
- __with() = default;
+ template <class Query, class... _Args>
+ requires(!__queryable_with<Env1, Query, _Args...>)
+ && __queryable_with<Env2, Query, _Args...>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(Query, _Args&&... __args) const
+ noexcept(__nothrow_queryable_with<Env2, Query, _Args...>)
+ -> __query_result_t<Env2, Query, _Args...> {
+ return __query<Query>()(env2_, static_cast<_Args&&>(__args)...);
+ }
- constexpr explicit __with(_Value __value) noexcept(
- __nothrow_decay_copyable<_Value>) :
- __value_(static_cast<_Value&&>(__value))
- {}
+ STDEXEC_ATTRIBUTE(no_unique_address) Env2 env2_;
+ };
- constexpr explicit __with(_Value __value, _Tag, _Tags...) noexcept(
- __nothrow_decay_copyable<_Value>) :
- __value_(static_cast<_Value&&>(__value))
- {}
+ template <class Env1, class Env2, class... Envs>
+ struct env<Env1, Env2, Envs...> : env<env<Env1, Env2>, Envs...> {
+ using __t = env;
+ using __id = env;
+ };
- template <__one_of<_Tag, _Tags...> _Key>
- auto query(_Key) const noexcept -> const _Value&
- {
- return __value_;
- }
+ template <class... _Envs>
+ STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE env(_Envs...) -> env<std::unwrap_reference_t<_Envs>...>;
- __with& operator=(const __with&) = delete;
-};
+ template <class _EnvId>
+ struct __fwd {
+ using _Env = __cvref_t<_EnvId>;
+ static_assert(__nothrow_move_constructible<_Env>);
-template <class _Value, class _Tag, class... _Tags>
-__with(_Value, _Tag, _Tags...) -> __with<_Value, _Tag, _Tags...>;
-
-template <class _EnvId>
-struct __fwd
-{
- using _Env = __cvref_t<_EnvId>;
- static_assert(__nothrow_move_constructible<_Env>);
-
- struct __t
- {
+ struct __t {
using __id = __fwd;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Env __env_;
+ using __fwd_env_t = __t;
-#if STDEXEC_GCC() && __GNUC__ < 12
- using __cvref_env_t = std::add_const_t<_Env>&;
-#else
- using __cvref_env_t = const _Env&;
-#endif
-
- template <__forwarding_query _Tag>
- requires tag_invocable<_Tag, __cvref_env_t>
- auto query(_Tag) const
- noexcept(nothrow_tag_invocable<_Tag, __cvref_env_t>)
- -> tag_invoke_result_t<_Tag, __cvref_env_t>
- {
- return tag_invoke(_Tag(), __env_);
+ template <__forwarding_query _Query, class... _Args>
+ requires __queryable_with<_Env, _Query, _Args...>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(_Query, _Args&&... __args) const
+ noexcept(__nothrow_queryable_with<_Env, _Query, _Args...>)
+ -> __query_result_t<_Env, _Query, _Args...> {
+ return __query<_Query>()(__env_, static_cast<_Args&&>(__args)...);
}
- __t& operator=(const __t&) = delete;
+ STDEXEC_ATTRIBUTE(no_unique_address)
+ _Env __env_;
+ };
};
-};
-struct __fwd_fn
-{
template <class _Env>
- auto operator()(_Env&& __env) const
- {
- return __t<__fwd<__cvref_id<_Env>>>{static_cast<_Env&&>(__env)};
- }
+ concept __is_fwd_env = __same_as<_Env, typename _Env::__fwd_env_t>;
- auto operator()(empty_env) const -> empty_env
- {
- return {};
- }
-};
+ struct __fwd_fn {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(_Env&& __env) const -> decltype(auto) {
+ if constexpr (__decays_to<_Env, env<>> || __is_fwd_env<__decay_t<_Env>>) {
+ return static_cast<_Env>(static_cast<_Env&&>(__env));
+ } else {
+ return __t<__fwd<__cvref_id<_Env>>>{static_cast<_Env&&>(__env)};
+ }
+ }
+ };
-template <class _EnvId, class _Tag>
-struct __without_
-{
- using _Env = __cvref_t<_EnvId>;
- static_assert(__nothrow_move_constructible<_Env>);
+ template <class _Env>
+ using __fwd_env_t = __call_result_t<__fwd_fn, _Env>;
- struct __t
- {
+ template <class _EnvId, class _Query>
+ struct __without_ {
+ using _Env = __cvref_t<_EnvId>;
+ static_assert(__nothrow_move_constructible<_Env>);
+
+ struct __t : __env_base<_Env> {
using __id = __without_;
- _Env __env_;
+ using __env_base<_Env>::query;
-#if STDEXEC_GCC() && __GNUC__ < 12
- using __cvref_env_t = std::add_const_t<_Env>&;
-#else
- using __cvref_env_t = const _Env&;
-#endif
-
- auto query(_Tag) const noexcept = delete;
-
- template <tag_invocable<__cvref_env_t> _Key>
- STDEXEC_ATTRIBUTE((always_inline))
- auto query(_Key) const
- noexcept(nothrow_tag_invocable<_Key, __cvref_env_t>)
- -> decltype(auto)
- {
- return tag_invoke(_Key(), __env_);
- }
-
- __t& operator=(const __t&) = delete;
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ auto query(_Query) const noexcept = delete;
+ };
};
-};
-struct __without_fn
-{
- template <class _Env, class _Tag>
- constexpr auto operator()(_Env&& __env, _Tag) const noexcept
- -> decltype(auto)
- {
- if constexpr (tag_invocable<_Tag, _Env>)
- {
- using _Without = __t<__without_<__cvref_id<_Env>, _Tag>>;
- return _Without{static_cast<_Env&&>(__env)};
+ struct __without_fn {
+ template <class _Env, class _Query>
+ constexpr auto operator()(_Env&& __env, _Query) const noexcept -> auto {
+ if constexpr (__queryable_with<_Env, _Query>) {
+ using _Without = __t<__without_<__cvref_id<_Env>, _Query>>;
+ return _Without{static_cast<_Env&&>(__env)};
+ } else {
+ return static_cast<_Env&&>(__env);
}
- else
- {
- return static_cast<_Env>(static_cast<_Env&&>(__env));
+ }
+ };
+
+ inline constexpr __without_fn __without{};
+
+ template <class _Env, class _Query, class... _Tags>
+ using __without_t = __result_of<__without, _Env, _Query, _Tags...>;
+
+ template <__nothrow_move_constructible _Fun>
+ struct __from {
+ using __t = __from;
+ using __id = __from;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fun __fun_;
+
+ template <class _Query, class... _Args>
+ requires __callable<const _Fun&, _Query, _Args...>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ auto query(_Query, _Args&&... __args) const
+ noexcept(__nothrow_callable<const _Fun&, _Query, _Args...>)
+ -> __call_result_t<const _Fun&, _Query, _Args...> {
+ return __fun_(_Query(), static_cast<_Args&&>(__args)...);
+ }
+ };
+
+ template <class _Fun>
+ STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __from(_Fun) -> __from<_Fun>;
+
+ struct __join_fn {
+ template <class _Env1, class _Env2>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(_Env1&& __env1, _Env2&& __env2) const noexcept -> decltype(auto) {
+ if constexpr (__decays_to<_Env1, env<>>) {
+ return __fwd_fn()(static_cast<_Env2&&>(__env2));
+ } else if constexpr (__decays_to<_Env2, env<>>) {
+ return static_cast<_Env1>(static_cast<_Env1&&>(__env1));
+ } else {
+ return env<_Env1, __fwd_env_t<_Env2>>{
+ {static_cast<_Env1&&>(__env1)}, __fwd_fn()(static_cast<_Env2&&>(__env2))};
}
- }
-};
+ }
+ };
-inline constexpr __without_fn __without{};
+ inline constexpr __join_fn __join{};
-template <class _Env, class _Tag, class... _Tags>
-using __without_t = __result_of<__without, _Env, _Tag, _Tags...>;
+ template <class _First, class... _Second>
+ using __join_env_t = __result_of<__join, _First, _Second...>;
-template <__nothrow_move_constructible _Fun>
-struct __from
-{
- using __t = __from;
- using __id = __from;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fun __fun_;
+ struct __as_root_env_fn {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(_Env __env) const noexcept
+ -> __join_env_t<__root_env, std::unwrap_reference_t<_Env>> {
+ return __join(__root_env{}, static_cast<std::unwrap_reference_t<_Env>&&>(__env));
+ }
+ };
- template <class _Tag>
- requires __callable<const _Fun&, _Tag>
- auto query(_Tag) const noexcept(__nothrow_callable<const _Fun&, _Tag>)
- -> __call_result_t<const _Fun&, _Tag>
- {
- return __fun_(_Tag());
- }
-
- __from& operator=(const __from&) = delete;
-};
-
-template <class _Fun>
-__from(_Fun) -> __from<_Fun>;
-
-struct __join_fn
-{
- auto operator()(empty_env, empty_env) const noexcept -> empty_env
- {
- return {};
- }
+ inline constexpr __as_root_env_fn __as_root_env{};
template <class _Env>
- auto operator()(_Env&& __env, empty_env = {}) const noexcept -> _Env
- {
- return static_cast<_Env&&>(__env);
- }
+ using __as_root_env_t = __result_of<__as_root_env, _Env>;
+ } // namespace __env
- template <class _Env>
- auto operator()(empty_env, _Env&& __env) const noexcept -> decltype(auto)
- {
- return __fwd_fn()(static_cast<_Env&&>(__env));
- }
+ using __env::__join_env_t;
+ using __env::__fwd_env_t;
- template <class _First, class _Second>
- auto operator()(_First&& __first, _Second&& __second) const noexcept
- -> env<_First, __call_result_t<__fwd_fn, _Second>>
- {
- return {static_cast<_First&&>(__first),
- __fwd_fn()(static_cast<_Second&&>(__second))};
- }
-};
-
-inline constexpr __join_fn __join{};
-
-template <class _First, class... _Second>
-using __join_t = __result_of<__join, _First, _Second...>;
-
-struct __as_root_env_fn
-{
- template <class _Env>
- constexpr auto operator()(_Env __env) const noexcept
- -> __join_t<__root_env, std::unwrap_reference_t<_Env>>
- {
- return __join(__root_env{},
- static_cast<std::unwrap_reference_t<_Env>&&>(__env));
- }
-};
-
-inline constexpr __as_root_env_fn __as_root_env{};
-
-template <class _Env>
-using __as_root_env_t = __result_of<__as_root_env, _Env>;
-} // namespace __env
-
-using __env::env;
-using __env::prop;
-using empty_env = env<>;
-
-/////////////////////////////////////////////////////////////////////////////
-namespace __get_env
-{
-// For getting an execution environment from a receiver or the attributes from a
-// sender.
-struct get_env_t
-{
- template <__same_as<get_env_t> _Self, class _EnvProvider>
- STDEXEC_ATTRIBUTE((always_inline))
- friend auto tag_invoke(_Self, const _EnvProvider& __env_provider) noexcept
- -> decltype(__env_provider.get_env())
- {
- static_assert(noexcept(__env_provider.get_env()),
- "get_env() members must be noexcept");
- return __env_provider.get_env();
- }
-
+ /////////////////////////////////////////////////////////////////////////////
+ namespace __get_env {
template <class _EnvProvider>
- requires tag_invocable<get_env_t, const _EnvProvider&>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(const _EnvProvider& __env_provider) const noexcept
- -> tag_invoke_result_t<get_env_t, const _EnvProvider&>
- {
- static_assert(
- queryable<tag_invoke_result_t<get_env_t, const _EnvProvider&>>);
+ concept __has_get_env = requires(const _EnvProvider& __env_provider) {
+ __env_provider.get_env();
+ };
+
+ // For getting an execution environment from a receiver or the attributes from a sender.
+ struct get_env_t {
+ template <class _EnvProvider>
+ requires __has_get_env<_EnvProvider>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(const _EnvProvider& __env_provider) const noexcept
+ -> decltype(__env_provider.get_env()) {
+ static_assert(queryable<decltype(__env_provider.get_env())>);
+ static_assert(noexcept(__env_provider.get_env()), "get_env() members must be noexcept");
+ return __env_provider.get_env();
+ }
+
+ template <class _EnvProvider>
+ requires(!__has_get_env<_EnvProvider>) && tag_invocable<get_env_t, const _EnvProvider&>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(const _EnvProvider& __env_provider) const noexcept
+ -> tag_invoke_result_t<get_env_t, const _EnvProvider&> {
+ static_assert(queryable<tag_invoke_result_t<get_env_t, const _EnvProvider&>>);
static_assert(nothrow_tag_invocable<get_env_t, const _EnvProvider&>);
return tag_invoke(*this, __env_provider);
- }
+ }
- template <class _EnvProvider>
- constexpr auto operator()(const _EnvProvider&) const noexcept -> empty_env
- {
+ template <class _EnvProvider>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(const _EnvProvider&) const noexcept -> env<> {
return {};
+ }
+ };
+ } // namespace __get_env
+
+ using __get_env::get_env_t;
+ inline constexpr get_env_t get_env{};
+
+ template <class _EnvProvider>
+ concept environment_provider = requires(_EnvProvider& __ep) {
+ { get_env(std::as_const(__ep)) } -> queryable;
+ };
+
+ template <class _Scheduler, class _LateDomain = __none_such>
+ struct __sched_attrs {
+ using __t = __sched_attrs;
+ using __id = __sched_attrs;
+
+ using __scheduler_t = __decay_t<_Scheduler>;
+ using __sched_domain_t = __query_result_or_t<get_domain_t, __scheduler_t, default_domain>;
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(get_completion_scheduler_t<set_value_t>) const noexcept -> __scheduler_t {
+ return __sched_;
}
-};
-} // namespace __get_env
-using __get_env::get_env_t;
-inline constexpr get_env_t get_env{};
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(get_domain_t) const noexcept -> __sched_domain_t {
+ return {};
+ }
-template <class _EnvProvider>
-concept environment_provider = //
- requires(_EnvProvider& __ep) {
- { get_env(std::as_const(__ep)) } -> queryable;
- };
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(get_domain_override_t) const noexcept -> _LateDomain
+ requires(!same_as<_LateDomain, __none_such>)
+ {
+ return {};
+ }
-using __env::__as_root_env;
-using __env::__as_root_env_t;
+ _Scheduler __sched_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _LateDomain __late_domain_ { };
+ };
-template <class _Env>
-concept __is_root_env = requires(_Env&& __env) {
- { __root_t{}(__env) } -> same_as<bool>;
- };
+ template <class _Scheduler, class _LateDomain = __none_such>
+ STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __sched_attrs(_Scheduler, _LateDomain = {})
+ -> __sched_attrs<std::unwrap_reference_t<_Scheduler>, _LateDomain>;
-template <class _Sender>
-concept __is_scheduler_affine = //
- requires {
- requires __v<
- __call_result_t<__is_scheduler_affine_t, env_of_t<_Sender>>>;
- };
+ template <class _Scheduler>
+ struct __sched_env {
+ using __t = __sched_env;
+ using __id = __sched_env;
+
+ using __scheduler_t = __decay_t<_Scheduler>;
+ using __sched_domain_t = __query_result_or_t<get_domain_t, __scheduler_t, default_domain>;
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(get_scheduler_t) const noexcept -> __scheduler_t {
+ return __sched_;
+ }
+
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto query(get_domain_t) const noexcept -> __sched_domain_t {
+ return {};
+ }
+
+ _Scheduler __sched_;
+ };
+
+ template <class _Scheduler>
+ STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
+ __sched_env(_Scheduler) -> __sched_env<std::unwrap_reference_t<_Scheduler>>;
+
+ using __env::__as_root_env_t;
+ using __env::__as_root_env;
+
+ template <class _Env>
+ concept __is_root_env = requires(_Env&& __env) {
+ { __root_t{}(__env) } -> same_as<bool>;
+ };
+
+ template <class _Sender, class... _Env>
+ concept __is_scheduler_affine = requires {
+ requires __is_scheduler_affine_t().operator()<env_of_t<_Sender>, _Env...>();
+ };
+
+ // The attributes of a sender adaptor that does not introduce asynchrony.
+ template <class _Sender>
+ struct __sync_attrs {
+ using __t = __sync_attrs;
+ using __id = __sync_attrs;
+
+ [[nodiscard]]
+ constexpr auto query(__is_scheduler_affine_t) const noexcept {
+ return __mbool<__is_scheduler_affine<_Sender>>();
+ }
+
+ template <class... _Env>
+ [[nodiscard]]
+ constexpr auto query(get_completion_behavior_t, const _Env&...) const noexcept {
+ return get_completion_behavior<_Sender, _Env...>();
+ }
+
+ template <__forwarding_query _Query, class... _Args>
+ requires __queryable_with<env_of_t<_Sender>, _Query, _Args...>
+ [[nodiscard]]
+ constexpr auto query(_Query, _Args&&... __args) const
+ noexcept(__nothrow_queryable_with<env_of_t<_Sender>, _Query, _Args...>)
+ -> __query_result_t<env_of_t<_Sender>, _Query, _Args...> {
+ return __query<_Query>()(get_env(__sndr_), static_cast<_Args&&>(__args)...);
+ }
+
+ const _Sender& __sndr_;
+ };
+
+ template <class _Sender>
+ STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __sync_attrs(const _Sender&) -> __sync_attrs<_Sender>;
+
} // namespace stdexec
STDEXEC_PRAGMA_POP()
diff --git a/include/sdbusplus/async/stdexec/__detail/__execute.hpp b/include/sdbusplus/async/stdexec/__detail/__execute.hpp
index cb62593..9a3f2d5 100644
--- a/include/sdbusplus/async/stdexec/__detail/__execute.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__execute.hpp
@@ -15,78 +15,40 @@
*/
#pragma once
-#include "__completion_signatures.hpp"
-#include "__concepts.hpp"
-#include "__cpo.hpp"
#include "__execution_fwd.hpp"
-#include "__meta.hpp"
+
+#include "__concepts.hpp"
#include "__receivers.hpp"
-#include "__schedulers.hpp"
#include "__senders.hpp"
-#include "__submit.hpp"
-#include "__tag_invoke.hpp"
+#include "__schedulers.hpp"
+#include "__start_detached.hpp"
+#include "__then.hpp"
#include "__transform_sender.hpp"
-#include "__type_traits.hpp"
-#include <exception>
-
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.execute]
-namespace __execute_
-{
-template <class _Fun>
-struct __as_receiver
-{
- using receiver_concept = receiver_t;
- _Fun __fun_;
-
- void set_value() noexcept
- {
- // terminates on exception:
- __fun_();
- }
-
- [[noreturn]] void set_error(std::exception_ptr) noexcept
- {
- std::terminate();
- }
-
- void set_stopped() noexcept {}
-};
-
-struct execute_t
-{
- template <scheduler _Scheduler, class _Fun>
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.execute]
+ namespace __execute_ {
+ struct execute_t {
+ template <scheduler _Scheduler, class _Fun>
requires __callable<_Fun&> && move_constructible<_Fun>
- void operator()(_Scheduler&& __sched, _Fun __fun) const noexcept(false)
- {
- // Look for a legacy customization
- if constexpr (tag_invocable<execute_t, _Scheduler, _Fun>)
- {
- tag_invoke(execute_t{}, static_cast<_Scheduler&&>(__sched),
- static_cast<_Fun&&>(__fun));
- }
- else
- {
- auto __domain = query_or(get_domain, __sched, default_domain());
- stdexec::apply_sender(__domain, *this,
- schedule(static_cast<_Scheduler&&>(__sched)),
- static_cast<_Fun&&>(__fun));
- }
- }
+ void operator()(_Scheduler&& __sched, _Fun __fun) const noexcept(false) {
+ auto __domain = query_or(get_domain, __sched, default_domain());
+ stdexec::apply_sender(
+ __domain,
+ *this,
+ schedule(static_cast<_Scheduler&&>(__sched)),
+ static_cast<_Fun&&>(__fun));
+ }
- template <sender_of<set_value_t()> _Sender, class _Fun>
+ template <sender_of<set_value_t()> _Sender, class _Fun>
requires __callable<_Fun&> && move_constructible<_Fun>
- void apply_sender(_Sender&& __sndr, _Fun __fun) const noexcept(false)
- {
- __submit(static_cast<_Sender&&>(__sndr),
- __as_receiver<_Fun>{static_cast<_Fun&&>(__fun)});
- }
-};
-} // namespace __execute_
+ void apply_sender(_Sender&& __sndr, _Fun __fun) const noexcept(false) {
+ start_detached(then(static_cast<_Sender&&>(__sndr), static_cast<_Fun&&>(__fun)));
+ }
+ };
+ } // namespace __execute_
-using __execute_::execute_t;
-inline constexpr execute_t execute{};
+ using __execute_::execute_t;
+ inline constexpr execute_t execute{};
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__execution_fwd.hpp b/include/sdbusplus/async/stdexec/__detail/__execution_fwd.hpp
index b5e58df..ddbc939 100644
--- a/include/sdbusplus/async/stdexec/__detail/__execution_fwd.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__execution_fwd.hpp
@@ -15,297 +15,296 @@
*/
#pragma once
-#include "__concepts.hpp"
-#include "__config.hpp"
+#include "__config.hpp" // IWYU pragma: export
#include "__meta.hpp"
+#include "__concepts.hpp"
#include "__type_traits.hpp"
-namespace stdexec
-{
-struct __none_such;
+// IWYU pragma: always_keep
-//////////////////////////////////////////////////////////////////////////////////////////////////
-struct default_domain;
+namespace stdexec {
+ struct __none_such;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __rcvrs
-{
-struct set_value_t;
-struct set_error_t;
-struct set_stopped_t;
-} // namespace __rcvrs
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ struct default_domain;
-using __rcvrs::set_error_t;
-using __rcvrs::set_stopped_t;
-using __rcvrs::set_value_t;
-extern const set_value_t set_value;
-extern const set_error_t set_error;
-extern const set_stopped_t set_stopped;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __rcvrs {
+ struct set_value_t;
+ struct set_error_t;
+ struct set_stopped_t;
+ } // namespace __rcvrs
-template <class _Tag>
-concept __completion_tag =
- __one_of<_Tag, set_value_t, set_error_t, set_stopped_t>;
+ using __rcvrs::set_value_t;
+ using __rcvrs::set_error_t;
+ using __rcvrs::set_stopped_t;
+ extern const set_value_t set_value;
+ extern const set_error_t set_error;
+ extern const set_stopped_t set_stopped;
-struct receiver_t;
+ template <class _Tag>
+ concept __completion_tag = __one_of<_Tag, set_value_t, set_error_t, set_stopped_t>;
-template <class _Sender>
-extern const bool enable_receiver;
+ struct receiver_t;
-namespace __env
-{
-template <class _Query, class _Value>
-struct prop;
+ template <class _Sender>
+ extern const bool enable_receiver;
-template <class... _Envs>
-struct env;
-} // namespace __env
+ namespace __env {
+ template <class _Query, class _Value>
+ struct prop;
-using __env::env;
-using __env::prop;
-using empty_env = env<>;
+ template <class _Query, auto _Value>
+ struct cprop;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __get_env
-{
-struct get_env_t;
-} // namespace __get_env
+ template <class... _Envs>
+ struct env;
+ } // namespace __env
-using __get_env::get_env_t;
-extern const get_env_t get_env;
+ using __env::prop;
+ using __env::cprop;
+ using __env::env;
+ using empty_env [[deprecated("stdexec::empty_env is now spelled stdexec::env<>")]] = env<>;
-template <class _EnvProvider>
-using env_of_t = __call_result_t<get_env_t, _EnvProvider>;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __get_env {
+ struct get_env_t;
+ } // namespace __get_env
-//////////////////////////////////////////////////////////////////////////////////////////////////
-enum class forward_progress_guarantee
-{
+ using __get_env::get_env_t;
+ extern const get_env_t get_env;
+
+ template <class _EnvProvider>
+ using env_of_t = __call_result_t<get_env_t, _EnvProvider>;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ enum class forward_progress_guarantee {
concurrent,
parallel,
weakly_parallel
-};
+ };
-namespace __queries
-{
-struct forwarding_query_t;
-struct execute_may_block_caller_t;
-struct get_forward_progress_guarantee_t;
-struct __has_algorithm_customizations_t;
-struct get_scheduler_t;
-struct get_delegation_scheduler_t;
-struct get_allocator_t;
-struct get_stop_token_t;
-template <__completion_tag _CPO>
-struct get_completion_scheduler_t;
-} // namespace __queries
+ namespace __queries {
+ struct forwarding_query_t;
+ struct execute_may_block_caller_t;
+ struct get_forward_progress_guarantee_t;
+ struct get_scheduler_t;
+ struct get_delegation_scheduler_t;
+ struct get_allocator_t;
+ struct get_stop_token_t;
+ template <__completion_tag _CPO>
+ struct get_completion_scheduler_t;
+ struct get_domain_t;
+ } // namespace __queries
-using __queries::__has_algorithm_customizations_t;
-using __queries::execute_may_block_caller_t;
-using __queries::forwarding_query_t;
-using __queries::get_allocator_t;
-using __queries::get_completion_scheduler_t;
-using __queries::get_delegation_scheduler_t;
-using __queries::get_forward_progress_guarantee_t;
-using __queries::get_scheduler_t;
-using __queries::get_stop_token_t;
+ using __queries::forwarding_query_t;
+ using __queries::execute_may_block_caller_t;
+ using __queries::get_forward_progress_guarantee_t;
+ using __queries::get_allocator_t;
+ using __queries::get_scheduler_t;
+ using __queries::get_delegation_scheduler_t;
+ using __queries::get_stop_token_t;
+ using __queries::get_completion_scheduler_t;
+ using __queries::get_domain_t;
-extern const forwarding_query_t forwarding_query;
-extern const execute_may_block_caller_t execute_may_block_caller;
-extern const __has_algorithm_customizations_t __has_algorithm_customizations;
-extern const get_forward_progress_guarantee_t get_forward_progress_guarantee;
-extern const get_scheduler_t get_scheduler;
-extern const get_delegation_scheduler_t get_delegation_scheduler;
-extern const get_allocator_t get_allocator;
-extern const get_stop_token_t get_stop_token;
-template <__completion_tag _CPO>
-extern const get_completion_scheduler_t<_CPO> get_completion_scheduler;
+ extern const forwarding_query_t forwarding_query;
+ extern const execute_may_block_caller_t execute_may_block_caller;
+ extern const get_forward_progress_guarantee_t get_forward_progress_guarantee;
+ extern const get_scheduler_t get_scheduler;
+ extern const get_delegation_scheduler_t get_delegation_scheduler;
+ extern const get_allocator_t get_allocator;
+ extern const get_stop_token_t get_stop_token;
+ template <__completion_tag _CPO>
+ extern const get_completion_scheduler_t<_CPO> get_completion_scheduler;
+ extern const get_domain_t get_domain;
-struct never_stop_token;
-class inplace_stop_source;
-class inplace_stop_token;
-template <class _Fn>
-class inplace_stop_callback;
+ struct never_stop_token;
+ class inplace_stop_source;
+ class inplace_stop_token;
+ template <class _Fn>
+ class inplace_stop_callback;
-template <class _Tp>
-using stop_token_of_t = __decay_t<__call_result_t<get_stop_token_t, _Tp>>;
+ template <class _Tp>
+ using stop_token_of_t = __decay_t<__call_result_t<get_stop_token_t, _Tp>>;
-template <class _Sender, class _CPO>
-concept __has_completion_scheduler =
+ template <class _Sender, class _CPO>
+ concept __has_completion_scheduler =
__callable<get_completion_scheduler_t<_CPO>, env_of_t<const _Sender&>>;
-template <class _Sender, class _CPO>
-using __completion_scheduler_for =
+ template <class _Sender, class _CPO>
+ using __completion_scheduler_for =
__call_result_t<get_completion_scheduler_t<_CPO>, env_of_t<const _Sender&>>;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __sigs
-{
-template <class _Sig>
-inline constexpr bool __is_compl_sig = false;
+ template <class _Env>
+ using __domain_of_t = __decay_t<__call_result_t<get_domain_t, _Env>>;
-struct get_completion_signatures_t;
-} // namespace __sigs
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __sigs {
+ template <class _Sig>
+ inline constexpr bool __is_compl_sig = false;
-template <class _Sig>
-concept __completion_signature = __sigs::__is_compl_sig<_Sig>;
+ struct get_completion_signatures_t;
+ } // namespace __sigs
-template <class... _Sigs>
-struct completion_signatures;
+ template <class _Sig>
+ concept __completion_signature = __sigs::__is_compl_sig<_Sig>;
-using __sigs::get_completion_signatures_t;
-extern const get_completion_signatures_t get_completion_signatures;
+ template <class... _Sigs>
+ struct completion_signatures;
-template <class _Sender, class... _Env>
-using __completion_signatures_of_t = //
+ using __sigs::get_completion_signatures_t;
+ extern const get_completion_signatures_t get_completion_signatures;
+
+ template <class _Sender, class... _Env>
+ using __completion_signatures_of_t =
__call_result_t<get_completion_signatures_t, _Sender, _Env...>;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __connect
-{
-struct connect_t;
-} // namespace __connect
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __connect {
+ struct connect_t;
+ } // namespace __connect
-using __connect::connect_t;
-extern const connect_t connect;
+ using __connect::connect_t;
+ extern const connect_t connect;
-template <class _Sender, class _Receiver>
-using connect_result_t = __call_result_t<connect_t, _Sender, _Receiver>;
+ template <class _Sender, class _Receiver>
+ concept __nothrow_connectable = __nothrow_callable<connect_t, _Sender, _Receiver>;
-template <class _Sender, class _Receiver>
-concept __nothrow_connectable =
- __nothrow_callable<connect_t, _Sender, _Receiver>;
+ struct sender_t;
-struct sender_t;
+ template <class _Sender>
+ extern const bool enable_sender;
-template <class _Sender>
-extern const bool enable_sender;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ struct operation_state_t;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __start
-{
-struct start_t;
-} // namespace __start
+ namespace __start {
+ struct start_t;
+ } // namespace __start
-using __start::start_t;
-extern const start_t start;
+ using __start::start_t;
+ extern const start_t start;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __sched
-{
-struct schedule_t;
-} // namespace __sched
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __sched {
+ struct schedule_t;
+ } // namespace __sched
-using __sched::schedule_t;
-extern const schedule_t schedule;
+ using __sched::schedule_t;
+ extern const schedule_t schedule;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __as_awaitable
-{
-struct as_awaitable_t;
-} // namespace __as_awaitable
+ struct scheduler_t;
-using __as_awaitable::as_awaitable_t;
-extern const as_awaitable_t as_awaitable;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __as_awaitable {
+ struct as_awaitable_t;
+ } // namespace __as_awaitable
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __starts_on_ns
-{
-struct starts_on_t;
-} // namespace __starts_on_ns
+ using __as_awaitable::as_awaitable_t;
+ extern const as_awaitable_t as_awaitable;
-using __starts_on_ns::starts_on_t;
-extern const starts_on_t starts_on;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ struct transform_sender_t;
+ extern const transform_sender_t transform_sender;
-using on_t [[deprecated("on_t has been renamed starts_on_t")]] = starts_on_t;
-[[deprecated("on has been renamed starts_on")]] extern const starts_on_t on;
+ template <class _Domain, class _Sender, class... _Env>
+ using transform_sender_result_t = __call_result_t<transform_sender_t, _Domain, _Sender, _Env...>;
-using start_on_t
- [[deprecated("start_on_t has been renamed starts_on_t")]] = starts_on_t;
-[[deprecated(
- "start_on has been renamed starts_on")]] extern const starts_on_t start_on;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __starts_on_ns {
+ struct starts_on_t;
+ } // namespace __starts_on_ns
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __continues_on
-{
-struct continues_on_t;
-} // namespace __continues_on
+ using __starts_on_ns::starts_on_t;
+ extern const starts_on_t starts_on;
-using __continues_on::continues_on_t;
-extern const continues_on_t continues_on;
+ using start_on_t [[deprecated("start_on_t has been renamed starts_on_t")]] = starts_on_t;
+ [[deprecated("start_on has been renamed starts_on")]]
+ extern const starts_on_t start_on;
-using transfer_t [[deprecated("transfer_t has been renamed continues_on_t")]] =
- continues_on_t;
-[[deprecated(
- "transfer has been renamed continues_on")]] extern const continues_on_t
- transfer;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __schfr {
+ struct schedule_from_t;
+ } // namespace __schfr
-using continue_t
- [[deprecated("continue_on_t has been renamed continues_on_t")]] =
- continues_on_t;
-[[deprecated(
- "continue_on has been renamed continues_on")]] extern const continues_on_t
- continue_on;
+ using __schfr::schedule_from_t;
+ extern const schedule_from_t schedule_from;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __transfer_just
-{
-struct transfer_just_t;
-} // namespace __transfer_just
+ namespace __continues_on {
+ struct continues_on_t;
+ } // namespace __continues_on
-using __transfer_just::transfer_just_t;
-extern const transfer_just_t transfer_just;
+ using __continues_on::continues_on_t;
+ extern const continues_on_t continues_on;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __bulk
-{
-struct bulk_t;
-} // namespace __bulk
+ using transfer_t [[deprecated("transfer_t has been renamed continues_on_t")]] = continues_on_t;
+ [[deprecated("transfer has been renamed continues_on")]]
+ extern const continues_on_t transfer;
-using __bulk::bulk_t;
-extern const bulk_t bulk;
+ using continue_t [[deprecated("continue_on_t has been renamed continues_on_t")]] = continues_on_t;
+ [[deprecated("continue_on has been renamed continues_on")]]
+ extern const continues_on_t continue_on;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __split
-{
-struct split_t;
-struct __split_t;
-} // namespace __split
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __transfer_just {
+ struct transfer_just_t;
+ } // namespace __transfer_just
-using __split::split_t;
-extern const split_t split;
+ using __transfer_just::transfer_just_t;
+ extern const transfer_just_t transfer_just;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __ensure_started
-{
-struct ensure_started_t;
-struct __ensure_started_t;
-} // namespace __ensure_started
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __bulk {
+ struct bulk_t;
+ struct bulk_chunked_t;
+ struct bulk_unchunked_t;
+ } // namespace __bulk
-using __ensure_started::ensure_started_t;
-extern const ensure_started_t ensure_started;
+ using __bulk::bulk_t;
+ using __bulk::bulk_chunked_t;
+ using __bulk::bulk_unchunked_t;
+ extern const bulk_t bulk;
+ extern const bulk_chunked_t bulk_chunked;
+ extern const bulk_unchunked_t bulk_unchunked;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-namespace __on_v2
-{
-struct on_t;
-} // namespace __on_v2
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __split {
+ struct split_t;
+ struct __split_t;
+ } // namespace __split
-namespace v2
-{
-using __on_v2::on_t;
-} // namespace v2
+ using __split::split_t;
+ extern const split_t split;
-namespace __detail
-{
-struct __sexpr_apply_t;
-} // namespace __detail
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __ensure_started {
+ struct ensure_started_t;
+ struct __ensure_started_t;
+ } // namespace __ensure_started
-using __detail::__sexpr_apply_t;
-extern const __sexpr_apply_t __sexpr_apply;
+ using __ensure_started::ensure_started_t;
+ extern const ensure_started_t ensure_started;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ namespace __on {
+ struct on_t;
+ } // namespace __on
+
+ using __on::on_t;
+ extern const on_t on;
+
+ namespace __detail {
+ struct __sexpr_apply_t;
+ } // namespace __detail
+
+ using __detail::__sexpr_apply_t;
+ extern const __sexpr_apply_t __sexpr_apply;
} // namespace stdexec
template <class...>
-[[deprecated]] void __print()
-{}
+[[deprecated]]
+void __print() {
+}
template <class...>
struct __undef;
diff --git a/include/sdbusplus/async/stdexec/__detail/__execution_legacy.hpp b/include/sdbusplus/async/stdexec/__detail/__execution_legacy.hpp
new file mode 100644
index 0000000..4e42725
--- /dev/null
+++ b/include/sdbusplus/async/stdexec/__detail/__execution_legacy.hpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2025 Lucian Radu Teodorescu
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "__config.hpp"
+
+#if STDEXEC_HAS_EXECUTION_POLICY()
+# include <execution>
+#endif
+
+namespace stdexec {
+
+#if STDEXEC_HAS_EXECUTION_POLICY()
+
+ using sequenced_policy = std::execution::sequenced_policy;
+ using parallel_policy = std::execution::parallel_policy;
+ using parallel_unsequenced_policy = std::execution::parallel_unsequenced_policy;
+
+ constexpr auto seq = std::execution::seq;
+ constexpr auto par = std::execution::par;
+ constexpr auto par_unseq = std::execution::par_unseq;
+
+ using std::is_execution_policy_v;
+ using std::is_execution_policy;
+
+#else
+
+ struct __hidden_construction { };
+
+ struct sequenced_policy {
+ constexpr explicit sequenced_policy(__hidden_construction) { };
+ sequenced_policy(const sequenced_policy&) = delete;
+ sequenced_policy& operator=(const sequenced_policy&) = delete;
+ };
+
+ struct parallel_policy {
+ constexpr explicit parallel_policy(__hidden_construction) { };
+ parallel_policy(const parallel_policy&) = delete;
+ parallel_policy& operator=(const parallel_policy&) = delete;
+ };
+
+ struct parallel_unsequenced_policy {
+ constexpr explicit parallel_unsequenced_policy(__hidden_construction) { };
+ parallel_unsequenced_policy(const parallel_unsequenced_policy&) = delete;
+ parallel_unsequenced_policy& operator=(const parallel_unsequenced_policy&) = delete;
+ };
+
+ inline constexpr sequenced_policy seq{__hidden_construction{}};
+ inline constexpr parallel_policy par{__hidden_construction{}};
+ inline constexpr parallel_unsequenced_policy par_unseq{__hidden_construction{}};
+
+ template <typename>
+ inline constexpr bool is_execution_policy_v = false;
+
+ template <>
+ inline constexpr bool is_execution_policy_v<sequenced_policy> = true;
+
+ template <>
+ inline constexpr bool is_execution_policy_v<parallel_policy> = true;
+
+ template <>
+ inline constexpr bool is_execution_policy_v<parallel_unsequenced_policy> = true;
+
+ template <class _T>
+ struct is_execution_policy : std::bool_constant<is_execution_policy_v<_T>> { };
+
+#endif
+
+#if STDEXEC_HAS_UNSEQUENCED_EXECUTION_POLICY()
+
+ using unsequenced_policy = std::execution::unsequenced_policy;
+
+ constexpr auto unseq = std::execution::unseq;
+
+#else
+
+# if STDEXEC_HAS_EXECUTION_POLICY()
+ // already defined above
+ struct __hidden_construction { };
+# endif
+
+ struct unsequenced_policy {
+ constexpr explicit unsequenced_policy(__hidden_construction) { };
+ unsequenced_policy(const unsequenced_policy&) = delete;
+ unsequenced_policy& operator=(const unsequenced_policy&) = delete;
+ };
+
+ inline constexpr unsequenced_policy unseq{__hidden_construction{}};
+
+ template <>
+ inline constexpr bool is_execution_policy_v<unsequenced_policy> = true;
+
+#endif
+
+} // namespace stdexec
\ No newline at end of file
diff --git a/include/sdbusplus/async/stdexec/__detail/__force_include.hpp b/include/sdbusplus/async/stdexec/__detail/__force_include.hpp
index 9a857f9..a0ed7ac 100644
--- a/include/sdbusplus/async/stdexec/__detail/__force_include.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__force_include.hpp
@@ -16,8 +16,8 @@
#if defined(__clang__) && defined(__CUDACC__)
-#ifdef __noinline__
-#undef __noinline__
-#endif
+# ifdef __noinline__
+# undef __noinline__
+# endif
#endif
diff --git a/include/sdbusplus/async/stdexec/__detail/__inline_scheduler.hpp b/include/sdbusplus/async/stdexec/__detail/__inline_scheduler.hpp
index e65a48b..28e6943 100644
--- a/include/sdbusplus/async/stdexec/__detail/__inline_scheduler.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__inline_scheduler.hpp
@@ -15,74 +15,75 @@
*/
#pragma once
-#include "__basic_sender.hpp"
-#include "__cpo.hpp"
-#include "__env.hpp"
#include "__execution_fwd.hpp"
+
+#include "__env.hpp"
#include "__receivers.hpp"
#include "__schedulers.hpp"
-#include "__utility.hpp"
-namespace stdexec
-{
-namespace __inln
-{
-struct __schedule_t
-{};
+namespace stdexec {
+ struct inline_scheduler {
+ private:
+ template <class _Receiver>
+ struct __opstate {
+ using __id = __opstate;
+ using __t = __opstate;
-struct __scheduler
-{
- using __t = __scheduler;
- using __id = __scheduler;
+ using operation_state_concept = operation_state_t;
- template <class _Tag = __schedule_t>
- STDEXEC_ATTRIBUTE((host, device))
- STDEXEC_MEMFN_DECL(auto schedule)(this __scheduler)
- {
- return __make_sexpr<_Tag>();
- }
+ STDEXEC_ATTRIBUTE(host, device)
+ constexpr void start() noexcept {
+ stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
+ }
- auto query(get_forward_progress_guarantee_t) const noexcept
- -> forward_progress_guarantee
- {
- return forward_progress_guarantee::weakly_parallel;
- }
-
- auto operator==(const __scheduler&) const noexcept -> bool = default;
-};
-
-struct __env
-{
- static constexpr bool query(__is_scheduler_affine_t) noexcept
- {
- return true;
- }
-
- constexpr auto query(get_completion_scheduler_t<set_value_t>) const noexcept
- -> __scheduler
- {
- return {};
- }
-};
-} // namespace __inln
-
-template <>
-struct __sexpr_impl<__inln::__schedule_t> : __sexpr_defaults
-{
- static constexpr auto get_attrs = //
- [](__ignore) noexcept { return __inln::__env(); };
-
- static constexpr auto get_completion_signatures = //
- [](__ignore,
- __ignore = {}) noexcept -> completion_signatures<set_value_t()> {
- return {};
+ _Receiver __rcvr_;
};
- static constexpr auto start = //
- []<class _Receiver>(__ignore, _Receiver& __rcvr) noexcept -> void {
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
- };
-};
+ struct __attrs {
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ static constexpr auto query(get_completion_behavior_t) noexcept {
+ return completion_behavior::inline_completion;
+ }
-static_assert(__is_scheduler_affine<schedule_result_t<__inln::__scheduler>>);
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ static constexpr auto query(get_completion_scheduler_t<set_value_t>) noexcept //
+ -> inline_scheduler {
+ return {};
+ }
+ };
+
+ struct __sender {
+ using __id = __sender;
+ using __t = __sender;
+
+ using sender_concept = sender_t;
+ using completion_signatures = stdexec::completion_signatures<set_value_t()>;
+
+ template <class _Receiver>
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ static constexpr auto connect(_Receiver __rcvr) noexcept -> __opstate<_Receiver> {
+ return {static_cast<_Receiver&&>(__rcvr)};
+ }
+
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ static constexpr auto get_env() noexcept -> __attrs {
+ return {};
+ }
+ };
+
+ public:
+ using __t = inline_scheduler;
+ using __id = inline_scheduler;
+
+ using scheduler_concept = scheduler_t;
+
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ static constexpr auto schedule() noexcept -> __sender {
+ return {};
+ }
+
+ auto operator==(const inline_scheduler&) const noexcept -> bool = default;
+ };
+
+ static_assert(__is_scheduler_affine<schedule_result_t<inline_scheduler>>);
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__into_variant.hpp b/include/sdbusplus/async/stdexec/__detail/__into_variant.hpp
index 0b1dcd5..8e99710 100644
--- a/include/sdbusplus/async/stdexec/__detail/__into_variant.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__into_variant.hpp
@@ -21,110 +21,94 @@
#include "__basic_sender.hpp"
#include "__concepts.hpp"
#include "__domain.hpp"
-#include "__env.hpp"
#include "__meta.hpp"
#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
+#include "__senders.hpp" // IWYU pragma: keep for __well_formed_sender
#include "__transform_completion_signatures.hpp"
#include "__transform_sender.hpp"
#include "__utility.hpp"
#include <exception>
#include <tuple>
-#include <variant>
+#include <variant> // IWYU pragma: keep
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.into_variant]
-namespace __into_variant
-{
-template <class _Sender, class _Env>
- requires sender_in<_Sender, _Env>
-using __into_variant_result_t = value_types_of_t<_Sender, _Env>;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.into_variant]
+ namespace __into_variant {
+ template <class _Sender, class _Env>
+ requires sender_in<_Sender, _Env>
+ using __into_variant_result_t = value_types_of_t<_Sender, _Env>;
-template <class _Sender, class... _Env>
-using __variant_t =
- __value_types_t<__completion_signatures_of_t<_Sender, _Env...>>;
+ template <class _Sender, class... _Env>
+ using __variant_t = __value_types_t<__completion_signatures_of_t<_Sender, _Env...>>;
-template <class _Variant>
-using __variant_completions =
- completion_signatures<set_value_t(_Variant),
- set_error_t(std::exception_ptr)>;
+ template <class _Variant>
+ using __variant_completions =
+ completion_signatures<set_value_t(_Variant), set_error_t(std::exception_ptr)>;
-template <class _Sender, class... _Env>
-using __completions = //
- transform_completion_signatures<
- __completion_signatures_of_t<_Sender, _Env...>,
- __meval<__variant_completions, __variant_t<_Sender, _Env...>>,
- __mconst<completion_signatures<>>::__f>;
+ template <class _Sender, class... _Env>
+ using __completions = transform_completion_signatures<
+ __completion_signatures_of_t<_Sender, _Env...>,
+ __meval<__variant_completions, __variant_t<_Sender, _Env...>>,
+ __mconst<completion_signatures<>>::__f
+ >;
-struct into_variant_t
-{
- template <sender _Sender>
- auto operator()(_Sender&& __sndr) const -> __well_formed_sender auto
- {
+ struct into_variant_t {
+ template <sender _Sender>
+ auto operator()(_Sender&& __sndr) const -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain,
- __make_sexpr<into_variant_t>(__(), static_cast<_Sender&&>(__sndr)));
- }
+ __domain, __make_sexpr<into_variant_t>(__(), static_cast<_Sender&&>(__sndr)));
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()() const noexcept -> __binder_back<into_variant_t>
- {
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()() const noexcept -> __binder_back<into_variant_t> {
return {{}, {}, {}};
- }
-};
-
-struct __into_variant_impl : __sexpr_defaults
-{
- static constexpr auto get_state = //
- []<class _Self, class _Receiver>(_Self&&, _Receiver&) noexcept {
- using __variant_t =
- value_types_of_t<__child_of<_Self>, env_of_t<_Receiver>>;
- return __mtype<__variant_t>();
- };
-
- static constexpr auto complete = //
- []<class _State, class _Receiver, class _Tag, class... _Args>(
- __ignore, _State, _Receiver& __rcvr, _Tag,
- _Args&&... __args) noexcept -> void {
- if constexpr (__same_as<_Tag, set_value_t>)
- {
- using __variant_t = __t<_State>;
- try
- {
- set_value(static_cast<_Receiver&&>(__rcvr),
- __variant_t{std::tuple<_Args&&...>{
- static_cast<_Args&&>(__args)...}});
- }
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- std::current_exception());
- }
- }
- else
- {
- _Tag()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
- }
+ }
};
- static constexpr auto get_completion_signatures = //
- []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept //
+ struct __into_variant_impl : __sexpr_defaults {
+ static constexpr auto get_state =
+ []<class _Self, class _Receiver>(_Self&&, _Receiver&) noexcept {
+ using __variant_t = value_types_of_t<__child_of<_Self>, env_of_t<_Receiver>>;
+ return __mtype<__variant_t>();
+ };
+
+ static constexpr auto complete =
+ []<class _State, class _Receiver, class _Tag, class... _Args>(
+ __ignore,
+ _State,
+ _Receiver& __rcvr,
+ _Tag,
+ _Args&&... __args) noexcept -> void {
+ if constexpr (__same_as<_Tag, set_value_t>) {
+ using __variant_t = __t<_State>;
+ STDEXEC_TRY {
+ set_value(
+ static_cast<_Receiver&&>(__rcvr),
+ __variant_t{std::tuple<_Args&&...>{static_cast<_Args&&>(__args)...}});
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
+ }
+ } else {
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
+ }
+ };
+
+ static constexpr auto get_completion_signatures =
+ []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept
-> __completions<__child_of<_Self>, _Env...> {
static_assert(sender_expr_for<_Self, into_variant_t>);
return {};
+ };
};
-};
-} // namespace __into_variant
+ } // namespace __into_variant
-using __into_variant::into_variant_t;
-inline constexpr into_variant_t into_variant{};
+ using __into_variant::into_variant_t;
+ inline constexpr into_variant_t into_variant{};
-template <>
-struct __sexpr_impl<into_variant_t> : __into_variant::__into_variant_impl
-{};
+ template <>
+ struct __sexpr_impl<into_variant_t> : __into_variant::__into_variant_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__intrusive_mpsc_queue.hpp b/include/sdbusplus/async/stdexec/__detail/__intrusive_mpsc_queue.hpp
index 2c5a020..6493bce 100644
--- a/include/sdbusplus/async/stdexec/__detail/__intrusive_mpsc_queue.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__intrusive_mpsc_queue.hpp
@@ -21,76 +21,62 @@
#pragma once
-#include <sdbusplus/async/stdexec/__spin_loop_pause.hpp>
#include <atomic>
-namespace stdexec
-{
-template <auto _Ptr>
-class __intrusive_mpsc_queue;
+#include <sdbusplus/async/stdexec/__spin_loop_pause.hpp>
-template <class _Node, std::atomic<void*> _Node::* _Next>
-class __intrusive_mpsc_queue<_Next>
-{
+namespace stdexec {
+ template <auto _Ptr>
+ class __intrusive_mpsc_queue;
+
+ template <class _Node, std::atomic<void*> _Node::* _Next>
+ class __intrusive_mpsc_queue<_Next> {
std::atomic<void*> __back_{&__nil_};
void* __front_{&__nil_};
std::atomic<_Node*> __nil_ = nullptr;
- void push_back_nil()
- {
- __nil_.store(nullptr, std::memory_order_relaxed);
- _Node* __prev = static_cast<_Node*>(
- __back_.exchange(&__nil_, std::memory_order_acq_rel));
- (__prev->*_Next).store(&__nil_, std::memory_order_release);
+ void push_back_nil() {
+ __nil_.store(nullptr, std::memory_order_relaxed);
+ auto* __prev = static_cast<_Node*>(__back_.exchange(&__nil_, std::memory_order_acq_rel));
+ (__prev->*_Next).store(&__nil_, std::memory_order_release);
}
- public:
- bool push_back(_Node* __new_node) noexcept
- {
- (__new_node->*_Next).store(nullptr, std::memory_order_relaxed);
- void* __prev_back =
- __back_.exchange(__new_node, std::memory_order_acq_rel);
- bool __is_nil = __prev_back == static_cast<void*>(&__nil_);
- if (__is_nil)
- {
- __nil_.store(__new_node, std::memory_order_release);
- }
- else
- {
- (static_cast<_Node*>(__prev_back)->*_Next)
- .store(__new_node, std::memory_order_release);
- }
- return __is_nil;
+ public:
+ auto push_back(_Node* __new_node) noexcept -> bool {
+ (__new_node->*_Next).store(nullptr, std::memory_order_relaxed);
+ void* __prev_back = __back_.exchange(__new_node, std::memory_order_acq_rel);
+ bool __is_nil = __prev_back == static_cast<void*>(&__nil_);
+ if (__is_nil) {
+ __nil_.store(__new_node, std::memory_order_release);
+ } else {
+ (static_cast<_Node*>(__prev_back)->*_Next).store(__new_node, std::memory_order_release);
+ }
+ return __is_nil;
}
- _Node* pop_front() noexcept
- {
- if (__front_ == static_cast<void*>(&__nil_))
- {
- _Node* __next = __nil_.load(std::memory_order_acquire);
- if (!__next)
- {
- return nullptr;
- }
- __front_ = __next;
+ auto pop_front() noexcept -> _Node* {
+ if (__front_ == static_cast<void*>(&__nil_)) {
+ _Node* __next = __nil_.load(std::memory_order_acquire);
+ if (!__next) {
+ return nullptr;
}
- _Node* __front = static_cast<_Node*>(__front_);
- void* __next = (__front->*_Next).load(std::memory_order_acquire);
- if (__next)
- {
- __front_ = __next;
- return __front;
- }
- STDEXEC_ASSERT(!__next);
- push_back_nil();
- do
- {
- __spin_loop_pause();
- __next = (__front->*_Next).load(std::memory_order_acquire);
- } while (!__next);
+ __front_ = __next;
+ }
+ auto* __front = static_cast<_Node*>(__front_);
+ void* __next = (__front->*_Next).load(std::memory_order_acquire);
+ if (__next) {
__front_ = __next;
return __front;
+ }
+ STDEXEC_ASSERT(!__next);
+ push_back_nil();
+ do {
+ __spin_loop_pause();
+ __next = (__front->*_Next).load(std::memory_order_acquire);
+ } while (!__next);
+ __front_ = __next;
+ return __front;
}
-};
-} // namespace stdexec
+ };
+} // namespace stdexec
\ No newline at end of file
diff --git a/include/sdbusplus/async/stdexec/__detail/__intrusive_ptr.hpp b/include/sdbusplus/async/stdexec/__detail/__intrusive_ptr.hpp
index 1a02dd2..622d70a 100644
--- a/include/sdbusplus/async/stdexec/__detail/__intrusive_ptr.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__intrusive_ptr.hpp
@@ -16,374 +16,315 @@
#pragma once
#include "__concepts.hpp"
-#include "__meta.hpp"
#include <atomic>
+#include <new> // IWYU pragma: keep for ::new
#include <cstddef>
-#include <memory>
-#include <new>
#include <type_traits>
+#include <utility>
#if STDEXEC_TSAN()
-#include <sanitizer/tsan_interface.h>
+# include <sanitizer/tsan_interface.h>
#endif
-namespace stdexec
-{
-namespace __ptr
-{
-template <std::size_t _ReservedBits>
-struct __count_and_bits
-{
- static constexpr std::size_t __ref_count_increment = 1ul << _ReservedBits;
+namespace stdexec {
+ namespace __ptr {
+ template <std::size_t _ReservedBits>
+ struct __count_and_bits {
+ static constexpr std::size_t __ref_count_increment = 1ul << _ReservedBits;
- enum struct __bits : std::size_t
- {
- };
+ enum struct __bits : std::size_t {
+ };
- friend constexpr std::size_t __count(__bits __b) noexcept
- {
+ friend constexpr auto __count(__bits __b) noexcept -> std::size_t {
return static_cast<std::size_t>(__b) / __ref_count_increment;
- }
+ }
- template <std::size_t _Bit>
- friend constexpr bool __bit(__bits __b) noexcept
- {
+ template <std::size_t _Bit>
+ friend constexpr auto __bit(__bits __b) noexcept -> bool {
static_assert(_Bit < _ReservedBits, "Bit index out of range");
return (static_cast<std::size_t>(__b) & (1ul << _Bit)) != 0;
- }
-};
+ }
+ };
-template <std::size_t _ReservedBits>
-using __bits_t = typename __count_and_bits<_ReservedBits>::__bits;
+ template <std::size_t _ReservedBits>
+ using __bits_t = __count_and_bits<_ReservedBits>::__bits;
-template <class _Ty, std::size_t _ReservedBits>
-struct __make_intrusive_t;
+ template <class _Ty, std::size_t _ReservedBits>
+ struct __make_intrusive_t;
-template <class _Ty, std::size_t _ReservedBits = 0ul>
-class __intrusive_ptr;
+ template <class _Ty, std::size_t _ReservedBits = 0ul>
+ class __intrusive_ptr;
-template <class _Ty, std::size_t _ReservedBits = 0ul>
-struct __enable_intrusive_from_this
-{
- auto __intrusive_from_this() noexcept
- -> __intrusive_ptr<_Ty, _ReservedBits>;
- auto __intrusive_from_this() const noexcept
- -> __intrusive_ptr<const _Ty, _ReservedBits>;
+ template <class _Ty, std::size_t _ReservedBits = 0ul>
+ struct __enable_intrusive_from_this {
+ auto __intrusive_from_this() noexcept -> __intrusive_ptr<_Ty, _ReservedBits>;
+ auto __intrusive_from_this() const noexcept -> __intrusive_ptr<const _Ty, _ReservedBits>;
+ private:
+ using __bits_t = __count_and_bits<_ReservedBits>::__bits;
+ friend _Ty;
+ auto __inc_ref() noexcept -> __bits_t;
+ auto __dec_ref() noexcept -> __bits_t;
- private:
- using __bits_t = typename __count_and_bits<_ReservedBits>::__bits;
- friend _Ty;
- __bits_t __inc_ref() noexcept;
- __bits_t __dec_ref() noexcept;
+ template <std::size_t _Bit>
+ [[nodiscard]]
+ auto __is_set() const noexcept -> bool;
+ template <std::size_t _Bit>
+ auto __set_bit() noexcept -> __bits_t;
+ template <std::size_t _Bit>
+ auto __clear_bit() noexcept -> __bits_t;
+ };
- template <std::size_t _Bit>
- bool __is_set() const noexcept;
- template <std::size_t _Bit>
- __bits_t __set_bit() noexcept;
- template <std::size_t _Bit>
- __bits_t __clear_bit() noexcept;
-};
+ STDEXEC_PRAGMA_PUSH()
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wtsan")
-STDEXEC_PRAGMA_PUSH()
-STDEXEC_PRAGMA_IGNORE_GNU("-Wtsan")
+ template <class _Ty, std::size_t _ReservedBits>
+ struct __control_block {
+ using __bits_t = __count_and_bits<_ReservedBits>::__bits;
+ static constexpr std::size_t __ref_count_increment = 1ul << _ReservedBits;
-template <class _Ty, std::size_t _ReservedBits>
-struct __control_block
-{
- using __bits_t = typename __count_and_bits<_ReservedBits>::__bits;
- static constexpr std::size_t __ref_count_increment = 1ul << _ReservedBits;
+ alignas(_Ty) unsigned char __value_[sizeof(_Ty)];
+ std::atomic<std::size_t> __ref_count_;
- alignas(_Ty) unsigned char __value_[sizeof(_Ty)];
- std::atomic<std::size_t> __ref_count_;
-
- template <class... _Us>
- explicit __control_block(_Us&&... __us) noexcept(noexcept(_Ty{
- __declval<_Us>()...})) : __ref_count_(__ref_count_increment)
- {
- // Construct the value *after* the initialization of the atomic in case
- // the constructor of _Ty calls __intrusive_from_this() (which
- // increments the ref count):
+ template <class... _Us>
+ explicit __control_block(_Us&&... __us) noexcept(noexcept(_Ty{__declval<_Us>()...}))
+ : __ref_count_(__ref_count_increment) {
+ // Construct the value *after* the initialization of the atomic in case the constructor of
+ // _Ty calls __intrusive_from_this() (which increments the ref count):
::new (static_cast<void*>(__value_)) _Ty{static_cast<_Us&&>(__us)...};
- }
+ }
- ~__control_block()
- {
+ ~__control_block() {
__value().~_Ty();
- }
+ }
- auto __value() noexcept -> _Ty&
- {
+ auto __value() noexcept -> _Ty& {
return *reinterpret_cast<_Ty*>(__value_);
- }
+ }
- __bits_t __inc_ref_() noexcept
- {
- auto __old = __ref_count_.fetch_add(__ref_count_increment,
- std::memory_order_relaxed);
+ auto __inc_ref_() noexcept -> __bits_t {
+ auto __old = __ref_count_.fetch_add(__ref_count_increment, std::memory_order_relaxed);
return static_cast<__bits_t>(__old);
- }
+ }
- __bits_t __dec_ref_() noexcept
- {
- auto __old = __ref_count_.fetch_sub(__ref_count_increment,
- std::memory_order_acq_rel);
- if (__count(static_cast<__bits_t>(__old)) == 1)
- {
- delete this;
+ auto __dec_ref_() noexcept -> __bits_t {
+ auto __old = __ref_count_.fetch_sub(__ref_count_increment, std::memory_order_acq_rel);
+ if (__count(static_cast<__bits_t>(__old)) == 1) {
+ delete this;
}
return static_cast<__bits_t>(__old);
- }
+ }
- // Returns true if the bit was set, false if it was already set.
- template <std::size_t _Bit>
- [[nodiscard]] bool __is_set_() const noexcept
- {
+ // Returns true if the bit was set, false if it was already set.
+ template <std::size_t _Bit>
+ [[nodiscard]]
+ auto __is_set_() const noexcept -> bool {
auto __old = __ref_count_.load(std::memory_order_relaxed);
return __bit<_Bit>(static_cast<__bits_t>(__old));
- }
+ }
- template <std::size_t _Bit>
- __bits_t __set_bit_() noexcept
- {
+ template <std::size_t _Bit>
+ auto __set_bit_() noexcept -> __bits_t {
static_assert(_Bit < _ReservedBits, "Bit index out of range");
constexpr std::size_t __mask = 1ul << _Bit;
auto __old = __ref_count_.fetch_or(__mask, std::memory_order_acq_rel);
return static_cast<__bits_t>(__old);
- }
+ }
- // Returns true if the bit was cleared, false if it was already cleared.
- template <std::size_t _Bit>
- __bits_t __clear_bit_() noexcept
- {
+ // Returns true if the bit was cleared, false if it was already cleared.
+ template <std::size_t _Bit>
+ auto __clear_bit_() noexcept -> __bits_t {
static_assert(_Bit < _ReservedBits, "Bit index out of range");
constexpr std::size_t __mask = 1ul << _Bit;
auto __old = __ref_count_.fetch_and(~__mask, std::memory_order_acq_rel);
return static_cast<__bits_t>(__old);
- }
-};
+ }
+ };
-STDEXEC_PRAGMA_POP()
+ STDEXEC_PRAGMA_POP()
-template <class _Ty, std::size_t _ReservedBits /* = 0ul */>
-class __intrusive_ptr
-{
- using _UncvTy = std::remove_cv_t<_Ty>;
- using __enable_intrusive_t =
- __enable_intrusive_from_this<_UncvTy, _ReservedBits>;
- friend _Ty;
- friend struct __make_intrusive_t<_Ty, _ReservedBits>;
- friend struct __enable_intrusive_from_this<_UncvTy, _ReservedBits>;
+ template <class _Ty, std::size_t _ReservedBits /* = 0ul */>
+ class __intrusive_ptr {
+ using _UncvTy = std::remove_cv_t<_Ty>;
+ using __enable_intrusive_t = __enable_intrusive_from_this<_UncvTy, _ReservedBits>;
+ friend _Ty;
+ friend struct __make_intrusive_t<_Ty, _ReservedBits>;
+ friend struct __enable_intrusive_from_this<_UncvTy, _ReservedBits>;
- __control_block<_UncvTy, _ReservedBits>* __data_{nullptr};
+ __control_block<_UncvTy, _ReservedBits>* __data_{nullptr};
- explicit __intrusive_ptr(
- __control_block<_UncvTy, _ReservedBits>* __data) noexcept :
- __data_(__data)
- {}
+ explicit __intrusive_ptr(__control_block<_UncvTy, _ReservedBits>* __data) noexcept
+ : __data_(__data) {
+ }
- void __inc_ref_() noexcept
- {
- if (__data_)
- {
- __data_->__inc_ref_();
+ void __inc_ref_() noexcept {
+ if (__data_) {
+ __data_->__inc_ref_();
}
- }
+ }
- void __dec_ref_() noexcept
- {
- if (__data_)
- {
- __data_->__dec_ref_();
+ void __dec_ref_() noexcept {
+ if (__data_) {
+ __data_->__dec_ref_();
}
- }
+ }
- // For use when types want to take over manual control of the reference
- // count. Very unsafe, but useful for implementing custom reference
- // counting.
- [[nodiscard]] __enable_intrusive_t* __release_() noexcept
- {
+ // For use when types want to take over manual control of the reference count.
+ // Very unsafe, but useful for implementing custom reference counting.
+ [[nodiscard]]
+ auto __release_() noexcept -> __enable_intrusive_t* {
auto* __data = std::exchange(__data_, nullptr);
- return __data ? &__c_upcast<__enable_intrusive_t>(__data->__value())
- : nullptr;
- }
+ return __data ? &__c_upcast<__enable_intrusive_t>(__data->__value()) : nullptr;
+ }
- public:
- using element_type = _Ty;
+ public:
+ using element_type = _Ty;
- __intrusive_ptr() = default;
+ __intrusive_ptr() = default;
- __intrusive_ptr(__intrusive_ptr&& __that) noexcept :
- __data_(std::exchange(__that.__data_, nullptr))
- {}
+ __intrusive_ptr(__intrusive_ptr&& __that) noexcept
+ : __data_(std::exchange(__that.__data_, nullptr)) {
+ }
- __intrusive_ptr(const __intrusive_ptr& __that) noexcept :
- __data_(__that.__data_)
- {
+ __intrusive_ptr(const __intrusive_ptr& __that) noexcept
+ : __data_(__that.__data_) {
__inc_ref_();
- }
+ }
- __intrusive_ptr(
- __enable_intrusive_from_this<_Ty, _ReservedBits>* __that) noexcept :
- __intrusive_ptr(
- __that ? __that->__intrusive_from_this() : __intrusive_ptr())
- {}
+ __intrusive_ptr(__enable_intrusive_from_this<_Ty, _ReservedBits>* __that) noexcept
+ : __intrusive_ptr(__that ? __that->__intrusive_from_this() : __intrusive_ptr()) {
+ }
- auto operator=(__intrusive_ptr&& __that) noexcept -> __intrusive_ptr&
- {
- [[maybe_unused]] __intrusive_ptr __old{
- std::exchange(__data_, std::exchange(__that.__data_, nullptr))};
+ auto operator=(__intrusive_ptr&& __that) noexcept -> __intrusive_ptr& {
+ [[maybe_unused]]
+ __intrusive_ptr __old{std::exchange(__data_, std::exchange(__that.__data_, nullptr))};
return *this;
- }
+ }
- auto operator=(const __intrusive_ptr& __that) noexcept -> __intrusive_ptr&
- {
+ auto operator=(const __intrusive_ptr& __that) noexcept -> __intrusive_ptr& {
return operator=(__intrusive_ptr(__that));
- }
+ }
- auto operator=(
- __enable_intrusive_from_this<_Ty, _ReservedBits>* __that) noexcept
- -> __intrusive_ptr&
- {
- return operator=(
- __that ? __that->__intrusive_from_this() : __intrusive_ptr());
- }
+ auto operator=(__enable_intrusive_from_this<_Ty, _ReservedBits>* __that) noexcept
+ -> __intrusive_ptr& {
+ return operator=(__that ? __that->__intrusive_from_this() : __intrusive_ptr());
+ }
- ~__intrusive_ptr()
- {
+ ~__intrusive_ptr() {
__dec_ref_();
- }
+ }
- void reset() noexcept
- {
+ void reset() noexcept {
operator=({});
- }
+ }
- void swap(__intrusive_ptr& __that) noexcept
- {
+ void swap(__intrusive_ptr& __that) noexcept {
std::swap(__data_, __that.__data_);
- }
+ }
- auto get() const noexcept -> _Ty*
- {
+ auto get() const noexcept -> _Ty* {
return &__data_->__value();
- }
+ }
- auto operator->() const noexcept -> _Ty*
- {
+ auto operator->() const noexcept -> _Ty* {
return &__data_->__value();
- }
+ }
- auto operator*() const noexcept -> _Ty&
- {
+ auto operator*() const noexcept -> _Ty& {
return __data_->__value();
- }
+ }
- explicit operator bool() const noexcept
- {
+ explicit operator bool() const noexcept {
return __data_ != nullptr;
- }
+ }
- auto operator!() const noexcept -> bool
- {
+ auto operator!() const noexcept -> bool {
return __data_ == nullptr;
- }
+ }
- auto operator==(const __intrusive_ptr&) const -> bool = default;
+ auto operator==(const __intrusive_ptr&) const -> bool = default;
- auto operator==(std::nullptr_t) const noexcept -> bool
- {
+ auto operator==(std::nullptr_t) const noexcept -> bool {
return __data_ == nullptr;
+ }
+ };
+
+ template <class _Ty, std::size_t _ReservedBits>
+ auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__intrusive_from_this() noexcept
+ -> __intrusive_ptr<_Ty, _ReservedBits> {
+ auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
+ &__c_downcast<_Ty>(*this));
+ __data->__inc_ref_();
+ return __intrusive_ptr<_Ty, _ReservedBits>{__data};
}
-};
-template <class _Ty, std::size_t _ReservedBits>
-auto __enable_intrusive_from_this<
- _Ty, _ReservedBits>::__intrusive_from_this() noexcept
- -> __intrusive_ptr<_Ty, _ReservedBits>
-{
- auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
+ template <class _Ty, std::size_t _ReservedBits>
+ auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__intrusive_from_this() const noexcept
+ -> __intrusive_ptr<const _Ty, _ReservedBits> {
+ auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
&__c_downcast<_Ty>(*this));
- __data->__inc_ref_();
- return __intrusive_ptr<_Ty, _ReservedBits>{__data};
-}
+ __data->__inc_ref_();
+ return __intrusive_ptr<const _Ty, _ReservedBits>{__data};
+ }
-template <class _Ty, std::size_t _ReservedBits>
-auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__intrusive_from_this()
- const noexcept -> __intrusive_ptr<const _Ty, _ReservedBits>
-{
- auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
+ template <class _Ty, std::size_t _ReservedBits>
+ auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__inc_ref() noexcept
+ -> __ptr::__bits_t<_ReservedBits> {
+ auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
&__c_downcast<_Ty>(*this));
- __data->__inc_ref_();
- return __intrusive_ptr<const _Ty, _ReservedBits>{__data};
-}
+ return __data->__inc_ref_();
+ }
-template <class _Ty, std::size_t _ReservedBits>
-__bits_t<_ReservedBits>
- __enable_intrusive_from_this<_Ty, _ReservedBits>::__inc_ref() noexcept
-{
- auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
+ template <class _Ty, std::size_t _ReservedBits>
+ auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__dec_ref() noexcept
+ -> __ptr::__bits_t<_ReservedBits> {
+
+ auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
&__c_downcast<_Ty>(*this));
- return __data->__inc_ref_();
-}
+ return __data->__dec_ref_();
+ }
-template <class _Ty, std::size_t _ReservedBits>
-__bits_t<_ReservedBits>
- __enable_intrusive_from_this<_Ty, _ReservedBits>::__dec_ref() noexcept
-{
- auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
+ template <class _Ty, std::size_t _ReservedBits>
+ template <std::size_t _Bit>
+ auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__is_set() const noexcept -> bool {
+ auto* __data = reinterpret_cast<const __control_block<_Ty, _ReservedBits>*>(
&__c_downcast<_Ty>(*this));
- return __data->__dec_ref_();
-}
+ return __data->template __is_set_<_Bit>();
+ }
-template <class _Ty, std::size_t _ReservedBits>
-template <std::size_t _Bit>
-bool __enable_intrusive_from_this<_Ty, _ReservedBits>::__is_set() const noexcept
-{
- auto* __data = reinterpret_cast<const __control_block<_Ty, _ReservedBits>*>(
+ template <class _Ty, std::size_t _ReservedBits>
+ template <std::size_t _Bit>
+ auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__set_bit() noexcept
+ -> __ptr::__bits_t<_ReservedBits> {
+ auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
&__c_downcast<_Ty>(*this));
- return __data->template __is_set_<_Bit>();
-}
+ return __data->template __set_bit_<_Bit>();
+ }
-template <class _Ty, std::size_t _ReservedBits>
-template <std::size_t _Bit>
-__bits_t<_ReservedBits>
- __enable_intrusive_from_this<_Ty, _ReservedBits>::__set_bit() noexcept
-{
- auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
+ template <class _Ty, std::size_t _ReservedBits>
+ template <std::size_t _Bit>
+ auto __enable_intrusive_from_this<_Ty, _ReservedBits>::__clear_bit() noexcept
+ -> __ptr::__bits_t<_ReservedBits> {
+ auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
&__c_downcast<_Ty>(*this));
- return __data->template __set_bit_<_Bit>();
-}
+ return __data->template __clear_bit_<_Bit>();
+ }
-template <class _Ty, std::size_t _ReservedBits>
-template <std::size_t _Bit>
-__bits_t<_ReservedBits>
- __enable_intrusive_from_this<_Ty, _ReservedBits>::__clear_bit() noexcept
-{
- auto* __data = reinterpret_cast<__control_block<_Ty, _ReservedBits>*>(
- &__c_downcast<_Ty>(*this));
- return __data->template __clear_bit_<_Bit>();
-}
-
-template <class _Ty, std::size_t _ReservedBits>
-struct __make_intrusive_t
-{
- template <class... _Us>
+ template <class _Ty, std::size_t _ReservedBits>
+ struct __make_intrusive_t {
+ template <class... _Us>
requires constructible_from<_Ty, _Us...>
- auto operator()(_Us&&... __us) const -> __intrusive_ptr<_Ty, _ReservedBits>
- {
+ auto operator()(_Us&&... __us) const -> __intrusive_ptr<_Ty, _ReservedBits> {
using _UncvTy = std::remove_cv_t<_Ty>;
return __intrusive_ptr<_Ty, _ReservedBits>{
- ::new __control_block<_UncvTy, _ReservedBits>{
- static_cast<_Us&&>(__us)...}};
- }
-};
-} // namespace __ptr
+ ::new __control_block<_UncvTy, _ReservedBits>{static_cast<_Us&&>(__us)...}};
+ }
+ };
+ } // namespace __ptr
-using __ptr::__enable_intrusive_from_this;
-using __ptr::__intrusive_ptr;
-template <class _Ty, std::size_t _ReservedBits = 0ul>
-inline constexpr __ptr::__make_intrusive_t<_Ty, _ReservedBits>
- __make_intrusive{};
+ using __ptr::__intrusive_ptr;
+ using __ptr::__enable_intrusive_from_this;
+ template <class _Ty, std::size_t _ReservedBits = 0ul>
+ inline constexpr __ptr::__make_intrusive_t<_Ty, _ReservedBits> __make_intrusive{};
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__intrusive_queue.hpp b/include/sdbusplus/async/stdexec/__detail/__intrusive_queue.hpp
index 9a98e33..7efcc81 100644
--- a/include/sdbusplus/async/stdexec/__detail/__intrusive_queue.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__intrusive_queue.hpp
@@ -18,163 +18,139 @@
#include "__config.hpp"
-#include <cassert>
#include <cstddef>
+#include <cassert>
#include <utility>
-namespace stdexec
-{
-namespace __queue
-{
-template <auto _Next>
-class __intrusive_queue;
+namespace stdexec {
+ namespace __queue {
+ template <auto _Next>
+ class __intrusive_queue;
-template <class _Item, _Item* _Item::* _Next>
-class __intrusive_queue<_Next>
-{
- public:
- __intrusive_queue() noexcept = default;
+ template <class _Item, _Item* _Item::* _Next>
+ class __intrusive_queue<_Next> {
+ public:
+ __intrusive_queue() noexcept = default;
- __intrusive_queue(__intrusive_queue&& __other) noexcept :
- __head_(std::exchange(__other.__head_, nullptr)),
- __tail_(std::exchange(__other.__tail_, nullptr))
- {}
+ __intrusive_queue(__intrusive_queue&& __other) noexcept
+ : __head_(std::exchange(__other.__head_, nullptr))
+ , __tail_(std::exchange(__other.__tail_, nullptr)) {
+ }
- __intrusive_queue(_Item* __head, _Item* __tail) noexcept :
- __head_(__head), __tail_(__tail)
- {}
+ __intrusive_queue(_Item* __head, _Item* __tail) noexcept
+ : __head_(__head)
+ , __tail_(__tail) {
+ }
- auto operator=(__intrusive_queue __other) noexcept -> __intrusive_queue&
- {
+ auto operator=(__intrusive_queue __other) noexcept -> __intrusive_queue& {
std::swap(__head_, __other.__head_);
std::swap(__tail_, __other.__tail_);
return *this;
- }
+ }
- ~__intrusive_queue()
- {
+ ~__intrusive_queue() {
STDEXEC_ASSERT(empty());
- }
+ }
- static auto make_reversed(_Item* __list) noexcept -> __intrusive_queue
- {
+ static auto make_reversed(_Item* __list) noexcept -> __intrusive_queue {
_Item* __new_head = nullptr;
_Item* __new_tail = __list;
- while (__list != nullptr)
- {
- _Item* __next = __list->*_Next;
- __list->*_Next = __new_head;
- __new_head = __list;
- __list = __next;
+ while (__list != nullptr) {
+ _Item* __next = __list->*_Next;
+ __list->*_Next = __new_head;
+ __new_head = __list;
+ __list = __next;
}
__intrusive_queue __result;
__result.__head_ = __new_head;
__result.__tail_ = __new_tail;
return __result;
- }
+ }
- static auto make(_Item* __list) noexcept -> __intrusive_queue
- {
+ static auto make(_Item* __list) noexcept -> __intrusive_queue {
__intrusive_queue __result{};
__result.__head_ = __list;
__result.__tail_ = __list;
- if (__list == nullptr)
- {
- return __result;
+ if (__list == nullptr) {
+ return __result;
}
- while (__result.__tail_->*_Next != nullptr)
- {
- __result.__tail_ = __result.__tail_->*_Next;
+ while (__result.__tail_->*_Next != nullptr) {
+ __result.__tail_ = __result.__tail_->*_Next;
}
return __result;
- }
+ }
- [[nodiscard]] auto empty() const noexcept -> bool
- {
+ [[nodiscard]]
+ auto empty() const noexcept -> bool {
return __head_ == nullptr;
- }
+ }
- void clear() noexcept
- {
+ void clear() noexcept {
__head_ = nullptr;
__tail_ = nullptr;
- }
+ }
- [[nodiscard]] auto pop_front() noexcept -> _Item*
- {
+ [[nodiscard]]
+ auto pop_front() noexcept -> _Item* {
STDEXEC_ASSERT(!empty());
_Item* __item = std::exchange(__head_, __head_->*_Next);
// This should test if __head_ == nullptr, but due to a bug in
// nvc++'s optimization, `__head_` isn't assigned until later.
// Filed as NVBug#3952534.
- if (__item->*_Next == nullptr)
- {
- __tail_ = nullptr;
+ if (__item->*_Next == nullptr) {
+ __tail_ = nullptr;
}
return __item;
- }
+ }
- void push_front(_Item* __item) noexcept
- {
+ void push_front(_Item* __item) noexcept {
STDEXEC_ASSERT(__item != nullptr);
__item->*_Next = __head_;
__head_ = __item;
- if (__tail_ == nullptr)
- {
- __tail_ = __item;
+ if (__tail_ == nullptr) {
+ __tail_ = __item;
}
- }
+ }
- void push_back(_Item* __item) noexcept
- {
+ void push_back(_Item* __item) noexcept {
STDEXEC_ASSERT(__item != nullptr);
__item->*_Next = nullptr;
- if (__tail_ == nullptr)
- {
- __head_ = __item;
- }
- else
- {
- __tail_->*_Next = __item;
+ if (__tail_ == nullptr) {
+ __head_ = __item;
+ } else {
+ __tail_->*_Next = __item;
}
__tail_ = __item;
- }
+ }
- void append(__intrusive_queue __other) noexcept
- {
+ void append(__intrusive_queue __other) noexcept {
if (__other.empty())
- return;
+ return;
auto* __other_head = std::exchange(__other.__head_, nullptr);
- if (empty())
- {
- __head_ = __other_head;
- }
- else
- {
- __tail_->*_Next = __other_head;
+ if (empty()) {
+ __head_ = __other_head;
+ } else {
+ __tail_->*_Next = __other_head;
}
__tail_ = std::exchange(__other.__tail_, nullptr);
- }
+ }
- void prepend(__intrusive_queue __other) noexcept
- {
+ void prepend(__intrusive_queue __other) noexcept {
if (__other.empty())
- return;
+ return;
__other.__tail_->*_Next = __head_;
__head_ = __other.__head_;
- if (__tail_ == nullptr)
- {
- __tail_ = __other.__tail_;
+ if (__tail_ == nullptr) {
+ __tail_ = __other.__tail_;
}
__other.__tail_ = nullptr;
__other.__head_ = nullptr;
- }
+ }
- struct iterator
- {
+ struct iterator {
using difference_type = std::ptrdiff_t;
using value_type = _Item*;
@@ -183,107 +159,91 @@
iterator() noexcept = default;
- explicit iterator(_Item* __pred, _Item* __item) noexcept :
- __predecessor_(__pred), __item_(__item)
- {}
-
- [[nodiscard]] auto operator*() const noexcept -> _Item*
- {
- STDEXEC_ASSERT(__item_ != nullptr);
- return __item_;
+ explicit iterator(_Item* __pred, _Item* __item) noexcept
+ : __predecessor_(__pred)
+ , __item_(__item) {
}
- [[nodiscard]] auto operator->() const noexcept -> _Item**
- {
- STDEXEC_ASSERT(__item_ != nullptr);
- return &__item_;
+ [[nodiscard]]
+ auto operator*() const noexcept -> _Item* {
+ STDEXEC_ASSERT(__item_ != nullptr);
+ return __item_;
}
- auto operator++() noexcept -> iterator&
- {
- __predecessor_ = __item_;
- if (__item_)
- {
- __item_ = __item_->*_Next;
- }
- return *this;
+ [[nodiscard]]
+ auto operator->() const noexcept -> _Item** {
+ STDEXEC_ASSERT(__item_ != nullptr);
+ return &__item_;
}
- auto operator++(int) noexcept -> iterator
- {
- iterator __result = *this;
- ++*this;
- return __result;
+ auto operator++() noexcept -> iterator& {
+ __predecessor_ = __item_;
+ if (__item_) {
+ __item_ = __item_->*_Next;
+ }
+ return *this;
}
- friend auto operator==(const iterator&, const iterator&) noexcept
- -> bool = default;
- };
+ auto operator++(int) noexcept -> iterator {
+ iterator __result = *this;
+ ++*this;
+ return __result;
+ }
- [[nodiscard]] auto begin() const noexcept -> iterator
- {
+ friend auto operator==(const iterator&, const iterator&) noexcept -> bool = default;
+ };
+
+ [[nodiscard]]
+ auto begin() const noexcept -> iterator {
return iterator(nullptr, __head_);
- }
+ }
- [[nodiscard]] auto end() const noexcept -> iterator
- {
+ [[nodiscard]]
+ auto end() const noexcept -> iterator {
return iterator(__tail_, nullptr);
- }
+ }
- void splice(iterator pos, __intrusive_queue& other, iterator first,
- iterator last) noexcept
- {
- if (first == last)
- {
- return;
+ void splice(iterator pos, __intrusive_queue& other, iterator first, iterator last) noexcept {
+ if (first == last) {
+ return;
}
STDEXEC_ASSERT(first.__item_ != nullptr);
STDEXEC_ASSERT(last.__predecessor_ != nullptr);
- if (other.__head_ == first.__item_)
- {
- other.__head_ = last.__item_;
- if (other.__head_ == nullptr)
- {
- other.__tail_ = nullptr;
- }
+ if (other.__head_ == first.__item_) {
+ other.__head_ = last.__item_;
+ if (other.__head_ == nullptr) {
+ other.__tail_ = nullptr;
+ }
+ } else {
+ STDEXEC_ASSERT(first.__predecessor_ != nullptr);
+ first.__predecessor_->*_Next = last.__item_;
+ last.__predecessor_->*_Next = pos.__item_;
}
- else
- {
- STDEXEC_ASSERT(first.__predecessor_ != nullptr);
- first.__predecessor_->*_Next = last.__item_;
- last.__predecessor_->*_Next = pos.__item_;
- }
- if (empty())
- {
- __head_ = first.__item_;
+ if (empty()) {
+ __head_ = first.__item_;
+ __tail_ = last.__predecessor_;
+ } else {
+ pos.__predecessor_->*_Next = first.__item_;
+ if (pos.__item_ == nullptr) {
__tail_ = last.__predecessor_;
+ }
}
- else
- {
- pos.__predecessor_->*_Next = first.__item_;
- if (pos.__item_ == nullptr)
- {
- __tail_ = last.__predecessor_;
- }
- }
- }
+ }
- auto front() const noexcept -> _Item*
- {
+ auto front() const noexcept -> _Item* {
return __head_;
- }
+ }
- auto back() const noexcept -> _Item*
- {
+ auto back() const noexcept -> _Item* {
return __tail_;
- }
+ }
- private:
- _Item* __head_ = nullptr;
- _Item* __tail_ = nullptr;
-};
-} // namespace __queue
+ private:
+ _Item* __head_ = nullptr;
+ _Item* __tail_ = nullptr;
+ };
+ } // namespace __queue
-using __queue::__intrusive_queue;
+ using __queue::__intrusive_queue;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__intrusive_slist.hpp b/include/sdbusplus/async/stdexec/__detail/__intrusive_slist.hpp
index 45a3b24..43d2b58 100644
--- a/include/sdbusplus/async/stdexec/__detail/__intrusive_slist.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__intrusive_slist.hpp
@@ -17,90 +17,80 @@
#include "__config.hpp"
-#include <cassert>
#include <cstddef>
+#include <cassert>
#include <iterator>
#include <utility>
-namespace stdexec
-{
-namespace __slist
-{
-template <auto _Next>
-class __intrusive_slist;
+namespace stdexec {
+ namespace __slist {
+ template <auto _Next>
+ class __intrusive_slist;
-template <class _Item, _Item* _Item::* _Next>
-class __intrusive_slist<_Next>
-{
- public:
- __intrusive_slist() noexcept = default;
+ template <class _Item, _Item* _Item::* _Next>
+ class __intrusive_slist<_Next> {
+ public:
+ __intrusive_slist() noexcept = default;
- __intrusive_slist(__intrusive_slist&& __other) noexcept :
- __head_(std::exchange(__other.__head_, nullptr))
- {}
+ __intrusive_slist(__intrusive_slist&& __other) noexcept
+ : __head_(std::exchange(__other.__head_, nullptr)) {
+ }
- __intrusive_slist(_Item* __head) noexcept : __head_(__head) {}
+ __intrusive_slist(_Item* __head) noexcept
+ : __head_(__head) {
+ }
- auto swap(__intrusive_slist& __other) noexcept -> void
- {
+ auto swap(__intrusive_slist& __other) noexcept -> void {
std::swap(__head_, __other.__head_);
- }
+ }
- auto operator=(__intrusive_slist __other) noexcept -> __intrusive_slist&
- {
+ auto operator=(__intrusive_slist __other) noexcept -> __intrusive_slist& {
swap(__other);
return *this;
- }
+ }
- [[nodiscard]] auto empty() const noexcept -> bool
- {
+ [[nodiscard]]
+ auto empty() const noexcept -> bool {
return __head_ == nullptr;
- }
+ }
- auto front() const noexcept -> _Item*
- {
+ auto front() const noexcept -> _Item* {
return __head_;
- }
+ }
- void clear() noexcept
- {
+ void clear() noexcept {
__head_ = nullptr;
- }
+ }
- [[nodiscard]] auto pop_front() noexcept -> _Item*
- {
+ [[nodiscard]]
+ auto pop_front() noexcept -> _Item* {
STDEXEC_ASSERT(!empty());
return std::exchange(__head_, __head_->*_Next);
- }
+ }
- void push_front(_Item* __item) noexcept
- {
+ void push_front(_Item* __item) noexcept {
STDEXEC_ASSERT(__item != nullptr);
__item->*_Next = std::exchange(__head_, __item);
- }
+ }
- [[nodiscard]] _Item* remove(_Item* __item) noexcept
- {
+ [[nodiscard]]
+ auto remove(_Item* __item) noexcept -> _Item* {
STDEXEC_ASSERT(__item != nullptr);
- if (__head_ == __item)
- {
- return pop_front();
+ if (__head_ == __item) {
+ return pop_front();
}
- for (_Item* __current : *this)
- {
- if (__current->*_Next == __item)
- {
- __current->*_Next = __item->*_Next;
- return __item;
- }
+ for (_Item* __current: *this) {
+ if (__current->*_Next == __item) {
+ __current->*_Next = __item->*_Next;
+ return __item;
+ }
}
return nullptr;
- }
+ }
- struct iterator
- {
+ struct iterator {
using iterator_category = std::forward_iterator_tag;
using difference_type = std::ptrdiff_t;
using value_type = _Item*;
@@ -111,52 +101,52 @@
iterator() noexcept = default;
- explicit iterator(_Item* __item) noexcept : __item_(__item) {}
-
- [[nodiscard]] auto operator*() const noexcept -> _Item*
- {
- STDEXEC_ASSERT(__item_ != nullptr);
- return __item_;
+ explicit iterator(_Item* __item) noexcept
+ : __item_(__item) {
}
- [[nodiscard]] auto operator->() const noexcept -> _Item**
- {
- STDEXEC_ASSERT(__item_ != nullptr);
- return &__item_;
+ [[nodiscard]]
+ auto operator*() const noexcept -> _Item* {
+ STDEXEC_ASSERT(__item_ != nullptr);
+ return __item_;
}
- auto operator++() noexcept -> iterator&
- {
- STDEXEC_ASSERT(__item_ != nullptr);
- __item_ = __item_->*_Next;
- return *this;
+ [[nodiscard]]
+ auto operator->() const noexcept -> _Item** {
+ STDEXEC_ASSERT(__item_ != nullptr);
+ return &__item_;
}
- auto operator++(int) noexcept -> iterator
- {
- iterator __result = *this;
- ++*this;
- return __result;
+ auto operator++() noexcept -> iterator& {
+ STDEXEC_ASSERT(__item_ != nullptr);
+ __item_ = __item_->*_Next;
+ return *this;
+ }
+
+ auto operator++(int) noexcept -> iterator {
+ iterator __result = *this;
+ ++*this;
+ return __result;
}
auto operator==(const iterator&) const noexcept -> bool = default;
- };
+ };
- [[nodiscard]] auto begin() const noexcept -> iterator
- {
+ [[nodiscard]]
+ auto begin() const noexcept -> iterator {
return iterator(__head_);
- }
+ }
- [[nodiscard]] auto end() const noexcept -> iterator
- {
+ [[nodiscard]]
+ auto end() const noexcept -> iterator {
return iterator(nullptr);
- }
+ }
- private:
- _Item* __head_ = nullptr;
-};
-} // namespace __slist
+ private:
+ _Item* __head_ = nullptr;
+ };
+ } // namespace __slist
-using __slist::__intrusive_slist;
+ using __slist::__intrusive_slist;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__just.hpp b/include/sdbusplus/async/stdexec/__detail/__just.hpp
index 6b46e61..c1e93b4 100644
--- a/include/sdbusplus/async/stdexec/__detail/__just.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__just.hpp
@@ -15,9 +15,10 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__basic_sender.hpp"
#include "__completion_signatures.hpp"
-#include "__execution_fwd.hpp"
#include "__meta.hpp"
#include "__receivers.hpp"
#include "__type_traits.hpp"
@@ -25,95 +26,93 @@
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.factories]
-namespace __just
-{
-template <class _JustTag>
-struct __impl : __sexpr_defaults
-{
- using __tag_t = typename _JustTag::__tag_t;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.factories]
+ namespace __just {
+ template <class _JustTag>
+ struct __impl : __sexpr_defaults {
+ using __tag_t = _JustTag::__tag_t;
- static constexpr auto get_completion_signatures =
+ static constexpr auto get_attrs = [](__ignore) noexcept
+ -> cprop<get_completion_behavior_t, completion_behavior::inline_completion> {
+ return {};
+ };
+
+ static constexpr auto get_completion_signatures =
[]<class _Sender>(_Sender&&, auto&&...) noexcept {
- static_assert(sender_expr_for<_Sender, _JustTag>);
- return completion_signatures<
- __mapply<__qf<__tag_t>, __decay_t<__data_of<_Sender>>>>{};
+ static_assert(sender_expr_for<_Sender, _JustTag>);
+ return completion_signatures<__mapply<__qf<__tag_t>, __decay_t<__data_of<_Sender>>>>{};
};
- static constexpr auto start =
- []<class _State, class _Receiver>(_State& __state,
- _Receiver& __rcvr) noexcept -> void {
+ static constexpr auto start =
+ []<class _State, class _Receiver>(_State& __state, _Receiver& __rcvr) noexcept -> void {
__state.apply(
- [&]<class... _Ts>(_Ts&... __ts) noexcept {
- __tag_t()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Ts&&>(__ts)...);
- },
- __state);
+ [&]<class... _Ts>(_Ts&... __ts) noexcept {
+ __tag_t()(static_cast<_Receiver&&>(__rcvr), static_cast<_Ts&&>(__ts)...);
+ },
+ __state);
+ };
+
+ static constexpr auto submit =
+ []<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver __rcvr) noexcept -> void {
+ static_assert(sender_expr_for<_Sender, _JustTag>);
+ auto&& __state = get_state(static_cast<_Sender&&>(__sndr), __rcvr);
+ __state.apply(
+ [&]<class... _Ts>(_Ts&&... __ts) noexcept {
+ __tag_t()(static_cast<_Receiver&&>(__rcvr), static_cast<_Ts&&>(__ts)...);
+ },
+ static_cast<decltype(__state)>(__state));
+ };
};
-};
-struct just_t
-{
- using __tag_t = set_value_t;
+ struct just_t {
+ using __tag_t = set_value_t;
- template <__movable_value... _Ts>
- STDEXEC_ATTRIBUTE((host, device))
- auto operator()(_Ts&&... __ts) const
- noexcept((__nothrow_decay_copyable<_Ts> && ...))
- {
+ template <__movable_value... _Ts>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto operator()(_Ts&&... __ts) const noexcept((__nothrow_decay_copyable<_Ts> && ...)) {
return __make_sexpr<just_t>(__tuple{static_cast<_Ts&&>(__ts)...});
- }
-};
+ }
+ };
-struct just_error_t
-{
- using __tag_t = set_error_t;
+ struct just_error_t {
+ using __tag_t = set_error_t;
- template <__movable_value _Error>
- STDEXEC_ATTRIBUTE((host, device))
- auto operator()(_Error&& __err) const
- noexcept(__nothrow_decay_copyable<_Error>)
- {
- return __make_sexpr<just_error_t>(
- __tuple{static_cast<_Error&&>(__err)});
- }
-};
+ template <__movable_value _Error>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto operator()(_Error&& __err) const noexcept(__nothrow_decay_copyable<_Error>) {
+ return __make_sexpr<just_error_t>(__tuple{static_cast<_Error&&>(__err)});
+ }
+ };
-struct just_stopped_t
-{
- using __tag_t = set_stopped_t;
+ struct just_stopped_t {
+ using __tag_t = set_stopped_t;
- template <class _Tag = just_stopped_t>
- STDEXEC_ATTRIBUTE((host, device))
- auto operator()() const noexcept
- {
+ template <class _Tag = just_stopped_t>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto operator()() const noexcept {
return __make_sexpr<_Tag>(__tuple{});
- }
-};
-} // namespace __just
+ }
+ };
+ } // namespace __just
-using __just::just_error_t;
-using __just::just_stopped_t;
-using __just::just_t;
+ using __just::just_t;
+ using __just::just_error_t;
+ using __just::just_stopped_t;
-template <>
-struct __sexpr_impl<just_t> : __just::__impl<just_t>
-{};
+ template <>
+ struct __sexpr_impl<just_t> : __just::__impl<just_t> { };
-template <>
-struct __sexpr_impl<just_error_t> : __just::__impl<just_error_t>
-{};
+ template <>
+ struct __sexpr_impl<just_error_t> : __just::__impl<just_error_t> { };
-template <>
-struct __sexpr_impl<just_stopped_t> : __just::__impl<just_stopped_t>
-{};
+ template <>
+ struct __sexpr_impl<just_stopped_t> : __just::__impl<just_stopped_t> { };
-inline constexpr just_t just{};
-inline constexpr just_error_t just_error{};
-inline constexpr just_stopped_t just_stopped{};
+ inline constexpr just_t just{};
+ inline constexpr just_error_t just_error{};
+ inline constexpr just_stopped_t just_stopped{};
} // namespace stdexec
STDEXEC_PRAGMA_POP()
diff --git a/include/sdbusplus/async/stdexec/__detail/__let.hpp b/include/sdbusplus/async/stdexec/__detail/__let.hpp
index 8df4522..4ec7e38 100644
--- a/include/sdbusplus/async/stdexec/__detail/__let.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__let.hpp
@@ -22,627 +22,565 @@
#include "__diagnostics.hpp"
#include "__domain.hpp"
#include "__env.hpp"
-#include "__inline_scheduler.hpp"
#include "__meta.hpp"
-#include "__receiver_ref.hpp"
+#include "__any_receiver_ref.hpp" // IWYU pragma: keep for __any::__receiver_ref
+#include "__schedulers.hpp"
#include "__sender_adaptor_closure.hpp"
#include "__senders.hpp"
-#include "__tag_invoke.hpp"
-#include "__transform_completion_signatures.hpp"
+#include "__submit.hpp"
#include "__transform_sender.hpp"
+#include "__transform_completion_signatures.hpp"
#include "__variant.hpp"
#include <exception>
-namespace stdexec
-{
-//////////////////////////////////////////////////////////////////////////////
-// [exec.let]
-namespace __let
-{
-// A dummy scheduler that is used by the metaprogramming below when the input
-// sender doesn't have a completion scheduler.
-struct __unknown_scheduler
-{
- struct __env
- {
- static constexpr bool query(__is_scheduler_affine_t) noexcept
- {
- return true;
+namespace stdexec {
+ //////////////////////////////////////////////////////////////////////////////
+ // [exec.let]
+ namespace __let {
+ // A dummy scheduler that is used by the metaprogramming below when the input sender doesn't
+ // have a completion scheduler.
+ struct __unknown_scheduler {
+ struct __attrs {
+ static constexpr auto query(__is_scheduler_affine_t) noexcept -> bool {
+ return true;
}
- constexpr auto query(
- get_completion_scheduler_t<set_value_t>) const noexcept
- {
- return __unknown_scheduler{};
+ [[nodiscard]]
+ constexpr auto query(get_completion_scheduler_t<set_value_t>) const noexcept {
+ return __unknown_scheduler{};
}
- };
+ };
- struct __sender
- {
+ struct __sender {
using sender_concept = sender_t;
- constexpr auto get_env() const noexcept -> __env
- {
- return __env();
+ [[nodiscard]]
+ constexpr auto get_env() const noexcept -> __attrs {
+ return {};
}
+ };
+
+ [[nodiscard]]
+ auto schedule() const noexcept {
+ return __sender();
+ }
+
+ auto operator==(const __unknown_scheduler&) const noexcept -> bool = default;
};
- auto schedule() const noexcept
- {
- return __sender();
- }
+ inline constexpr auto __get_rcvr = [](auto& __op_state) noexcept -> decltype(auto) {
+ return (__op_state.__rcvr_);
+ };
- bool operator==(const __unknown_scheduler&) const noexcept = default;
-};
+ inline constexpr auto __get_env = [](auto& __op_state) noexcept -> decltype(auto) {
+ return __op_state.__state_.__get_env(__op_state.__rcvr_);
+ };
-inline constexpr auto __get_rcvr =
- [](auto& __op_state) noexcept -> decltype(auto) {
- return (__op_state.__rcvr_);
-};
+ template <class _Set, class _Domain = dependent_domain>
+ struct __let_t;
-inline constexpr auto __get_env =
- [](auto& __op_state) noexcept -> decltype(auto) {
- return __op_state.__state_.__get_env(__op_state.__rcvr_);
-};
+ template <class _Set>
+ inline constexpr __mstring __in_which_let_msg{"In stdexec::let_value(Sender, Function)..."};
-template <class _Set, class _Domain = dependent_domain>
-struct __let_t;
+ template <>
+ inline constexpr __mstring __in_which_let_msg<set_error_t>{
+ "In stdexec::let_error(Sender, Function)..."};
-template <class _Set>
-inline constexpr __mstring __in_which_let_msg{
- "In stdexec::let_value(Sender, Function)..."};
+ template <>
+ inline constexpr __mstring __in_which_let_msg<set_stopped_t>{
+ "In stdexec::let_stopped(Sender, Function)..."};
-template <>
-inline constexpr __mstring __in_which_let_msg<set_error_t>{
- "In stdexec::let_error(Sender, Function)..."};
+ template <class _Set>
+ using __on_not_callable = __callable_error<__in_which_let_msg<_Set>>;
-template <>
-inline constexpr __mstring __in_which_let_msg<set_stopped_t>{
- "In stdexec::let_stopped(Sender, Function)..."};
+ template <class _ReceiverId, class _SchedulerId>
+ struct __rcvr_sch {
+ using _Receiver = stdexec::__t<_ReceiverId>;
+ using _Scheduler = stdexec::__t<_SchedulerId>;
-template <class _Set>
-using __on_not_callable = __callable_error<__in_which_let_msg<_Set>>;
+ struct __t {
+ using receiver_concept = receiver_t;
+ using __id = __rcvr_sch;
+ _Receiver __rcvr_;
+ _Scheduler __sched_;
-template <class _Receiver, class _Scheduler>
-struct __receiver_with_sched
-{
- using receiver_concept = receiver_t;
- _Receiver __rcvr_;
- _Scheduler __sched_;
+ template <class... _As>
+ void set_value(_As&&... __as) noexcept {
+ stdexec::set_value(static_cast<_Receiver&&>(__rcvr_), static_cast<_As&&>(__as)...);
+ }
- template <class... _As>
- void set_value(_As&&... __as) noexcept
- {
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr_),
- static_cast<_As&&>(__as)...);
- }
+ template <class _Error>
+ void set_error(_Error&& __err) noexcept {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr_), static_cast<_Error&&>(__err));
+ }
- template <class _Error>
- void set_error(_Error&& __err) noexcept
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr_),
- static_cast<_Error&&>(__err));
- }
+ void set_stopped() noexcept {
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
+ }
- void set_stopped() noexcept
- {
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
- }
+ auto get_env() const noexcept {
+ return __env::__join(__sched_env{__sched_}, stdexec::get_env(__rcvr_));
+ }
+ };
+ };
- auto get_env() const noexcept
- {
- return __env::__join(
- prop{get_scheduler, __sched_},
- __env::__without(stdexec::get_env(__rcvr_), get_domain));
- }
-};
+ template <class _Receiver, class _Scheduler>
+ using __receiver_with_sched_t = __t<__rcvr_sch<__id<_Receiver>, __id<_Scheduler>>>;
-template <class _Receiver, class _Scheduler>
-__receiver_with_sched(_Receiver, _Scheduler)
- -> __receiver_with_sched<_Receiver, _Scheduler>;
+ // If the input sender knows its completion scheduler, make it the current scheduler
+ // in the environment seen by the result sender.
+ template <class _Scheduler, class _Env>
+ using __result_env_t = __if_c<
+ __is_scheduler_affine<schedule_result_t<_Scheduler>>,
+ _Env,
+ __join_env_t<__sched_env<_Scheduler>, _Env>
+ >;
-// If the input sender knows its completion scheduler, make it the current
-// scheduler in the environment seen by the result sender.
-template <class _Scheduler, class _Env>
-using __result_env_t =
- __if_c<__is_scheduler_affine<schedule_result_t<_Scheduler>>, _Env,
- __env::__join_t< //
- prop<get_scheduler_t, _Scheduler>,
- __env::__without_t<_Env, get_domain_t>>>;
-
-template <__mstring _Where, __mstring _What>
-struct _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_
-{};
+ template <__mstring _Where, __mstring _What>
+ struct _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_ { };
#if STDEXEC_EDG()
-template <class _Sender, class _Set, class... _Env>
-struct __bad_result_sender_
-{
- using __t = __mexception<
+ template <class _Sender, class _Set, class... _Env>
+ struct __bad_result_sender_ {
+ using __t = __mexception<
_FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_<
- __in_which_let_msg<_Set>,
- "The function must return a valid sender for the current environment"_mstr>,
- _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>...>;
-};
-template <class _Sender, class _Set, class... _Env>
-using __bad_result_sender = __t<__bad_result_sender_<_Sender, _Set, _Env...>>;
+ __in_which_let_msg<_Set>,
+ "The function must return a valid sender for the current environment"_mstr
+ >,
+ _WITH_SENDER_<_Sender>,
+ _WITH_ENVIRONMENT_<_Env>...
+ >;
+ };
+ template <class _Sender, class _Set, class... _Env>
+ using __bad_result_sender = __t<__bad_result_sender_<_Sender, _Set, _Env...>>;
#else
-template <class _Sender, class _Set, class... _Env>
-using __bad_result_sender = __mexception<
- _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_<
+ template <class _Sender, class _Set, class... _Env>
+ using __bad_result_sender = __mexception<
+ _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_<
__in_which_let_msg<_Set>,
- "The function must return a valid sender for the current environment"_mstr>,
- _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>...>;
+ "The function must return a valid sender for the current environment"_mstr
+ >,
+ _WITH_SENDER_<_Sender>,
+ _WITH_ENVIRONMENT_<_Env>...
+ >;
#endif
-template <class _Sender, class... _Env>
-concept __potentially_valid_sender_in =
- sender_in<_Sender, _Env...> || (sender<_Sender> && (sizeof...(_Env) == 0));
+ template <class _Sender, class... _Env>
+ concept __potentially_valid_sender_in = sender_in<_Sender, _Env...>
+ || (sender<_Sender> && (sizeof...(_Env) == 0));
-template <class _Set, class _Sender, class... _Env>
-using __ensure_sender = //
- __minvoke_if_c<__potentially_valid_sender_in<_Sender, _Env...>,
- __q<__midentity>,
- __mbind_back_q<__bad_result_sender, _Set, _Env...>, _Sender>;
+ template <class _Set, class _Sender, class... _Env>
+ using __ensure_sender = __minvoke_if_c<
+ __potentially_valid_sender_in<_Sender, _Env...>,
+ __q<__midentity>,
+ __mbind_back_q<__bad_result_sender, _Set, _Env...>,
+ _Sender
+ >;
-// A metafunction that computes the result sender type for a given set of
-// argument types
-template <class _Set, class _Fun, class _Sched, class... _Env>
-struct __result_sender_fn
-{
- template <class... _Args>
- using __f = //
- __meval<
- __ensure_sender, _Set,
- __mcall<__mtry_catch_q<__call_result_t, __on_not_callable<_Set>>,
- _Fun, __decay_t<_Args>&...>,
- __result_env_t<_Sched, _Env>...>;
-};
+ // A metafunction that computes the result sender type for a given set of argument types
+ template <class _Set, class _Fun, class _Sched, class... _Env>
+ struct __result_sender_fn {
+ template <class... _Args>
+ using __f = __meval<
+ __ensure_sender,
+ _Set,
+ __mcall<__mtry_catch_q<__call_result_t, __on_not_callable<_Set>>, _Fun, __decay_t<_Args>&...>,
+ __result_env_t<_Sched, _Env>...
+ >;
+ };
-// The receiver that gets connected to the result sender is the input receiver,
-// possibly augmented with the input sender's completion scheduler (which is
-// where the result sender will be started).
-template <class _Receiver, class _Scheduler>
-using __result_receiver_t =
- __if_c<__is_scheduler_affine<schedule_result_t<_Scheduler>>, _Receiver,
- __receiver_with_sched<_Receiver, _Scheduler>>;
+ // The receiver that gets connected to the result sender is the input receiver,
+ // possibly augmented with the input sender's completion scheduler (which is
+ // where the result sender will be started).
+ template <class _Receiver, class _Scheduler>
+ using __result_receiver_t = __if_c<
+ __is_scheduler_affine<schedule_result_t<_Scheduler>>,
+ _Receiver,
+ __receiver_with_sched_t<_Receiver, _Scheduler>
+ >;
-template <class _ResultSender, class _Scheduler, class... _Env>
-using __receiver_ref_t = //
- __meval<__any_::__receiver_ref,
- __completion_signatures_of_t<_ResultSender,
- __result_env_t<_Scheduler, _Env>...>,
- __result_env_t<_Scheduler, _Env>...>;
+ template <class _ResultSender, class _Scheduler, class... _Env>
+ using __receiver_ref_t = __meval<
+ __any_::__receiver_ref,
+ __completion_signatures_of_t<_ResultSender, __result_env_t<_Scheduler, _Env>...>,
+ __result_env_t<_Scheduler, _Env>...
+ >;
-template <class _ResultSender, class _Scheduler, class _Receiver>
-concept __needs_receiver_ref =
- __nothrow_connectable<
+ template <class _ResultSender, class _Scheduler, class _Receiver>
+ concept __needs_receiver_ref =
+ __nothrow_connectable<
_ResultSender,
- __receiver_ref_t<_ResultSender, _Scheduler, env_of_t<_Receiver>>> &&
- !__nothrow_connectable<_ResultSender,
- __result_receiver_t<_Receiver, _Scheduler>>;
+ __receiver_ref_t<_ResultSender, _Scheduler, env_of_t<_Receiver>>
+ >
+ && !__nothrow_connectable<_ResultSender, __result_receiver_t<_Receiver, _Scheduler>>;
-template <class _Sender, class _Receiver>
-using __nothrow_connectable_t =
- __mbool<__nothrow_connectable<_Sender, _Receiver>>;
+ template <class _Sender, class _Receiver>
+ using __nothrow_connectable_t = __mbool<__nothrow_connectable<_Sender, _Receiver>>;
-template <class _ResultSender, class _Scheduler, class... _Env>
-using __nothrow_connectable_receiver_ref_t =
- __meval<__nothrow_connectable_t, _ResultSender,
- __receiver_ref_t<_ResultSender, _Scheduler, _Env...>>;
+ template <class _ResultSender, class _Scheduler, class... _Env>
+ using __nothrow_connectable_receiver_ref_t = __meval<
+ __nothrow_connectable_t,
+ _ResultSender,
+ __receiver_ref_t<_ResultSender, _Scheduler, _Env...>
+ >;
-template <class _ResultSender, class _Scheduler, class _Receiver>
-using __checked_result_receiver_t = //
- __if_c<__needs_receiver_ref<_ResultSender, _Scheduler, _Receiver>,
- __receiver_ref_t<_ResultSender, _Scheduler, env_of_t<_Receiver>>,
- __result_receiver_t<_Receiver, _Scheduler>>;
+ template <class _ResultSender, class _Scheduler, class _Receiver>
+ using __checked_result_receiver_t = __if_c<
+ __needs_receiver_ref<_ResultSender, _Scheduler, _Receiver>,
+ __receiver_ref_t<_ResultSender, _Scheduler, env_of_t<_Receiver>>,
+ __result_receiver_t<_Receiver, _Scheduler>
+ >;
-template <class _ResultSender, class _Scheduler, class _Receiver>
-using __op_state_t = connect_result_t<
- _ResultSender,
- __checked_result_receiver_t<_ResultSender, _Scheduler, _Receiver>>;
+ template <class _ResultSender, class _Scheduler, class _Receiver>
+ using __submit_result = submit_result<
+ _ResultSender,
+ __checked_result_receiver_t<_ResultSender, _Scheduler, _Receiver>
+ >;
-template <class _SetTag, class _Fun, class _Sched, class... _Env>
-struct __transform_signal_fn
-{
- template <class... _Args>
- using __nothrow_connect =
- __mand<__mbool<(__nothrow_decay_copyable<_Args> && ...) &&
- __nothrow_callable<_Fun, _Args...>>,
- __nothrow_connectable_receiver_ref_t<
- __mcall<__result_sender_fn<_SetTag, _Fun, _Sched, _Env...>,
- _Args...>,
- _Sched, _Env...>>;
+ template <class _SetTag, class _Fun, class _Sched, class... _Env>
+ struct __transform_signal_fn {
+ template <class... _Args>
+ using __nothrow_connect = __mand<
+ __mbool<(__nothrow_decay_copyable<_Args> && ...) && __nothrow_callable<_Fun, _Args...>>,
+ __nothrow_connectable_receiver_ref_t<
+ __mcall<__result_sender_fn<_SetTag, _Fun, _Sched, _Env...>, _Args...>,
+ _Sched,
+ _Env...
+ >
+ >;
- template <class... _Args>
- using __f = //
- __mcall<__mtry_q<__concat_completion_signatures>,
- __completion_signatures_of_t<
- __mcall<__result_sender_fn<_SetTag, _Fun, _Sched, _Env...>,
- _Args...>,
- __result_env_t<_Sched, _Env>...>,
- __eptr_completion_if_t<__nothrow_connect<_Args...>>>;
-};
+ template <class... _Args>
+ using __f = __mcall<
+ __mtry_q<__concat_completion_signatures>,
+ __completion_signatures_of_t<
+ __mcall<__result_sender_fn<_SetTag, _Fun, _Sched, _Env...>, _Args...>,
+ __result_env_t<_Sched, _Env>...
+ >,
+ __eptr_completion_if_t<__nothrow_connect<_Args...>>
+ >;
+ };
-template <class _Sender, class _Set>
-using __completion_sched =
- __query_result_or_t<get_completion_scheduler_t<_Set>, env_of_t<_Sender>,
- __unknown_scheduler>;
+ template <class _Sender, class _Set>
+ using __completion_sched =
+ __query_result_or_t<get_completion_scheduler_t<_Set>, env_of_t<_Sender>, __unknown_scheduler>;
-template <class _LetTag, class _Fun, class _CvrefSender, class... _Env>
-using __completions = //
- __gather_completion_signatures<
- __completion_signatures_of_t<_CvrefSender, _Env...>, __t<_LetTag>,
- __transform_signal_fn<__t<_LetTag>, _Fun,
- __completion_sched<_CvrefSender, __t<_LetTag>>,
- _Env...>::template __f,
- __sigs::__default_completion,
- __mtry_q<__concat_completion_signatures>::__f>;
+ template <class _LetTag, class _Fun, class _CvrefSender, class... _Env>
+ using __completions = __gather_completion_signatures<
+ __completion_signatures_of_t<_CvrefSender, _Env...>,
+ __t<_LetTag>,
+ __transform_signal_fn<
+ __t<_LetTag>,
+ _Fun,
+ __completion_sched<_CvrefSender, __t<_LetTag>>,
+ _Env...
+ >::template __f,
+ __sigs::__default_completion,
+ __mtry_q<__concat_completion_signatures>::__f
+ >;
-template <__mstring _Where, __mstring _What>
-struct _NO_COMMON_DOMAIN_
-{};
+ template <__mstring _Where, __mstring _What>
+ struct _NO_COMMON_DOMAIN_ { };
-template <class _Set>
-using __no_common_domain_t = //
- _NO_COMMON_DOMAIN_<
- __in_which_let_msg<_Set>,
- "The senders returned by Function do not all share a common domain"_mstr>;
+ template <class _Set>
+ using __no_common_domain_t = _NO_COMMON_DOMAIN_<
+ __in_which_let_msg<_Set>,
+ "The senders returned by Function do not all share a common domain"_mstr
+ >;
-template <class _Set>
-struct __try_common_domain_fn
-{
- struct __error_fn
- {
+ template <class _Set, class _Sched>
+ struct __try_common_domain_fn {
+ struct __error_fn {
template <class... _Senders>
- using __f = __mexception<__no_common_domain_t<_Set>,
- _WITH_SENDERS_<_Senders...>>;
+ using __f = __mexception<__no_common_domain_t<_Set>, _WITH_SENDERS_<_Senders...>>;
+ };
+
+ // If a sender is "scheduler affine", then it will complete on the same execution
+ // context on which it was started (e.g., just(42)). In this case, the domain of the
+ // scheduler is the domain of the sender.
+ template <class... _Senders>
+ using __common_domain = __common_domain_t<
+ __if_c<__is_scheduler_affine<_Senders>, schedule_result_t<_Sched>, _Senders>...
+ >;
+
+ template <class... _Senders>
+ using __f = __mcall<__mtry_catch_q<__common_domain, __error_fn>, _Senders...>;
};
- template <class... _Senders>
- using __f = __mcall<__mtry_catch_q<__domain::__common_domain_t, __error_fn>,
- _Senders...>;
-};
+ // Compute all the domains of all the result senders and make sure they're all the same
+ template <class _Set, class _Child, class _Fun, class _Sched, class... _Env>
+ using __result_domain_t = __gather_completions<
+ _Set,
+ __completion_signatures_of_t<_Child, _Env...>,
+ __result_sender_fn<_Set, _Fun, _Sched, _Env...>,
+ __try_common_domain_fn<_Set, _Sched>
+ >;
-// Compute all the domains of all the result senders and make sure they're all
-// the same
-template <class _Set, class _Child, class _Fun, class _Env, class _Sched>
-using __result_domain_t = //
- __gather_completions<_Set, __completion_signatures_of_t<_Child, _Env>,
- __result_sender_fn<_Set, _Fun, _Sched, _Env>,
- __try_common_domain_fn<_Set>>;
-
-template <class _LetTag, class _Env>
-auto __mk_transform_env_fn(_Env&& __env) noexcept
-{
- using _Set = __t<_LetTag>;
- return [&]<class _Fun, class _Child>(__ignore, _Fun&&,
- _Child&& __child) -> decltype(auto) {
+ template <class _LetTag, class _Env>
+ auto __mk_transform_env_fn(_Env&& __env) noexcept {
+ using _Set = __t<_LetTag>;
+ return [&]<class _Fun, class _Child>(__ignore, _Fun&&, _Child&& __child) -> decltype(auto) {
using __completions_t = __completion_signatures_of_t<_Child, _Env>;
- if constexpr (__merror<__completions_t>)
- {
- return __completions_t();
- }
- else
- {
- using _Scheduler = __completion_sched<_Child, _Set>;
- if constexpr (__is_scheduler_affine<schedule_result_t<_Scheduler>>)
- {
- return (__env);
- }
- else
- {
- return __env::__join(
- prop{get_scheduler, get_completion_scheduler<_Set>(
- stdexec::get_env(__child))},
- __env::__without(static_cast<_Env&&>(__env), get_domain));
- }
- }
- };
-}
-
-template <class _LetTag, class _Env>
-auto __mk_transform_sender_fn(_Env&&) noexcept
-{
- using _Set = __t<_LetTag>;
-
- return []<class _Fun, class _Child>(__ignore, _Fun&& __fun,
- _Child&& __child) {
- using __completions_t = __completion_signatures_of_t<_Child, _Env>;
-
- if constexpr (__merror<__completions_t>)
- {
- return __completions_t();
- }
- else
- {
- using _Sched = __completion_sched<_Child, _Set>;
- using _Domain = __result_domain_t<_Set, _Child, _Fun, _Env, _Sched>;
-
- if constexpr (__merror<_Domain>)
- {
- return _Domain();
- }
- else if constexpr (same_as<_Domain, dependent_domain>)
- {
- using _Domain2 = __late_domain_of_t<_Child, _Env>;
- return __make_sexpr<__let_t<_Set, _Domain2>>(
- static_cast<_Fun&&>(__fun), static_cast<_Child&&>(__child));
- }
- else
- {
- static_assert(!same_as<_Domain, __unknown_scheduler>);
- return __make_sexpr<__let_t<_Set, _Domain>>(
- static_cast<_Fun&&>(__fun), static_cast<_Child&&>(__child));
- }
- }
- };
-}
-
-//! Metafunction creating the operation state needed to connect the result of
-//! calling the sender factory function, `_Fun`, and passing its result to a
-//! receiver.
-template <class _Receiver, class _Fun, class _Set, class _Sched>
-struct __op_state_for
-{
- template <class... _Args>
- using __f = __op_state_t<
- __mcall<__result_sender_fn<_Set, _Fun, _Sched, env_of_t<_Receiver>>,
- _Args...>,
- _Sched, _Receiver>;
-};
-
-//! The core of the operation state for `let_*`.
-//! This gets bundled up into a larger operation state
-//! (`__detail::__op_state<...>`).
-template <class _Receiver, class _Fun, class _Set, class _Sched,
- class... _Tuples>
-struct __let_state
-{
- using __fun_t = _Fun;
- using __sched_t = _Sched;
- using __env_t = __result_env_t<_Sched, env_of_t<_Receiver>>;
- using __result_variant = __variant_for<__monostate, _Tuples...>;
- using __op_state_variant = //
- __variant_for<__monostate,
- __mapply<__op_state_for<_Receiver, _Fun, _Set, _Sched>,
- _Tuples>...>;
-
- template <class _ResultSender, class _OpState>
- auto __get_result_receiver(const _ResultSender&, _OpState& __op_state)
- -> decltype(auto)
- {
- if constexpr (__needs_receiver_ref<_ResultSender, _Sched, _Receiver>)
- {
- using __receiver_ref =
- __receiver_ref_t<_ResultSender, _Sched, env_of_t<_Receiver>>;
- return __receiver_ref{__op_state, __let::__get_env,
- __let::__get_rcvr};
- }
- else
- {
- _Receiver& __rcvr = __op_state.__rcvr_;
- if constexpr (__is_scheduler_affine<schedule_result_t<_Sched>>)
- {
- return static_cast<_Receiver&&>(__rcvr);
- }
- else
- {
- return __receiver_with_sched{static_cast<_Receiver&&>(__rcvr),
- this->__sched_};
- }
- }
- }
-
- auto __get_env(const _Receiver& __rcvr) const noexcept -> __env_t
- {
- if constexpr (__is_scheduler_affine<schedule_result_t<_Sched>>)
- {
- return stdexec::get_env(__rcvr);
- }
- else
- {
+ if constexpr (__merror<__completions_t>) {
+ return __completions_t();
+ } else {
+ using _Scheduler = __completion_sched<_Child, _Set>;
+ if constexpr (__is_scheduler_affine<schedule_result_t<_Scheduler>>) {
+ return (__env);
+ } else {
return __env::__join(
- prop{get_scheduler, __sched_},
- __env::__without(stdexec::get_env(__rcvr), get_domain));
+ __sched_env{get_completion_scheduler<_Set>(stdexec::get_env(__child))},
+ static_cast<_Env&&>(__env));
+ }
}
+ };
}
- STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
- _Fun __fun_;
- STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
- _Sched __sched_;
- //! Variant to hold the results passed from upstream before passing them to
- //! the function:
- __result_variant __args_{};
- //! Variant type for holding the operation state from connecting
- //! the function result to the downstream receiver:
- __op_state_variant __op_state3_{};
-};
+ template <class _LetTag, class _Env>
+ auto __mk_transform_sender_fn(_Env&&) noexcept {
+ using _Set = __t<_LetTag>;
-//! Implementation of the `let_*_t` types, where `_Set` is, e.g., `set_value_t`
-//! for `let_value`.
-template <class _Set, class _Domain>
-struct __let_t
-{
- using __domain_t = _Domain;
- using __t = _Set;
+ return []<class _Fun, class _Child>(__ignore, _Fun&& __fun, _Child&& __child) {
+ using __completions_t = __completion_signatures_of_t<_Child, _Env>;
- template <sender _Sender, __movable_value _Fun>
- auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender
- auto
- {
+ if constexpr (__merror<__completions_t>) {
+ return __completions_t();
+ } else {
+ using _Sched = __completion_sched<_Child, _Set>;
+ using _Domain = __result_domain_t<_Set, _Child, _Fun, _Sched, _Env>;
+
+ if constexpr (__merror<_Domain>) {
+ return _Domain();
+ } else if constexpr (same_as<_Domain, dependent_domain>) {
+ using _Domain2 = __late_domain_of_t<_Child, _Env>;
+ return __make_sexpr<__let_t<_Set, _Domain2>>(
+ static_cast<_Fun&&>(__fun), static_cast<_Child&&>(__child));
+ } else {
+ static_assert(!same_as<_Domain, __unknown_scheduler>);
+ return __make_sexpr<__let_t<_Set, _Domain>>(
+ static_cast<_Fun&&>(__fun), static_cast<_Child&&>(__child));
+ }
+ }
+ };
+ }
+
+ //! Metafunction creating the operation state needed to connect the result of calling
+ //! the sender factory function, `_Fun`, and passing its result to a receiver.
+ template <class _Receiver, class _Fun, class _Set, class _Sched>
+ struct __submit_datum_for {
+ // compute the result of calling submit with the result of executing _Fun
+ // with _Args. if the result is void, substitute with __ignore.
+ template <class... _Args>
+ using __f = __submit_result<
+ __mcall<__result_sender_fn<_Set, _Fun, _Sched, env_of_t<_Receiver>>, _Args...>,
+ _Sched,
+ _Receiver
+ >;
+ };
+
+ //! The core of the operation state for `let_*`.
+ //! This gets bundled up into a larger operation state (`__detail::__op_state<...>`).
+ template <class _Receiver, class _Fun, class _Set, class _Sched, class... _Tuples>
+ struct __let_state {
+ using __fun_t = _Fun;
+ using __sched_t = _Sched;
+ using __env_t = __result_env_t<_Sched, env_of_t<_Receiver>>;
+ using __rcvr_t = __receiver_with_sched_t<_Receiver, _Sched>;
+ using __result_variant = __variant_for<__monostate, _Tuples...>;
+ using __submit_variant = __variant_for<
+ __monostate,
+ __mapply<__submit_datum_for<_Receiver, _Fun, _Set, _Sched>, _Tuples>...
+ >;
+
+ template <class _ResultSender, class _OpState>
+ auto __get_result_receiver(const _ResultSender&, _OpState& __op_state) -> decltype(auto) {
+ if constexpr (__needs_receiver_ref<_ResultSender, _Sched, _Receiver>) {
+ using __receiver_ref = __receiver_ref_t<_ResultSender, _Sched, env_of_t<_Receiver>>;
+ return __receiver_ref{__op_state, __let::__get_env, __let::__get_rcvr};
+ } else {
+ _Receiver& __rcvr = __op_state.__rcvr_;
+ if constexpr (__is_scheduler_affine<schedule_result_t<_Sched>>) {
+ return static_cast<_Receiver&&>(__rcvr);
+ } else {
+ return __rcvr_t{static_cast<_Receiver&&>(__rcvr), this->__sched_};
+ }
+ }
+ }
+
+ auto __get_env(const _Receiver& __rcvr) const noexcept -> __env_t {
+ if constexpr (__is_scheduler_affine<schedule_result_t<_Sched>>) {
+ return stdexec::get_env(__rcvr);
+ } else {
+ return __env::__join(__sched_env{__sched_}, stdexec::get_env(__rcvr));
+ }
+ }
+
+ STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
+ _Fun __fun_;
+ STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
+ _Sched __sched_;
+ //! Variant to hold the results passed from upstream before passing them to the function:
+ __result_variant __args_{};
+ //! Variant type for holding the operation state from connecting
+ //! the function result to the downstream receiver:
+ __submit_variant __storage_{};
+ };
+
+ //! Implementation of the `let_*_t` types, where `_Set` is, e.g., `set_value_t` for `let_value`.
+ template <class _Set, class _Domain>
+ struct __let_t {
+ using __domain_t = _Domain;
+ using __t = _Set;
+
+ template <sender _Sender, __movable_value _Fun>
+ auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain,
- __make_sexpr<__let_t<_Set>>(static_cast<_Fun&&>(__fun),
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<__let_t<_Set>>(static_cast<_Fun&&>(__fun), static_cast<_Sender&&>(__sndr)));
+ }
- template <class _Fun>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Fun __fun) const -> __binder_back<__let_t, _Fun>
- {
+ template <class _Fun>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Fun __fun) const -> __binder_back<__let_t, _Fun> {
return {{static_cast<_Fun&&>(__fun)}, {}, {}};
- }
+ }
- using _Sender = __1;
- using _Function = __0;
- using __legacy_customizations_t =
- __types<tag_invoke_t(__let_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(const _Sender&)),
- _Sender, _Function),
- tag_invoke_t(__let_t, _Sender, _Function)>;
+ template <sender_expr_for<__let_t<_Set>> _Sender, class _Env>
+ static auto transform_env(_Sender&& __sndr, const _Env& __env) -> decltype(auto) {
+ return __sexpr_apply(
+ static_cast<_Sender&&>(__sndr), __mk_transform_env_fn<__let_t<_Set>>(__env));
+ }
- template <sender_expr_for<__let_t<_Set>> _Sender, class _Env>
- static auto transform_env(_Sender&& __sndr, const _Env& __env)
- -> decltype(auto)
- {
- return __sexpr_apply(static_cast<_Sender&&>(__sndr),
- __mk_transform_env_fn<__let_t<_Set>>(__env));
- }
-
- template <sender_expr_for<__let_t<_Set>> _Sender, class _Env>
+ template <sender_expr_for<__let_t<_Set>> _Sender, class _Env>
requires same_as<__early_domain_of_t<_Sender>, dependent_domain>
- static auto transform_sender(_Sender&& __sndr, const _Env& __env)
- -> decltype(auto)
- {
- return __sexpr_apply(static_cast<_Sender&&>(__sndr),
- __mk_transform_sender_fn<__let_t<_Set>>(__env));
- }
-};
-
-template <class _Set, class _Domain>
-struct __let_impl : __sexpr_defaults
-{
- static constexpr auto get_attrs = //
- []<class _Child>(__ignore, const _Child& __child) noexcept {
- return __env::__join(prop{get_domain, _Domain()},
- stdexec::get_env(__child));
- };
-
- static constexpr auto get_completion_signatures = //
- []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept
- -> __completions<__let_t<_Set, _Domain>, __data_of<_Self>,
- __child_of<_Self>, _Env...> {
- static_assert(sender_expr_for<_Self, __let_t<_Set, _Domain>>);
- return {};
+ static auto transform_sender(_Sender&& __sndr, const _Env& __env) -> decltype(auto) {
+ return __sexpr_apply(
+ static_cast<_Sender&&>(__sndr), __mk_transform_sender_fn<__let_t<_Set>>(__env));
+ }
};
- static constexpr auto get_state = //
- []<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver&) {
- static_assert(sender_expr_for<_Sender, __let_t<_Set, _Domain>>);
- using _Fun = __data_of<_Sender>;
- using _Child = __child_of<_Sender>;
+ template <class _Set, class _Domain>
+ struct __let_impl : __sexpr_defaults {
+ static constexpr auto get_attrs =
+ []<class _Fun, class _Child>(const _Fun&, const _Child& __child) noexcept {
+ if constexpr (!same_as<_Domain, dependent_domain>) {
+ return __env::__join(prop{get_domain, _Domain()}, stdexec::get_env(__child));
+ } else {
using _Sched = __completion_sched<_Child, _Set>;
- using __mk_let_state =
- __mbind_front_q<__let_state, _Receiver, _Fun, _Set, _Sched>;
+ using _Domain2 = __result_domain_t<_Set, _Child, _Fun, _Sched>;
- using __let_state_t =
- __gather_completions_of<_Set, _Child, env_of_t<_Receiver>,
- __q<__decayed_tuple>, __mk_let_state>;
-
- return __sndr.apply(
- static_cast<_Sender&&>(__sndr),
- [&]<class _Fn, class _Child>(__ignore, _Fn&& __fn,
- _Child&& __child) {
- _Sched __sched = query_or(get_completion_scheduler<_Set>,
- stdexec::get_env(__child),
- __unknown_scheduler());
- return __let_state_t{static_cast<_Fn&&>(__fn), __sched};
- });
+ if constexpr (__merror<_Domain2>) {
+ return __env::__join(prop{get_domain, dependent_domain()}, stdexec::get_env(__child));
+ } else {
+ return __env::__join(prop{get_domain, _Domain2()}, stdexec::get_env(__child));
+ }
+ }
};
- //! Helper function to actually invoke the function to produce `let_*`'s
- //! sender, connect it to the downstream receiver, and start it. This is the
- //! heart of `let_*`.
- template <class _State, class _OpState, class... _As>
- static void __bind_(_State& __state, _OpState& __op_state, _As&&... __as)
- {
+ static constexpr auto get_completion_signatures =
+ []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept
+ -> __completions<__let_t<_Set, _Domain>, __data_of<_Self>, __child_of<_Self>, _Env...> {
+ static_assert(sender_expr_for<_Self, __let_t<_Set, _Domain>>);
+ return {};
+ };
+
+ static constexpr auto get_state =
+ []<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver&) {
+ static_assert(sender_expr_for<_Sender, __let_t<_Set, _Domain>>);
+ using _Fun = __data_of<_Sender>;
+ using _Child = __child_of<_Sender>;
+ using _Sched = __decay_t<__completion_sched<_Child, _Set>>;
+ using __mk_let_state = __mbind_front_q<__let_state, _Receiver, _Fun, _Set, _Sched>;
+
+ using __let_state_t = __gather_completions_of<
+ _Set,
+ _Child,
+ env_of_t<_Receiver>,
+ __q<__decayed_tuple>,
+ __mk_let_state
+ >;
+
+ return __sndr.apply(
+ static_cast<_Sender&&>(__sndr),
+ [&]<class _Fn, class _Child>(__ignore, _Fn&& __fn, _Child&& __child) {
+ _Sched __sched = query_or(
+ get_completion_scheduler<_Set>, stdexec::get_env(__child), __unknown_scheduler());
+ return __let_state_t{static_cast<_Fn&&>(__fn), __sched};
+ });
+ };
+
+ //! Helper function to actually invoke the function to produce `let_*`'s sender,
+ //! connect it to the downstream receiver, and start it. This is the heart of
+ //! `let_*`.
+ template <class _State, class _OpState, class... _As>
+ static void __bind_(_State& __state, _OpState& __op_state, _As&&... __as) {
// Store the passed-in (received) args:
- auto& __args = __state.__args_.emplace_from(
- __tup::__mktuple, static_cast<_As&&>(__as)...);
+ auto& __args = __state.__args_.emplace_from(__tup::__mktuple, static_cast<_As&&>(__as)...);
// Apply the function to the args to get the sender:
auto __sndr2 = __args.apply(std::move(__state.__fun_), __args);
- // Create a receiver based on the state, the computed sender, and the
- // operation state:
+ // Create a receiver based on the state, the computed sender, and the operation state:
auto __rcvr2 = __state.__get_result_receiver(__sndr2, __op_state);
// Connect the sender to the receiver and start it:
- auto& __op2 = __state.__op_state3_.emplace_from(
- stdexec::connect, std::move(__sndr2), std::move(__rcvr2));
- stdexec::start(__op2);
- }
+ using __result_t = decltype(submit_result{std::move(__sndr2), std::move(__rcvr2)});
+ auto& __op = __state.__storage_
+ .template emplace<__result_t>(std::move(__sndr2), std::move(__rcvr2));
+ __op.submit(std::move(__sndr2), std::move(__rcvr2));
+ }
- template <class _OpState, class... _As>
- static void __bind(_OpState& __op_state, _As&&... __as) noexcept
- {
+ template <class _OpState, class... _As>
+ static void __bind(_OpState& __op_state, _As&&... __as) noexcept {
using _State = decltype(__op_state.__state_);
using _Receiver = decltype(__op_state.__rcvr_);
- using _Fun = typename _State::__fun_t;
- using _Sched = typename _State::__sched_t;
+ using _Fun = _State::__fun_t;
+ using _Sched = _State::__sched_t;
using _ResultSender =
- __mcall<__result_sender_fn<_Set, _Fun, _Sched, env_of_t<_Receiver>>,
- _As...>;
+ __mcall<__result_sender_fn<_Set, _Fun, _Sched, env_of_t<_Receiver>>, _As...>;
_State& __state = __op_state.__state_;
_Receiver& __rcvr = __op_state.__rcvr_;
- if constexpr ((__nothrow_decay_copyable<_As> && ...) &&
- __nothrow_callable<_Fun, _As...> &&
- __v<__nothrow_connectable_receiver_ref_t<
- _ResultSender, _Sched, env_of_t<_Receiver>>>)
- {
+ if constexpr (
+ (__nothrow_decay_copyable<_As> && ...) && __nothrow_callable<_Fun, _As...>
+ && __v<__nothrow_connectable_receiver_ref_t<_ResultSender, _Sched, env_of_t<_Receiver>>>) {
+ __bind_(__state, __op_state, static_cast<_As&&>(__as)...);
+ } else {
+ STDEXEC_TRY {
__bind_(__state, __op_state, static_cast<_As&&>(__as)...);
- }
- else
- {
- try
- {
- __bind_(__state, __op_state, static_cast<_As&&>(__as)...);
- }
- catch (...)
- {
- using _Receiver = decltype(__op_state.__rcvr_);
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- std::current_exception());
- }
- }
- }
-
- static constexpr auto complete = //
- []<class _OpState, class _Tag, class... _As>(
- __ignore, _OpState& __op_state, _Tag,
- _As&&... __as) noexcept -> void {
- if constexpr (__same_as<_Tag, _Set>)
- {
- // Intercept the channel of interest to compute the sender and
- // connect it:
- __bind(__op_state, static_cast<_As&&>(__as)...);
- }
- else
- {
- // Forward the other channels downstream:
+ }
+ STDEXEC_CATCH_ALL {
using _Receiver = decltype(__op_state.__rcvr_);
- _Tag()(static_cast<_Receiver&&>(__op_state.__rcvr_),
- static_cast<_As&&>(__as)...);
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
+ }
}
+ }
+
+ static constexpr auto complete = []<class _OpState, class _Tag, class... _As>(
+ __ignore,
+ _OpState& __op_state,
+ _Tag,
+ _As&&... __as) noexcept -> void {
+ if constexpr (__same_as<_Tag, _Set>) {
+ // Intercept the channel of interest to compute the sender and connect it:
+ __bind(__op_state, static_cast<_As&&>(__as)...);
+ } else {
+ // Forward the other channels downstream:
+ using _Receiver = decltype(__op_state.__rcvr_);
+ _Tag()(static_cast<_Receiver&&>(__op_state.__rcvr_), static_cast<_As&&>(__as)...);
+ }
+ };
};
-};
-} // namespace __let
+ } // namespace __let
-using let_value_t = __let::__let_t<set_value_t>;
-inline constexpr let_value_t let_value{};
+ using let_value_t = __let::__let_t<set_value_t>;
+ inline constexpr let_value_t let_value{};
-using let_error_t = __let::__let_t<set_error_t>;
-inline constexpr let_error_t let_error{};
+ using let_error_t = __let::__let_t<set_error_t>;
+ inline constexpr let_error_t let_error{};
-using let_stopped_t = __let::__let_t<set_stopped_t>;
-inline constexpr let_stopped_t let_stopped{};
+ using let_stopped_t = __let::__let_t<set_stopped_t>;
+ inline constexpr let_stopped_t let_stopped{};
-template <class _Set, class _Domain>
-struct __sexpr_impl<__let::__let_t<_Set, _Domain>> :
- __let::__let_impl<_Set, _Domain>
-{};
+ template <class _Set, class _Domain>
+ struct __sexpr_impl<__let::__let_t<_Set, _Domain>> : __let::__let_impl<_Set, _Domain> { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__manual_lifetime.hpp b/include/sdbusplus/async/stdexec/__detail/__manual_lifetime.hpp
index 82fb917..8dd9d32 100644
--- a/include/sdbusplus/async/stdexec/__detail/__manual_lifetime.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__manual_lifetime.hpp
@@ -16,29 +16,24 @@
*/
#pragma once
-#include "../concepts.hpp"
+#include "__concepts.hpp"
-#include <cstddef>
#include <memory>
#include <new>
-#include <type_traits>
-namespace stdexec
-{
+namespace stdexec {
-//! Holds storage for a `_Ty`, but allows clients to `__construct(...)`,
-//! `__destry()`, and `__get()` the `_Ty` without regard for usual lifetime
-//! rules.
-template <class _Ty>
-class __manual_lifetime
-{
- public:
- //! Constructor does nothing: It's on you to call `__construct(...)` or
- //! `__construct_from(...)` if you want the `_Ty`'s lifetime to begin.
- constexpr __manual_lifetime() noexcept {}
- //! Destructor does nothing: It's on you to call `__destroy()` if you mean
- //! to.
- constexpr ~__manual_lifetime() {}
+ //! Holds storage for a `_Ty`, but allows clients to `__construct(...)`, `__destry()`,
+ //! and `__get()` the `_Ty` without regard for usual lifetime rules.
+ template <class _Ty>
+ class __manual_lifetime {
+ public:
+ //! Constructor does nothing: It's on you to call `__construct(...)` or `__construct_from(...)`
+ //! if you want the `_Ty`'s lifetime to begin.
+ constexpr __manual_lifetime() noexcept = default;
+
+ //! Destructor does nothing: It's on you to call `__destroy()` if you mean to.
+ constexpr ~__manual_lifetime() = default;
__manual_lifetime(const __manual_lifetime&) = delete;
auto operator=(const __manual_lifetime&) -> __manual_lifetime& = delete;
@@ -47,61 +42,55 @@
auto operator=(__manual_lifetime&&) -> __manual_lifetime& = delete;
//! Construct the `_Ty` in place.
- //! There are no safeties guarding against the case that there's already one
- //! there.
+ //! There are no safeties guarding against the case that there's already one there.
template <class... _Args>
- auto __construct(_Args&&... __args) noexcept(
- stdexec::__nothrow_constructible_from<_Ty, _Args...>) -> _Ty&
- {
- // Use placement new instead of std::construct_at to support aggregate
- // initialization with brace elision.
- return *std::launder(::new (static_cast<void*>(__buffer_))
- _Ty{static_cast<_Args&&>(__args)...});
+ auto __construct(_Args&&... __args)
+ noexcept(stdexec::__nothrow_constructible_from<_Ty, _Args...>) -> _Ty& {
+ // Use placement new instead of std::construct_at to support aggregate initialization with
+ // brace elision.
+ return *std::launder(::new (static_cast<void*>(__buffer_))
+ _Ty{static_cast<_Args&&>(__args)...});
}
//! Construct the `_Ty` in place from the result of calling `func`.
- //! There are no safeties guarding against the case that there's already one
- //! there.
+ //! There are no safeties guarding against the case that there's already one there.
template <class _Func, class... _Args>
- auto __construct_from(_Func&& func, _Args&&... __args) -> _Ty&
- {
- // Use placement new instead of std::construct_at in case the function
- // returns an immovable type.
- return *std::launder(::new (static_cast<void*>(__buffer_)) _Ty{
- (static_cast<_Func&&>(func))(static_cast<_Args&&>(__args)...)});
+ auto __construct_from(_Func&& func, _Args&&... __args) -> _Ty& {
+ // Use placement new instead of std::construct_at in case the function returns an immovable
+ // type.
+ return *std::launder(::new (static_cast<void*>(__buffer_))
+ _Ty{(static_cast<_Func&&>(func))(static_cast<_Args&&>(__args)...)});
}
+
//! End the lifetime of the contained `_Ty`.
//! Precondition: The lifetime has started.
- void __destroy() noexcept
- {
- std::destroy_at(&__get());
- }
- //! Get access to the `_Ty`.
- //! Precondition: The lifetime has started.
- auto __get() & noexcept -> _Ty&
- {
- return *reinterpret_cast<_Ty*>(__buffer_);
+ void __destroy() noexcept {
+ std::destroy_at(&__get());
}
//! Get access to the `_Ty`.
//! Precondition: The lifetime has started.
- auto __get() && noexcept -> _Ty&&
- {
- return static_cast<_Ty&&>(*reinterpret_cast<_Ty*>(__buffer_));
+ auto __get() & noexcept -> _Ty& {
+ return *reinterpret_cast<_Ty*>(__buffer_);
}
//! Get access to the `_Ty`.
//! Precondition: The lifetime has started.
- auto __get() const& noexcept -> const _Ty&
- {
- return *reinterpret_cast<const _Ty*>(__buffer_);
+ auto __get() && noexcept -> _Ty&& {
+ return static_cast<_Ty&&>(*reinterpret_cast<_Ty*>(__buffer_));
+ }
+
+ //! Get access to the `_Ty`.
+ //! Precondition: The lifetime has started.
+ auto __get() const & noexcept -> const _Ty& {
+ return *reinterpret_cast<const _Ty*>(__buffer_);
}
//! Move semantics aren't supported.
//! If you want to move the `_Ty`, use `std::move(ml.__get())`.
- auto __get() const&& noexcept -> const _Ty&& = delete;
+ auto __get() const && noexcept -> const _Ty&& = delete;
- private:
+ private:
alignas(_Ty) unsigned char __buffer_[sizeof(_Ty)]{};
-};
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__meta.hpp b/include/sdbusplus/async/stdexec/__detail/__meta.hpp
index 045536c..35f0866 100644
--- a/include/sdbusplus/async/stdexec/__detail/__meta.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__meta.hpp
@@ -15,948 +15,829 @@
*/
#pragma once
-#include "__concepts.hpp"
+#include <cstddef>
+#include <cassert>
+#include <compare>
+#include <type_traits>
+
#include "__config.hpp"
+#include "__concepts.hpp"
#include "__type_traits.hpp"
#include "__utility.hpp"
-#include <cassert>
-#include <compare>
-#include <cstddef>
-#include <exception>
-#include <type_traits>
-#include <utility>
+namespace stdexec {
+ //! Convenience metafunction getting the dependant type `__t` out of `_Tp`.
+ //! That is, `typename _Tp::__t`.
+ //! See MAINTAINERS.md#class-template-parameters for details.
+ template <class _Tp>
+ using __t = _Tp::__t;
-namespace stdexec
-{
-//! Convenience metafunction getting the dependant type `__t` out of `_Tp`.
-//! That is, `typename _Tp::__t`.
-//! See MAINTAINERS.md#class-template-parameters for details.
-template <class _Tp>
-using __t = typename _Tp::__t;
-
-template <class _Ty>
-struct __mtype
-{
+ template <class _Ty>
+ struct __mtype {
using __t = _Ty;
-};
+ };
-template <class...>
-inline constexpr bool __mnever = false;
+ template <class...>
+ inline constexpr bool __mnever = false;
-template <auto _Value>
-using __mtypeof = decltype(_Value);
+ template <auto _Value>
+ using __mtypeof = decltype(_Value);
-template <class...>
-struct __types;
+ template <class...>
+ struct __types;
-template <class _Tp>
-using __midentity = _Tp;
+ template <class _Tp>
+ using __midentity = _Tp;
-template <auto _Np>
-struct __mconstant
-{
+ template <auto _Np>
+ struct __mconstant {
using type = __mconstant;
using value_type = __mtypeof<_Np>;
static constexpr auto value = _Np;
- constexpr operator value_type() const noexcept
- {
- return value;
+ constexpr operator value_type() const noexcept {
+ return value;
}
- constexpr auto operator()() const noexcept -> value_type
- {
- return value;
+ constexpr auto operator()() const noexcept -> value_type {
+ return value;
}
-};
+ };
-// Because of nvc++ nvbugs#4679848, we can't make __mbool a simple alias for
-// __mconstant, and because of nvc++ nvbugs#4668709 it can't be a simple alias
-// for std::bool_constant, either. :-( template <bool _Bp> using __mbool =
-// __mconstant<_Bp>;
-
-template <bool _Bp>
-struct __mbool : std::bool_constant<_Bp>
-{};
-
-using __mtrue = __mbool<true>;
-using __mfalse = __mbool<false>;
-
-// nvbugs#4679848 and nvbugs#4668709 also preclude __mconstant from representing
-// a compile-time size_t.
-enum class __muchar : unsigned char
-{
-};
+ // nvbugs#4679848 and nvbugs#4668709 also preclude __mconstant from representing a compile-time
+ // size_t.
+ enum class __u8 : unsigned char {
+ };
#if STDEXEC_NVCC() || STDEXEC_EDG()
-template <std::size_t _Np>
-using __msize_t = std::integral_constant<std::size_t, _Np>;
+ template <std::size_t _Np>
+ using __msize_t = std::integral_constant<std::size_t, _Np>;
#elif STDEXEC_MSVC()
-template <std::size_t _Np>
-using __msize_t = __mconstant<_Np>;
+ template <std::size_t _Np>
+ using __msize_t = __mconstant<_Np>;
#else
-template <std::size_t _Np>
-using __msize_t = __muchar (*)[_Np + 1]; // +1 to avoid zero-size array
+ template <std::size_t _Np>
+ using __msize_t = __u8 (*)[_Np + 1]; // +1 to avoid zero-size array
#endif
-//! Metafunction selects the first of two type arguments.
-template <class _Tp, class _Up>
-using __mfirst = _Tp;
+ //! Metafunction selects the first of two type arguments.
+ template <class _Tp, class _Up>
+ using __mfirst = _Tp;
-//! Metafunction selects the second of two type arguments.
-template <class _Tp, class _Up>
-using __msecond = _Up;
+ //! Metafunction selects the second of two type arguments.
+ template <class _Tp, class _Up>
+ using __msecond = _Up;
-template <class...>
-struct __undefined;
+ template <class...>
+ struct __undefined;
-template <class _Tp>
-extern const __undefined<_Tp> __v;
+ template <class _Tp>
+ extern const __undefined<_Tp> __v;
-template <class _Tp>
+ template <class _Tp>
requires __typename<__mtypeof<_Tp::value>>
-inline constexpr auto __v<_Tp> = _Tp::value;
+ inline constexpr __mtypeof<_Tp::value> __v<_Tp> = _Tp::value;
-// These specializations exist because instantiating a variable template is
-// cheaper than instantiating a class template.
-template <class _Tp, class _Up>
-inline constexpr bool __v<std::is_same<_Tp, _Up>> = false;
+ // These specializations exist because instantiating a variable template is cheaper than
+ // instantiating a class template.
+ template <class _Tp, class _Up>
+ inline constexpr bool __v<std::is_same<_Tp, _Up>> = false;
-template <class _Tp>
-inline constexpr bool __v<std::is_same<_Tp, _Tp>> = true;
+ template <class _Tp>
+ inline constexpr bool __v<std::is_same<_Tp, _Tp>> = true;
-template <class _Tp, _Tp _Ip>
-inline constexpr _Tp __v<std::integral_constant<_Tp, _Ip>> = _Ip;
+ template <class _Tp, _Tp _Ip>
+ inline constexpr _Tp __v<std::integral_constant<_Tp, _Ip>> = _Ip;
-template <auto _Np>
-inline constexpr auto __v<__mconstant<_Np>> = _Np;
+ // `__mtypeof<_Np>` instead of `auto` to work around NVHPC/EDG bug.
+ template <auto _Np>
+ inline constexpr __mtypeof<_Np> __v<__mconstant<_Np>> = _Np;
-template <std::size_t _Np>
-inline constexpr std::size_t __v<__muchar (*)[_Np]> =
- _Np - 1; // see definition of __msize_t
+ template <std::size_t _Np>
+ inline constexpr std::size_t __v<__u8 (*)[_Np]> = _Np - 1; // see definition of __msize_t
-namespace __pack
-{
-template <std::size_t... _Is>
-struct __t;
-} // namespace __pack
+ template <std::size_t... _Is>
+ struct __iota;
-template <std::size_t... _Is>
-using __indices = __pack::__t<_Is...>*;
+ template <std::size_t... _Is>
+ using __indices = __iota<_Is...> *;
#if STDEXEC_MSVC()
-namespace __pack
-{
-template <class _Ty, _Ty... _Is>
-struct __idx;
+ namespace __pack {
+ template <class _Ty, _Ty... _Is>
+ struct __idx;
-template <class>
-extern int __mkidx;
+ template <class>
+ extern int __mkidx;
-template <std::size_t... _Is>
-extern __indices<_Is...> __mkidx<__idx<std::size_t, _Is...>>;
-} // namespace __pack
+ template <std::size_t... _Is>
+ extern __indices<_Is...> __mkidx<__idx<std::size_t, _Is...>>;
+ } // namespace __pack
-template <std::size_t _Np>
-using __make_indices = //
- decltype(__pack::__mkidx<
- __make_integer_seq<__pack::__idx, std::size_t, _Np>>);
+ template <std::size_t _Np>
+ using __make_indices =
+ decltype(__pack::__mkidx<__make_integer_seq<__pack::__idx, std::size_t, _Np>>);
#elif STDEXEC_HAS_BUILTIN(__make_integer_seq)
-namespace __pack
-{
-template <class _Ty, _Ty... _Is>
-using __idx = __indices<_Is...>;
-} // namespace __pack
+ namespace __pack {
+ template <class _Ty, _Ty... _Is>
+ using __idx = __indices<_Is...>;
+ } // namespace __pack
-template <std::size_t _Np>
-using __make_indices = __make_integer_seq<__pack::__idx, std::size_t, _Np>;
+ template <std::size_t _Np>
+ using __make_indices = __make_integer_seq<__pack::__idx, std::size_t, _Np>;
#elif STDEXEC_HAS_BUILTIN(__integer_pack)
-namespace __pack
-{
-template <std::size_t _Np>
-extern __indices<__integer_pack(_Np)...> __make_indices;
-} // namespace __pack
+ namespace __pack {
+ template <std::size_t _Np>
+ extern __indices<__integer_pack(_Np)...> __make_indices;
+ } // namespace __pack
-template <std::size_t _Np>
-using __make_indices = decltype(__pack::__make_indices<_Np>);
+ template <std::size_t _Np>
+ using __make_indices = decltype(__pack::__make_indices<_Np>);
#else
-namespace __pack
-{
-template <std::size_t... _Is>
-auto __mk_indices(__indices<0, _Is...>) -> __indices<_Is...>;
+ namespace __pack {
+ template <std::size_t... _Is>
+ auto __mk_indices(__indices<0, _Is...>) -> __indices<_Is...>;
-template <std::size_t _Np, class = char[_Np], std::size_t... _Is>
-auto __mk_indices(__indices<_Np, _Is...>)
- -> decltype(__mk_indices(__indices<_Np - 1, 0, (_Is + 1)...>{}));
-} // namespace __pack
+ template <std::size_t _Np, class = char[_Np], std::size_t... _Is>
+ auto __mk_indices(__indices<_Np, _Is...>)
+ -> decltype(__mk_indices(__indices<_Np - 1, 0, (_Is + 1)...>{}));
+ } // namespace __pack
-template <std::size_t _Np>
-using __make_indices = decltype(__pack::__mk_indices(__indices<_Np>{}));
+ template <std::size_t _Np>
+ using __make_indices = decltype(__pack::__mk_indices(__indices<_Np>{}));
#endif
-template <class... _Ts>
-using __indices_for = __make_indices<sizeof...(_Ts)>;
+ template <class... _Ts>
+ using __indices_for = __make_indices<sizeof...(_Ts)>;
-STDEXEC_PRAGMA_PUSH()
-STDEXEC_PRAGMA_IGNORE_MSVC(4293)
+ STDEXEC_PRAGMA_PUSH()
+ STDEXEC_PRAGMA_IGNORE_MSVC(4293)
-constexpr std::size_t __mpow2(std::size_t __size) noexcept
-{
+ constexpr auto __mpow2(std::size_t __size) noexcept -> std::size_t {
--__size;
__size |= __size >> 1;
__size |= __size >> 2;
__size |= __size >> 4;
__size |= __size >> 8;
if constexpr (sizeof(__size) >= 4)
- __size |= __size >> 16;
+ __size |= __size >> 16;
if constexpr (sizeof(__size) >= 8)
- __size |= __size >> 32;
+ __size |= __size >> 32;
return ++__size;
-}
+ }
-STDEXEC_PRAGMA_POP()
+ STDEXEC_PRAGMA_POP()
-template <std::size_t _Len>
-struct __mstring
-{
+ template <std::size_t _Len>
+ struct __mstring {
#if STDEXEC_EDG()
template <std::size_t _Ny, std::size_t... _Is>
- constexpr __mstring(const char (&__str)[_Ny], __indices<_Is...>) noexcept :
- __what_{(_Is < _Ny ? __str[_Is] : '\0')...}
- {}
+ constexpr __mstring(const char (&__str)[_Ny], __indices<_Is...>) noexcept
+ : __what_{(_Is < _Ny ? __str[_Is] : '\0')...} {
+ }
template <std::size_t _Ny>
- constexpr __mstring(const char (&__str)[_Ny], int = 0) noexcept :
- __mstring{__str, __make_indices<_Len>{}}
- {}
+ constexpr __mstring(const char (&__str)[_Ny], int = 0) noexcept
+ : __mstring{__str, __make_indices<_Len>{}} {
+ }
#else
template <std::size_t _Ny>
- constexpr __mstring(const char (&__str)[_Ny], int = 0) noexcept : __what_{}
- {
- for (auto __i = 0ull; char __ch : __str)
- {
- __what_[__i++] = __ch;
- }
+ constexpr __mstring(const char (&__str)[_Ny], int = 0) noexcept {
+ for (auto __i = 0ull; char __ch: __str) {
+ __what_[__i++] = __ch;
+ }
}
#endif
- static constexpr auto __length() noexcept -> std::size_t
- {
- return _Len;
+ static constexpr auto __length() noexcept -> std::size_t {
+ return _Len;
}
- constexpr auto operator==(const __mstring&) const noexcept
- -> bool = default;
+ constexpr auto operator==(const __mstring &) const noexcept -> bool = default;
template <std::size_t _OtherLen>
- constexpr auto operator==(const __mstring<_OtherLen>&) const noexcept
- -> bool
- {
- return false;
+ constexpr auto operator==(const __mstring<_OtherLen> &) const noexcept -> bool {
+ return false;
}
#if !STDEXEC_EDG()
- constexpr auto operator<=>(const __mstring&) const noexcept
- -> std::strong_ordering = default;
+ constexpr auto operator<=>(const __mstring &) const noexcept -> std::strong_ordering = default;
#endif
template <std::size_t _OtherLen>
- constexpr auto operator<=>(const __mstring<_OtherLen>& __other)
- const noexcept -> std::strong_ordering
- {
- constexpr std::size_t __len = _Len < _OtherLen ? _Len : _OtherLen;
- for (std::size_t __i = 0; __i < __len; ++__i)
- {
- auto __cmp = (__what_[__i] <=> __other.__what_[__i]);
- if (__cmp != 0)
- {
- return __cmp;
- }
+ constexpr auto
+ operator<=>(const __mstring<_OtherLen> &__other) const noexcept -> std::strong_ordering {
+ constexpr std::size_t __len = _Len < _OtherLen ? _Len : _OtherLen;
+ for (std::size_t __i = 0; __i < __len; ++__i) {
+ auto __cmp = (__what_[__i] <=> __other.__what_[__i]);
+ if (__cmp != 0) {
+ return __cmp;
}
- if constexpr (_Len == _OtherLen)
- {
- return std::strong_ordering::equal;
- }
- return (_Len < _OtherLen) ? std::strong_ordering::less
- : std::strong_ordering::greater;
+ }
+ if constexpr (_Len == _OtherLen) {
+ return std::strong_ordering::equal;
+ }
+ return (_Len < _OtherLen) ? std::strong_ordering::less : std::strong_ordering::greater;
}
- char __what_[_Len];
-};
+ char __what_[_Len]{};
+ };
-template <std::size_t _Len>
-__mstring(const char (&__str)[_Len]) -> __mstring<_Len>;
+ template <std::size_t _Len>
+ __mstring(const char (&__str)[_Len]) -> __mstring<_Len>;
-template <std::size_t _Len>
-__mstring(const char (&__str)[_Len], int) -> __mstring<__mpow2(_Len)>;
+ template <std::size_t _Len>
+ __mstring(const char (&__str)[_Len], int) -> __mstring<__mpow2(_Len)>;
-STDEXEC_PRAGMA_PUSH()
-STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals")
+ STDEXEC_PRAGMA_PUSH()
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals")
-// Use a standard user-defined string literal template
-template <__mstring _Str>
-[[deprecated("Use _mstr instead")]] constexpr auto operator""__csz() noexcept
- -> __mtypeof<_Str>
-{
+ // Use a standard user-defined string literal template
+ template <__mstring _Str>
+ [[deprecated("Use _mstr instead")]]
+ constexpr auto operator""__csz() noexcept -> __mtypeof<_Str> {
return _Str;
-}
+ }
-// Use a standard user-defined string literal template
-template <__mstring _Str>
-constexpr auto operator""_mstr() noexcept -> __mtypeof<_Str>
-{
+ // Use a standard user-defined string literal template
+ template <__mstring _Str>
+ constexpr auto operator""_mstr() noexcept -> __mtypeof<_Str> {
return _Str;
-}
+ }
-STDEXEC_PRAGMA_POP()
+ STDEXEC_PRAGMA_POP()
-template <class T>
-constexpr auto __mnameof() noexcept
-{
+ template <class T>
+ constexpr auto __mnameof() noexcept {
#if STDEXEC_MSVC()
return __mstring{__FUNCSIG__, 0};
#else
return __mstring{__PRETTY_FUNCTION__, 0};
#endif
-}
+ }
-using __msuccess = int;
+ using __msuccess = int;
-template <class _What, class... _With>
-struct _WARNING_
-{};
+ template <class _What, class... _With>
+ struct _WARNING_ { };
-template <class _What, class... _With>
-struct _ERROR_
-{
+ template <class _What, class... _With>
+ struct _ERROR_ {
+ using __what_t = _What;
auto operator,(__msuccess) const noexcept -> _ERROR_;
-};
+ };
-template <__mstring... _What>
-struct _WHAT_
-{};
+ template <__mstring... _What>
+ struct _WHAT_ { };
-template <class _What, class... _With>
-using __mexception = _ERROR_<_What, _With...>;
+ template <class _What, class... _With>
+ using __mexception = _ERROR_<_What, _With...>;
-template <class>
-extern __msuccess __ok_v;
+ template <class>
+ extern __msuccess __ok_v;
-template <class _What, class... _With>
-extern _ERROR_<_What, _With...> __ok_v<__mexception<_What, _With...>>;
+ template <class _What, class... _With>
+ extern _ERROR_<_What, _With...> __ok_v<__mexception<_What, _With...>>;
-template <class _Ty>
-using __ok_t = decltype(__ok_v<_Ty>);
+ template <class _Ty>
+ using __ok_t = decltype(__ok_v<_Ty>);
-template <class... _Ts>
-using __disp = decltype((__msuccess(), ..., __ok_t<_Ts>()));
+ template <class... _Ts>
+ using __disp = decltype((__msuccess(), ..., __ok_t<_Ts>()));
-template <class _Arg>
-concept __ok = STDEXEC_IS_SAME(__ok_t<_Arg>, __msuccess);
+ template <class _Arg>
+ concept __ok = STDEXEC_IS_SAME(__ok_t<_Arg>, __msuccess);
-template <class _Arg>
-concept __merror = !STDEXEC_IS_SAME(__ok_t<_Arg>, __msuccess);
+ template <class _Arg>
+ concept __merror = !STDEXEC_IS_SAME(__ok_t<_Arg>, __msuccess);
-template <class... _Args>
-concept _Ok = (STDEXEC_IS_SAME(__ok_t<_Args>, __msuccess) && ...);
+ template <class... _Args>
+ concept _Ok = (STDEXEC_IS_SAME(__ok_t<_Args>, __msuccess) && ...);
-//! The struct `__i` is the implementation of P2300's
-//! [_`META-APPLY`_](https://eel.is/c++draft/exec#util.cmplsig-5).
-//! > [Note [1](https://eel.is/c++draft/exec#util.cmplsig-note-1):
-//! > The purpose of META-APPLY is to make it valid to use non-variadic
-//! > templates as Variant and Tuple arguments to gather-signatures. — end note]
-//! In addition to avoiding the dreaded "pack expanded into non-pack argument"
-//! error, it is part of the meta-error propagation mechanism. if any of the
-//! argument types are a specialization of `_ERROR_`, `__i` will short-circuit
-//! and return the error.
-//! `__minvoke` and `__meval` are implemented in terms of `__i`.
-template <bool _ArgsOK, bool _FnOK = true>
-struct __i;
+ //! The struct `__i` is the implementation of P2300's
+ //! [_`META-APPLY`_](https://eel.is/c++draft/exec#util.cmplsig-5).
+ //! > [Note [1](https://eel.is/c++draft/exec#util.cmplsig-note-1):
+ //! > The purpose of META-APPLY is to make it valid to use non-variadic
+ //! > templates as Variant and Tuple arguments to gather-signatures. — end note]
+ //! In addition to avoiding the dreaded "pack expanded into non-pack argument" error,
+ //! it is part of the meta-error propagation mechanism. if any of the argument types
+ //! are a specialization of `_ERROR_`, `__i` will short-circuit and return the error.
+ //! `__minvoke` and `__meval` are implemented in terms of `__i`.
+ template <bool _ArgsOK, bool _FnOK = true>
+ struct __i;
#if STDEXEC_EDG()
-// Most compilers memoize alias template specializations, but
-// nvc++ does not. So we memoize the type computations by
-// indirecting through a class template specialization.
-template <template <class...> class _Fn, class... _Args>
-using __meval__ = //
- typename __i<_Ok<_Args...>> //
- ::template __g<_Fn, _Args...>; //
+ // Most compilers memoize alias template specializations, but
+ // nvc++ does not. So we memoize the type computations by
+ // indirecting through a class template specialization.
+ template <template <class...> class _Fn, class... _Args>
+ using __meval__ = __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
-template <template <class...> class _Fn, class... _Args>
-struct __meval_
-{};
+ template <template <class...> class _Fn, class... _Args>
+ struct __meval_ { };
-template <template <class...> class _Fn, class... _Args>
+ template <template <class...> class _Fn, class... _Args>
requires __typename<__meval__<_Fn, _Args...>>
-struct __meval_<_Fn, _Args...>
-{
+ struct __meval_<_Fn, _Args...> {
using __t = __meval__<_Fn, _Args...>;
-};
+ };
-template <template <class...> class _Fn, class... _Args>
-using __meval = __t<__meval_<_Fn, _Args...>>;
+ template <template <class...> class _Fn, class... _Args>
+ using __meval = __t<__meval_<_Fn, _Args...>>;
-template <class _Fn, class... _Args>
-using __minvoke__ = //
- typename __i<_Ok<_Args...>, _Ok<_Fn>> //
- ::template __f<_Fn> //
- ::template __f<_Args...>; //
+ template <class _Fn, class... _Args>
+ using __minvoke__ = __i<_Ok<_Args...>, _Ok<_Fn>>::template __f<_Fn>::template __f<_Args...>;
-template <class _Fn, class... _Args>
-struct __minvoke_
-{};
+ template <class _Fn, class... _Args>
+ struct __minvoke_ { };
-template <class _Fn, class... _Args>
+ template <class _Fn, class... _Args>
requires __typename<__minvoke__<_Fn, _Args...>>
-struct __minvoke_<_Fn, _Args...>
-{
+ struct __minvoke_<_Fn, _Args...> {
using __t = __minvoke__<_Fn, _Args...>;
-};
+ };
-template <class _Fn, class... _Args>
-using __minvoke = __t<__minvoke_<_Fn, _Args...>>;
+ template <class _Fn, class... _Args>
+ using __minvoke = __t<__minvoke_<_Fn, _Args...>>;
#else
-template <template <class...> class _Fn, class... _Args>
-using __meval = //
- typename __i<_Ok<_Args...>> //
- ::template __g<_Fn, _Args...>; //
+ template <template <class...> class _Fn, class... _Args>
+ using __meval = __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
-//! Metafunction invocation
-//! Given a metafunction, `_Fn`, and args.
-//! We expect `_Fn::__f` to be type alias template "implementing" the
-//! metafunction `_Fn`.
-template <class _Fn, class... _Args>
-using __minvoke = //
- typename __i<_Ok<_Args...>, _Ok<_Fn>> //
- ::template __f<_Fn> //
- ::template __f<_Args...>; //
+ //! Metafunction invocation
+ //! Given a metafunction, `_Fn`, and args.
+ //! We expect `_Fn::__f` to be type alias template "implementing" the metafunction `_Fn`.
+ template <class _Fn, class... _Args>
+ using __minvoke = __i<_Ok<_Args...>, _Ok<_Fn>>::template __f<_Fn>::template __f<_Args...>;
#endif
-template <class _Fn, class... _Args>
-using __mcall = typename _Fn::template __f<_Args...>;
+ template <class _Fn, class... _Args>
+ using __mcall = _Fn::template __f<_Args...>;
-struct __disp_q
-{
+ template <class _Fn, class _Arg>
+ using __mcall1 = _Fn::template __f<_Arg>;
+
+ struct __disp_q {
template <class... _Args>
using __f = __disp<_Args...>;
-};
+ };
-template <>
-struct __i<true, true>
-{
+ template <>
+ struct __i<true, true> {
template <template <class...> class _Fn, class... _Args>
using __g = _Fn<_Args...>;
template <class _Fn>
using __f = _Fn;
-};
+ };
-template <>
-struct __i<false, true>
-{
+ template <>
+ struct __i<false, true> {
template <template <class...> class, class... _Args>
using __g = __disp<_Args...>;
template <class>
using __f = __disp_q;
-};
+ };
-template <bool _ArgsOK>
-struct __i<_ArgsOK, false>
-{
+ template <bool _ArgsOK>
+ struct __i<_ArgsOK, false> {
template <class _Fn>
using __f = _Fn;
-};
+ };
-//! This struct template is like
-//! [mpl::quote](https://www.boost.org/doc/libs/1_86_0/libs/mpl/doc/refmanual/quote.html).
-//! It turns an alias/class template into a metafunction that also propagates
-//! "meta-exceptions". All of the meta utilities recognize specializations of
-//! stdexec::_ERROR_ as an error type. Error types short-circuit the evaluation
-//! of the metafunction and are automatically propagated like an exception.
-//! Note: `__minvoke` and `__meval` also participate in this error propagation.
-//!
-//! This design lets us report type errors briefly at the library boundary, even
-//! if the actual error happens deep inside a meta-program.
-template <template <class...> class _Fn>
-struct __q
-{
+ //! This struct template is like [mpl::quote](https://www.boost.org/doc/libs/1_86_0/libs/mpl/doc/refmanual/quote.html).
+ //! It turns an alias/class template into a metafunction that also propagates "meta-exceptions".
+ //! All of the meta utilities recognize specializations of stdexec::_ERROR_ as an error type.
+ //! Error types short-circuit the evaluation of the metafunction and are automatically propagated like an exception.
+ //! Note: `__minvoke` and `__meval` also participate in this error propagation.
+ //!
+ //! This design lets us report type errors briefly at the library boundary, even if the
+ //! actual error happens deep inside a meta-program.
+ template <template <class...> class _Fn>
+ struct __q {
template <class... _Args>
- using __f = typename __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
-};
+ using __f = __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
+ };
-template <template <class...> class _Fn>
-struct __qq
-{
+ template <template <class...> class _Fn>
+ struct __qq {
template <class... _Args>
using __f = _Fn<_Args...>;
-};
+ };
-template <template <class> class _Fn>
-struct __q1
-{
+ template <template <class> class _Fn>
+ struct __q1 {
template <class _Ty>
using __f = _Fn<_Ty>;
-};
+ };
-template <template <class, class> class _Fn>
-struct __q2
-{
+ template <template <class, class> class _Fn>
+ struct __q2 {
template <class _Ty, class _Uy>
using __f = _Fn<_Ty, _Uy>;
-};
+ };
-template <template <class...> class _Fn>
-using __mtry_q = __q<_Fn>;
+ template <template <class...> class _Fn>
+ using __mtry_q = __q<_Fn>;
-template <class _Fn>
-struct __mtry : __mtry_q<_Fn::template __f>
-{};
+ template <class _Fn>
+ struct __mtry : __mtry_q<_Fn::template __f> { };
-template <template <class...> class _Fn, class... _Front>
-struct __mbind_front_q
-{
+ template <template <class...> class _Fn, class... _Front>
+ struct __mbind_front_q {
template <class... _Args>
using __f = __meval<_Fn, _Front..., _Args...>;
-};
+ };
-template <class _Fn, class... _Front>
-using __mbind_front = __mbind_front_q<_Fn::template __f, _Front...>;
+ template <class _Fn, class... _Front>
+ using __mbind_front = __mbind_front_q<_Fn::template __f, _Front...>;
-template <template <class...> class _Fn, class... _Back>
-struct __mbind_back_q
-{
+ template <template <class...> class _Fn, class... _Back>
+ struct __mbind_back_q {
template <class... _Args>
using __f = __meval<_Fn, _Args..., _Back...>;
-};
+ };
-template <class _Fn, class... _Back>
-using __mbind_back = __mbind_back_q<_Fn::template __f, _Back...>;
+ template <class _Fn, class... _Back>
+ using __mbind_back = __mbind_back_q<_Fn::template __f, _Back...>;
-template <template <class...> class _Tp, class... _Args>
-concept __mvalid = requires { typename __meval<_Tp, _Args...>; };
+ template <template <class...> class _Tp, class... _Args>
+ concept __mvalid = requires { typename __meval<_Tp, _Args...>; };
-template <class _Fn, class... _Args>
-concept __minvocable = __mvalid<_Fn::template __f, _Args...>;
+ template <class _Fn, class... _Args>
+ concept __minvocable = __mvalid<_Fn::template __f, _Args...>;
-template <template <class...> class _Tp, class... _Args>
-concept __msucceeds = __mvalid<_Tp, _Args...> && __ok<__meval<_Tp, _Args...>>;
+ template <template <class...> class _Tp, class... _Args>
+ concept __msucceeds = __mvalid<_Tp, _Args...> && __ok<__meval<_Tp, _Args...>>;
-template <class _Fn, class... _Args>
-concept __minvocable_succeeds =
- __minvocable<_Fn, _Args...> && __ok<__minvoke<_Fn, _Args...>>;
+ template <class _Fn, class... _Args>
+ concept __minvocable_succeeds = __minvocable<_Fn, _Args...> && __ok<__minvoke<_Fn, _Args...>>;
-template <class _Fn, class... _Args>
-struct __minvoke_force_
-{
+ template <class _Fn, class... _Args>
+ struct __minvoke_force_ {
using __t = __minvoke<_Fn, _Args...>;
-};
-template <class _Fn, class... _Args>
-using __minvoke_force = __t<__minvoke_force_<_Fn, _Args...>>;
+ };
+ template <class _Fn, class... _Args>
+ using __minvoke_force = __t<__minvoke_force_<_Fn, _Args...>>;
-template <class _Fn, class... _Args>
-struct __mdefer_
-{};
+ template <class _Fn, class... _Args>
+ struct __mdefer_ { };
-template <class _Fn, class... _Args>
+ template <class _Fn, class... _Args>
requires __minvocable<_Fn, _Args...>
-struct __mdefer_<_Fn, _Args...>
-{
+ struct __mdefer_<_Fn, _Args...> {
using __t = __minvoke<_Fn, _Args...>;
-};
+ };
-template <class _Fn, class... _Args>
-struct __mdefer : __mdefer_<_Fn, _Args...>
-{};
+ template <class _Fn, class... _Args>
+ struct __mdefer : __mdefer_<_Fn, _Args...> { };
-template <class _Fn, class... _Args>
-using __mmemoize = __t<__mdefer<_Fn, _Args...>>;
+ template <class _Fn, class... _Args>
+ using __mmemoize = __t<__mdefer<_Fn, _Args...>>;
-template <template <class...> class _Fn, class... _Args>
-using __mmemoize_q = __mmemoize<__q<_Fn>, _Args...>;
+ template <template <class...> class _Fn, class... _Args>
+ using __mmemoize_q = __mmemoize<__q<_Fn>, _Args...>;
-struct __if_
-{
- //! Metafunction selects `_True` if the bool template is `true`, otherwise
- //! the second. That is, `__<true>::__f<A, B>` is `A` and `__<false>::__f<A,
- //! B>` is B. This is similar to `std::conditional_t<Cond, A, B>`.
+ struct __if_ {
+ //! Metafunction selects `_True` if the bool template is `true`, otherwise the second.
+ //! That is, `__<true>::__f<A, B>` is `A` and `__<false>::__f<A, B>` is B.
+ //! This is similar to `std::conditional_t<Cond, A, B>`.
template <bool>
- struct __
- {
- template <class _True, class...>
- using __f = _True;
+ struct __ {
+ template <class _True, class...>
+ using __f = _True;
};
template <class _Pred, class _True, class... _False>
using __f = __minvoke<__<static_cast<bool>(__v<_Pred>)>, _True, _False...>;
-};
+ };
-// Specialization; see above.
-template <>
-struct __if_::__<false>
-{
+ // Specialization; see above.
+ template <>
+ struct __if_::__<false> {
template <class, class _False>
using __f = _False;
-};
+ };
-template <class _Pred, class _True = void, class... _False>
+ template <class _Pred, class _True = void, class... _False>
requires(sizeof...(_False) <= 1)
-using __if = __minvoke<__if_, _Pred, _True, _False...>;
+ using __if = __minvoke<__if_, _Pred, _True, _False...>;
-template <bool _Pred, class _True = void, class... _False>
+ template <bool _Pred, class _True = void, class... _False>
requires(sizeof...(_False) <= 1)
-using __if_c = __minvoke<__if_::__<_Pred>, _True, _False...>;
+ using __if_c = __minvoke<__if_::__<_Pred>, _True, _False...>;
-template <class _Pred, class _True, class _False, class... _Args>
-using __minvoke_if = __minvoke<__if<_Pred, _True, _False>, _Args...>;
+ template <class _Pred, class _True, class _False, class... _Args>
+ using __minvoke_if = __minvoke<__if<_Pred, _True, _False>, _Args...>;
-template <bool _Pred, class _True, class _False, class... _Args>
-using __minvoke_if_c = __minvoke<__if_c<_Pred, _True, _False>, _Args...>;
+ template <bool _Pred, class _True, class _False, class... _Args>
+ using __minvoke_if_c = __minvoke<__if_c<_Pred, _True, _False>, _Args...>;
-template <class _Tp>
-struct __mconst
-{
+ template <class _Tp>
+ struct __mconst {
template <class...>
using __f = _Tp;
-};
+ };
-inline constexpr __mstring __mbad_substitution =
+ inline constexpr __mstring __mbad_substitution =
"The specified meta-function could not be evaluated with the types provided."_mstr;
-template <__mstring _Diagnostic = __mbad_substitution>
-struct _BAD_SUBSTITUTION_
-{};
+ template <__mstring _Diagnostic = __mbad_substitution>
+ struct _BAD_SUBSTITUTION_ { };
-template <class... _Args>
-struct _WITH_TYPES_;
+ template <class... _Args>
+ struct _WITH_TYPES_;
-template <template <class...> class _Fun>
-struct _WITH_META_FUNCTION_T_
-{
+ template <template <class...> class _Fun>
+ struct _WITH_META_FUNCTION_T_ {
template <class... _Args>
- using __f = __mexception<_BAD_SUBSTITUTION_<>, _WITH_META_FUNCTION_T_,
- _WITH_TYPES_<_Args...>>;
-};
+ using __f = __mexception<_BAD_SUBSTITUTION_<>, _WITH_META_FUNCTION_T_, _WITH_TYPES_<_Args...>>;
+ };
-template <class _Fun>
-struct _WITH_META_FUNCTION_
-{
+ template <class _Fun>
+ struct _WITH_META_FUNCTION_ {
template <class... _Args>
- using __f = __mexception<_BAD_SUBSTITUTION_<>, _WITH_META_FUNCTION_,
- _WITH_TYPES_<_Args...>>;
-};
+ using __f = __mexception<_BAD_SUBSTITUTION_<>, _WITH_META_FUNCTION_, _WITH_TYPES_<_Args...>>;
+ };
-template <template <class...> class _Try, class _Catch>
-struct __mtry_catch_q
-{
+ template <template <class...> class _Try, class _Catch>
+ struct __mtry_catch_q {
template <class... _Args>
- using __f = __minvoke<__if_c<__mvalid<_Try, _Args...>, __q<_Try>, _Catch>,
- _Args...>;
-};
+ using __f = __minvoke<__if_c<__mvalid<_Try, _Args...>, __q<_Try>, _Catch>, _Args...>;
+ };
-template <class _Try, class _Catch>
-struct __mtry_catch
-{
+ template <class _Try, class _Catch>
+ struct __mtry_catch {
template <class... _Args>
- using __f =
- __minvoke<__if_c<__minvocable<_Try, _Args...>, _Try, _Catch>, _Args...>;
-};
+ using __f = __minvoke<__if_c<__minvocable<_Try, _Args...>, _Try, _Catch>, _Args...>;
+ };
-template <class _Fn, class _Default>
-using __with_default = __mtry_catch<_Fn, __mconst<_Default>>;
+ template <class _Fn, class _Default>
+ using __with_default = __mtry_catch<_Fn, __mconst<_Default>>;
-template <template <class...> class _Fn, class _Default>
-using __with_default_q = __mtry_catch_q<_Fn, __mconst<_Default>>;
+ template <template <class...> class _Fn, class _Default>
+ using __with_default_q = __mtry_catch_q<_Fn, __mconst<_Default>>;
-template <class _Fn, class _Default, class... _Args>
-using __minvoke_or = __minvoke<__with_default<_Fn, _Default>, _Args...>;
+ template <class _Fn, class _Default, class... _Args>
+ using __minvoke_or = __minvoke<__with_default<_Fn, _Default>, _Args...>;
-template <template <class...> class _Fn, class _Default, class... _Args>
-using __meval_or = __minvoke<__with_default_q<_Fn, _Default>, _Args...>;
+ template <template <class...> class _Fn, class _Default, class... _Args>
+ using __meval_or = __minvoke<__with_default_q<_Fn, _Default>, _Args...>;
-template <template <class...> class _Fn>
-struct __mtry_eval_
-{
+ template <template <class...> class _Fn>
+ struct __mtry_eval_ {
template <class... _Args>
using __f = __meval<_Fn, _Args...>;
-};
+ };
-template <template <class...> class _Fn, class... _Args>
-using __mtry_eval =
- __minvoke<__mtry_catch<__mtry_eval_<_Fn>, _WITH_META_FUNCTION_T_<_Fn>>,
- _Args...>;
+ template <template <class...> class _Fn, class... _Args>
+ using __mtry_eval =
+ __minvoke<__mtry_catch<__mtry_eval_<_Fn>, _WITH_META_FUNCTION_T_<_Fn>>, _Args...>;
-template <class _Fn, class... _Args>
-using __mtry_invoke =
- __minvoke<__mtry_catch<_Fn, _WITH_META_FUNCTION_<_Fn>>, _Args...>;
+ template <class _Fn, class... _Args>
+ using __mtry_invoke = __minvoke<__mtry_catch<_Fn, _WITH_META_FUNCTION_<_Fn>>, _Args...>;
-template <class _Ty, class... _Default>
-using __msuccess_or_t = __if_c<__ok<_Ty>, _Ty, _Default...>;
+ template <class _Ty, class... _Default>
+ using __msuccess_or_t = __if_c<__ok<_Ty>, _Ty, _Default...>;
-template <class _Ty, class... _Default>
-using __merror_or_t = __if_c<__merror<_Ty>, _Ty, _Default...>;
+ template <class _Ty, class... _Default>
+ using __merror_or_t = __if_c<__merror<_Ty>, _Ty, _Default...>;
-template <class _Fn, class _Continuation = __q<__types>>
-struct __mtransform
-{
+ template <class _Fn, class _Continuation = __q<__types>>
+ struct __mtransform {
template <class... _Args>
using __f = __minvoke<_Continuation, __minvoke<_Fn, _Args>...>;
-};
+ };
-template <bool>
-struct __mfold_right_
-{
+ template <bool>
+ struct __mfold_right_ {
template <class _Fn, class _State, class _Head, class... _Tail>
- using __f = __minvoke<__mfold_right_<sizeof...(_Tail) == 0>, _Fn,
- __minvoke<_Fn, _State, _Head>, _Tail...>;
-};
+ using __f =
+ __minvoke<__mfold_right_<sizeof...(_Tail) == 0>, _Fn, __minvoke<_Fn, _State, _Head>, _Tail...>;
+ };
-template <>
-struct __mfold_right_<true>
-{ // empty pack
+ template <>
+ struct __mfold_right_<true> { // empty pack
template <class _Fn, class _State, class...>
using __f = _State;
-};
+ };
-template <class _Init, class _Fn>
-struct __mfold_right
-{
+ template <class _Init, class _Fn>
+ struct __mfold_right {
template <class... _Args>
- using __f =
- __minvoke<__mfold_right_<sizeof...(_Args) == 0>, _Fn, _Init, _Args...>;
-};
+ using __f = __minvoke<__mfold_right_<sizeof...(_Args) == 0>, _Fn, _Init, _Args...>;
+ };
-template <bool>
-struct __mfold_left_
-{
+ template <bool>
+ struct __mfold_left_ {
template <class _Fn, class _State, class _Head, class... _Tail>
- using __f = __minvoke<
- _Fn,
- __mcall<__mfold_left_<sizeof...(_Tail) == 0>, _Fn, _State, _Tail...>,
- _Head>;
-};
+ using __f =
+ __minvoke<_Fn, __mcall<__mfold_left_<sizeof...(_Tail) == 0>, _Fn, _State, _Tail...>, _Head>;
+ };
-template <>
-struct __mfold_left_<true>
-{ // empty pack
+ template <>
+ struct __mfold_left_<true> { // empty pack
template <class _Fn, class _State, class...>
using __f = _State;
-};
+ };
-template <class _Init, class _Fn>
-struct __mfold_left
-{
+ template <class _Init, class _Fn>
+ struct __mfold_left {
template <class... _Args>
- using __f =
- __minvoke<__mfold_left_<sizeof...(_Args) == 0>, _Fn, _Init, _Args...>;
-};
+ using __f = __minvoke<__mfold_left_<sizeof...(_Args) == 0>, _Fn, _Init, _Args...>;
+ };
-template <class _Fn>
-struct __mcurry
-{
+ template <class _Fn>
+ struct __mcurry {
template <class... _Ts>
using __f = __minvoke<_Fn, _Ts...>;
-};
+ };
-template <class _Tp>
-struct __muncurry_;
+ template <class _Tp>
+ struct __muncurry_;
-template <template <class...> class _Ap, class... _As>
-struct __muncurry_<_Ap<_As...>>
-{
+ template <template <class...> class _Ap, class... _As>
+ struct __muncurry_<_Ap<_As...>> {
template <class _Fn>
using __f = __minvoke<_Fn, _As...>;
-};
+ };
-template <std::size_t... _Ns>
-struct __muncurry_<__pack::__t<_Ns...>*>
-{
+ template <std::size_t... _Ns>
+ struct __muncurry_<__indices<_Ns...>> {
template <class _Fn>
using __f = __minvoke<_Fn, __msize_t<_Ns>...>;
-};
+ };
-template <template <class _Np, _Np...> class _Cp, class _Np, _Np... _Ns>
-struct __muncurry_<_Cp<_Np, _Ns...>>
-{
+ template <template <class _Np, _Np...> class _Cp, class _Np, _Np... _Ns>
+ struct __muncurry_<_Cp<_Np, _Ns...>> {
template <class _Fn>
using __f = __minvoke<_Fn, std::integral_constant<_Np, _Ns>...>;
-};
+ };
-template <class _What, class... _With>
-struct __muncurry_<_ERROR_<_What, _With...>>
-{
+ template <class _What, class... _With>
+ struct __muncurry_<_ERROR_<_What, _With...>> {
template <class _Fn>
using __f = _ERROR_<_What, _With...>;
-};
+ };
-template <class _Fn>
-struct __muncurry
-{
+ template <class _Fn>
+ struct __muncurry {
template <class _Tp>
- using __f = typename __muncurry_<_Tp>::template __f<_Fn>;
-};
+ using __f = __muncurry_<_Tp>::template __f<_Fn>;
+ };
-template <class _Fn, class _List>
-using __mapply = __minvoke<__muncurry<_Fn>, _List>;
+ template <class _Fn, class _List>
+ using __mapply = __minvoke<__muncurry<_Fn>, _List>;
-template <bool>
-struct __mconcat_
-{
- template <class... _Ts, template <class...> class _Ap = __types,
- class... _As, template <class...> class _Bp = __types,
- class... _Bs, template <class...> class _Cp = __types,
- class... _Cs, template <class...> class _Dp = __types,
- class... _Ds, class... _Tail>
- static auto __f(__types<_Ts...>*, _Ap<_As...>*, _Bp<_Bs...>* = nullptr,
- _Cp<_Cs...>* = nullptr, _Dp<_Ds...>* = nullptr,
- _Tail*... __tail)
- -> decltype(__mconcat_<(sizeof...(_Tail) == 0)>::__f(
- static_cast<__types<_Ts..., _As..., _Bs..., _Cs..., _Ds...>*>(
- nullptr),
- __tail...));
-};
+ template <bool>
+ struct __mconcat_ {
+ template <
+ class... _Ts,
+ template <class...> class _Ap = __types,
+ class... _As,
+ template <class...> class _Bp = __types,
+ class... _Bs,
+ template <class...> class _Cp = __types,
+ class... _Cs,
+ template <class...> class _Dp = __types,
+ class... _Ds,
+ class... _Tail
+ >
+ static auto __f(
+ __types<_Ts...> *,
+ _Ap<_As...> *,
+ _Bp<_Bs...> * = nullptr,
+ _Cp<_Cs...> * = nullptr,
+ _Dp<_Ds...> * = nullptr,
+ _Tail *...__tail)
+ -> __midentity<decltype(__mconcat_<(sizeof...(_Tail) == 0)>::__f(
+ static_cast<__types<_Ts..., _As..., _Bs..., _Cs..., _Ds...> *>(nullptr),
+ __tail...))>;
+ };
-template <>
-struct __mconcat_<true>
-{
+ template <>
+ struct __mconcat_<true> {
template <class... _As>
- static auto __f(__types<_As...>*) -> __types<_As...>;
-};
+ static auto __f(__types<_As...> *) -> __types<_As...>;
+ };
-template <class _Continuation = __qq<__types>>
-struct __mconcat
-{
+ template <class _Continuation = __qq<__types>>
+ struct __mconcat {
template <class... _Args>
- using __f = __mapply<_Continuation,
- decltype(__mconcat_<(sizeof...(_Args) == 0)>::__f(
- {}, static_cast<_Args*>(nullptr)...))>;
-};
+ using __f = __mapply<
+ _Continuation,
+ decltype(__mconcat_<(sizeof...(_Args) == 0)>::__f({}, static_cast<_Args *>(nullptr)...))
+ >;
+ };
-struct __msize
-{
+ struct __msize {
template <class... _Ts>
using __f = __msize_t<sizeof...(_Ts)>;
-};
+ };
-template <class _Ty>
-struct __mcount
-{
+ template <class _Ty>
+ struct __mcount {
template <class... _Ts>
using __f = __msize_t<(__same_as<_Ts, _Ty> + ... + 0)>;
-};
+ };
-template <class _Fn>
-struct __mcount_if
-{
+ template <class _Fn>
+ struct __mcount_if {
template <class... _Ts>
using __f = __msize_t<(bool(__v<__minvoke<_Fn, _Ts>>) + ... + 0)>;
-};
+ };
-template <class _Tp>
-struct __mcontains
-{
+ template <class _Tp>
+ struct __mcontains {
template <class... _Args>
using __f = __mbool<(__same_as<_Tp, _Args> || ...)>;
-};
+ };
-template <class _Continuation = __q<__types>>
-struct __mpush_back
-{
+ template <class _Continuation = __q<__types>>
+ struct __mpush_back {
template <class _List, class _Item>
using __f = __mapply<__mbind_back<_Continuation, _Item>, _List>;
-};
+ };
-template <class...>
-struct __mcompose
-{};
+ template <class...>
+ struct __mcompose { };
-template <class _First>
-struct __mcompose<_First> : _First
-{};
+ template <class _First>
+ struct __mcompose<_First> : _First { };
-template <class _Second, class _First>
-struct __mcompose<_Second, _First>
-{
+ template <class _Second, class _First>
+ struct __mcompose<_Second, _First> {
template <class... _Args>
using __f = __minvoke<_Second, __minvoke<_First, _Args...>>;
-};
+ };
-template <class _Last, class _Penultimate, class... _Rest>
-struct __mcompose<_Last, _Penultimate, _Rest...>
-{
+ template <class _Last, class _Penultimate, class... _Rest>
+ struct __mcompose<_Last, _Penultimate, _Rest...> {
template <class... _Args>
- using __f =
- __minvoke<_Last,
- __minvoke<__mcompose<_Penultimate, _Rest...>, _Args...>>;
-};
+ using __f = __minvoke<_Last, __minvoke<__mcompose<_Penultimate, _Rest...>, _Args...>>;
+ };
-template <template <class...> class _Second, template <class...> class _First>
-struct __mcompose_q
-{
+ template <template <class...> class _Second, template <class...> class _First>
+ struct __mcompose_q {
template <class... _Args>
using __f = _Second<_First<_Args...>>;
-};
+ };
-template <class _Old, class _New, class _Continuation = __q<__types>>
-struct __mreplace
-{
+ template <class _Old, class _New, class _Continuation = __q<__types>>
+ struct __mreplace {
template <class... _Args>
- using __f = __minvoke<_Continuation,
- __if_c<__same_as<_Args, _Old>, _New, _Args>...>;
-};
+ using __f = __minvoke<_Continuation, __if_c<__same_as<_Args, _Old>, _New, _Args>...>;
+ };
-template <class _Old, class _Continuation = __q<__types>>
-struct __mremove
-{
+ template <class _Old, class _Continuation = __q<__types>>
+ struct __mremove {
template <class... _Args>
- using __f = //
- __minvoke<__mconcat<_Continuation>,
- __if_c<__same_as<_Args, _Old>, __types<>, __types<_Args>>...>;
-};
+ using __f = __minvoke<
+ __mconcat<_Continuation>,
+ __if_c<__same_as<_Args, _Old>, __types<>, __types<_Args>>...
+ >;
+ };
-template <class _Pred, class _Continuation = __q<__types>>
-struct __mremove_if
-{
+ template <class _Pred, class _Continuation = __q<__types>>
+ struct __mremove_if {
template <class... _Args>
- using __f = //
- __minvoke<__mconcat<_Continuation>,
- __if<__minvoke<_Pred, _Args>, __types<>, __types<_Args>>...>;
-};
+ using __f = __minvoke<
+ __mconcat<_Continuation>,
+ __if<__minvoke<_Pred, _Args>, __types<>, __types<_Args>>...
+ >;
+ };
-template <class _Return>
-struct __qf
-{
+ template <class _Return>
+ struct __qf {
template <class... _Args>
using __f = _Return(_Args...);
-};
+ };
-template <class _Ty, class...>
-using __mfront_ = _Ty;
-template <class... _As>
-using __mfront = __meval<__mfront_, _As...>;
-template <class... _As>
+ template <class _Ty, class...>
+ using __mfront_ = _Ty;
+ template <class... _As>
+ using __mfront = __meval<__mfront_, _As...>;
+ template <class... _As>
requires(sizeof...(_As) == 1)
-using __msingle = __mfront<_As...>;
-template <class _Default, class... _As>
+ using __msingle = __mfront<_As...>;
+ template <class _Default, class... _As>
requires(sizeof...(_As) <= 1)
-using __msingle_or_ = __mfront<_As..., _Default>;
-template <class _Default>
-using __msingle_or = __mbind_front_q<__msingle_or_, _Default>;
+ using __msingle_or_ = __mfront<_As..., _Default>;
+ template <class _Default>
+ using __msingle_or = __mbind_front_q<__msingle_or_, _Default>;
-//! A concept checking if `_Ty` has a dependent type `_Ty::__id`.
-//! See MAINTAINERS.md#class-template-parameters.
-template <class _Ty>
-concept __has_id = requires { typename _Ty::__id; };
+ //! A concept checking if `_Ty` has a dependent type `_Ty::__id`.
+ //! See MAINTAINERS.md#class-template-parameters.
+ template <class _Ty>
+ concept __has_id = requires { typename _Ty::__id; };
-//! Identity mapping `_Ty` to itself.
-//! That is, `std::is_same_v<T, typename _Id<T>::__t>`.
-template <class _Ty>
-struct _Id
-{
+ //! Identity mapping `_Ty` to itself.
+ //! That is, `std::is_same_v<T, typename _Id<T>::__t>`.
+ template <class _Ty>
+ struct _Id {
using __t = _Ty;
// Uncomment the line below to find any code that likely misuses the
@@ -964,593 +845,396 @@
// reference is a likely misuse. The static_assert below will trigger
// when the type passed to the __id alias template is a reference to
// a type that is setup to use ADL isolation.
- // static_assert(!__has_id<std::remove_cvref_t<_Ty>>);
-};
+ //static_assert(!__has_id<std::remove_cvref_t<_Ty>>);
+ };
-//! Helper metafunction detail of `__id`, below.
-template <bool = true>
-struct __id_
-{
+ //! Helper metafunction detail of `__id`, below.
+ template <bool = true>
+ struct __id_ {
template <class _Ty>
- using __f = typename _Ty::__id;
-};
+ using __f = _Ty::__id;
+ };
-template <>
-struct __id_<false>
-{
+ template <>
+ struct __id_<false> {
template <class _Ty>
using __f = _Id<_Ty>;
-};
+ };
-//! Metafunction mapping `_Ty` to either
-//! * `typename _Ty::__id` if that exists, or to
-//! * `_Ty` (itself) otherwise.
-//! See MAINTAINERS.md#class-template-parameters.
-template <class _Ty>
-using __id = __minvoke<__id_<__has_id<_Ty>>, _Ty>;
+ //! Metafunction mapping `_Ty` to either
+ //! * `typename _Ty::__id` if that exists, or to
+ //! * `_Ty` (itself) otherwise.
+ //! See MAINTAINERS.md#class-template-parameters.
+ template <class _Ty>
+ using __id = __minvoke<__id_<__has_id<_Ty>>, _Ty>;
-template <class _From, class _To = __decay_t<_From>>
-using __cvref_t = __copy_cvref_t<_From, __t<_To>>;
+ template <class _From, class _To = __decay_t<_From>>
+ using __cvref_t = __copy_cvref_t<_From, __t<_To>>;
-template <class _From, class _To = __decay_t<_From>>
-using __cvref_id = __copy_cvref_t<_From, __id<_To>>;
+ template <class _From, class _To = __decay_t<_From>>
+ using __cvref_id = __copy_cvref_t<_From, __id<_To>>;
#if STDEXEC_EDG()
-// nvc++ doesn't cache the results of alias template specializations.
-// To avoid repeated computation of the same function return type,
-// cache the result ourselves in a class template specialization.
-template <class _Fun, class... _As>
-using __call_result_ = decltype(__declval<_Fun>()(__declval<_As>()...));
-template <class _Fun, class... _As>
-using __call_result_t = __t<__mdefer<__q<__call_result_>, _Fun, _As...>>;
+ // nvc++ doesn't cache the results of alias template specializations.
+ // To avoid repeated computation of the same function return type,
+ // cache the result ourselves in a class template specialization.
+ template <class _Fun, class... _As>
+ using __call_result_ = decltype(__declval<_Fun>()(__declval<_As>()...));
+ template <class _Fun, class... _As>
+ using __call_result_t = __t<__mdefer<__q<__call_result_>, _Fun, _As...>>;
#else
-template <class _Fun, class... _As>
-using __call_result_t = decltype(__declval<_Fun>()(__declval<_As>()...));
+ template <class _Fun, class... _As>
+ using __call_result_t = decltype(__declval<_Fun>()(__declval<_As>()...));
#endif
// BUGBUG TODO file this bug with nvc++
#if STDEXEC_EDG()
-template <const auto& _Fun, class... _As>
-using __result_of = __call_result_t<decltype(_Fun), _As...>;
+ template <const auto &_Fun, class... _As>
+ using __result_of = __call_result_t<decltype(_Fun), _As...>;
#else
-template <const auto& _Fun, class... _As>
-using __result_of = decltype(_Fun(__declval<_As>()...));
+ template <const auto &_Fun, class... _As>
+ using __result_of = decltype(_Fun(__declval<_As>()...));
#endif
-template <const auto& _Fun, class... _As>
-inline constexpr bool __noexcept_of = noexcept(_Fun(__declval<_As>()...));
+ template <const auto &_Fun, class... _As>
+ inline constexpr bool __noexcept_of = noexcept(_Fun(__declval<_As>()...));
-// For emplacing non-movable types into optionals:
-template <class _Fn>
+ // For emplacing non-movable types into optionals:
+ template <class _Fn>
requires std::is_nothrow_move_constructible_v<_Fn>
-struct __emplace_from
-{
+ struct __emplace_from {
_Fn __fn_;
using __t = __call_result_t<_Fn>;
- operator __t() && noexcept(__nothrow_callable<_Fn>)
- {
- return static_cast<_Fn&&>(__fn_)();
+ operator __t() && noexcept(__nothrow_callable<_Fn>) {
+ return static_cast<_Fn &&>(__fn_)();
}
- auto operator()() && noexcept(__nothrow_callable<_Fn>) -> __t
- {
- return static_cast<_Fn&&>(__fn_)();
+ auto operator()() && noexcept(__nothrow_callable<_Fn>) -> __t {
+ return static_cast<_Fn &&>(__fn_)();
}
-};
+ };
-template <class _Fn>
-__emplace_from(_Fn) -> __emplace_from<_Fn>;
+ template <class _Fn>
+ __emplace_from(_Fn) -> __emplace_from<_Fn>;
-template <class _Fn, class _Continuation, class _List1, class _List2>
-struct __mzip_with2_ :
- __mzip_with2_<_Fn, _Continuation, __mapply<__qq<__types>, _List1>,
- __mapply<__qq<__types>, _List2>>
-{};
+ template <class _Fn, class _Continuation, class _List1, class _List2>
+ struct __mzip_with2_
+ : __mzip_with2_<
+ _Fn,
+ _Continuation,
+ __mapply<__qq<__types>, _List1>,
+ __mapply<__qq<__types>, _List2>
+ > { };
-template < //
- class _Fn, //
- class _Continuation, //
+ template <
+ class _Fn,
+ class _Continuation,
template <class...> class _Cp,
- class... _Cs, //
- template <class...> class _Dp, class... _Ds>
- requires requires {
- typename __minvoke<_Continuation, __minvoke<_Fn, _Cs, _Ds>...>;
- }
-struct __mzip_with2_<_Fn, _Continuation, _Cp<_Cs...>, _Dp<_Ds...>>
-{
+ class... _Cs,
+ template <class...> class _Dp,
+ class... _Ds
+ >
+ requires requires { typename __minvoke<_Continuation, __minvoke<_Fn, _Cs, _Ds>...>; }
+ struct __mzip_with2_<_Fn, _Continuation, _Cp<_Cs...>, _Dp<_Ds...>> {
using __t = __minvoke<_Continuation, __minvoke<_Fn, _Cs, _Ds>...>;
-};
+ };
-template <class _Fn, class _Continuation = __q<__types>>
-struct __mzip_with2
-{
+ template <class _Fn, class _Continuation = __q<__types>>
+ struct __mzip_with2 {
template <class _Cp, class _Dp>
using __f = __t<__mzip_with2_<_Fn, _Continuation, _Cp, _Dp>>;
-};
+ };
-template <bool>
-struct __mfind_if_
-{
+ template <bool>
+ struct __mfind_if_ {
template <class _Fn, class _Continuation, class _Head, class... _Tail>
- using __f = //
- __minvoke<__if_c<__v<__minvoke<_Fn, _Head>>,
- __mbind_front<_Continuation, _Head>,
- __mbind_front<__mfind_if_<(sizeof...(_Tail) != 0)>,
- _Fn, _Continuation>>,
- _Tail...>;
-};
+ using __f = __minvoke<
+ __if_c<
+ __v<__minvoke<_Fn, _Head>>,
+ __mbind_front<_Continuation, _Head>,
+ __mbind_front<__mfind_if_<(sizeof...(_Tail) != 0)>, _Fn, _Continuation>
+ >,
+ _Tail...
+ >;
+ };
-template <>
-struct __mfind_if_<false>
-{
+ template <>
+ struct __mfind_if_<false> {
template <class _Fn, class _Continuation>
using __f = __minvoke<_Continuation>;
-};
+ };
-template <class _Fn, class _Continuation = __q<__types>>
-struct __mfind_if
-{
+ template <class _Fn, class _Continuation = __q<__types>>
+ struct __mfind_if {
template <class... _Args>
- using __f = __minvoke<__mfind_if_<(sizeof...(_Args) != 0)>, _Fn,
- _Continuation, _Args...>;
-};
+ using __f = __minvoke<__mfind_if_<(sizeof...(_Args) != 0)>, _Fn, _Continuation, _Args...>;
+ };
-template <class _Fn>
-struct __mfind_if_i
-{
+ template <class _Fn>
+ struct __mfind_if_i {
template <class... _Args>
- using __f = __msize_t<(
- sizeof...(_Args) - __v<__minvoke<__mfind_if<_Fn, __msize>, _Args...>>)>;
-};
+ using __f = __msize_t<(sizeof...(_Args) - __v<__minvoke<__mfind_if<_Fn, __msize>, _Args...>>)>;
+ };
#if STDEXEC_MSVC()
-#define __mvalue_of(...) __VA_ARGS__::value
+# define __mvalue_of(...) __VA_ARGS__::value
#else
-#define __mvalue_of(...) __v<__VA_ARGS__>
+# define __mvalue_of(...) __v<__VA_ARGS__>
#endif
-template <class... _Booleans>
-using __mand_t = __mbool<(__mvalue_of(_Booleans) && ...)>;
-template <class... _Booleans>
-using __mand = __meval<__mand_t, _Booleans...>;
+ template <class... _Booleans>
+ using __mand_t = __mbool<(__mvalue_of(_Booleans) && ...)>;
+ template <class... _Booleans>
+ using __mand = __meval<__mand_t, _Booleans...>;
-template <class... _Booleans>
-using __mor_t = __mbool<(__mvalue_of(_Booleans) || ...)>;
-template <class... _Booleans>
-using __mor = __meval<__mor_t, _Booleans...>;
+ template <class... _Booleans>
+ using __mor_t = __mbool<(__mvalue_of(_Booleans) || ...)>;
+ template <class... _Booleans>
+ using __mor = __meval<__mor_t, _Booleans...>;
-template <class _Boolean>
-using __mnot_t = __mbool<!__mvalue_of(_Boolean)>;
-template <class _Boolean>
-using __mnot = __meval<__mnot_t, _Boolean>;
+ template <class _Boolean>
+ using __mnot_t = __mbool<!__mvalue_of(_Boolean)>;
+ template <class _Boolean>
+ using __mnot = __meval<__mnot_t, _Boolean>;
#if STDEXEC_EDG()
-template <class... _Ints>
-struct __mplus_t : __mconstant<(__v<_Ints> + ...)>
-{};
+ template <class... _Ints>
+ struct __mplus_t : __mconstant<(__v<_Ints> + ...)> { };
#else
-template <class... _Ints>
-using __mplus_t = __mconstant<(__mvalue_of(_Ints) + ...)>;
+ template <class... _Ints>
+ using __mplus_t = __mconstant<(__mvalue_of(_Ints) + ...)>;
#endif
#undef __mvalue_of
-template <class _Fn>
-struct __mall_of
-{
+ template <class _Fn>
+ struct __mall_of {
template <class... _Args>
using __f = __mand<__minvoke<_Fn, _Args>...>;
-};
+ };
-template <class _Fn>
-struct __mnone_of
-{
+ template <class _Fn>
+ struct __mnone_of {
template <class... _Args>
using __f = __mand<__mnot<__minvoke<_Fn, _Args>>...>;
-};
+ };
-template <class _Fn>
-struct __many_of
-{
+ template <class _Fn>
+ struct __many_of {
template <class... _Args>
using __f = __mor<__minvoke<_Fn, _Args>...>;
-};
+ };
-// C++23 pack indexing is disabled for clang because of
-// https://github.com/llvm/llvm-project/issues/116105
-#if defined(__cpp_pack_indexing) && !STDEXEC_CLANG()
-template <class _Np, class... _Ts>
-using __m_at = _Ts...[__v<_Np>];
+#if !STDEXEC_STD_NO_PACK_INDEXING()
+ STDEXEC_PRAGMA_PUSH()
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wc++26-extensions")
-template <std::size_t _Np, class... _Ts>
-using __m_at_c = _Ts...[_Np];
+ template <bool>
+ struct __m_at_ {
+ template <class _Np, class... _Ts>
+ using __f = _Ts...[__v<_Np>];
+ };
+
+ template <class _Np, class... _Ts>
+ using __m_at = __minvoke<__m_at_<__v<_Np> == ~0ul>, _Np, _Ts...>;
+
+ template <std::size_t _Np, class... _Ts>
+ using __m_at_c = __minvoke<__m_at_<_Np == ~0ul>, __msize_t<_Np>, _Ts...>;
+
+ STDEXEC_PRAGMA_POP()
#elif STDEXEC_HAS_BUILTIN(__type_pack_element)
-template <bool>
-struct __m_at_
-{
+ template <bool>
+ struct __m_at_ {
template <class _Np, class... _Ts>
using __f = __type_pack_element<__v<_Np>, _Ts...>;
-};
+ };
-template <class _Np, class... _Ts>
-using __m_at = __minvoke<__m_at_<__v<_Np> == ~0ul>, _Np, _Ts...>;
+ template <class _Np, class... _Ts>
+ using __m_at = __minvoke<__m_at_<__v<_Np> == ~0ul>, _Np, _Ts...>;
-template <std::size_t _Np, class... _Ts>
-using __m_at_c = __minvoke<__m_at_<_Np == ~0ul>, __msize_t<_Np>, _Ts...>;
+ template <std::size_t _Np, class... _Ts>
+ using __m_at_c = __minvoke<__m_at_<_Np == ~0ul>, __msize_t<_Np>, _Ts...>;
#else
-template <std::size_t>
-using __void_ptr = void*;
+ template <std::size_t>
+ using __void_ptr = void *;
-template <class _Ty>
-using __mtype_ptr = __mtype<_Ty>*;
+ template <class _Ty>
+ using __mtype_ptr = __mtype<_Ty> *;
-template <class _Ty>
-struct __m_at_;
+ template <class _Ty>
+ struct __m_at_;
-template <std::size_t... _Is>
-struct __m_at_<__indices<_Is...>>
-{
+ template <std::size_t... _Is>
+ struct __m_at_<__indices<_Is...>> {
template <class _Up, class... _Us>
- static _Up __f_(__void_ptr<_Is>..., _Up*, _Us*...);
+ static _Up __f_(__void_ptr<_Is>..., _Up *, _Us *...);
template <class... _Ts>
using __f = __t<decltype(__m_at_::__f_(__mtype_ptr<_Ts>()...))>;
-};
+ };
-template <std::size_t _Np, class... _Ts>
-using __m_at_c = __minvoke<__m_at_<__make_indices<_Np>>, _Ts...>;
+ template <std::size_t _Np, class... _Ts>
+ using __m_at_c = __minvoke<__m_at_<__make_indices<_Np>>, _Ts...>;
-template <class _Np, class... _Ts>
-using __m_at = __m_at_c<__v<_Np>, _Ts...>;
+ template <class _Np, class... _Ts>
+ using __m_at = __m_at_c<__v<_Np>, _Ts...>;
#endif
-template <class... _Ts>
-using __mback = __m_at_c<sizeof...(_Ts) - 1, _Ts...>;
+ template <class... _Ts>
+ using __mback = __m_at_c<sizeof...(_Ts) - 1, _Ts...>;
-template <class _Continuation = __q<__types>>
-struct __mpop_back
-{
+ template <class _Continuation = __q<__types>>
+ struct __mpop_back {
template <class>
struct __impl;
template <std::size_t... _Idx>
- struct __impl<__indices<_Idx...>>
- {
- template <class... _Ts>
- using __f = __minvoke<_Continuation, __m_at_c<_Idx, _Ts...>...>;
+ struct __impl<__indices<_Idx...>> {
+ template <class... _Ts>
+ using __f = __minvoke<_Continuation, __m_at_c<_Idx, _Ts...>...>;
};
template <class... _Ts>
- requires(sizeof...(_Ts) != 0)
+ requires(sizeof...(_Ts) != 0)
using __f = __minvoke<__impl<__make_indices<sizeof...(_Ts) - 1>>, _Ts...>;
-};
+ };
-template <std::size_t _Np>
-struct __placeholder
-{
+ template <std::size_t _Np>
+ struct __placeholder {
__placeholder() = default;
- constexpr __placeholder(void*) noexcept {}
-
- constexpr friend auto __get_placeholder_offset(__placeholder) noexcept
- -> std::size_t
- {
- return _Np;
+ constexpr __placeholder(void *) noexcept {
}
-};
-using __0 = __placeholder<0>;
-using __1 = __placeholder<1>;
-using __2 = __placeholder<2>;
-using __3 = __placeholder<3>;
+ constexpr friend auto __get_placeholder_offset(__placeholder) noexcept -> std::size_t {
+ return _Np;
+ }
+ };
+
+ using __0 = __placeholder<0>;
+ using __1 = __placeholder<1>;
+ using __2 = __placeholder<2>;
+ using __3 = __placeholder<3>;
#if defined(__cpp_pack_indexing)
-template <std::size_t _Np>
-struct __nth_pack_element_t
-{
+ STDEXEC_PRAGMA_PUSH()
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wc++26-extensions")
+
+ template <std::size_t _Np>
+ struct __nth_pack_element_t {
template <class... _Ts>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr decltype(auto) operator()(_Ts&&... __ts) const noexcept
- {
- static_assert(_Np < sizeof...(_Ts));
- return static_cast<_Ts...[_Np]&&>(__ts...[_Np]);
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr auto operator()(_Ts &&...__ts) const noexcept -> decltype(auto) {
+ static_assert(_Np < sizeof...(_Ts));
+ return static_cast<_Ts...[_Np] &&>(__ts...[_Np]);
}
-};
+ };
+
+ STDEXEC_PRAGMA_POP()
#else
-template <class... _Ignore>
-struct __nth_pack_element_impl
-{
+ template <class... _Ignore>
+ struct __nth_pack_element_impl {
template <class _Ty, class... _Us>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr _Ty&& operator()(_Ignore..., _Ty&& __t, _Us&&...) const noexcept
- {
- return static_cast<decltype(__t)&&>(__t);
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr _Ty &&operator()(_Ignore..., _Ty &&__t, _Us &&...) const noexcept {
+ return static_cast<decltype(__t) &&>(__t);
}
-};
+ };
-template <std::size_t _Np>
-struct __nth_pack_element_t
-{
+ template <std::size_t _Np>
+ struct __nth_pack_element_t {
template <std::size_t... _Is>
- STDEXEC_ATTRIBUTE((always_inline))
- static constexpr auto __impl(__indices<_Is...>) noexcept
- {
- return __nth_pack_element_impl<__ignore_t<_Is>...>();
+ STDEXEC_ATTRIBUTE(always_inline)
+ static constexpr auto __impl(__indices<_Is...>) noexcept {
+ return __nth_pack_element_impl<__ignore_t<_Is>...>();
}
template <class... _Ts>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr decltype(auto) operator()(_Ts&&... __ts) const noexcept
- {
- static_assert(_Np < sizeof...(_Ts));
- return __impl(__make_indices<_Np>())(static_cast<_Ts&&>(__ts)...);
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr decltype(auto) operator()(_Ts &&...__ts) const noexcept {
+ static_assert(_Np < sizeof...(_Ts));
+ return __impl(__make_indices<_Np>())(static_cast<_Ts &&>(__ts)...);
}
-};
+ };
#endif
-template <std::size_t _Np>
-inline constexpr __nth_pack_element_t<_Np> __nth_pack_element{};
+ template <std::size_t _Np>
+ inline constexpr __nth_pack_element_t<_Np> __nth_pack_element{};
-template <auto... _Vs>
-struct __mliterals
-{
+ template <auto... _Vs>
+ struct __mliterals {
template <std::size_t _Np>
- STDEXEC_ATTRIBUTE((always_inline))
- static constexpr auto __nth() noexcept
- {
- return stdexec::__nth_pack_element<_Np>(_Vs...);
+ STDEXEC_ATTRIBUTE(always_inline)
+ static constexpr auto __nth() noexcept {
+ return stdexec::__nth_pack_element<_Np>(_Vs...);
}
-};
+ };
-template <std::size_t _Np>
-struct __nth_member
-{
+ template <std::size_t _Np>
+ struct __nth_member {
template <class _Ty>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr decltype(auto) operator()(_Ty&& __ty) const noexcept
- {
- return static_cast<_Ty&&>(__ty).*(__ty.__mbrs_.template __nth<_Np>());
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr auto operator()(_Ty &&__ty) const noexcept -> decltype(auto) {
+ return static_cast<_Ty &&>(__ty).*(__ty.__mbrs_.template __nth<_Np>());
}
-};
+ };
-template <class _Ty, std::size_t _Offset = 0>
-struct __mdispatch_
-{
+ template <class _Set, class... _Ty>
+ concept __mset_contains = (STDEXEC_IS_BASE_OF(__mtype<_Ty>, _Set) && ...);
+
+ struct __mset_nil;
+
+ namespace __set {
template <class... _Ts>
- auto operator()(_Ts&&...) const noexcept(noexcept(_Ty{})) -> _Ty
- {
- return _Ty{};
- }
-};
-
-template <std::size_t _Np, std::size_t _Offset>
-struct __mdispatch_<__placeholder<_Np>, _Offset>
-{
- template <class... _Ts>
- auto operator()(_Ts&&... __ts) const noexcept -> decltype(auto)
- {
- return stdexec::__nth_pack_element<_Np + _Offset>(
- static_cast<_Ts&&>(__ts)...);
- }
-};
-
-template <std::size_t _Np, std::size_t _Offset>
-struct __mdispatch_<__placeholder<_Np>&, _Offset>
-{
- template <class... _Ts>
- auto operator()(_Ts&&... __ts) const noexcept -> decltype(auto)
- {
- return stdexec::__nth_pack_element<_Np + _Offset>(__ts...);
- }
-};
-
-template <std::size_t _Np, std::size_t _Offset>
-struct __mdispatch_<__placeholder<_Np>&&, _Offset>
-{
- template <class... _Ts>
- auto operator()(_Ts&&... __ts) const noexcept -> decltype(auto)
- {
- return std::move(stdexec::__nth_pack_element<_Np + _Offset>(__ts...));
- }
-};
-
-template <std::size_t _Np, std::size_t _Offset>
-struct __mdispatch_<const __placeholder<_Np>&, _Offset>
-{
- template <class... _Ts>
- auto operator()(_Ts&&... __ts) const noexcept -> decltype(auto)
- {
- return std::as_const(
- stdexec::__nth_pack_element<_Np + _Offset>(__ts...));
- }
-};
-
-template <class _Ret, class... _Args, std::size_t _Offset>
-struct __mdispatch_<_Ret (*)(_Args...), _Offset>
-{
- template <class... _Ts>
- requires(__callable<__mdispatch_<_Args, _Offset>, _Ts...> && ...) &&
- __callable<_Ret, __call_result_t<__mdispatch_<_Args, _Offset>,
- _Ts...>...>
- auto operator()(_Ts&&... __ts) const noexcept(
- __nothrow_callable<
- _Ret, __call_result_t<__mdispatch_<_Args, _Offset>, _Ts...>...>)
- -> __call_result_t<
- _Ret, __call_result_t<__mdispatch_<_Args, _Offset>, _Ts...>...>
- {
- return _Ret{}(
- __mdispatch_<_Args, _Offset>{}(static_cast<_Ts&&>(__ts)...)...);
- }
-};
-
-template <class _Ret, class... _Args, std::size_t _Offset>
-struct __mdispatch_<_Ret (*)(_Args..., ...), _Offset>
-{
- static_assert(_Offset == 0, "nested pack expressions are not supported");
- using _Pattern = __mback<_Args...>;
- static constexpr std::size_t __offset =
- __get_placeholder_offset(static_cast<__mtype<_Pattern>*>(nullptr));
-
- struct __impl
- {
- template <std::size_t... _Idx, class... _Ts>
- requires(__callable<__mdispatch_<_Args>, _Ts...> && ...) &&
- (__callable<__mdispatch_<_Pattern, _Idx + 1>, _Ts...> &&
- ...) &&
- __callable< //
- _Ret, __call_result_t<__mdispatch_<_Args>, _Ts...>...,
- __call_result_t<__mdispatch_<_Pattern, _Idx + 1>,
- _Ts...>...>
- auto operator()(__indices<_Idx...>, _Ts&&... __ts) const noexcept(
- __nothrow_callable< //
- _Ret, //
- __call_result_t<__mdispatch_<_Args>, _Ts...>..., //
- __call_result_t<__mdispatch_<_Pattern, _Idx + 1>, _Ts...>...>)
- -> __call_result_t< //
- _Ret, __call_result_t<__mdispatch_<_Args>, _Ts...>...,
- __call_result_t<__mdispatch_<_Pattern, _Idx + 1>, _Ts...>...>
- {
- return _Ret()( //
- __mdispatch_<_Args>()(static_cast<_Ts&&>(__ts)...)..., //
- __mdispatch_<_Pattern, _Idx + 1>()(
- static_cast<_Ts&&>(__ts)...)...);
- }
+ struct __inherit : __mtype<__mset_nil> {
+ template <template <class...> class _Fn>
+ using rebind = _Fn<_Ts...>;
};
- template <class... _Ts>
- requires(__offset < sizeof...(_Ts)) &&
- __callable<__impl,
- __make_indices<sizeof...(_Ts) - __offset - 1>,
- _Ts...>
- auto operator()(_Ts&&... __ts) const noexcept(
- __nothrow_callable<
- __impl, __make_indices<sizeof...(_Ts) - __offset - 1>, _Ts...>)
- -> __msecond<
- __if_c<(__offset < sizeof...(_Ts))>,
- __call_result_t<
- __impl, __make_indices<sizeof...(_Ts) - __offset - 1>, _Ts...>>
- {
- return __impl()(__make_indices<sizeof...(_Ts) - __offset - 1>(),
- static_cast<_Ts&&>(__ts)...);
- }
+ template <class _Ty, class... _Ts>
+ struct __inherit<_Ty, _Ts...>
+ : __mtype<_Ty>
+ , __inherit<_Ts...> {
+ template <template <class...> class _Fn>
+ using rebind = _Fn<_Ty, _Ts...>;
+ };
- template <class... _Ts>
- requires(sizeof...(_Ts) == __offset) &&
- __callable<
- __mdispatch_<__minvoke<__mpop_back<__qf<_Ret>>, _Args...>*>,
- _Ts...>
- auto operator()(_Ts&&... __ts) const //
- noexcept(__nothrow_callable<
- __mdispatch_<__minvoke<__mpop_back<__qf<_Ret>>, _Args...>*>,
- _Ts...>)
- -> __msecond<
- __if_c<(sizeof...(_Ts) == __offset)>,
- __call_result_t<
- __mdispatch_<__minvoke<__mpop_back<__qf<_Ret>>, _Args...>*>,
- _Ts...>>
- {
- return __mdispatch_<__minvoke<__mpop_back<__qf<_Ret>>, _Args...>*>()(
- static_cast<_Ts&&>(__ts)...);
- }
-};
+ template <class... _Set>
+ auto operator+(__inherit<_Set...> &) -> __inherit<_Set...>;
-template <class _Ty>
-struct __mdispatch
-{};
+ template <class... _Set, class _Ty>
+ auto operator%(__inherit<_Set...> &, __mtype<_Ty> &) -> __if_c<
+ __mset_contains<__inherit<_Set...>, _Ty>,
+ __inherit<_Set...>,
+ __inherit<_Ty, _Set...>
+ > &;
-template <class _Ret, class... _Args>
-struct __mdispatch<_Ret(_Args...)> : __mdispatch_<_Ret (*)(_Args...)>
-{};
+ template <class _ExpectedSet, class... _Ts>
+ concept __mset_eq = (sizeof...(_Ts) == __v<__mapply<__msize, _ExpectedSet>>)
+ && __mset_contains<_ExpectedSet, _Ts...>;
-template <class _Ret, class... _Args>
-struct __mdispatch<_Ret(_Args..., ...)> : __mdispatch_<_Ret (*)(_Args..., ...)>
-{};
+ template <class _ExpectedSet>
+ struct __eq {
+ template <class... _Ts>
+ using __f = __mbool<__mset_eq<_ExpectedSet, _Ts...>>;
+ };
+ } // namespace __set
-template <class _Ty, class... _Ts>
-concept __dispatchable = __callable<__mdispatch<_Ty>, _Ts...>;
+ template <class... _Ts>
+ using __mset = __set::__inherit<_Ts...>;
-template <class _Ty, class... _Ts>
-concept __nothrow_dispatchable = __nothrow_callable<__mdispatch<_Ty>, _Ts...>;
+ template <class _Set, class... _Ts>
+ using __mset_insert = decltype(+(__declval<_Set &>() % ... % __declval<__mtype<_Ts> &>()));
-template <class _Ty, class... _Ts>
-using __dispatch_result_t = __call_result_t<__mdispatch<_Ty>, _Ts...>;
+ template <class... _Ts>
+ using __mmake_set = __mset_insert<__mset<>, _Ts...>;
-template <class _Signature, class... _Args>
-using __try_dispatch_ = __mbool<__dispatchable<_Signature, _Args...>>;
+ template <class _Set1, class _Set2>
+ concept __mset_eq = __v<__mapply<__set::__eq<_Set1>, _Set2>>;
-template <class _Signatures, class _Continuation = __q<__mfront>>
-struct __which
-{};
-
-template <template <class...> class _Cp, class... _Signatures,
- class _Continuation>
-struct __which<_Cp<_Signatures...>, _Continuation>
-{
- template <class... _Args>
- using __f = //
- __minvoke<__mfind_if<__mbind_back_q<__try_dispatch_, _Args...>,
- _Continuation>,
- _Signatures...>;
-};
-
-template <class _Signatures, class _DefaultFn, class... _Args>
-using __make_dispatcher = //
- __minvoke<__mtry_catch<__mcompose<__q<__mdispatch>, __which<_Signatures>>,
- _DefaultFn>,
- _Args...>;
-
-template <class _Set, class... _Ty>
-concept __mset_contains = (STDEXEC_IS_BASE_OF(__mtype<_Ty>, _Set) && ...);
-
-namespace __set
-{
-template <class... _Ts>
-struct __inherit
-{};
-
-template <class _Ty, class... _Ts>
-struct __inherit<_Ty, _Ts...> : __mtype<_Ty>, __inherit<_Ts...>
-{};
-
-template <class... _Set>
-auto operator+(__inherit<_Set...>&) -> __inherit<_Set...>;
-
-template <class... _Set, class _Ty>
-auto operator%(__inherit<_Set...>&, __mtype<_Ty>&) //
- -> __if_c< //
- __mset_contains<__inherit<_Set...>, _Ty>, __inherit<_Set...>,
- __inherit<_Ty, _Set...>>&;
-
-template <class _ExpectedSet, class... _Ts>
-concept __mset_eq = //
- (sizeof...(_Ts) == __v<__mapply<__msize, _ExpectedSet>>) && //
- __mset_contains<_ExpectedSet, _Ts...>;
-
-template <class _ExpectedSet>
-struct __eq
-{
- template <class... _Ts>
- using __f = __mbool<__mset_eq<_ExpectedSet, _Ts...>>;
-};
-} // namespace __set
-
-template <class... _Ts>
-using __mset = __set::__inherit<_Ts...>;
-
-template <class _Set, class... _Ts>
-using __mset_insert =
- decltype(+(__declval<_Set&>() % ... % __declval<__mtype<_Ts>&>()));
-
-template <class... _Ts>
-using __mmake_set = __mset_insert<__mset<>, _Ts...>;
-
-template <class _Set1, class _Set2>
-concept __mset_eq = __v<__mapply<__set::__eq<_Set1>, _Set2>>;
-
-template <class _Continuation = __q<__types>>
-struct __munique
-{
+ template <class _Continuation = __q<__types>>
+ struct __munique {
template <class... _Ts>
using __f = __mapply<_Continuation, __mmake_set<_Ts...>>;
-};
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__on.hpp b/include/sdbusplus/async/stdexec/__detail/__on.hpp
index e2347a3..5255fe1 100644
--- a/include/sdbusplus/async/stdexec/__detail/__on.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__on.hpp
@@ -21,247 +21,206 @@
#include "__basic_sender.hpp"
#include "__concepts.hpp"
#include "__continues_on.hpp"
-#include "__cpo.hpp"
#include "__diagnostics.hpp"
#include "__domain.hpp"
#include "__env.hpp"
#include "__inline_scheduler.hpp"
#include "__meta.hpp"
#include "__schedulers.hpp"
+#include "__senders_core.hpp"
#include "__sender_adaptor_closure.hpp"
#include "__sender_introspection.hpp"
-#include "__senders_core.hpp"
#include "__transform_sender.hpp"
#include "__type_traits.hpp"
#include "__utility.hpp"
#include "__write_env.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.on]
-namespace __on_v2
-{
-inline constexpr __mstring __on_context =
- "In stdexec::on(Scheduler, Sender)..."_mstr;
-inline constexpr __mstring __no_scheduler_diag =
- "stdexec::on() requires a scheduler to transition back to."_mstr;
-inline constexpr __mstring __no_scheduler_details =
- "The provided environment lacks a value for the get_scheduler() query."_mstr;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.on]
+ namespace __on {
+ inline constexpr __mstring __on_context = "In stdexec::on(Scheduler, Sender)..."_mstr;
+ inline constexpr __mstring __no_scheduler_diag =
+ "stdexec::on() requires a scheduler to transition back to."_mstr;
+ inline constexpr __mstring __no_scheduler_details =
+ "The provided environment lacks a value for the get_scheduler() query."_mstr;
-template <__mstring _Context = __on_context,
- __mstring _Diagnostic = __no_scheduler_diag,
- __mstring _Details = __no_scheduler_details>
-struct _CANNOT_RESTORE_EXECUTION_CONTEXT_AFTER_ON_
-{};
+ template <
+ __mstring _Context = __on_context,
+ __mstring _Diagnostic = __no_scheduler_diag,
+ __mstring _Details = __no_scheduler_details
+ >
+ struct _CANNOT_RESTORE_EXECUTION_CONTEXT_AFTER_ON_ { };
-struct on_t;
+ struct on_t;
-template <class _Sender, class _Env>
-struct __no_scheduler_in_environment
-{
- using sender_concept = sender_t;
+ template <class _Sender, class _Env>
+ struct __no_scheduler_in_environment {
+ using sender_concept = sender_t;
- static auto get_completion_signatures(const __no_scheduler_in_environment&,
- const auto&) noexcept
- {
- return __mexception<_CANNOT_RESTORE_EXECUTION_CONTEXT_AFTER_ON_<>,
- _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>{};
- }
-};
+ static auto
+ get_completion_signatures(const __no_scheduler_in_environment&, const auto&) noexcept {
+ return __mexception<
+ _CANNOT_RESTORE_EXECUTION_CONTEXT_AFTER_ON_<>,
+ _WITH_SENDER_<_Sender>,
+ _WITH_ENVIRONMENT_<_Env>
+ >{};
+ }
+ };
-template <class _Scheduler, class _Closure>
-struct __on_data
-{
- _Scheduler __sched_;
- _Closure __clsur_;
-};
-template <class _Scheduler, class _Closure>
-__on_data(_Scheduler, _Closure) -> __on_data<_Scheduler, _Closure>;
+ template <class _Scheduler, class _Closure>
+ struct __on_data {
+ _Scheduler __sched_;
+ _Closure __clsur_;
+ };
+ template <class _Scheduler, class _Closure>
+ __on_data(_Scheduler, _Closure) -> __on_data<_Scheduler, _Closure>;
-template <class _Scheduler>
-struct __with_sched
-{
- using __t = __with_sched;
- using __id = __with_sched;
+ template <class _Scheduler>
+ struct __with_sched {
+ using __t = __with_sched;
+ using __id = __with_sched;
- _Scheduler __sched_;
+ _Scheduler __sched_;
- auto query(get_scheduler_t) const noexcept -> _Scheduler
- {
+ auto query(get_scheduler_t) const noexcept -> _Scheduler {
return __sched_;
- }
+ }
- auto query(get_domain_t) const noexcept
- {
+ auto query(get_domain_t) const noexcept {
return query_or(get_domain, __sched_, default_domain());
- }
-};
+ }
+ };
-template <class _Scheduler>
-__with_sched(_Scheduler) -> __with_sched<_Scheduler>;
+ template <class _Scheduler>
+ __with_sched(_Scheduler) -> __with_sched<_Scheduler>;
-////////////////////////////////////////////////////////////////////////////////////////////////
-struct on_t
-{
- template <scheduler _Scheduler, sender _Sender>
- auto operator()(_Scheduler&& __sched, _Sender&& __sndr) const
- -> __well_formed_sender auto
- {
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ struct on_t {
+ template <scheduler _Scheduler, sender _Sender>
+ auto operator()(_Scheduler&& __sched, _Sender&& __sndr) const -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain, __make_sexpr<on_t>(static_cast<_Scheduler&&>(__sched),
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<on_t>(static_cast<_Scheduler&&>(__sched), static_cast<_Sender&&>(__sndr)));
+ }
- template <sender _Sender, scheduler _Scheduler,
- __sender_adaptor_closure_for<_Sender> _Closure>
- auto operator()(_Sender&& __sndr, _Scheduler&& __sched,
- _Closure&& __clsur) const -> __well_formed_sender auto
- {
+ template <sender _Sender, scheduler _Scheduler, __sender_adaptor_closure_for<_Sender> _Closure>
+ auto operator()(_Sender&& __sndr, _Scheduler&& __sched, _Closure&& __clsur) const
+ -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain,
- __make_sexpr<on_t>(__on_data{static_cast<_Scheduler&&>(__sched),
- static_cast<_Closure&&>(__clsur)},
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<on_t>(
+ __on_data{static_cast<_Scheduler&&>(__sched), static_cast<_Closure&&>(__clsur)},
+ static_cast<_Sender&&>(__sndr)));
+ }
- template <scheduler _Scheduler, __sender_adaptor_closure _Closure>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Scheduler&& __sched, _Closure&& __clsur) const
- {
+ template <scheduler _Scheduler, __sender_adaptor_closure _Closure>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Scheduler&& __sched, _Closure&& __clsur) const {
return __binder_back<on_t, __decay_t<_Scheduler>, __decay_t<_Closure>>{
- {{static_cast<_Scheduler&&>(__sched)},
- {static_cast<_Closure&&>(__clsur)}},
- {},
- {}};
- }
-
- template <class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto __transform_env_fn(_Env&& __env) noexcept
- {
- return [&]<class _Data>(__ignore, _Data&& __data,
- __ignore) noexcept -> decltype(auto) {
- if constexpr (scheduler<_Data>)
- {
- return __detail::__mkenv_sched(static_cast<_Env&&>(__env),
- static_cast<_Data&&>(__data));
- }
- else
- {
- return static_cast<_Env>(static_cast<_Env&&>(__env));
- }
+ {{static_cast<_Scheduler&&>(__sched)}, {static_cast<_Closure&&>(__clsur)}},
+ {},
+ {}
};
- }
+ }
- template <class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto __transform_sender_fn(const _Env& __env) noexcept
- {
- return [&]<class _Data, class _Child>(__ignore, _Data&& __data,
- _Child&& __child) {
- if constexpr (scheduler<_Data>)
- {
- // This branch handles the case where `on` was called like
- // `on(sch, snd)`
- auto __old = query_or(get_scheduler, __env, __none_such{});
- if constexpr (__same_as<decltype(__old), __none_such>)
- {
- if constexpr (__is_root_env<_Env>)
- {
- return continues_on(
- starts_on(static_cast<_Data&&>(__data),
- static_cast<_Child&&>(__child)),
- __inln::__scheduler{});
- }
- else
- {
- return __none_such{};
- }
- }
- else
- {
- return continues_on(
- starts_on(static_cast<_Data&&>(__data),
- static_cast<_Child&&>(__child)),
- static_cast<decltype(__old)&&>(__old));
- }
- }
- else
- {
- // This branch handles the case where `on` was called like
- // `on(snd, sch, clsur)`
- auto __old = query_or(
- get_completion_scheduler<set_value_t>, get_env(__child),
- query_or(get_scheduler, __env, __none_such{}));
- if constexpr (__same_as<decltype(__old), __none_such>)
- {
- return __none_such{};
- }
- else
- {
- auto&& [__sched, __clsur] = static_cast<_Data&&>(__data);
- return __write_env( //
- continues_on( //
- __forward_like<_Data>(__clsur)( //
- continues_on( //
- __write_env(static_cast<_Child&&>(__child),
- __with_sched{__old}), //
- __sched)), //
- __old),
- __with_sched{__sched});
- }
- }
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto __transform_env_fn(_Env&& __env) noexcept {
+ return [&]<class _Data>(__ignore, _Data&& __data, __ignore) noexcept -> decltype(auto) {
+ if constexpr (scheduler<_Data>) {
+ return __env::__join(
+ __sched_env{static_cast<_Data&&>(__data)}, static_cast<_Env&&>(__env));
+ } else {
+ return static_cast<_Env>(static_cast<_Env&&>(__env));
+ }
};
- }
+ }
- template <class _Sender, class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto transform_env(const _Sender& __sndr, _Env&& __env) noexcept
- {
- return __sexpr_apply(__sndr,
- __transform_env_fn(static_cast<_Env&&>(__env)));
- }
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto __transform_sender_fn(const _Env& __env) noexcept {
+ return [&]<class _Data, class _Child>(__ignore, _Data&& __data, _Child&& __child) {
+ // If __is_root_env<_Env> is true, then this sender has no parent, so there is
+ // no need to restore the execution context. We can use the inline scheduler
+ // as the scheduler if __env does not have one.
+ using __default_t = __if_c<__is_root_env<_Env>, inline_scheduler, __none_such>;
- template <class _Sender, class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto transform_sender(_Sender&& __sndr, const _Env& __env)
- {
+ // If scheduler<_Data> is true, then this sender was created with `on(sch, sndr)`.
+ // In that case, the child sender is not a predecessor, so its completion
+ // scheduler is not the one we want to restore. If scheduler<_Data> is false,
+ // then this sender was created with `sndr | on(sch, clsur)`. The child sender
+ // *is* a predecessor, so we can use its completion scheduler to restore the
+ // execution context.
+ using __query_t =
+ __if_c<scheduler<_Data>, __none_such, get_completion_scheduler_t<set_value_t>>;
+
+ // Fetch the scheduler on which this operation will be started, and to which
+ // execution should be restored:
+ auto __old =
+ query_or(__query_t{}, get_env(__child), query_or(get_scheduler, __env, __default_t{}));
+
+ if constexpr (__same_as<decltype(__old), __none_such>) {
+ return __none_such{};
+ } else if constexpr (scheduler<_Data>) {
+ // This branch handles the case where `on` was called like `on(sch, sndr)`
+ return continues_on(
+ starts_on(static_cast<_Data&&>(__data), static_cast<_Child&&>(__child)),
+ static_cast<decltype(__old)&&>(__old));
+ } else {
+ // This branch handles the case where `on` was called like `sndr | on(sch, clsur)`
+ auto&& [__sched, __clsur] = static_cast<_Data&&>(__data);
+ return write_env(
+ continues_on(
+ __forward_like<_Data>(__clsur)(continues_on(
+ write_env(static_cast<_Child&&>(__child), __with_sched{__old}), __sched)),
+ __old),
+ __with_sched{__sched});
+ }
+ };
+ }
+
+ template <class _Sender, class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto transform_env(const _Sender& __sndr, _Env&& __env) noexcept {
+ return __sexpr_apply(__sndr, __transform_env_fn(static_cast<_Env&&>(__env)));
+ }
+
+ template <class _Sender, class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto transform_sender(_Sender&& __sndr, const _Env& __env) {
auto __tfx_sndr_fn = __transform_sender_fn(__env);
using _TfxSndrFn = decltype(__tfx_sndr_fn);
using _NewSndr = __sexpr_apply_result_t<_Sender, _TfxSndrFn>;
- if constexpr (__same_as<_NewSndr, __none_such>)
- {
- return __no_scheduler_in_environment<_Sender, _Env>{};
+ if constexpr (__same_as<_NewSndr, __none_such>) {
+ return __no_scheduler_in_environment<_Sender, _Env>{};
+ } else {
+ return __sexpr_apply(
+ static_cast<_Sender&&>(__sndr), static_cast<_TfxSndrFn&&>(__tfx_sndr_fn));
}
- else
- {
- return __sexpr_apply(static_cast<_Sender&&>(__sndr),
- static_cast<_TfxSndrFn&&>(__tfx_sndr_fn));
- }
- }
-};
-} // namespace __on_v2
+ }
+ };
+ } // namespace __on
-namespace v2
-{
-using __on_v2::on_t;
-inline constexpr on_t on{};
+ using __on::on_t;
+ inline constexpr on_t on{};
-using continue_on_t = v2::on_t;
-inline constexpr continue_on_t continue_on{}; // for back-compat
-} // namespace v2
+ namespace v2 {
+ using on_t [[deprecated("use stdexec::on_t instead")]] = stdexec::on_t;
+ [[deprecated("use stdexec::on instead")]]
+ inline constexpr stdexec::on_t const & on = stdexec::on;
+ } // namespace v2
-template <>
-struct __sexpr_impl<v2::on_t> : __sexpr_defaults
-{
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __merror_or_t< //
- __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>>,
- dependent_completions> { return {}; };
-};
+ template <>
+ struct __sexpr_impl<on_t> : __sexpr_defaults {
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __merror_or_t<
+ __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>>,
+ dependent_completions
+ > {
+ return {};
+ };
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__operation_states.hpp b/include/sdbusplus/async/stdexec/__detail/__operation_states.hpp
index 8e29d85..e46353b 100644
--- a/include/sdbusplus/async/stdexec/__detail/__operation_states.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__operation_states.hpp
@@ -23,51 +23,42 @@
#include <type_traits>
-namespace stdexec
-{
-// operation state tag type
-struct operation_state_t
-{};
+namespace stdexec {
+ // operation state tag type
+ struct operation_state_t { };
-/////////////////////////////////////////////////////////////////////////////
-// [execution.op_state]
-namespace __start
-{
-struct start_t
-{
- template <__same_as<start_t> _Self, class _OpState>
- STDEXEC_ATTRIBUTE((always_inline))
- friend auto tag_invoke(_Self, _OpState& __op) noexcept
- -> decltype(__op.start())
- {
- static_assert(noexcept(__op.start()),
- "start() members must be noexcept");
- static_assert(__same_as<decltype(__op.start()), void>,
- "start() members must return void");
- __op.start();
- }
-
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.op_state]
+ namespace __start {
template <class _Op>
- requires tag_invocable<start_t, _Op&>
- STDEXEC_ATTRIBUTE((always_inline))
- void operator()(_Op& __op) const noexcept
- {
- static_assert(nothrow_tag_invocable<start_t, _Op&>);
- (void)tag_invoke(start_t{}, __op);
- }
-};
-} // namespace __start
+ concept __has_start = requires(_Op &__op) { __op.start(); };
-using __start::start_t;
-inline constexpr start_t start{};
+ struct start_t {
+ template <class _Op>
+ requires __has_start<_Op>
+ STDEXEC_ATTRIBUTE(always_inline)
+ void operator()(_Op &__op) const noexcept {
+ static_assert(noexcept(__op.start()), "start() members must be noexcept");
+ static_assert(__same_as<decltype(__op.start()), void>, "start() members must return void");
+ __op.start();
+ }
-/////////////////////////////////////////////////////////////////////////////
-// [execution.op_state]
-template <class _Op>
-concept operation_state = //
- destructible<_Op> && //
- std::is_object_v<_Op> && //
- requires(_Op& __op) { //
- stdexec::start(__op);
+ template <class _Op>
+ requires(!__has_start<_Op>) && tag_invocable<start_t, _Op &>
+ STDEXEC_ATTRIBUTE(always_inline)
+ void operator()(_Op &__op) const noexcept {
+ static_assert(nothrow_tag_invocable<start_t, _Op &>);
+ (void) tag_invoke(start_t{}, __op);
+ }
};
+ } // namespace __start
+
+ using __start::start_t;
+ inline constexpr start_t start{};
+
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.op_state]
+ template <class _Op>
+ concept operation_state = destructible<_Op> && std::is_object_v<_Op>
+ && requires(_Op &__op) { stdexec::start(__op); };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__optional.hpp b/include/sdbusplus/async/stdexec/__detail/__optional.hpp
index 7591e20..bcfa382 100644
--- a/include/sdbusplus/async/stdexec/__detail/__optional.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__optional.hpp
@@ -19,152 +19,165 @@
// include these after __execution_fwd.hpp
#include "__concepts.hpp"
-#include "__type_traits.hpp"
+#include "__scope.hpp"
+#include <new> // IWYU pragma: keep for ::new
#include <exception>
#include <memory>
-#include <new>
#include <utility>
-namespace stdexec
-{
-namespace __opt
-{
-struct __bad_optional_access : std::exception
-{
- const char* what() const noexcept override
- {
+namespace stdexec {
+ namespace __opt {
+ struct __bad_optional_access : std::exception {
+ [[nodiscard]]
+ auto what() const noexcept -> const char* override {
return "stdexec::__optional: bad access";
- }
-};
-
-inline constexpr struct __nullopt_t
-{
-} __nullopt{};
-
-// A simplified version of std::optional for better compile times
-template <class _Tp>
-struct __optional
-{
- static_assert(destructible<_Tp>);
-
- union
- {
- _Tp __value;
+ }
};
- bool __has_value = false;
+ inline auto __mk_has_value_guard(bool& __has_value) noexcept {
+ __has_value = true;
+ return __scope_guard{[&]() noexcept { __has_value = false; }};
+ }
- __optional() noexcept {}
+ inline constexpr struct __nullopt_t {
+ } __nullopt{};
- __optional(__nullopt_t) noexcept {}
+ // A simplified version of std::optional for better compile times
+ template <class _Tp>
+ struct __optional {
+ static_assert(destructible<_Tp>);
- __optional(__optional&&) = delete; // immovable for simplicity's sake
+ union {
+ _Tp __value_;
+ };
- template <__not_decays_to<__optional> _Up>
+ bool __has_value_ = false;
+
+ __optional() noexcept {
+ }
+
+ __optional(__nullopt_t) noexcept {
+ }
+
+ __optional(__optional&&) = delete; // immovable for simplicity's sake
+
+ template <__not_decays_to<__optional> _Up>
requires constructible_from<_Tp, _Up>
- __optional(_Up&& __v) : __value(static_cast<_Up&&>(__v)), __has_value(true)
- {}
+ __optional(_Up&& __v) noexcept(__nothrow_constructible_from<_Tp, _Up>) {
+ emplace(static_cast<_Up&&>(__v));
+ }
- template <class... _Us>
+ template <class... _Us>
requires constructible_from<_Tp, _Us...>
- __optional(std::in_place_t, _Us&&... __us) :
- __value(static_cast<_Us&&>(__us)...), __has_value(true)
- {}
+ __optional(std::in_place_t, _Us&&... __us)
+ noexcept(__nothrow_constructible_from<_Tp, _Us...>) {
+ emplace(static_cast<_Us&&>(__us)...);
+ }
- ~__optional()
- {
- if (__has_value)
- {
- std::destroy_at(std::addressof(__value));
+ ~__optional() {
+ if (__has_value_) {
+ std::destroy_at(std::addressof(__value_));
}
- }
+ }
- template <class... _Us>
+ // The following emplace function must take great care to avoid use-after-free bugs.
+ // If the object being constructed calls `start` on a newly created operation state
+ // (as does the object returned from `submit`), and if `start` completes inline, it
+ // could cause the destruction of the outer operation state that owns *this. The
+ // function below uses the following pattern to avoid this:
+ // 1. Set __has_value_ to true.
+ // 2. Create a scope guard that will reset __has_value_ to false if the constructor
+ // throws.
+ // 3. Construct the new object in the storage, which may cause the invalidation of
+ // *this. The emplace function must not access any members of *this after this point.
+ // 4. Dismiss the scope guard, which will leave __has_value_ set to true.
+ // 5. Return a reference to the new object -- which may be invalid! Calling code
+ // must be aware of the danger.
+ template <class... _Us>
requires constructible_from<_Tp, _Us...>
- _Tp& emplace(_Us&&... __us) noexcept(
- __nothrow_constructible_from<_Tp, _Us...>)
- {
- reset(); // sets __has_value to false in case the next line throws
- ::new (&__value) _Tp{static_cast<_Us&&>(__us)...};
- __has_value = true;
- return __value;
- }
+ auto emplace(_Us&&... __us) noexcept(__nothrow_constructible_from<_Tp, _Us...>) -> _Tp& {
+ reset();
+ auto __sg = __mk_has_value_guard(__has_value_);
+ auto* __p = ::new (static_cast<void*>(std::addressof(__value_)))
+ _Tp{static_cast<_Us&&>(__us)...};
+ __sg.__dismiss();
+ return *std::launder(__p);
+ }
- _Tp& value() &
- {
- if (!__has_value)
- {
- throw __bad_optional_access();
+ template <class _Fn, class... _Args>
+ requires same_as<_Tp, __call_result_t<_Fn, _Args...>>
+ auto __emplace_from(_Fn&& __f, _Args&&... __args) noexcept(__nothrow_callable<_Fn, _Args...>)
+ -> _Tp& {
+ reset();
+ auto __sg = __mk_has_value_guard(__has_value_);
+ auto* __p = ::new (static_cast<void*>(std::addressof(__value_)))
+ _Tp(static_cast<_Fn&&>(__f)(static_cast<_Args&&>(__args)...));
+ __sg.__dismiss();
+ return *std::launder(__p);
+ }
+
+ auto value() & -> _Tp& {
+ if (!__has_value_) {
+ STDEXEC_THROW(__bad_optional_access());
}
- return __value;
- }
+ return __value_;
+ }
- const _Tp& value() const&
- {
- if (!__has_value)
- {
- throw __bad_optional_access();
+ auto value() const & -> const _Tp& {
+ if (!__has_value_) {
+ STDEXEC_THROW(__bad_optional_access());
}
- return __value;
- }
+ return __value_;
+ }
- _Tp&& value() &&
- {
- if (!__has_value)
- {
- throw __bad_optional_access();
+ auto value() && -> _Tp&& {
+ if (!__has_value_) {
+ STDEXEC_THROW(__bad_optional_access());
}
- return static_cast<_Tp&&>(__value);
- }
+ return static_cast<_Tp&&>(__value_);
+ }
- _Tp& operator*() & noexcept
- {
- STDEXEC_ASSERT(__has_value);
- return __value;
- }
+ auto operator*() & noexcept -> _Tp& {
+ STDEXEC_ASSERT(__has_value_);
+ return __value_;
+ }
- const _Tp& operator*() const& noexcept
- {
- STDEXEC_ASSERT(__has_value);
- return __value;
- }
+ auto operator*() const & noexcept -> const _Tp& {
+ STDEXEC_ASSERT(__has_value_);
+ return __value_;
+ }
- _Tp&& operator*() && noexcept
- {
- STDEXEC_ASSERT(__has_value);
- return static_cast<_Tp&&>(__value);
- }
+ auto operator*() && noexcept -> _Tp&& {
+ STDEXEC_ASSERT(__has_value_);
+ return static_cast<_Tp&&>(__value_);
+ }
- _Tp* operator->() & noexcept
- {
- STDEXEC_ASSERT(__has_value);
- return &__value;
- }
+ auto operator->() & noexcept -> _Tp* {
+ STDEXEC_ASSERT(__has_value_);
+ return &__value_;
+ }
- const _Tp* operator->() const& noexcept
- {
- STDEXEC_ASSERT(__has_value);
- return &__value;
- }
+ auto operator->() const & noexcept -> const _Tp* {
+ STDEXEC_ASSERT(__has_value_);
+ return &__value_;
+ }
- bool has_value() const noexcept
- {
- return __has_value;
- }
+ [[nodiscard]]
+ auto has_value() const noexcept -> bool {
+ return __has_value_;
+ }
- void reset() noexcept
- {
- if (__has_value)
- {
- std::destroy_at(std::addressof(__value));
- __has_value = false;
+ void reset() noexcept {
+ if (__has_value_) {
+ std::destroy_at(std::addressof(__value_));
+ __has_value_ = false;
}
- }
-};
-} // namespace __opt
+ }
+ };
+ } // namespace __opt
-using __opt::__bad_optional_access;
-using __opt::__nullopt;
-using __opt::__optional;
+ using __opt::__optional;
+ using __opt::__bad_optional_access;
+ using __opt::__nullopt;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__preprocessor.hpp b/include/sdbusplus/async/stdexec/__detail/__preprocessor.hpp
new file mode 100644
index 0000000..67c22e4
--- /dev/null
+++ b/include/sdbusplus/async/stdexec/__detail/__preprocessor.hpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2022 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#define STDEXEC_STRINGIZE_(...) #__VA_ARGS__
+#define STDEXEC_STRINGIZE(...) STDEXEC_STRINGIZE_(__VA_ARGS__)
+
+#define STDEXEC_CAT_(_XP, ...) _XP##__VA_ARGS__
+#define STDEXEC_CAT(_XP, ...) STDEXEC_CAT_(_XP, __VA_ARGS__)
+
+#define STDEXEC_EXPAND(...) __VA_ARGS__
+#define STDEXEC_EVAL(_MACRO, ...) _MACRO(__VA_ARGS__)
+#define STDEXEC_EAT(...)
+
+#define STDEXEC_IIF(_XP, _YP, ...) \
+ STDEXEC_IIF_EVAL(STDEXEC_CAT(STDEXEC_IIF_, _XP), _YP, __VA_ARGS__)
+#define STDEXEC_IIF_0(_YP, ...) __VA_ARGS__
+#define STDEXEC_IIF_1(_YP, ...) _YP
+#define STDEXEC_IIF_EVAL(_MACRO, ...) _MACRO(__VA_ARGS__)
+
+#define STDEXEC_COMPL(_B) STDEXEC_COMPL_CAT(STDEXEC_COMPL_, _B)
+#define STDEXEC_COMPL_0 1 // NOLINT(modernize-macro-to-enum)
+#define STDEXEC_COMPL_1 0 // NOLINT(modernize-macro-to-enum)
+#define STDEXEC_COMPL_CAT(_XP, ...) _XP##__VA_ARGS__
+
+#define STDEXEC_COUNT(...) \
+ STDEXEC_EXPAND(STDEXEC_COUNT_(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1))
+#define STDEXEC_COUNT_(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _NP, ...) _NP
+
+#define STDEXEC_CHECK(...) STDEXEC_EXPAND(STDEXEC_CHECK_(__VA_ARGS__, 0, ))
+#define STDEXEC_CHECK_(_XP, _NP, ...) _NP
+#define STDEXEC_PROBE(...) STDEXEC_PROBE_(__VA_ARGS__, 1)
+#define STDEXEC_PROBE_(_XP, _NP, ...) _XP, _NP,
+
+#define STDEXEC_NOT(_XP) STDEXEC_CHECK(STDEXEC_CAT(STDEXEC_NOT_, _XP))
+#define STDEXEC_NOT_0 STDEXEC_PROBE(~, 1)
+
+#define STDEXEC_BOOL(_XP) STDEXEC_COMPL(STDEXEC_NOT(_XP))
+#define STDEXEC_IF(_XP, _YP, ...) STDEXEC_IIF(STDEXEC_BOOL(_XP), _YP, __VA_ARGS__)
+
+#define STDEXEC_WHEN(_XP, ...) STDEXEC_IF(_XP, STDEXEC_EXPAND, STDEXEC_EAT)(__VA_ARGS__)
+
+////////////////////////////////////////////////////////////////////////////////
+// STDEXEC_FOR_EACH
+// Inspired by "Recursive macros with C++20 __VA_OPT__", by David Mazières
+// https://www.scs.stanford.edu/~dm/blog/va-opt.html
+#define STDEXEC_EXPAND_R(...) \
+ STDEXEC_EXPAND_R1(STDEXEC_EXPAND_R1(STDEXEC_EXPAND_R1(STDEXEC_EXPAND_R1(__VA_ARGS__)))) \
+ /**/
+#define STDEXEC_EXPAND_R1(...) \
+ STDEXEC_EXPAND_R2(STDEXEC_EXPAND_R2(STDEXEC_EXPAND_R2(STDEXEC_EXPAND_R2(__VA_ARGS__)))) \
+ /**/
+#define STDEXEC_EXPAND_R2(...) \
+ STDEXEC_EXPAND_R3(STDEXEC_EXPAND_R3(STDEXEC_EXPAND_R3(STDEXEC_EXPAND_R3(__VA_ARGS__)))) \
+ /**/
+#define STDEXEC_EXPAND_R3(...) \
+ STDEXEC_EXPAND(STDEXEC_EXPAND(STDEXEC_EXPAND(STDEXEC_EXPAND(__VA_ARGS__)))) \
+ /**/
+
+#define STDEXEC_PARENS ()
+#define STDEXEC_FOR_EACH(_MACRO, ...) \
+ __VA_OPT__(STDEXEC_EXPAND_R(STDEXEC_FOR_EACH_HELPER(_MACRO, __VA_ARGS__))) \
+ /**/
+#define STDEXEC_FOR_EACH_HELPER(_MACRO, _A1, ...) \
+ _MACRO(_A1) __VA_OPT__(STDEXEC_FOR_EACH_AGAIN STDEXEC_PARENS(_MACRO, __VA_ARGS__)) /**/
+#define STDEXEC_FOR_EACH_AGAIN() STDEXEC_FOR_EACH_HELPER
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define STDEXEC_FRONT(...) __VA_OPT__(STDEXEC_FRONT_HELPER(__VA_ARGS__))
+#define STDEXEC_FRONT_HELPER(_A1, ...) _A1
+#define STDEXEC_BACK(...) __VA_OPT__(STDEXEC_EXPAND_R(STDEXEC_BACK_HELPER(__VA_ARGS__)))
+#define STDEXEC_BACK_HELPER(_A1, ...) \
+ STDEXEC_FRONT(__VA_OPT__(, ) _A1, ) __VA_OPT__(STDEXEC_BACK_AGAIN STDEXEC_PARENS(__VA_ARGS__))
+#define STDEXEC_BACK_AGAIN() STDEXEC_BACK_HELPER
+
+#define STDEXEC_TAIL(_, ...) __VA_ARGS__
+
+#define STDEXEC_REPEAT(_N, _MACRO, ...) STDEXEC_REPEAT_(_N, _MACRO, __VA_ARGS__)
+#define STDEXEC_REPEAT_(_N, _MACRO, ...) STDEXEC_REPEAT_##_N(_MACRO, __VA_ARGS__)
+#define STDEXEC_REPEAT_0(_MACRO, ...)
+#define STDEXEC_REPEAT_1(_MACRO, ...) _MACRO(0 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_2(_MACRO, ...) \
+ STDEXEC_REPEAT_1(_MACRO, __VA_ARGS__) _MACRO(1 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_3(_MACRO, ...) \
+ STDEXEC_REPEAT_2(_MACRO, __VA_ARGS__) _MACRO(2 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_4(_MACRO, ...) \
+ STDEXEC_REPEAT_3(_MACRO, __VA_ARGS__) _MACRO(3 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_5(_MACRO, ...) \
+ STDEXEC_REPEAT_4(_MACRO, __VA_ARGS__) _MACRO(4 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_6(_MACRO, ...) \
+ STDEXEC_REPEAT_5(_MACRO, __VA_ARGS__) _MACRO(5 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_7(_MACRO, ...) \
+ STDEXEC_REPEAT_6(_MACRO, __VA_ARGS__) _MACRO(6 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_8(_MACRO, ...) \
+ STDEXEC_REPEAT_7(_MACRO, __VA_ARGS__) _MACRO(7 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_9(_MACRO, ...) \
+ STDEXEC_REPEAT_8(_MACRO, __VA_ARGS__) _MACRO(8 __VA_OPT__(, ) __VA_ARGS__)
+#define STDEXEC_REPEAT_10(_MACRO, ...) \
+ STDEXEC_REPEAT_9(_MACRO, __VA_ARGS__) _MACRO(9 __VA_OPT__(, ) __VA_ARGS__)
diff --git a/include/sdbusplus/async/stdexec/__detail/__query.hpp b/include/sdbusplus/async/stdexec/__detail/__query.hpp
new file mode 100644
index 0000000..8476bd7
--- /dev/null
+++ b/include/sdbusplus/async/stdexec/__detail/__query.hpp
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2025 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <type_traits>
+
+#include "__config.hpp"
+#include "__concepts.hpp"
+#include "__execution_fwd.hpp"
+#include "__tag_invoke.hpp"
+#include "__type_traits.hpp"
+
+namespace stdexec {
+ // [exec.queries.queryable]
+ template <class T>
+ concept queryable = destructible<T>;
+
+ template <class _Env, class _Query, class... _Args>
+ concept __member_queryable_with =
+ queryable<_Env>
+ && requires(const _Env& __env, const _Query& __query, __declfn<_Args&&>... __args) {
+ { __env.query(__query, __args()...) };
+ };
+
+ template <class _Env, class _Query, class... _Args>
+ concept __nothrow_member_queryable_with =
+ __member_queryable_with<_Env, _Query, _Args...>
+ && requires(const _Env& __env, const _Query& __query, __declfn<_Args&&>... __args) {
+ { __env.query(__query, __args()...) } noexcept;
+ };
+
+ template <class _Env, class _Qy, class... _Args>
+ using __member_query_result_t =
+ decltype(__declval<const _Env&>().query(__declval<const _Qy&>(), __declval<_Args>()...));
+
+ constexpr __none_such __no_default{};
+
+ template <class _Query, class _Env, class... _Args>
+ concept __has_validation = requires { _Query::template __validate<_Env, _Args...>(); };
+
+ template <class _Query, auto _Default = __no_default, class _Transform = __q1<__midentity>>
+ struct __query // NOLINT(bugprone-crtp-constructor-accessibility)
+ : __query<_Query, __no_default, _Transform> {
+ using __query<_Query, __no_default, _Transform>::operator();
+
+ template <class... _Args>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(__ignore, _Args&&...) const noexcept //
+ -> __mcall1<_Transform, __mtypeof<_Default>> {
+ return _Default;
+ }
+ };
+
+ template <class _Query, class _Transform>
+ struct __query<_Query, __no_default, _Transform> {
+ template <class Sig>
+ static inline constexpr _Query (*signature)(Sig) = nullptr;
+
+ // Query with a .query member function:
+ template <class _Qy = _Query, class _Env, class... _Args>
+ requires __member_queryable_with<const _Env&, _Qy, _Args...>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ constexpr auto operator()(const _Env& __env, _Args&&... __args) const
+ noexcept(__nothrow_member_queryable_with<_Env, _Qy, _Args...>)
+ -> __mcall1<_Transform, __member_query_result_t<_Env, _Qy, _Args...>> {
+ if constexpr (__has_validation<_Query, _Env, _Args...>) {
+ _Query::template __validate<_Env, _Args...>();
+ }
+ return __env.query(_Query(), static_cast<_Args&&>(__args)...);
+ }
+
+ // Query with tag_invoke (legacy):
+ template <class _Qy = _Query, class _Env, class... _Args>
+ requires(!__member_queryable_with<const _Env&, _Qy, _Args...>)
+ && tag_invocable<_Qy, const _Env&, _Args...>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ constexpr auto operator()(const _Env& __env, _Args&&... __args) const
+ noexcept(nothrow_tag_invocable<_Qy, const _Env&, _Args...>)
+ -> __mcall1<_Transform, tag_invoke_result_t<_Qy, const _Env&, _Args...>> {
+ if constexpr (__has_validation<_Query, _Env, _Args...>) {
+ _Query::template __validate<_Env, _Args...>();
+ }
+ return tag_invoke(_Query(), __env, static_cast<_Args&&>(__args)...);
+ }
+ };
+
+ template <class _Env, class _Query, class... _Args>
+ concept __queryable_with = __callable<__query<_Query>, _Env&, _Args...>;
+
+ template <class _Env, class _Query, class... _Args>
+ concept __nothrow_queryable_with = __nothrow_callable<__query<_Query>, _Env&, _Args...>;
+
+ template <class _Env, class _Query, class... _Args>
+ using __query_result_t = __call_result_t<__query<_Query>, _Env&, _Args...>;
+
+ template <class _Env, class _Query, class... _Args>
+ concept __statically_queryable_with_impl = requires(_Query __q, _Args&&... __args) {
+ std::remove_reference_t<_Env>::query(__q, static_cast<_Args&&>(__args)...);
+ };
+
+ template <class _Env, class _Query, class... _Args>
+ concept __statically_queryable_with = __queryable_with<_Env, _Query, _Args...>
+ && __statically_queryable_with_impl<_Env, _Query, _Args...>;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // [exec.queries]
+ namespace __queries {
+ template <class _Tp>
+ concept __is_bool_constant = requires { typename __mbool<_Tp::value>; };
+
+ struct forwarding_query_t {
+ template <class _Query>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ consteval auto operator()(_Query) const noexcept -> bool {
+ if constexpr (__queryable_with<_Query, forwarding_query_t>) {
+ return __query<forwarding_query_t>()(_Query());
+ } else {
+ return derived_from<_Query, forwarding_query_t>;
+ }
+ }
+ };
+
+ struct query_or_t {
+ template <class _Query, class _Queryable, class _Default, class... _Args>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto operator()(_Query, _Queryable&&, _Default&& __default, _Args&&...) const
+ noexcept(__nothrow_move_constructible<_Default>) -> _Default {
+ return static_cast<_Default&&>(__default);
+ }
+
+ template <class _Query, class _Queryable, class _Default, class... _Args>
+ requires __callable<_Query, _Queryable, _Args...>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto
+ operator()(_Query __query, _Queryable&& __queryable, _Default&&, _Args&&... __args) const
+ noexcept(__nothrow_callable<_Query, _Queryable, _Args...>)
+ -> __call_result_t<_Query, _Queryable, _Args...> {
+ return static_cast<_Query&&>(
+ __query)(static_cast<_Queryable&&>(__queryable), static_cast<_Args&&>(__args)...);
+ }
+ };
+ } // namespace __queries
+
+ using __queries::forwarding_query_t;
+ using __queries::query_or_t;
+
+ inline constexpr forwarding_query_t forwarding_query{};
+ inline constexpr query_or_t query_or{}; // NOT TO SPEC
+
+ template <class _Tag>
+ concept __forwarding_query = forwarding_query(_Tag{});
+} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__ranges.hpp b/include/sdbusplus/async/stdexec/__detail/__ranges.hpp
index e98513e..6157d58 100644
--- a/include/sdbusplus/async/stdexec/__detail/__ranges.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__ranges.hpp
@@ -18,9 +18,9 @@
#include "__config.hpp"
#include "__type_traits.hpp"
-#if 0 // STDEXEC_HAS_STD_RANGES()
+#if 0 //STDEXEC_HAS_STD_RANGES()
-#include <ranges>
+# include <ranges>
namespace stdexec::ranges {
using std::ranges::begin;
@@ -34,92 +34,77 @@
#else
-#include <iterator>
+# include <iterator>
-namespace stdexec::ranges
-{
+namespace stdexec::ranges {
-namespace __detail
-{
-void begin();
-void end();
+ namespace __detail {
+ void begin();
+ void end();
-template <class _Ty>
-concept __has_member_begin =
- requires(_Ty&& __v) { static_cast<_Ty&&>(__v).begin(); };
+ template <class _Ty>
+ concept __has_member_begin = requires(_Ty&& __v) { static_cast<_Ty &&>(__v).begin(); };
-template <class _Ty>
-concept __has_free_begin =
- __has_member_begin<_Ty> ||
- requires(_Ty&& __v) { begin((static_cast<_Ty&&>(__v))); };
+ template <class _Ty>
+ concept __has_free_begin = __has_member_begin<_Ty>
+ || requires(_Ty&& __v) { begin((static_cast<_Ty &&>(__v))); };
-template <class _Ty>
-concept __has_member_end =
- requires(_Ty&& __v) { static_cast<_Ty&&>(__v).end(); };
+ template <class _Ty>
+ concept __has_member_end = requires(_Ty&& __v) { static_cast<_Ty &&>(__v).end(); };
-template <class _Ty>
-concept __has_free_end =
- __has_member_end<_Ty> ||
- requires(_Ty&& __v) { end((static_cast<_Ty&&>(__v))); };
+ template <class _Ty>
+ concept __has_free_end = __has_member_end<_Ty>
+ || requires(_Ty&& __v) { end((static_cast<_Ty &&>(__v))); };
-struct __begin_t
-{
- template <class _Range>
+ struct __begin_t {
+ template <class _Range>
requires __has_member_begin<_Range>
- auto operator()(_Range&& __rng) const
- noexcept(noexcept((static_cast<_Range&&>(__rng)).begin()))
- -> decltype((static_cast<_Range&&>(__rng)).begin())
- {
+ auto
+ operator()(_Range&& __rng) const noexcept(noexcept((static_cast<_Range&&>(__rng)).begin()))
+ -> decltype((static_cast<_Range&&>(__rng)).begin()) {
return static_cast<_Range&&>(__rng).begin();
- }
+ }
- template <class _Range>
+ template <class _Range>
requires __has_free_begin<_Range>
- auto operator()(_Range&& __rng) const
- noexcept(noexcept(begin((static_cast<_Range&&>(__rng)))))
- -> decltype(begin((static_cast<_Range&&>(__rng))))
- {
+ auto
+ operator()(_Range&& __rng) const noexcept(noexcept(begin((static_cast<_Range&&>(__rng)))))
+ -> decltype(begin((static_cast<_Range&&>(__rng)))) {
return begin((static_cast<_Range&&>(__rng)));
- }
-};
+ }
+ };
-struct __end_t
-{
- template <class _Range>
+ struct __end_t {
+ template <class _Range>
requires __has_member_end<_Range>
- auto operator()(_Range&& __rng) const
- noexcept(noexcept((static_cast<_Range&&>(__rng)).end()))
- -> decltype((static_cast<_Range&&>(__rng)).end())
- {
+ auto operator()(_Range&& __rng) const noexcept(noexcept((static_cast<_Range&&>(__rng)).end()))
+ -> decltype((static_cast<_Range&&>(__rng)).end()) {
return static_cast<_Range&&>(__rng).end();
- }
+ }
- template <class _Range>
+ template <class _Range>
requires __has_free_end<_Range>
- auto operator()(_Range&& __rng) const
- noexcept(noexcept(end((static_cast<_Range&&>(__rng)))))
- -> decltype(end((static_cast<_Range&&>(__rng))))
- {
+ auto operator()(_Range&& __rng) const noexcept(noexcept(end((static_cast<_Range&&>(__rng)))))
+ -> decltype(end((static_cast<_Range&&>(__rng)))) {
return end((static_cast<_Range&&>(__rng)));
- }
-};
-} // namespace __detail
+ }
+ };
+ } // namespace __detail
-inline constexpr __detail::__begin_t begin{};
-inline constexpr __detail::__end_t end{};
+ inline constexpr __detail::__begin_t begin{};
+ inline constexpr __detail::__end_t end{};
-template <class _Range>
-using iterator_t = decltype(begin((__declval<_Range>())));
+ template <class _Range>
+ using iterator_t = decltype(begin((__declval<_Range>())));
-template <class _Range>
-using sentinel_t = decltype(end((__declval<_Range>())));
+ template <class _Range>
+ using sentinel_t = decltype(end((__declval<_Range>())));
-template <class _Range>
-using range_reference_t = decltype(*begin((__declval<_Range>())));
+ template <class _Range>
+ using range_reference_t = decltype(*begin((__declval<_Range>())));
-template <class _Range>
-using range_value_t =
- typename std::iterator_traits<iterator_t<_Range>>::value_type;
+ template <class _Range>
+ using range_value_t = std::iterator_traits<iterator_t<_Range>>::value_type;
} // namespace stdexec::ranges
diff --git a/include/sdbusplus/async/stdexec/__detail/__read_env.hpp b/include/sdbusplus/async/stdexec/__detail/__read_env.hpp
index 23ab05a..e10f43c 100644
--- a/include/sdbusplus/async/stdexec/__detail/__read_env.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__read_env.hpp
@@ -23,145 +23,145 @@
#include "__concepts.hpp"
#include "__diagnostics.hpp"
#include "__env.hpp"
-#include "__meta.hpp"
#include "__optional.hpp"
+#include "__meta.hpp"
#include "__receivers.hpp"
-#include "__tag_invoke.hpp"
+#include "__submit.hpp" // IWYU pragma: keep
#include <exception>
-namespace stdexec
-{
-namespace __read
-{
-template <class _Tag, class _ReceiverId>
-using __result_t = __call_result_t<_Tag, env_of_t<stdexec::__t<_ReceiverId>>>;
+namespace stdexec {
+ namespace __read {
+ template <class _Tag, class _ReceiverId>
+ using __result_t = __call_result_t<_Tag, env_of_t<stdexec::__t<_ReceiverId>>>;
-template <class _Tag, class _ReceiverId>
-concept __nothrow_t =
- __nothrow_callable<_Tag, env_of_t<stdexec::__t<_ReceiverId>>>;
+ template <class _Tag, class _ReceiverId>
+ concept __nothrow_t = __nothrow_callable<_Tag, env_of_t<stdexec::__t<_ReceiverId>>>;
-inline constexpr __mstring __query_failed_diag =
- "The current execution environment doesn't have a value for the given query."_mstr;
+ inline constexpr __mstring __query_failed_diag =
+ "The current execution environment doesn't have a value for the given query."_mstr;
-template <class _Tag, class _Env>
-using __query_failed_error = //
- __mexception< //
- _NOT_CALLABLE_<"In stdexec::read()..."_mstr, __query_failed_diag>,
- _WITH_QUERY_<_Tag>, _WITH_ENVIRONMENT_<_Env>>;
-
-template <class _Tag, class _Env>
- requires __callable<_Tag, _Env>
-using __completions_t = //
- __if_c<__nothrow_callable<_Tag, _Env>,
- completion_signatures<set_value_t(__call_result_t<_Tag, _Env>)>,
- completion_signatures<set_value_t(__call_result_t<_Tag, _Env>),
- set_error_t(std::exception_ptr)>>;
-
-template <class _Tag, class _Ty>
-struct __state
-{
- using __query = _Tag;
- using __result = _Ty;
- __optional<_Ty> __result_;
-};
-
-template <class _Tag, class _Ty>
- requires __same_as<_Ty, _Ty&&>
-struct __state<_Tag, _Ty>
-{
- using __query = _Tag;
- using __result = _Ty;
-};
-
-struct __read_env_t
-{
- template <class _Tag>
- constexpr auto operator()(_Tag) const noexcept
- {
- return __make_sexpr<__read_env_t>(_Tag());
- }
-};
-
-struct __read_env_impl : __sexpr_defaults
-{
template <class _Tag, class _Env>
- using __completions_t = __minvoke<
- __mtry_catch_q<__read::__completions_t, __q<__query_failed_error>>,
- _Tag, _Env>;
+ using __query_failed_error = __mexception<
+ _NOT_CALLABLE_<"In stdexec::read_env()..."_mstr, __query_failed_diag>,
+ _WITH_QUERY_<_Tag>,
+ _WITH_ENVIRONMENT_<_Env>
+ >;
- static constexpr auto get_completion_signatures = //
+ template <class _Tag, class _Env>
+ requires __callable<_Tag, _Env>
+ using __completions_t = __if_c<
+ __nothrow_callable<_Tag, _Env>,
+ completion_signatures<set_value_t(__call_result_t<_Tag, _Env>)>,
+ completion_signatures<set_value_t(__call_result_t<_Tag, _Env>), set_error_t(std::exception_ptr)>
+ >;
+
+ template <class _Tag, class _Ty>
+ struct __state {
+ using __query = _Tag;
+ using __result = _Ty;
+ __optional<_Ty> __result_;
+ };
+
+ template <class _Tag, class _Ty>
+ requires __same_as<_Ty, _Ty&&>
+ struct __state<_Tag, _Ty> {
+ using __query = _Tag;
+ using __result = _Ty;
+ };
+
+ struct read_env_t {
+ template <class _Tag>
+ constexpr auto operator()(_Tag) const noexcept {
+ return __make_sexpr<read_env_t>(_Tag());
+ }
+ };
+
+ struct __read_env_impl : __sexpr_defaults {
+ template <class _Tag, class _Env>
+ using __completions_t =
+ __minvoke<__mtry_catch_q<__read::__completions_t, __q<__query_failed_error>>, _Tag, _Env>;
+
+ static constexpr auto get_attrs = [](__ignore) noexcept
+ -> cprop<get_completion_behavior_t, completion_behavior::inline_completion> {
+ return {};
+ };
+
+ static constexpr auto get_completion_signatures =
[]<class _Self, class _Env>(const _Self&, _Env&&) noexcept
- -> __completions_t<__data_of<_Self>, _Env> { return {}; };
+ -> __completions_t<__data_of<_Self>, _Env> {
+ return {};
+ };
- static constexpr auto get_state = //
+ static constexpr auto get_state =
[]<class _Self, class _Receiver>(const _Self&, _Receiver&) noexcept {
- using __query = __data_of<_Self>;
- using __result = __call_result_t<__query, env_of_t<_Receiver>>;
- return __state<__query, __result>();
+ using __query = __data_of<_Self>;
+ using __result = __call_result_t<__query, env_of_t<_Receiver>>;
+ return __state<__query, __result>();
};
- static constexpr auto start = //
- []<class _State, class _Receiver>(_State& __state,
- _Receiver& __rcvr) noexcept -> void {
- using __query = typename _State::__query;
- using __result = typename _State::__result;
- if constexpr (__same_as<__result, __result&&>)
- {
- // The query returns a reference type; pass it straight through to
- // the receiver.
- stdexec::__set_value_invoke(static_cast<_Receiver&&>(__rcvr),
- __query(), stdexec::get_env(__rcvr));
+ static constexpr auto start =
+ []<class _State, class _Receiver>(_State& __state, _Receiver& __rcvr) noexcept -> void {
+ using __query = _State::__query;
+ using __result = _State::__result;
+ if constexpr (__same_as<__result, __result&&>) {
+ // The query returns a reference type; pass it straight through to the receiver.
+ stdexec::__set_value_invoke(
+ static_cast<_Receiver&&>(__rcvr), __query(), stdexec::get_env(__rcvr));
+ } else {
+ constexpr bool _Nothrow = __nothrow_callable<__query, env_of_t<_Receiver>>;
+ auto __query_fn = [&]() noexcept(_Nothrow) -> __result&& {
+ __state.__result_.__emplace_from(
+ [&]() noexcept(_Nothrow) { return __query()(stdexec::get_env(__rcvr)); });
+ return static_cast<__result&&>(*__state.__result_);
+ };
+ stdexec::__set_value_invoke(static_cast<_Receiver&&>(__rcvr), __query_fn);
}
- else
- {
- constexpr bool _Nothrow =
- __nothrow_callable<__query, env_of_t<_Receiver>>;
- auto __query_fn = [&]() noexcept(_Nothrow) -> __result&& {
- __state.__result_.emplace(
- __emplace_from{[&]() noexcept(_Nothrow) {
- return __query()(stdexec::get_env(__rcvr));
- }});
- return static_cast<__result&&>(*__state.__result_);
- };
- stdexec::__set_value_invoke(static_cast<_Receiver&&>(__rcvr),
- __query_fn);
- }
+ };
+
+ static constexpr auto submit =
+ []<class _Sender, class _Receiver>(const _Sender&, _Receiver __rcvr) noexcept
+ requires std::is_reference_v<__call_result_t<__data_of<_Sender>, env_of_t<_Receiver>>>
+ {
+ static_assert(sender_expr_for<_Sender, read_env_t>);
+ using __query = __data_of<_Sender>;
+ stdexec::__set_value_invoke(
+ static_cast<_Receiver&&>(__rcvr), __query(), stdexec::get_env(__rcvr));
+ };
};
-};
-} // namespace __read
+ } // namespace __read
-inline constexpr __read::__read_env_t read{};
-inline constexpr __read::__read_env_t read_env{};
+ using __read::read_env_t;
+ [[deprecated("read has been renamed to read_env")]]
+ inline constexpr read_env_t read{};
+ inline constexpr read_env_t read_env{};
-template <>
-struct __sexpr_impl<__read::__read_env_t> : __read::__read_env_impl
-{};
+ template <>
+ struct __sexpr_impl<__read::read_env_t> : __read::__read_env_impl { };
-namespace __queries
-{
-template <class _Tag>
-inline auto get_scheduler_t::operator()() const noexcept
-{
- return read_env(get_scheduler);
-}
+ namespace __queries {
+ template <class _Tag>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto get_scheduler_t::operator()() const noexcept {
+ return read_env(get_scheduler);
+ }
-template <class _Tag>
-inline auto get_delegation_scheduler_t::operator()() const noexcept
-{
- return read_env(get_delegation_scheduler);
-}
+ template <class _Tag>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto get_delegation_scheduler_t::operator()() const noexcept {
+ return read_env(get_delegation_scheduler);
+ }
-template <class _Tag>
-inline auto get_allocator_t::operator()() const noexcept
-{
- return read_env(get_allocator);
-}
+ template <class _Tag>
+ STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto get_allocator_t::operator()() const noexcept {
+ return read_env(get_allocator);
+ }
-template <class _Tag>
-inline auto get_stop_token_t::operator()() const noexcept
-{
- return read_env(get_stop_token);
-}
-} // namespace __queries
+ template <class _Tag>
+ //STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
+ constexpr auto get_stop_token_t::operator()() const noexcept {
+ return read_env(get_stop_token);
+ }
+ } // namespace __queries
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__receiver_adaptor.hpp b/include/sdbusplus/async/stdexec/__detail/__receiver_adaptor.hpp
index b948eaa..982d292 100644
--- a/include/sdbusplus/async/stdexec/__detail/__receiver_adaptor.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__receiver_adaptor.hpp
@@ -15,176 +15,151 @@
*/
#pragma once
-#include "__concepts.hpp"
-#include "__cpo.hpp"
#include "__execution_fwd.hpp"
+
+#include "__concepts.hpp"
#include "__receivers.hpp"
-#include "__tag_invoke.hpp"
#include "__type_traits.hpp"
#include "__utility.hpp"
-namespace stdexec
-{
-namespace __adaptors
-{
-namespace __no
-{
-struct __nope
-{};
+namespace stdexec {
+ namespace __adaptors {
+ namespace __no {
+ struct __nope { };
-struct __receiver : __nope
-{
- using receiver_concept = receiver_t;
+ struct __receiver : __nope {
+ using receiver_concept = receiver_t;
- void set_error(std::exception_ptr) noexcept;
- void set_stopped() noexcept;
- auto get_env() const noexcept -> empty_env;
-};
-} // namespace __no
+ void set_error(std::exception_ptr) noexcept;
+ void set_stopped() noexcept;
+ [[nodiscard]]
+ auto get_env() const noexcept -> env<>;
+ };
+ } // namespace __no
-using __not_a_receiver = __no::__receiver;
+ using __not_a_receiver = __no::__receiver;
-template <class _Base>
-struct __adaptor_base
-{
- template <class _T1>
+ template <class _Base>
+ struct __adaptor_base {
+ template <class _T1>
requires constructible_from<_Base, _T1>
- explicit __adaptor_base(_T1&& __base) : __base_(static_cast<_T1&&>(__base))
- {}
+ explicit __adaptor_base(_T1&& __base)
+ : __base_(static_cast<_T1&&>(__base)) {
+ }
- private:
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Base __base_;
+ private:
+ STDEXEC_ATTRIBUTE(no_unique_address) _Base __base_;
- protected:
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- _Base& base() & noexcept
- {
+ protected:
+ STDEXEC_ATTRIBUTE(host, device, always_inline) auto base() & noexcept -> _Base& {
return __base_;
- }
+ }
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- const _Base& base() const& noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto base() const & noexcept -> const _Base& {
return __base_;
- }
+ }
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- _Base&& base() && noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device, always_inline) auto base() && noexcept -> _Base&& {
return static_cast<_Base&&>(__base_);
- }
-};
+ }
+ };
-template <derived_from<__no::__nope> _Base>
-struct __adaptor_base<_Base>
-{};
+ template <derived_from<__no::__nope> _Base>
+ struct __adaptor_base<_Base> { };
// BUGBUG Not to spec: on gcc and nvc++, member functions in derived classes
// don't shadow type aliases of the same name in base classes. :-O
// On mingw gcc, 'bool(type::existing_member_function)' evaluates to true,
// but 'int(type::existing_member_function)' is an error (as desired).
-#define STDEXEC_DISPATCH_MEMBER(_TAG) \
- template <class _Self, class... _Ts> \
- STDEXEC_ATTRIBUTE((host, device, always_inline)) \
- static auto __call_##_TAG(_Self&& __self, _Ts&&... __ts) noexcept \
- -> decltype((static_cast<_Self&&>(__self)) \
- ._TAG(static_cast<_Ts&&>(__ts)...)) \
- { \
- static_assert(noexcept((static_cast<_Self&&>(__self)) \
- ._TAG(static_cast<_Ts&&>(__ts)...))); \
- return static_cast<_Self&&>(__self)._TAG(static_cast<_Ts&&>(__ts)...); \
- } /**/
+#define STDEXEC_DISPATCH_MEMBER(_TAG) \
+ template <class _Self, class... _Ts> \
+ STDEXEC_ATTRIBUTE(host, device, always_inline) \
+ static auto __call_##_TAG(_Self&& __self, _Ts&&... __ts) noexcept \
+ -> decltype((static_cast<_Self&&>(__self))._TAG(static_cast<_Ts&&>(__ts)...)) { \
+ static_assert(noexcept((static_cast<_Self&&>(__self))._TAG(static_cast<_Ts&&>(__ts)...))); \
+ return static_cast<_Self&&>(__self)._TAG(static_cast<_Ts&&>(__ts)...); \
+ } /**/
#define STDEXEC_CALL_MEMBER(_TAG, ...) __call_##_TAG(__VA_ARGS__)
#if STDEXEC_CLANG()
// Only clang gets this right.
-#define STDEXEC_MISSING_MEMBER(_Dp, _TAG) requires { typename _Dp::_TAG; }
-#define STDEXEC_DEFINE_MEMBER(_TAG) \
- STDEXEC_DISPATCH_MEMBER(_TAG) using _TAG = void
+# define STDEXEC_MISSING_MEMBER(_Dp, _TAG) requires { typename _Dp::_TAG; }
+# define STDEXEC_DEFINE_MEMBER(_TAG) STDEXEC_DISPATCH_MEMBER(_TAG) using _TAG = void
#else
-#define STDEXEC_MISSING_MEMBER(_Dp, _TAG) (__missing_##_TAG<_Dp>())
-#define STDEXEC_DEFINE_MEMBER(_TAG) \
- template <class _Dp> \
- static constexpr bool __missing_##_TAG() noexcept \
- { \
- return requires { requires bool(int(_Dp::_TAG)); }; \
- } \
- STDEXEC_DISPATCH_MEMBER(_TAG) \
+# define STDEXEC_MISSING_MEMBER(_Dp, _TAG) (__missing_##_TAG<_Dp>())
+# define STDEXEC_DEFINE_MEMBER(_TAG) \
+ template <class _Dp> \
+ static constexpr bool __missing_##_TAG() noexcept { \
+ return requires { requires bool(int(_Dp::_TAG)); }; \
+ } \
+ STDEXEC_DISPATCH_MEMBER(_TAG) \
static constexpr int _TAG = 1 /**/
#endif
-template <__class _Derived, class _Base = __not_a_receiver>
-struct receiver_adaptor : __adaptor_base<_Base>, receiver_t
-{
- static constexpr bool __has_base = !derived_from<_Base, __no::__nope>;
+ template <__class _Derived, class _Base = __not_a_receiver>
+ struct receiver_adaptor
+ : __adaptor_base<_Base>
+ , receiver_t {
- template <class _Self>
- using __base_from_derived_t = decltype(__declval<_Self>().base());
+ static constexpr bool __has_base = !derived_from<_Base, __no::__nope>;
- using __get_base_fn =
- __if_c<__has_base, __mbind_back_q<__copy_cvref_t, _Base>,
- __q<__base_from_derived_t>>;
+ template <class _Self>
+ using __base_from_derived_t = decltype(__declval<_Self>().base());
- template <class _Self>
- using __base_t = __minvoke<__get_base_fn, _Self&&>;
+ using __get_base_fn =
+ __if_c<__has_base, __mbind_back_q<__copy_cvref_t, _Base>, __q<__base_from_derived_t>>;
- template <class _Self>
- STDEXEC_ATTRIBUTE((host, device))
- static auto __get_base(_Self&& __self) noexcept -> __base_t<_Self>
- {
- if constexpr (__has_base)
- {
- return __c_upcast<receiver_adaptor>(static_cast<_Self&&>(__self))
- .base();
+ template <class _Self>
+ using __base_t = __minvoke<__get_base_fn, _Self&&>;
+
+ template <class _Self>
+ STDEXEC_ATTRIBUTE(host, device)
+ static auto __get_base(_Self&& __self) noexcept -> __base_t<_Self> {
+ if constexpr (__has_base) {
+ return __c_upcast<receiver_adaptor>(static_cast<_Self&&>(__self)).base();
+ } else {
+ return static_cast<_Self&&>(__self).base();
}
- else
- {
- return static_cast<_Self&&>(__self).base();
- }
- }
+ }
- public:
- using receiver_concept = receiver_t;
+ public:
+ using receiver_concept = receiver_t;
- receiver_adaptor() = default;
- using __adaptor_base<_Base>::__adaptor_base;
+ receiver_adaptor() = default;
+ using __adaptor_base<_Base>::__adaptor_base;
- template <class... _As, class _Self = _Derived>
+ template <class... _As, class _Self = _Derived>
requires __callable<set_value_t, __base_t<_Self>, _As...>
- STDEXEC_ATTRIBUTE((host, device))
- void set_value(_As&&... __as) && noexcept
- {
- return stdexec::set_value(__get_base(static_cast<_Self&&>(*this)),
- static_cast<_As&&>(__as)...);
- }
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_value(_As&&... __as) && noexcept {
+ return stdexec::set_value(
+ __get_base(static_cast<_Self&&>(*this)), static_cast<_As&&>(__as)...);
+ }
- template <class _Error, class _Self = _Derived>
+ template <class _Error, class _Self = _Derived>
requires __callable<set_error_t, __base_t<_Self>, _Error>
- STDEXEC_ATTRIBUTE((host, device))
- void set_error(_Error&& __err) && noexcept
- {
- return stdexec::set_error(__get_base(static_cast<_Self&&>(*this)),
- static_cast<_Error&&>(__err));
- }
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_error(_Error&& __err) && noexcept {
+ return stdexec::set_error(
+ __get_base(static_cast<_Self&&>(*this)), static_cast<_Error&&>(__err));
+ }
- template <class _Self = _Derived>
+ template <class _Self = _Derived>
requires __callable<set_stopped_t, __base_t<_Self>>
- STDEXEC_ATTRIBUTE((host, device))
- void set_stopped() && noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_stopped() && noexcept {
return stdexec::set_stopped(__get_base(static_cast<_Self&&>(*this)));
- }
+ }
- template <class _Self = _Derived>
- STDEXEC_ATTRIBUTE((host, device))
- auto get_env() const noexcept -> env_of_t<__base_t<const _Self&>>
- {
+ template <class _Self = _Derived>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto get_env() const noexcept -> env_of_t<__base_t<const _Self&>> {
return stdexec::get_env(__get_base(static_cast<const _Self&>(*this)));
- }
-};
-} // namespace __adaptors
+ }
+ };
+ } // namespace __adaptors
-template <__class _Derived, receiver _Base = __adaptors::__not_a_receiver>
-using receiver_adaptor = __adaptors::receiver_adaptor<_Derived, _Base>;
+ template <__class _Derived, receiver _Base = __adaptors::__not_a_receiver>
+ using receiver_adaptor = __adaptors::receiver_adaptor<_Derived, _Base>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__receiver_ref.hpp b/include/sdbusplus/async/stdexec/__detail/__receiver_ref.hpp
index fdb2d7e..a26708f 100644
--- a/include/sdbusplus/async/stdexec/__detail/__receiver_ref.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__receiver_ref.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021-2024 NVIDIA Corporation
+ * Copyright (c) 2025 NVIDIA Corporation
*
* Licensed under the Apache License Version 2.0 with LLVM Exceptions
* (the "License"); you may not use this file except in compliance with
@@ -15,120 +15,93 @@
*/
#pragma once
-#include "__completion_signatures.hpp"
-#include "__cpo.hpp"
-#include "__env.hpp"
+#include "__concepts.hpp"
+#include "__config.hpp"
#include "__execution_fwd.hpp"
-#include "__schedulers.hpp"
+#include "__operation_states.hpp"
+#include "__receivers.hpp"
-#include <functional>
+#include <memory>
-namespace stdexec
-{
-namespace __any_
-{
-template <class _Sig>
-struct __rcvr_vfun;
-
-template <class _Tag, class... _Args>
-struct __rcvr_vfun<_Tag(_Args...)>
-{
- void (*__complete_)(void*, _Args&&...) noexcept;
-
- void operator()(void* __obj, _Tag, _Args&&... __args) const noexcept
- {
- __complete_(__obj, static_cast<_Args&&>(__args)...);
- }
-};
-
-template <class _GetReceiver = std::identity, class _Obj, class _Tag,
- class... _Args>
-constexpr auto __rcvr_vfun_fn(_Obj*, _Tag (*)(_Args...)) noexcept
-{
- return +[](void* __ptr, _Args&&... __args) noexcept {
- _Obj* __obj = static_cast<_Obj*>(__ptr);
- _Tag()(std::move(_GetReceiver()(*__obj)),
- static_cast<_Args&&>(__args)...);
- };
-}
-
-template <class _Sigs, class _Env>
-struct __receiver_vtable_for;
-
-template <class _Env, class... _Sigs>
-struct __receiver_vtable_for<completion_signatures<_Sigs...>, _Env> :
- __rcvr_vfun<_Sigs>...
-{
- _Env (*__do_get_env)(const void* __op_state) noexcept;
-
- template <class _OpState, class _GetEnv>
- static auto __s_get_env(const void* __ptr) noexcept -> _Env
- {
- auto* __op_state = static_cast<const _OpState*>(__ptr);
- return _GetEnv()(*__op_state);
- }
-
- template <class _OpState, class _GetEnv, class _GetReceiver = std::identity>
- explicit constexpr __receiver_vtable_for(_OpState* __op, _GetEnv,
- _GetReceiver = {}) noexcept :
- __rcvr_vfun<_Sigs>{__rcvr_vfun_fn<_GetReceiver>(
- __op, static_cast<_Sigs*>(nullptr))}...,
- __do_get_env{&__s_get_env<_OpState, _GetEnv>}
- {}
-
- using __rcvr_vfun<_Sigs>::operator()...;
-
- auto __get_env(const void* __op_state) const noexcept -> _Env
- {
- return __do_get_env(__op_state);
- }
-};
-
-template <class _OpState, class _GetEnv, class _GetReceiver, class _Env,
- class _Sigs>
-inline constexpr __receiver_vtable_for<_Sigs, _Env> __receiver_vtable_for_v{
- static_cast<_OpState*>(nullptr), _GetEnv{}, _GetReceiver{}};
-
-template <class _Sigs, class _Env = empty_env>
-class __receiver_ref
-{
- public:
+namespace stdexec {
+ template <class _Rcvr, class _Env = env_of_t<_Rcvr>>
+ struct __rcvr_ref {
using receiver_concept = receiver_t;
- using __t = __receiver_ref;
- using __id = __receiver_ref;
- template <class _OpState, class _GetEnv, class _GetReceiver = std::identity>
- __receiver_ref(_OpState& __op_state, _GetEnv, _GetReceiver = {}) noexcept :
- __vtable_{&__any_::__receiver_vtable_for_v<_OpState, _GetEnv,
- _GetReceiver, _Env, _Sigs>},
- __op_state_{&__op_state}
- {}
-
- auto get_env() const noexcept -> decltype(auto)
- {
- return __vtable_->__get_env(__op_state_);
+ STDEXEC_ATTRIBUTE(host, device)
+ explicit constexpr __rcvr_ref(_Rcvr& __rcvr) noexcept
+ : __rcvr_{std::addressof(__rcvr)} {
}
template <class... _As>
- void set_value(_As&&... __as) noexcept
- {
- (*__vtable_)(__op_state_, set_value_t(), static_cast<_As&&>(__as)...);
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_value(_As&&... __as) noexcept {
+ stdexec::set_value(static_cast<_Rcvr&&>(*__rcvr_), static_cast<_As&&>(__as)...);
}
template <class _Error>
- void set_error(_Error&& __err) noexcept
- {
- (*__vtable_)(__op_state_, set_error_t(), static_cast<_Error&&>(__err));
+ STDEXEC_ATTRIBUTE(host, device)
+ void set_error(_Error&& __err) noexcept {
+ stdexec::set_error(static_cast<_Rcvr&&>(*__rcvr_), static_cast<_Error&&>(__err));
}
- void set_stopped() noexcept
- {
- (*__vtable_)(__op_state_, set_stopped_t());
+ STDEXEC_ATTRIBUTE(host, device) void set_stopped() noexcept {
+ stdexec::set_stopped(static_cast<_Rcvr&&>(*__rcvr_));
}
- private:
- const __receiver_vtable_for<_Sigs, _Env>* __vtable_;
- void* __op_state_;
-};
-} // namespace __any_
+ [[nodiscard]]
+ STDEXEC_ATTRIBUTE(host, device) auto get_env() const noexcept -> _Env {
+ static_assert(
+ std::is_same_v<_Env, env_of_t<_Rcvr>>,
+ "get_env() must return the same type as env_of_t<_Rcvr>");
+ return stdexec::get_env(*__rcvr_);
+ }
+
+ private:
+ _Rcvr* __rcvr_;
+ };
+
+ namespace __detail {
+ template <class _Rcvr, size_t = sizeof(_Rcvr)>
+ STDEXEC_ATTRIBUTE(host, device)
+ constexpr auto __is_type_complete(int) noexcept {
+ return true;
+ }
+
+ template <class _Rcvr>
+ STDEXEC_ATTRIBUTE(host, device)
+ constexpr auto __is_type_complete(long) noexcept {
+ return false;
+ }
+ } // namespace __detail
+
+ // The __ref_rcvr function and its helpers are used to avoid wrapping a receiver in a
+ // __rcvr_ref when that is possible. The logic goes as follows:
+
+ // 1. If the receiver is an instance of __rcvr_ref, return it.
+ // 2. If the type is incomplete or an operation state, return a __rcvr_ref wrapping the
+ // receiver.
+ // 3. If the receiver is nothrow copy constructible, return it.
+ // 4. Otherwise, return a __rcvr_ref wrapping the receiver.
+ template <class _Env = void, class _Rcvr>
+ STDEXEC_ATTRIBUTE(nodiscard, host, device)
+ constexpr auto __ref_rcvr(_Rcvr& __rcvr) noexcept {
+ if constexpr (std::is_same_v<_Env, void>) {
+ return stdexec::__ref_rcvr<env_of_t<_Rcvr>>(__rcvr);
+ } else if constexpr (__is_instance_of<_Rcvr, __rcvr_ref>) {
+ return __rcvr;
+ } else if constexpr (!__detail::__is_type_complete<_Rcvr>(0)) {
+ return __rcvr_ref<_Rcvr, _Env>{__rcvr};
+ } else if constexpr (operation_state<_Rcvr>) {
+ return __rcvr_ref<_Rcvr, _Env>{__rcvr};
+ } else if constexpr (__nothrow_constructible_from<_Rcvr, const _Rcvr&>) {
+ return const_cast<const _Rcvr&>(__rcvr);
+ } else {
+ return __rcvr_ref{__rcvr};
+ }
+ STDEXEC_UNREACHABLE();
+ }
+
+ template <class _Rcvr, class _Env = env_of_t<_Rcvr>>
+ using __rcvr_ref_t = decltype(stdexec::__ref_rcvr<_Env>(stdexec::__declval<_Rcvr&>()));
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__receivers.hpp b/include/sdbusplus/async/stdexec/__detail/__receivers.hpp
index a3e365c..955e250 100644
--- a/include/sdbusplus/async/stdexec/__detail/__receivers.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__receivers.hpp
@@ -15,221 +15,206 @@
*/
#pragma once
-#include "../functional.hpp"
+#include "__execution_fwd.hpp"
+
#include "__concepts.hpp"
#include "__diagnostics.hpp"
#include "__env.hpp"
-#include "__execution_fwd.hpp"
#include "__tag_invoke.hpp"
+#include "../functional.hpp"
+
#include <exception>
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.receivers]
-namespace __rcvrs
-{
-struct set_value_t
-{
- template <class _Fn, class... _Args>
- using __f = __minvoke<_Fn, _Args...>;
-
- template <__same_as<set_value_t> _Self, class _Receiver, class... _As>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- friend auto tag_invoke(_Self, _Receiver&& __rcvr, _As&&... __as) noexcept
- -> decltype(static_cast<_Receiver&&>(__rcvr).set_value(
- static_cast<_As&&>(__as)...))
- {
- static_assert(noexcept(static_cast<_Receiver&&>(__rcvr).set_value(
- static_cast<_As&&>(__as)...)),
- "set_value member functions must be noexcept");
- static_assert(
- __same_as<decltype(static_cast<_Receiver&&>(__rcvr).set_value(
- static_cast<_As&&>(__as)...)),
- void>,
- "set_value member functions must return void");
- static_cast<_Receiver&&>(__rcvr).set_value(static_cast<_As&&>(__as)...);
- }
-
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.receivers]
+ namespace __rcvrs {
template <class _Receiver, class... _As>
- requires tag_invocable<set_value_t, _Receiver, _As...>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- void operator()(_Receiver&& __rcvr, _As&&... __as) const noexcept
- {
- static_assert(nothrow_tag_invocable<set_value_t, _Receiver, _As...>);
- (void)tag_invoke(stdexec::set_value_t{},
- static_cast<_Receiver&&>(__rcvr),
- static_cast<_As&&>(__as)...);
- }
-};
-
-struct set_error_t
-{
- template <class _Fn, class... _Args>
- requires(sizeof...(_Args) == 1)
- using __f = __minvoke<_Fn, _Args...>;
-
- template <__same_as<set_error_t> _Self, class _Receiver, class _Error>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- friend auto tag_invoke(_Self, _Receiver&& __rcvr, _Error&& __err) noexcept
- -> decltype(static_cast<_Receiver&&>(__rcvr).set_error(
- static_cast<_Error&&>(__err)))
- {
- static_assert(noexcept(static_cast<_Receiver&&>(__rcvr).set_error(
- static_cast<_Error&&>(__err))),
- "set_error member functions must be noexcept");
- static_assert(
- __same_as<decltype(static_cast<_Receiver&&>(__rcvr).set_error(
- static_cast<_Error&&>(__err))),
- void>,
- "set_error member functions must return void");
- static_cast<_Receiver&&>(__rcvr).set_error(
- static_cast<_Error&&>(__err));
- }
-
- template <class _Receiver, class _Error>
- requires tag_invocable<set_error_t, _Receiver, _Error>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- void operator()(_Receiver&& __rcvr, _Error&& __err) const noexcept
- {
- static_assert(nothrow_tag_invocable<set_error_t, _Receiver, _Error>);
- (void)tag_invoke(stdexec::set_error_t{},
- static_cast<_Receiver&&>(__rcvr),
- static_cast<_Error&&>(__err));
- }
-};
-
-struct set_stopped_t
-{
- template <class _Fn, class... _Args>
- requires(sizeof...(_Args) == 0)
- using __f = __minvoke<_Fn, _Args...>;
-
- template <__same_as<set_stopped_t> _Self, class _Receiver>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- friend auto tag_invoke(_Self, _Receiver&& __rcvr) noexcept
- -> decltype(static_cast<_Receiver&&>(__rcvr).set_stopped())
- {
- static_assert(noexcept(static_cast<_Receiver&&>(__rcvr).set_stopped()),
- "set_stopped member functions must be noexcept");
- static_assert(
- __same_as<decltype(static_cast<_Receiver&&>(__rcvr).set_stopped()),
- void>,
- "set_stopped member functions must return void");
- static_cast<_Receiver&&>(__rcvr).set_stopped();
- }
-
- template <class _Receiver>
- requires tag_invocable<set_stopped_t, _Receiver>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- void operator()(_Receiver&& __rcvr) const noexcept
- {
- static_assert(nothrow_tag_invocable<set_stopped_t, _Receiver>);
- (void)tag_invoke(stdexec::set_stopped_t{},
- static_cast<_Receiver&&>(__rcvr));
- }
-};
-} // namespace __rcvrs
-
-using __rcvrs::set_error_t;
-using __rcvrs::set_stopped_t;
-using __rcvrs::set_value_t;
-inline constexpr set_value_t set_value{};
-inline constexpr set_error_t set_error{};
-inline constexpr set_stopped_t set_stopped{};
-
-struct receiver_t
-{
- using receiver_concept = receiver_t; // NOT TO SPEC
-};
-
-namespace __detail
-{
-template <class _Receiver>
-concept __enable_receiver = //
- (STDEXEC_EDG(requires { typename _Receiver::receiver_concept; }&&) //
- derived_from<typename _Receiver::receiver_concept, receiver_t>) ||
- requires { typename _Receiver::is_receiver; } // back-compat, NOT TO SPEC
- || STDEXEC_IS_BASE_OF(receiver_t,
- _Receiver); // NOT TO SPEC, for receiver_adaptor
-} // namespace __detail
-
-template <class _Receiver>
-inline constexpr bool enable_receiver =
- __detail::__enable_receiver<_Receiver>; // NOT TO SPEC
-
-template <class _Receiver>
-concept receiver = //
- enable_receiver<__decay_t<_Receiver>> //
- && environment_provider<__cref_t<_Receiver>> //
- && move_constructible<__decay_t<_Receiver>> //
- && constructible_from<__decay_t<_Receiver>, _Receiver>;
-
-namespace __detail
-{
-template <class _Receiver, class _Tag, class... _Args>
-auto __try_completion(_Tag (*)(_Args...))
- -> __mexception<_MISSING_COMPLETION_SIGNAL_<_Tag(_Args...)>,
- _WITH_RECEIVER_<_Receiver>>;
-
-template <class _Receiver, class _Tag, class... _Args>
- requires nothrow_tag_invocable<_Tag, _Receiver, _Args...>
-auto __try_completion(_Tag (*)(_Args...)) -> __msuccess;
-
-template <class _Receiver, class... _Sigs>
-auto __try_completions(completion_signatures<_Sigs...>*) //
- -> decltype((
- __msuccess(), ...,
- __detail::__try_completion<_Receiver>(static_cast<_Sigs*>(nullptr))));
-} // namespace __detail
-
-template <class _Receiver, class _Completions>
-concept receiver_of = //
- receiver<_Receiver> && //
- requires(_Completions* __completions) {
- {
- __detail::__try_completions<__decay_t<_Receiver>>(__completions)
- } -> __ok;
+ concept __set_value_member = requires(_Receiver &&__rcvr, _As &&...__args) {
+ static_cast<_Receiver &&>(__rcvr).set_value(static_cast<_As &&>(__args)...);
};
-template <class _Receiver, class _Sender>
-concept __receiver_from =
- receiver_of<_Receiver,
- __completion_signatures_of_t<_Sender, env_of_t<_Receiver>>>;
+ struct set_value_t {
+ template <class _Fn, class... _As>
+ using __f = __minvoke<_Fn, _As...>;
-/// A utility for calling set_value with the result of a function invocation:
-template <bool _CanThrow = false, class _Receiver, class _Fun, class... _As>
-void __set_value_invoke(_Receiver&& __rcvr, _Fun&& __fun,
- _As&&... __as) noexcept(!_CanThrow)
-{
- if constexpr (_CanThrow || __nothrow_invocable<_Fun, _As...>)
- {
- if constexpr (same_as<void, __invoke_result_t<_Fun, _As...>>)
- {
- __invoke(static_cast<_Fun&&>(__fun), static_cast<_As&&>(__as)...);
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
- }
- else
- {
- set_value(static_cast<_Receiver&&>(__rcvr),
- __invoke(static_cast<_Fun&&>(__fun),
- static_cast<_As&&>(__as)...));
- }
+ template <class _Receiver, class... _As>
+ requires __set_value_member<_Receiver, _As...>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ void operator()(_Receiver &&__rcvr, _As &&...__as) const noexcept {
+ static_assert(
+ noexcept(static_cast<_Receiver &&>(__rcvr).set_value(static_cast<_As &&>(__as)...)),
+ "set_value member functions must be noexcept");
+ static_assert(
+ __same_as<
+ decltype(static_cast<_Receiver &&>(__rcvr).set_value(static_cast<_As &&>(__as)...)),
+ void
+ >,
+ "set_value member functions must return void");
+ static_cast<_Receiver &&>(__rcvr).set_value(static_cast<_As &&>(__as)...);
+ }
+
+ template <class _Receiver, class... _As>
+ requires(!__set_value_member<_Receiver, _As...>)
+ && tag_invocable<set_value_t, _Receiver, _As...>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ void operator()(_Receiver &&__rcvr, _As &&...__as) const noexcept {
+ static_assert(nothrow_tag_invocable<set_value_t, _Receiver, _As...>);
+ (void) tag_invoke(*this, static_cast<_Receiver &&>(__rcvr), static_cast<_As &&>(__as)...);
+ }
+ };
+
+ template <class _Receiver, class _Error>
+ concept __set_error_member = requires(_Receiver &&__rcvr, _Error &&__err) {
+ static_cast<_Receiver &&>(__rcvr).set_error(static_cast<_Error &&>(__err));
+ };
+
+ struct set_error_t {
+ template <class _Fn, class... _Args>
+ requires(sizeof...(_Args) == 1)
+ using __f = __minvoke<_Fn, _Args...>;
+
+ template <class _Receiver, class _Error>
+ requires __set_error_member<_Receiver, _Error>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ void operator()(_Receiver &&__rcvr, _Error &&__err) const noexcept {
+ static_assert(
+ noexcept(static_cast<_Receiver &&>(__rcvr).set_error(static_cast<_Error &&>(__err))),
+ "set_error member functions must be noexcept");
+ static_assert(
+ __same_as<
+ decltype(static_cast<_Receiver &&>(__rcvr).set_error(static_cast<_Error &&>(__err))),
+ void
+ >,
+ "set_error member functions must return void");
+ static_cast<_Receiver &&>(__rcvr).set_error(static_cast<_Error &&>(__err));
+ }
+
+ template <class _Receiver, class _Error>
+ requires(!__set_error_member<_Receiver, _Error>)
+ && tag_invocable<set_error_t, _Receiver, _Error>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ void operator()(_Receiver &&__rcvr, _Error &&__err) const noexcept {
+ static_assert(nothrow_tag_invocable<set_error_t, _Receiver, _Error>);
+ (void) tag_invoke(*this, static_cast<_Receiver &&>(__rcvr), static_cast<_Error &&>(__err));
+ }
+ };
+
+ template <class _Receiver>
+ concept __set_stopped_member = requires(_Receiver &&__rcvr) {
+ static_cast<_Receiver &&>(__rcvr).set_stopped();
+ };
+
+ struct set_stopped_t {
+ template <class _Fn, class... _Args>
+ requires(sizeof...(_Args) == 0)
+ using __f = __minvoke<_Fn, _Args...>;
+
+ template <class _Receiver>
+ requires __set_stopped_member<_Receiver>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ void operator()(_Receiver &&__rcvr) const noexcept {
+ static_assert(
+ noexcept(static_cast<_Receiver &&>(__rcvr).set_stopped()),
+ "set_stopped member functions must be noexcept");
+ static_assert(
+ __same_as<decltype(static_cast<_Receiver &&>(__rcvr).set_stopped()), void>,
+ "set_stopped member functions must return void");
+ static_cast<_Receiver &&>(__rcvr).set_stopped();
+ }
+
+ template <class _Receiver>
+ requires(!__set_stopped_member<_Receiver>) && tag_invocable<set_stopped_t, _Receiver>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ void operator()(_Receiver &&__rcvr) const noexcept {
+ static_assert(nothrow_tag_invocable<set_stopped_t, _Receiver>);
+ (void) tag_invoke(*this, static_cast<_Receiver &&>(__rcvr));
+ }
+ };
+ } // namespace __rcvrs
+
+ using __rcvrs::set_value_t;
+ using __rcvrs::set_error_t;
+ using __rcvrs::set_stopped_t;
+ inline constexpr set_value_t set_value{};
+ inline constexpr set_error_t set_error{};
+ inline constexpr set_stopped_t set_stopped{};
+
+ struct receiver_t {
+ using receiver_concept = receiver_t; // NOT TO SPEC
+ };
+
+ namespace __detail {
+ template <class _Receiver>
+ concept __enable_receiver =
+ (STDEXEC_WHEN(
+ STDEXEC_EDG(),
+ requires { typename _Receiver::receiver_concept; } &&)
+ derived_from<typename _Receiver::receiver_concept, receiver_t>)
+ || requires { typename _Receiver::is_receiver; } // back-compat, NOT TO SPEC
+ || STDEXEC_IS_BASE_OF(receiver_t, _Receiver); // NOT TO SPEC, for receiver_adaptor
+ } // namespace __detail
+
+ template <class _Receiver>
+ inline constexpr bool enable_receiver = __detail::__enable_receiver<_Receiver>; // NOT TO SPEC
+
+ template <class _Receiver>
+ concept receiver = enable_receiver<__decay_t<_Receiver>>
+ && environment_provider<__cref_t<_Receiver>>
+ && move_constructible<__decay_t<_Receiver>>
+ && constructible_from<__decay_t<_Receiver>, _Receiver>;
+
+ namespace __detail {
+ template <class _Receiver, class _Tag, class... _Args>
+ auto __try_completion(_Tag (*)(_Args...))
+ -> __mexception<_MISSING_COMPLETION_SIGNAL_<_Tag(_Args...)>, _WITH_RECEIVER_<_Receiver>>;
+
+ template <class _Receiver, class _Tag, class... _Args>
+ requires __callable<_Tag, _Receiver, _Args...>
+ auto __try_completion(_Tag (*)(_Args...)) -> __msuccess;
+
+ template <class _Receiver, class... _Sigs>
+ auto __try_completions(completion_signatures<_Sigs...> *) -> decltype((
+ __msuccess(),
+ ...,
+ __detail::__try_completion<__decay_t<_Receiver>>(static_cast<_Sigs *>(nullptr))));
+ } // namespace __detail
+
+ template <class _Receiver, class _Completions>
+ concept receiver_of = receiver<_Receiver> && requires(_Completions *__completions) {
+ { __detail::__try_completions<_Receiver>(__completions) } -> __ok;
+ };
+
+ template <class _Receiver, class _Sender>
+ concept __receiver_from =
+ receiver_of<_Receiver, __completion_signatures_of_t<_Sender, env_of_t<_Receiver>>>;
+
+ /// A utility for calling set_value with the result of a function invocation:
+ template <class _Receiver, class _Fun, class... _As>
+ STDEXEC_ATTRIBUTE(host, device)
+ void __set_value_invoke(_Receiver &&__rcvr, _Fun &&__fun, _As &&...__as) noexcept {
+ STDEXEC_TRY {
+ if constexpr (same_as<void, __invoke_result_t<_Fun, _As...>>) {
+ __invoke(static_cast<_Fun &&>(__fun), static_cast<_As &&>(__as)...);
+ stdexec::set_value(static_cast<_Receiver &&>(__rcvr));
+ } else {
+ stdexec::set_value(
+ static_cast<_Receiver &&>(__rcvr),
+ __invoke(static_cast<_Fun &&>(__fun), static_cast<_As &&>(__as)...));
+ }
}
- else
- {
- try
- {
- stdexec::__set_value_invoke<true>(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Fun&&>(__fun),
- static_cast<_As&&>(__as)...);
- }
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- std::current_exception());
- }
+ STDEXEC_CATCH_ALL {
+ if constexpr (!__nothrow_invocable<_Fun, _As...>) {
+ stdexec::set_error(static_cast<_Receiver &&>(__rcvr), std::current_exception());
+ }
}
-}
+ }
+
+ template <class _Tag, class _Receiver>
+ auto __mk_completion_fn(_Tag, _Receiver &__rcvr) noexcept {
+ return [&]<class... _Args>(_Args &&...__args) noexcept {
+ _Tag()(static_cast<_Receiver &&>(__rcvr), static_cast<_Args &&>(__args)...);
+ };
+ }
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__run_loop.hpp b/include/sdbusplus/async/stdexec/__detail/__run_loop.hpp
index 180352e..fde9d2d 100644
--- a/include/sdbusplus/async/stdexec/__detail/__run_loop.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__run_loop.hpp
@@ -19,7 +19,6 @@
// include these after __execution_fwd.hpp
#include "__completion_signatures.hpp"
-#include "__cpo.hpp"
#include "__env.hpp"
#include "__meta.hpp"
#include "__receivers.hpp"
@@ -30,234 +29,203 @@
#include <mutex>
#include <utility>
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// run_loop
-namespace __loop
-{
-class run_loop;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // run_loop
+ namespace __loop {
+ class run_loop;
-struct __task : __immovable
-{
- __task* __next_ = this;
+ struct __task : __immovable {
+ __task* __next_ = this;
- union
- {
+ union {
__task* __tail_ = nullptr;
void (*__execute_)(__task*) noexcept;
+ };
+
+ void __execute() noexcept {
+ (*__execute_)(this);
+ }
};
- void __execute() noexcept
- {
- (*__execute_)(this);
- }
-};
+ template <class _ReceiverId>
+ struct __operation {
+ using _Receiver = stdexec::__t<_ReceiverId>;
-template <class _ReceiverId>
-struct __operation
-{
- using _Receiver = stdexec::__t<_ReceiverId>;
-
- struct __t : __task
- {
+ struct __t : __task {
using __id = __operation;
run_loop* __loop_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Receiver __rcvr_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rcvr_;
- static void __execute_impl(__task* __p) noexcept
- {
- auto& __rcvr = static_cast<__t*>(__p)->__rcvr_;
- try
- {
- if (stdexec::get_stop_token(stdexec::get_env(__rcvr))
- .stop_requested())
- {
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
- }
- else
- {
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
- }
+ static void __execute_impl(__task* __p) noexcept {
+ auto& __rcvr = static_cast<__t*>(__p)->__rcvr_;
+ STDEXEC_TRY {
+ if (stdexec::get_stop_token(stdexec::get_env(__rcvr)).stop_requested()) {
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
+ } else {
+ stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
}
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- std::current_exception());
- }
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
+ }
}
- explicit __t(__task* __tail) noexcept : __task{{}, this, __tail} {}
+ explicit __t(__task* __tail) noexcept
+ : __task{{}, this, __tail} {
+ }
- __t(__task* __next, run_loop* __loop, _Receiver __rcvr) :
- __task{{}, __next, {}}, __loop_{__loop},
- __rcvr_{static_cast<_Receiver&&>(__rcvr)}
- {
- __execute_ = &__execute_impl;
+ __t(__task* __next, run_loop* __loop, _Receiver __rcvr)
+ : __task{{}, __next, {}}
+ , __loop_{__loop}
+ , __rcvr_{static_cast<_Receiver&&>(__rcvr)} {
+ __execute_ = &__execute_impl;
}
void start() & noexcept;
+ };
};
-};
-class run_loop
-{
- template <class>
- friend struct __operation;
+ class run_loop {
+ template <class>
+ friend struct __operation;
+ public:
+ struct __scheduler {
+ private:
+ struct __schedule_task {
+ using __t = __schedule_task;
+ using __id = __schedule_task;
+ using sender_concept = sender_t;
+ using completion_signatures = stdexec::completion_signatures<
+ set_value_t(),
+ set_error_t(std::exception_ptr),
+ set_stopped_t()
+ >;
- public:
- struct __scheduler
- {
- private:
- struct __schedule_task
- {
- using __t = __schedule_task;
- using __id = __schedule_task;
- using sender_concept = sender_t;
- using completion_signatures = stdexec::completion_signatures<
- set_value_t(), set_error_t(std::exception_ptr),
- set_stopped_t()>;
+ template <class _Receiver>
+ using __operation = stdexec::__t<__operation<stdexec::__id<_Receiver>>>;
- template <class _Receiver>
- using __operation =
- stdexec::__t<__operation<stdexec::__id<_Receiver>>>;
+ template <class _Receiver>
+ auto connect(_Receiver __rcvr) const -> __operation<_Receiver> {
+ return {&__loop_->__head_, __loop_, static_cast<_Receiver&&>(__rcvr)};
+ }
- template <class _Receiver>
- auto connect(_Receiver __rcvr) const -> __operation<_Receiver>
- {
- return {&__loop_->__head_, __loop_,
- static_cast<_Receiver&&>(__rcvr)};
+ private:
+ friend __scheduler;
+
+ struct __env {
+ using __t = __env;
+ using __id = __env;
+
+ run_loop* __loop_;
+
+ template <class _CPO>
+ auto query(get_completion_scheduler_t<_CPO>) const noexcept -> __scheduler {
+ return __loop_->get_scheduler();
}
+ };
- private:
- friend __scheduler;
+ explicit __schedule_task(run_loop* __loop) noexcept
+ : __loop_(__loop) {
+ }
- struct __env
- {
- using __t = __env;
- using __id = __env;
+ run_loop* const __loop_;
- run_loop* __loop_;
-
- template <class _CPO>
- auto query(get_completion_scheduler_t<_CPO>) const noexcept
- -> __scheduler
- {
- return __loop_->get_scheduler();
- }
- };
-
- explicit __schedule_task(run_loop* __loop) noexcept :
- __loop_(__loop)
- {}
-
- run_loop* const __loop_;
-
- public:
- auto get_env() const noexcept -> __env
- {
- return __env{__loop_};
- }
+ public:
+ [[nodiscard]]
+ auto get_env() const noexcept -> __env {
+ return __env{__loop_};
+ }
};
friend run_loop;
- explicit __scheduler(run_loop* __loop) noexcept : __loop_(__loop) {}
+ explicit __scheduler(run_loop* __loop) noexcept
+ : __loop_(__loop) {
+ }
run_loop* __loop_;
- public:
+ public:
using __t = __scheduler;
using __id = __scheduler;
auto operator==(const __scheduler&) const noexcept -> bool = default;
- [[nodiscard]] auto schedule() const noexcept -> __schedule_task
- {
- return __schedule_task{__loop_};
+ [[nodiscard]]
+ auto schedule() const noexcept -> __schedule_task {
+ return __schedule_task{__loop_};
}
+ [[nodiscard]]
auto query(get_forward_progress_guarantee_t) const noexcept
- -> stdexec::forward_progress_guarantee
- {
- return stdexec::forward_progress_guarantee::parallel;
+ -> stdexec::forward_progress_guarantee {
+ return stdexec::forward_progress_guarantee::parallel;
}
// BUGBUG NOT TO SPEC
- auto query(execute_may_block_caller_t) const noexcept -> bool
- {
- return false;
+ [[nodiscard]]
+ auto query(execute_may_block_caller_t) const noexcept -> bool {
+ return false;
}
+ };
+
+ auto get_scheduler() noexcept -> __scheduler {
+ return __scheduler{this};
+ }
+
+ void run();
+
+ void finish();
+
+ private:
+ void __push_back_(__task* __task);
+ auto __pop_front_() -> __task*;
+
+ std::mutex __mutex_;
+ std::condition_variable __cv_;
+ __task __head_{{}, &__head_, {&__head_}};
+ bool __stop_ = false;
};
- auto get_scheduler() noexcept -> __scheduler
- {
- return __scheduler{this};
- }
-
- void run();
-
- void finish();
-
- private:
- void __push_back_(__task* __task);
- auto __pop_front_() -> __task*;
-
- std::mutex __mutex_;
- std::condition_variable __cv_;
- __task __head_{{}, &__head_, {&__head_}};
- bool __stop_ = false;
-};
-
-template <class _ReceiverId>
-inline void __operation<_ReceiverId>::__t::start() & noexcept
-{
- try
- {
+ template <class _ReceiverId>
+ inline void __operation<_ReceiverId>::__t::start() & noexcept {
+ STDEXEC_TRY {
__loop_->__push_back_(this);
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr_), std::current_exception());
+ }
}
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr_),
- std::current_exception());
- }
-}
-inline void run_loop::run()
-{
- for (__task* __task; (__task = __pop_front_()) != &__head_;)
- {
+ inline void run_loop::run() {
+ for (__task* __task; (__task = __pop_front_()) != &__head_;) {
__task->__execute();
+ }
}
-}
-inline void run_loop::finish()
-{
- std::unique_lock __lock{__mutex_};
- __stop_ = true;
- __cv_.notify_all();
-}
+ inline void run_loop::finish() {
+ std::unique_lock __lock{__mutex_};
+ __stop_ = true;
+ __cv_.notify_all();
+ }
-inline void run_loop::__push_back_(__task* __task)
-{
- std::unique_lock __lock{__mutex_};
- __task->__next_ = &__head_;
- __head_.__tail_ = __head_.__tail_->__next_ = __task;
- __cv_.notify_one();
-}
+ inline void run_loop::__push_back_(__task* __task) {
+ std::unique_lock __lock{__mutex_};
+ __task->__next_ = &__head_;
+ __head_.__tail_ = __head_.__tail_->__next_ = __task;
+ __cv_.notify_one();
+ }
-inline auto run_loop::__pop_front_() -> __task*
-{
- std::unique_lock __lock{__mutex_};
- __cv_.wait(__lock,
- [this] { return __head_.__next_ != &__head_ || __stop_; });
- if (__head_.__tail_ == __head_.__next_)
+ inline auto run_loop::__pop_front_() -> __task* {
+ std::unique_lock __lock{__mutex_};
+ __cv_.wait(__lock, [this] { return __head_.__next_ != &__head_ || __stop_; });
+ if (__head_.__tail_ == __head_.__next_)
__head_.__tail_ = &__head_;
- return std::exchange(__head_.__next_, __head_.__next_->__next_);
-}
-} // namespace __loop
+ return std::exchange(__head_.__next_, __head_.__next_->__next_);
+ }
+ } // namespace __loop
-// NOT TO SPEC
-using run_loop = __loop::run_loop;
+ // NOT TO SPEC
+ using run_loop = __loop::run_loop;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__schedule_from.hpp b/include/sdbusplus/async/stdexec/__detail/__schedule_from.hpp
index 4321863..c613ab2 100644
--- a/include/sdbusplus/async/stdexec/__detail/__schedule_from.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__schedule_from.hpp
@@ -18,267 +18,206 @@
#include "__execution_fwd.hpp"
// include these after __execution_fwd.hpp
+#include "__basic_sender.hpp"
#include "__concepts.hpp"
#include "__domain.hpp"
#include "__env.hpp"
#include "__meta.hpp"
#include "__operation_states.hpp"
+#include "__senders.hpp"
#include "__schedulers.hpp"
-#include "__senders_core.hpp"
#include "__transform_completion_signatures.hpp"
#include "__tuple.hpp"
#include "__variant.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.schedule_from]
-namespace __schfr
-{
-template <class... _Ts>
-using __tuple_t = __tuple_for<__decay_t<_Ts>...>;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.schedule_from]
+ namespace __schfr {
+ // Compute a variant type that is capable of storing the results of the
+ // input sender when it completes. The variant has type:
+ // variant<
+ // monostate,
+ // tuple<set_stopped_t>,
+ // tuple<set_value_t, __decay_t<_Values1>...>,
+ // tuple<set_value_t, __decay_t<_Values2>...>,
+ // ...
+ // tuple<set_error_t, __decay_t<_Error1>>,
+ // tuple<set_error_t, __decay_t<_Error2>>,
+ // ...
+ // >
+ template <class _CvrefSender, class _Env>
+ using __results_of = __for_each_completion_signature<
+ __completion_signatures_of_t<_CvrefSender, _Env>,
+ __decayed_tuple,
+ __munique<__qq<stdexec::__variant_for>>::__f
+ >;
-template <class... _Ts>
-using __variant_t = __variant_for<__monostate, _Ts...>;
-
-// Compute a variant type that is capable of storing the results of the
-// input sender when it completes. The variant has type:
-// variant<
-// monostate,
-// tuple<set_stopped_t>,
-// tuple<set_value_t, __decay_t<_Values1>...>,
-// tuple<set_value_t, __decay_t<_Values2>...>,
-// ...
-// tuple<set_error_t, __decay_t<_Error1>>,
-// tuple<set_error_t, __decay_t<_Error2>>,
-// ...
-// >
-template <class _CvrefSender, class _Env>
-using __variant_for = //
- __for_each_completion_signature<
- __completion_signatures_of_t<_CvrefSender, _Env>, __tuple_t,
- __munique<__qq<__variant_for>>::__f>;
-
-template <class... _Values>
-using __decay_value_sig = set_value_t (*)(__decay_t<_Values>...);
-
-template <class _Error>
-using __decay_error_sig = set_error_t (*)(__decay_t<_Error>);
-
-template <class... _Ts>
-using __all_nothrow_decay_copyable =
- __mbool<(__nothrow_decay_copyable<_Ts> && ...)>;
-
-template <class _CvrefSender, class... _Env>
-using __all_nothrow_decay_copyable_results = //
- __for_each_completion_signature<
- __completion_signatures_of_t<_CvrefSender, _Env...>,
- __all_nothrow_decay_copyable, __mand_t>;
-
-template <class _Scheduler, class _CvrefSender, class... _Env>
-using __completions_t = //
- __mtry_q<__concat_completion_signatures>::__f<
- __transform_completion_signatures<
- __completion_signatures_of_t<_CvrefSender, _Env...>,
- __decay_value_sig, __decay_error_sig, set_stopped_t (*)(),
- __completion_signature_ptrs>,
- transform_completion_signatures<
- __completion_signatures_of_t<schedule_result_t<_Scheduler>,
- _Env...>,
- __eptr_completion_if_t<
- __all_nothrow_decay_copyable_results<_CvrefSender, _Env...>>,
- __mconst<completion_signatures<>>::__f>>;
-
-template <class _SchedulerId>
-struct __environ
-{
- using _Scheduler = stdexec::__t<_SchedulerId>;
-
- struct __t
- {
- using __id = __environ;
-
- _Scheduler __sched_;
-
- template <__one_of<set_value_t, set_stopped_t> _Tag>
- auto query(get_completion_scheduler_t<_Tag>) const noexcept
- {
- return __sched_;
- }
-
- auto query(get_domain_t) const noexcept
- {
- return query_or(get_domain, __sched_, default_domain());
- }
- };
-};
-
-template <class _Scheduler, class _Sexpr, class _Receiver>
-struct __state;
-
-template <class _State>
-STDEXEC_ATTRIBUTE((always_inline))
-auto __make_visitor_fn(_State* __state) noexcept
-{
- return [__state]<class _Tup>(_Tup& __tupl) noexcept -> void {
- if constexpr (__same_as<_Tup, __monostate>)
- {
- std::terminate(); // reaching this indicates a bug in schedule_from
- }
- else
- {
- __tupl.apply(
- [&]<class... _Args>(auto __tag,
- _Args&... __args) noexcept -> void {
- __tag(std::move(__state->__receiver()),
- static_cast<_Args&&>(__args)...);
- },
- __tupl);
- }
- };
-}
-
-// This receiver is to be completed on the execution context associated with the
-// scheduler. When the source sender completes, the completion information is
-// saved off in the operation state so that when this receiver completes, it can
-// read the completion out of the operation state and forward it to the output
-// receiver after transitioning to the scheduler's context.
-template <class _Scheduler, class _Sexpr, class _Receiver>
-struct __receiver2
-{
- using receiver_concept = receiver_t;
-
- void set_value() noexcept
- {
- __state_->__data_.visit(__schfr::__make_visitor_fn(__state_),
- __state_->__data_);
- }
+ template <class... _Values>
+ using __decay_value_sig = set_value_t (*)(__decay_t<_Values>...);
template <class _Error>
- void set_error(_Error&& __err) noexcept
- {
- stdexec::set_error(static_cast<_Receiver&&>(__state_->__receiver()),
- static_cast<_Error&&>(__err));
+ using __decay_error_sig = set_error_t (*)(__decay_t<_Error>);
+
+ template <class _Scheduler, class _Completions, class... _Env>
+ using __completions_impl_t = __mtry_q<__concat_completion_signatures>::__f<
+ __transform_completion_signatures<
+ _Completions,
+ __decay_value_sig,
+ __decay_error_sig,
+ set_stopped_t (*)(),
+ __completion_signature_ptrs
+ >,
+ transform_completion_signatures<
+ __completion_signatures_of_t<schedule_result_t<_Scheduler>, _Env...>,
+ __eptr_completion_if_t<__nothrow_decay_copyable_results_t<_Completions>>,
+ __mconst<completion_signatures<>>::__f
+ >
+ >;
+
+ template <class _Scheduler, class _CvrefSender, class... _Env>
+ using __completions_t =
+ __completions_impl_t<_Scheduler, __completion_signatures_of_t<_CvrefSender, _Env...>, _Env...>;
+
+ template <class _Scheduler, class _Sexpr, class _Receiver>
+ struct __state;
+
+ template <class _State>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto __make_visitor_fn(_State* __state) noexcept {
+ return [__state]<class _Tup>(_Tup& __tupl) noexcept -> void {
+ __tupl.apply(
+ [&]<class... _Args>(auto __tag, _Args&... __args) noexcept -> void {
+ __tag(std::move(__state->__receiver()), static_cast<_Args&&>(__args)...);
+ },
+ __tupl);
+ };
}
- void set_stopped() noexcept
- {
- stdexec::set_stopped(static_cast<_Receiver&&>(__state_->__receiver()));
- }
+ // This receiver is to be completed on the execution context associated with the scheduler. When
+ // the source sender completes, the completion information is saved off in the operation state
+ // so that when this receiver completes, it can read the completion out of the operation state
+ // and forward it to the output receiver after transitioning to the scheduler's context.
+ template <class _SchedulerId, class _SexprId, class _ReceiverId>
+ struct __rcvr2 {
+ using _Scheduler = stdexec::__t<_SchedulerId>;
+ using _Sexpr = stdexec::__t<_SexprId>;
+ using _Receiver = stdexec::__t<_ReceiverId>;
- auto get_env() const noexcept -> env_of_t<_Receiver>
- {
- return stdexec::get_env(__state_->__receiver());
- }
+ struct __t {
+ using receiver_concept = receiver_t;
+ using __id = __rcvr2;
- __state<_Scheduler, _Sexpr, _Receiver>* __state_;
-};
+ void set_value() noexcept {
+ __state_->__data_.visit(__schfr::__make_visitor_fn(__state_), __state_->__data_);
+ }
-template <class _Scheduler, class _Sexpr, class _Receiver>
-struct __state :
- __enable_receiver_from_this<_Sexpr, _Receiver,
- __state<_Scheduler, _Sexpr, _Receiver>>,
- __immovable
-{
- using __variant_t = __variant_for<__child_of<_Sexpr>, env_of_t<_Receiver>>;
- using __receiver2_t = __receiver2<_Scheduler, _Sexpr, _Receiver>;
+ template <class _Error>
+ void set_error(_Error&& __err) noexcept {
+ stdexec::set_error(
+ static_cast<_Receiver&&>(__state_->__receiver()), static_cast<_Error&&>(__err));
+ }
- __variant_t __data_;
- connect_result_t<schedule_result_t<_Scheduler>, __receiver2_t> __state2_;
+ void set_stopped() noexcept {
+ stdexec::set_stopped(static_cast<_Receiver&&>(__state_->__receiver()));
+ }
- explicit __state(_Scheduler __sched) :
- __data_(), __state2_(connect(schedule(__sched), __receiver2_t{this}))
- {}
-};
+ auto get_env() const noexcept -> env_of_t<_Receiver> {
+ return stdexec::get_env(__state_->__receiver());
+ }
-struct schedule_from_t
-{
- template <scheduler _Scheduler, sender _Sender>
- auto operator()(_Scheduler&& __sched, _Sender&& __sndr) const
- -> __well_formed_sender auto
- {
- using _Env = __t<__environ<__id<__decay_t<_Scheduler>>>>;
- auto __env = _Env{{static_cast<_Scheduler&&>(__sched)}};
+ __state<_Scheduler, _Sexpr, _Receiver>* __state_;
+ };
+ };
+
+ template <class _Scheduler, class _Sexpr, class _Receiver>
+ using __receiver2 = __t<__rcvr2<__id<_Scheduler>, __id<_Sexpr>, __id<_Receiver>>>;
+
+ template <class _Scheduler, class _Sexpr, class _Receiver>
+ struct __state
+ : __enable_receiver_from_this<_Sexpr, _Receiver, __state<_Scheduler, _Sexpr, _Receiver>>
+ , __immovable {
+ using __variant_t = __results_of<__child_of<_Sexpr>, env_of_t<_Receiver>>;
+ using __receiver2_t = __receiver2<_Scheduler, _Sexpr, _Receiver>;
+
+ __variant_t __data_;
+ connect_result_t<schedule_result_t<_Scheduler>, __receiver2_t> __state2_;
+
+ explicit __state(_Scheduler __sched)
+ : __data_()
+ , __state2_(connect(schedule(__sched), __receiver2_t{this})) {
+ }
+ };
+
+ struct schedule_from_t {
+ template <scheduler _Scheduler, sender _Sender>
+ auto operator()(_Scheduler __sched, _Sender&& __sndr) const -> __well_formed_sender auto {
auto __domain = query_or(get_domain, __sched, default_domain());
return stdexec::transform_sender(
- __domain, __make_sexpr<schedule_from_t>(
- std::move(__env), static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<schedule_from_t>(
+ static_cast<_Scheduler&&>(__sched), static_cast<_Sender&&>(__sndr)));
+ }
+ };
- using _Sender = __1;
- using _Env = __0;
- using __legacy_customizations_t = __types<tag_invoke_t(
- schedule_from_t, get_completion_scheduler_t<set_value_t>(_Env&),
- _Sender)>;
-};
+ struct __schedule_from_impl : __sexpr_defaults {
+ template <class _Sender>
+ using __scheduler_t =
+ __decay_t<__call_result_t<get_completion_scheduler_t<set_value_t>, env_of_t<_Sender>>>;
-struct __schedule_from_impl : __sexpr_defaults
-{
- template <class _Sender>
- using __scheduler_t =
- __decay_t<__call_result_t<get_completion_scheduler_t<set_value_t>,
- env_of_t<_Sender>>>;
+ static constexpr auto get_attrs = []<class _Data, class _Child>(
+ const _Data& __data,
+ const _Child& __child) noexcept {
+ auto __domain = query_or(get_domain, __data, default_domain{});
+ return __env::__join(__sched_attrs{std::cref(__data), __domain}, stdexec::get_env(__child));
+ };
- static constexpr auto get_attrs = //
- []<class _Data, class _Child>(const _Data& __data,
- const _Child& __child) noexcept {
- return __env::__join(__data, stdexec::get_env(__child));
- };
-
- static constexpr auto get_completion_signatures = //
+ static constexpr auto get_completion_signatures =
[]<class _Sender, class... _Env>(_Sender&&, _Env&&...) noexcept
- -> __completions_t<__scheduler_t<_Sender>, __child_of<_Sender>,
- _Env...> {
+ -> __completions_t<__scheduler_t<_Sender>, __child_of<_Sender>, _Env...> {
static_assert(sender_expr_for<_Sender, schedule_from_t>);
return {};
- };
+ };
- static constexpr auto get_state =
+ static constexpr auto get_state =
[]<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver&) {
- static_assert(sender_expr_for<_Sender, schedule_from_t>);
- auto __sched =
- get_completion_scheduler<set_value_t>(stdexec::get_env(__sndr));
- using _Scheduler = decltype(__sched);
- return __state<_Scheduler, _Sender, _Receiver>{__sched};
+ static_assert(sender_expr_for<_Sender, schedule_from_t>);
+ auto __sched = get_completion_scheduler<set_value_t>(stdexec::get_env(__sndr));
+ using _Scheduler = decltype(__sched);
+ return __state<_Scheduler, _Sender, _Receiver>{__sched};
};
- static constexpr auto complete = //
+ static constexpr auto complete =
[]<class _State, class _Receiver, class _Tag, class... _Args>(
- __ignore, _State& __state, _Receiver& __rcvr, _Tag __tag,
- _Args&&... __args) noexcept -> void {
- // Write the tag and the args into the operation state so that we can
- // forward the completion from within the scheduler's execution context.
- if constexpr (__nothrow_callable<__tup::__mktuple_t, _Tag, _Args...>)
- {
- __state.__data_.emplace_from(__tup::__mktuple, __tag,
- static_cast<_Args&&>(__args)...);
- }
- else
- {
- try
- {
- __state.__data_.emplace_from(__tup::__mktuple, __tag,
- static_cast<_Args&&>(__args)...);
- }
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- std::current_exception());
- return;
- }
+ __ignore,
+ _State& __state,
+ _Receiver& __rcvr,
+ _Tag __tag,
+ _Args&&... __args) noexcept -> void {
+ // Write the tag and the args into the operation state so that we can forward the completion
+ // from within the scheduler's execution context.
+ if constexpr (__nothrow_callable<__tup::__mktuple_t, _Tag, _Args...>) {
+ __state.__data_.emplace_from(__tup::__mktuple, __tag, static_cast<_Args&&>(__args)...);
+ } else {
+ STDEXEC_TRY {
+ __state.__data_.emplace_from(__tup::__mktuple, __tag, static_cast<_Args&&>(__args)...);
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
+ return;
+ }
}
- // Enqueue the schedule operation so the completion happens on the
- // scheduler's execution context.
+ // Enqueue the schedule operation so the completion happens on the scheduler's execution
+ // context.
stdexec::start(__state.__state2_);
+ };
};
-};
-} // namespace __schfr
+ } // namespace __schfr
-using __schfr::schedule_from_t;
-inline constexpr schedule_from_t schedule_from{};
+ using __schfr::schedule_from_t;
+ inline constexpr schedule_from_t schedule_from{};
-template <>
-struct __sexpr_impl<schedule_from_t> : __schfr::__schedule_from_impl
-{};
+ template <>
+ struct __sexpr_impl<schedule_from_t> : __schfr::__schedule_from_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__schedulers.hpp b/include/sdbusplus/async/stdexec/__detail/__schedulers.hpp
index bb0c4aa..e1d1413 100644
--- a/include/sdbusplus/async/stdexec/__detail/__schedulers.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__schedulers.hpp
@@ -19,140 +19,101 @@
// include these after __execution_fwd.hpp
#include "__concepts.hpp"
-#include "__cpo.hpp"
#include "__env.hpp"
-#include "__senders.hpp"
+#include "__senders_core.hpp"
#include "__tag_invoke.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.schedule]
-namespace __sched
-{
-struct schedule_t
-{
- template <__same_as<schedule_t> _Self, class _Scheduler>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- friend auto tag_invoke(_Self, _Scheduler&& __sched) //
- noexcept(noexcept(static_cast<_Scheduler&&>(__sched).schedule()))
- -> decltype(static_cast<_Scheduler&&>(__sched).schedule())
- {
- static_assert(
- sender<decltype(static_cast<_Scheduler&&>(__sched).schedule())>,
- "schedule() member functions must return a sender");
- return static_cast<_Scheduler&&>(__sched).schedule();
- }
-
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.schedule]
+ namespace __sched {
template <class _Scheduler>
- requires tag_invocable<schedule_t, _Scheduler>
- STDEXEC_ATTRIBUTE((host, device))
- auto operator()(_Scheduler&& __sched) const
+ concept __has_schedule_member = requires(_Scheduler&& __sched) {
+ static_cast<_Scheduler &&>(__sched).schedule();
+ };
+
+ struct schedule_t {
+ template <class _Scheduler>
+ requires __has_schedule_member<_Scheduler>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_Scheduler&& __sched) const
+ noexcept(noexcept(static_cast<_Scheduler&&>(__sched).schedule()))
+ -> decltype(static_cast<_Scheduler&&>(__sched).schedule()) {
+ static_assert(
+ sender<decltype(static_cast<_Scheduler&&>(__sched).schedule())>,
+ "schedule() member functions must return a sender");
+ return static_cast<_Scheduler&&>(__sched).schedule();
+ }
+
+ template <class _Scheduler>
+ requires(!__has_schedule_member<_Scheduler>) && tag_invocable<schedule_t, _Scheduler>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_Scheduler&& __sched) const
noexcept(nothrow_tag_invocable<schedule_t, _Scheduler>)
- {
+ -> tag_invoke_result_t<schedule_t, _Scheduler> {
static_assert(sender<tag_invoke_result_t<schedule_t, _Scheduler>>);
- return tag_invoke(schedule_t{}, static_cast<_Scheduler&&>(__sched));
- }
+ return tag_invoke(*this, static_cast<_Scheduler&&>(__sched));
+ }
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
+ static constexpr auto query(forwarding_query_t) noexcept -> bool {
return false;
+ }
+ };
+ } // namespace __sched
+
+ using __sched::schedule_t;
+ inline constexpr schedule_t schedule{};
+
+ struct scheduler_t { };
+
+ template <class _Scheduler>
+ concept __has_schedule = requires(_Scheduler&& __sched) {
+ { schedule(static_cast<_Scheduler &&>(__sched)) } -> sender;
+ };
+
+ template <class _Scheduler>
+ concept __sender_has_completion_scheduler = requires(_Scheduler&& __sched) {
+ {
+ stdexec::__decay_copy(
+ get_completion_scheduler<set_value_t>(
+ get_env(schedule(static_cast<_Scheduler &&>(__sched)))))
+ } -> same_as<__decay_t<_Scheduler>>;
+ };
+
+ template <class _Scheduler>
+ concept scheduler = __has_schedule<_Scheduler> && __sender_has_completion_scheduler<_Scheduler>
+ && equality_comparable<__decay_t<_Scheduler>>
+ && copy_constructible<__decay_t<_Scheduler>>;
+
+ template <scheduler _Scheduler>
+ using schedule_result_t = __call_result_t<schedule_t, _Scheduler>;
+
+ template <class _SchedulerProvider>
+ concept __scheduler_provider = requires(const _SchedulerProvider& __sp) {
+ { get_scheduler(__sp) } -> scheduler;
+ };
+
+ namespace __queries {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ constexpr void get_scheduler_t::__validate() noexcept {
+ static_assert(__nothrow_callable<get_scheduler_t, const _Env&>);
+ static_assert(scheduler<__call_result_t<get_scheduler_t, const _Env&>>);
}
-};
-} // namespace __sched
-using __sched::schedule_t;
-inline constexpr schedule_t schedule{};
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ constexpr void get_delegation_scheduler_t::__validate() noexcept {
+ static_assert(__nothrow_callable<get_delegation_scheduler_t, const _Env&>);
+ static_assert(scheduler<__call_result_t<get_delegation_scheduler_t, const _Env&>>);
+ }
-template <class _Scheduler>
-concept __has_schedule = //
- requires(_Scheduler&& __sched) {
- { schedule(static_cast<_Scheduler&&>(__sched)) } -> sender;
- };
-
-template <class _Scheduler>
-concept __sender_has_completion_scheduler =
- requires(_Scheduler&& __sched) {
- {
- stdexec::__decay_copy(get_completion_scheduler<set_value_t>(
- get_env(schedule(static_cast<_Scheduler&&>(__sched)))))
- } -> same_as<__decay_t<_Scheduler>>;
- };
-
-template <class _Scheduler>
-concept scheduler = //
- __has_schedule<_Scheduler> //
- && __sender_has_completion_scheduler<_Scheduler> //
- && equality_comparable<__decay_t<_Scheduler>> //
- && copy_constructible<__decay_t<_Scheduler>>;
-
-template <scheduler _Scheduler>
-using schedule_result_t = __call_result_t<schedule_t, _Scheduler>;
-
-template <class _SchedulerProvider>
-concept __scheduler_provider = //
- requires(const _SchedulerProvider& __sp) {
- { get_scheduler(__sp) } -> scheduler;
- };
-
-namespace __queries
-{
-template <class _Env>
- requires tag_invocable<get_scheduler_t, const _Env&>
-inline auto get_scheduler_t::operator()(const _Env& __env) const noexcept
- -> tag_invoke_result_t<get_scheduler_t, const _Env&>
-{
- static_assert(nothrow_tag_invocable<get_scheduler_t, const _Env&>);
- static_assert(scheduler<tag_invoke_result_t<get_scheduler_t, const _Env&>>);
- return tag_invoke(get_scheduler_t{}, __env);
-}
-
-template <class _Env>
- requires tag_invocable<get_delegation_scheduler_t, const _Env&>
-inline auto get_delegation_scheduler_t::operator()(
- const _Env& __env) const noexcept
- -> tag_invoke_result_t<get_delegation_scheduler_t, const _Env&>
-{
- static_assert(
- nothrow_tag_invocable<get_delegation_scheduler_t, const _Env&>);
- static_assert(
- scheduler<
- tag_invoke_result_t<get_delegation_scheduler_t, const _Env&>>);
- return tag_invoke(get_delegation_scheduler_t{}, __env);
-}
-
-template <__completion_tag _Tag>
-template <__has_completion_scheduler_for<_Tag> _Env>
-auto get_completion_scheduler_t<_Tag>::operator()(
- const _Env& __env) const noexcept
- -> tag_invoke_result_t<get_completion_scheduler_t<_Tag>, const _Env&>
-{
- static_assert(
- nothrow_tag_invocable<get_completion_scheduler_t<_Tag>, const _Env&>,
- "get_completion_scheduler<_Tag> should be noexcept");
- static_assert(
- scheduler<tag_invoke_result_t<get_completion_scheduler_t<_Tag>,
- const _Env&>>);
- return tag_invoke(*this, __env);
-}
-} // namespace __queries
-
-namespace __detail
-{
-// A handy utility for augmenting an environment with a scheduler.
-template <class _Env, class _Scheduler>
-STDEXEC_ATTRIBUTE((always_inline))
-auto __mkenv_sched(_Env&& __env, _Scheduler __sched)
-{
- auto __env2 =
- __env::__join(prop{get_scheduler, __sched},
- __env::__without(static_cast<_Env&&>(__env), get_domain));
- using _Env2 = decltype(__env2);
-
- struct __env_t : _Env2
- {};
-
- return __env_t{static_cast<_Env2&&>(__env2)};
-}
-} // namespace __detail
+ template <__completion_tag _Tag>
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline, host, device)
+ constexpr void get_completion_scheduler_t<_Tag>::__validate() noexcept {
+ static_assert(__nothrow_callable<get_completion_scheduler_t<_Tag>, const _Env&>);
+ static_assert(scheduler<__call_result_t<get_completion_scheduler_t<_Tag>, const _Env&>>);
+ }
+ } // namespace __queries
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__scope.hpp b/include/sdbusplus/async/stdexec/__detail/__scope.hpp
index d4e18fc..d40dfc4 100644
--- a/include/sdbusplus/async/stdexec/__detail/__scope.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__scope.hpp
@@ -16,116 +16,88 @@
#pragma once
#include "__config.hpp"
-#include "__meta.hpp"
+#include "__concepts.hpp"
+#include "__utility.hpp"
-namespace stdexec
-{
-template <class _Fn, class... _Ts>
+namespace stdexec {
+ template <class _Fn, class... _Ts>
requires __nothrow_callable<_Fn, _Ts...>
-struct __scope_guard;
+ struct __scope_guard;
-template <class _Fn>
-struct __scope_guard<_Fn>
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fn __fn_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- __immovable __hidden_{};
+ template <class _Fn>
+ struct __scope_guard<_Fn> {
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fn __fn_;
+ STDEXEC_ATTRIBUTE(no_unique_address) __immovable __hidden_ { };
bool __dismissed_{false};
- ~__scope_guard()
- {
- if (!__dismissed_)
- static_cast<_Fn&&>(__fn_)();
+ ~__scope_guard() {
+ if (!__dismissed_)
+ static_cast<_Fn&&>(__fn_)();
}
- void __dismiss() noexcept
- {
- __dismissed_ = true;
+ void __dismiss() noexcept {
+ __dismissed_ = true;
}
-};
+ };
-template <class _Fn, class _T0>
-struct __scope_guard<_Fn, _T0>
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fn __fn_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T0 __t0_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- __immovable __hidden_{};
+ template <class _Fn, class _T0>
+ struct __scope_guard<_Fn, _T0> {
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fn __fn_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _T0 __t0_;
+ STDEXEC_ATTRIBUTE(no_unique_address) __immovable __hidden_ { };
bool __dismissed_{false};
- void __dismiss() noexcept
- {
- __dismissed_ = true;
+ void __dismiss() noexcept {
+ __dismissed_ = true;
}
- ~__scope_guard()
- {
- if (!__dismissed_)
- static_cast<_Fn&&>(__fn_)(static_cast<_T0&&>(__t0_));
+ ~__scope_guard() {
+ if (!__dismissed_)
+ static_cast<_Fn&&>(__fn_)(static_cast<_T0&&>(__t0_));
}
-};
+ };
-template <class _Fn, class _T0, class _T1>
-struct __scope_guard<_Fn, _T0, _T1>
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fn __fn_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T0 __t0_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T1 __t1_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- __immovable __hidden_{};
+ template <class _Fn, class _T0, class _T1>
+ struct __scope_guard<_Fn, _T0, _T1> {
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fn __fn_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _T0 __t0_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _T1 __t1_;
+ STDEXEC_ATTRIBUTE(no_unique_address) __immovable __hidden_ { };
bool __dismissed_{false};
- void __dismiss() noexcept
- {
- __dismissed_ = true;
+ void __dismiss() noexcept {
+ __dismissed_ = true;
}
- ~__scope_guard()
- {
- if (!__dismissed_)
- static_cast<_Fn&&>(
- __fn_)(static_cast<_T0&&>(__t0_), static_cast<_T1&&>(__t1_));
+ ~__scope_guard() {
+ if (!__dismissed_)
+ static_cast<_Fn&&>(__fn_)(static_cast<_T0&&>(__t0_), static_cast<_T1&&>(__t1_));
}
-};
+ };
-template <class _Fn, class _T0, class _T1, class _T2>
-struct __scope_guard<_Fn, _T0, _T1, _T2>
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fn __fn_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T0 __t0_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T1 __t1_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T2 __t2_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- __immovable __hidden_{};
+ template <class _Fn, class _T0, class _T1, class _T2>
+ struct __scope_guard<_Fn, _T0, _T1, _T2> {
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fn __fn_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _T0 __t0_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _T1 __t1_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _T2 __t2_;
+ STDEXEC_ATTRIBUTE(no_unique_address) __immovable __hidden_ { };
bool __dismissed_{false};
- void __dismiss() noexcept
- {
- __dismissed_ = true;
+ void __dismiss() noexcept {
+ __dismissed_ = true;
}
- ~__scope_guard()
- {
- if (!__dismissed_)
- static_cast<_Fn&&>(
- __fn_)(static_cast<_T0&&>(__t0_), static_cast<_T1&&>(__t1_),
- static_cast<_T2&&>(__t2_));
+ ~__scope_guard() {
+ if (!__dismissed_)
+ static_cast<_Fn&&>(
+ __fn_)(static_cast<_T0&&>(__t0_), static_cast<_T1&&>(__t1_), static_cast<_T2&&>(__t2_));
}
-};
+ };
-template <class _Fn, class... _Ts>
-__scope_guard(_Fn, _Ts...) -> __scope_guard<_Fn, _Ts...>;
+ template <class _Fn, class... _Ts>
+ __scope_guard(_Fn, _Ts...) -> __scope_guard<_Fn, _Ts...>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__sender_adaptor_closure.hpp b/include/sdbusplus/async/stdexec/__detail/__sender_adaptor_closure.hpp
index 5f879a1..3f5edf3 100644
--- a/include/sdbusplus/async/stdexec/__detail/__sender_adaptor_closure.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__sender_adaptor_closure.hpp
@@ -15,174 +15,144 @@
*/
#pragma once
-#include "__concepts.hpp"
#include "__execution_fwd.hpp"
+
+#include "__concepts.hpp"
#include "__senders_core.hpp"
#include "__tuple.hpp"
#include "__type_traits.hpp"
-namespace stdexec
-{
-// NOT TO SPEC:
-namespace __closure
-{
-template <__class _Dp>
-struct sender_adaptor_closure;
-} // namespace __closure
+namespace stdexec {
+ // NOT TO SPEC:
+ namespace __closure {
+ template <__class _Dp>
+ struct sender_adaptor_closure;
+ } // namespace __closure
-using __closure::sender_adaptor_closure;
+ using __closure::sender_adaptor_closure;
-template <class _Tp>
-concept __sender_adaptor_closure =
- derived_from<__decay_t<_Tp>, sender_adaptor_closure<__decay_t<_Tp>>> &&
- move_constructible<__decay_t<_Tp>> //
- && constructible_from<__decay_t<_Tp>, _Tp>;
+ template <class _Tp>
+ concept __sender_adaptor_closure =
+ derived_from<__decay_t<_Tp>, sender_adaptor_closure<__decay_t<_Tp>>>
+ && move_constructible<__decay_t<_Tp>> && constructible_from<__decay_t<_Tp>, _Tp>;
-template <class _Tp, class _Sender>
-concept __sender_adaptor_closure_for = //
- __sender_adaptor_closure<_Tp> //
- && sender<__decay_t<_Sender>> //
- && __callable<_Tp, __decay_t<_Sender>> //
- && sender<__call_result_t<_Tp, __decay_t<_Sender>>>;
+ template <class _Tp, class _Sender>
+ concept __sender_adaptor_closure_for = __sender_adaptor_closure<_Tp> && sender<__decay_t<_Sender>>
+ && __callable<_Tp, __decay_t<_Sender>>
+ && sender<__call_result_t<_Tp, __decay_t<_Sender>>>;
-namespace __closure
-{
-template <class _T0, class _T1>
-struct __compose : sender_adaptor_closure<__compose<_T0, _T1>>
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T0 __t0_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _T1 __t1_;
+ namespace __closure {
+ template <class _T0, class _T1>
+ struct __compose : sender_adaptor_closure<__compose<_T0, _T1>> {
+ STDEXEC_ATTRIBUTE(no_unique_address) _T0 __t0_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _T1 __t1_;
- template <sender _Sender>
- requires __callable<_T0, _Sender> &&
- __callable<_T1, __call_result_t<_T0, _Sender>>
- STDEXEC_ATTRIBUTE((always_inline))
- __call_result_t<_T1, __call_result_t<_T0, _Sender>> operator()(
- _Sender&& __sndr) &&
- {
- return static_cast<_T1&&>(__t1_)(
- static_cast<_T0&&>(__t0_)(static_cast<_Sender&&>(__sndr)));
- }
+ template <sender _Sender>
+ requires __callable<_T0, _Sender> && __callable<_T1, __call_result_t<_T0, _Sender>>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Sender&& __sndr) && -> __call_result_t<_T1, __call_result_t<_T0, _Sender>> {
+ return static_cast<_T1&&>(__t1_)(static_cast<_T0&&>(__t0_)(static_cast<_Sender&&>(__sndr)));
+ }
- template <sender _Sender>
- requires __callable<const _T0&, _Sender> &&
- __callable<const _T1&, __call_result_t<const _T0&, _Sender>>
- STDEXEC_ATTRIBUTE((always_inline))
- __call_result_t<_T1, __call_result_t<_T0, _Sender>> operator()(
- _Sender&& __sndr) const&
- {
+ template <sender _Sender>
+ requires __callable<const _T0&, _Sender>
+ && __callable<const _T1&, __call_result_t<const _T0&, _Sender>>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Sender&& __sndr)
+ const & -> __call_result_t<const _T1&, __call_result_t<const _T0&, _Sender>> {
return __t1_(__t0_(static_cast<_Sender&&>(__sndr)));
+ }
+ };
+
+ template <__class _Dp>
+ struct sender_adaptor_closure { };
+
+ template <sender _Sender, __sender_adaptor_closure_for<_Sender> _Closure>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator|(_Sender&& __sndr, _Closure&& __clsur) -> __call_result_t<_Closure, _Sender> {
+ return static_cast<_Closure&&>(__clsur)(static_cast<_Sender&&>(__sndr));
}
-};
-template <__class _Dp>
-struct sender_adaptor_closure
-{};
+ template <__sender_adaptor_closure _T0, __sender_adaptor_closure _T1>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator|(_T0&& __t0, _T1&& __t1) -> __compose<__decay_t<_T0>, __decay_t<_T1>> {
+ return {{}, static_cast<_T0&&>(__t0), static_cast<_T1&&>(__t1)};
+ }
-template <sender _Sender, __sender_adaptor_closure_for<_Sender> _Closure>
-STDEXEC_ATTRIBUTE((always_inline))
-__call_result_t<_Closure, _Sender> operator|(_Sender&& __sndr,
- _Closure&& __clsur)
-{
- return static_cast<_Closure&&>(__clsur)(static_cast<_Sender&&>(__sndr));
-}
-
-template <__sender_adaptor_closure _T0, __sender_adaptor_closure _T1>
-STDEXEC_ATTRIBUTE((always_inline))
-__compose<__decay_t<_T0>, __decay_t<_T1>> operator|(_T0&& __t0, _T1&& __t1)
-{
- return {{}, static_cast<_T0&&>(__t0), static_cast<_T1&&>(__t1)};
-}
-
-template <class _Fun, class... _As>
-struct __binder_back :
- __tuple_for<_As...>,
- sender_adaptor_closure<__binder_back<_Fun, _As...>>
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fun __fun_{};
+ template <class _Fun, class... _As>
+ struct __binder_back
+ : __tuple_for<_As...>
+ , sender_adaptor_closure<__binder_back<_Fun, _As...>> {
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fun __fun_ { };
#if STDEXEC_INTELLISENSE()
- // MSVCBUG
- // https://developercommunity.visualstudio.com/t/rejects-valid-EDG-invocation-of-lambda/10786020
+ // MSVCBUG https://developercommunity.visualstudio.com/t/rejects-valid-EDG-invocation-of-lambda/10786020
- template <class _Sender>
- struct __lambda_rvalue
- {
+ template <class _Sender>
+ struct __lambda_rvalue {
__binder_back& __self_;
_Sender& __sndr_;
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- auto operator()(_As&... __as) const //
- noexcept(__nothrow_callable<_Fun, _Sender, _As...>)
- -> __call_result_t<_Fun, _Sender, _As...>
- {
- return static_cast<_Fun&&>(__self_.__fun_)(
- static_cast<_Sender&&>(__sndr_), static_cast<_As&&>(__as)...);
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_As&... __as) const noexcept(__nothrow_callable<_Fun, _Sender, _As...>)
+ -> __call_result_t<_Fun, _Sender, _As...> {
+ return static_cast<_Fun&&>(
+ __self_.__fun_)(static_cast<_Sender&&>(__sndr_), static_cast<_As&&>(__as)...);
}
- };
+ };
- template <class _Sender>
- struct __lambda_lvalue
- {
- const __binder_back& __self_;
+ template <class _Sender>
+ struct __lambda_lvalue {
+ __binder_back const & __self_;
_Sender& __sndr_;
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- auto operator()(const _As&... __as) const //
- noexcept(__nothrow_callable<const _Fun&, _Sender, const _As&...>)
- -> __call_result_t<const _Fun&, _Sender, const _As&...>
- {
- return __self_.__fun_(static_cast<_Sender&&>(__sndr_), __as...);
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(const _As&... __as) const
+ noexcept(__nothrow_callable<const _Fun&, _Sender, const _As&...>)
+ -> __call_result_t<const _Fun&, _Sender, const _As&...> {
+ return __self_.__fun_(static_cast<_Sender&&>(__sndr_), __as...);
}
- };
+ };
#endif
- template <sender _Sender>
+ template <sender _Sender>
requires __callable<_Fun, _Sender, _As...>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- auto operator()(_Sender&& __sndr) && //
- noexcept(__nothrow_callable<_Fun, _Sender, _As...>)
- -> __call_result_t<_Fun, _Sender, _As...>
- {
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_Sender&& __sndr) && noexcept(__nothrow_callable<_Fun, _Sender, _As...>)
+ -> __call_result_t<_Fun, _Sender, _As...> {
#if STDEXEC_INTELLISENSE()
return this->apply(__lambda_rvalue<_Sender>{*this, __sndr}, *this);
#else
return this->apply(
- [&__sndr, this](_As&... __as) //
- noexcept(__nothrow_callable<_Fun, _Sender, _As...>)
- -> __call_result_t<_Fun, _Sender, _As...> {
- return static_cast<_Fun&&>(
- __fun_)(static_cast<_Sender&&>(__sndr),
- static_cast<_As&&>(__as)...);
- },
- *this);
+ [&__sndr, this](_As&... __as) noexcept(
+ __nothrow_callable<_Fun, _Sender, _As...>) -> __call_result_t<_Fun, _Sender, _As...> {
+ return static_cast<_Fun&&>(
+ __fun_)(static_cast<_Sender&&>(__sndr), static_cast<_As&&>(__as)...);
+ },
+ *this);
#endif
- }
+ }
- template <sender _Sender>
+ template <sender _Sender>
requires __callable<const _Fun&, _Sender, const _As&...>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- auto operator()(_Sender&& __sndr) const& //
- noexcept(__nothrow_callable<const _Fun&, _Sender, const _As&...>)
- -> __call_result_t<const _Fun&, _Sender, const _As&...>
- {
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_Sender&& __sndr) const & noexcept(
+ __nothrow_callable<const _Fun&, _Sender, const _As&...>)
+ -> __call_result_t<const _Fun&, _Sender, const _As&...> {
#if STDEXEC_INTELLISENSE()
return this->apply(__lambda_lvalue<_Sender>{*this, __sndr}, *this);
#else
return this->apply(
- [&__sndr, this](const _As&... __as) //
- noexcept(__nothrow_callable<const _Fun&, _Sender, const _As&...>)
- -> __call_result_t<const _Fun&, _Sender, const _As&...> {
- return __fun_(static_cast<_Sender&&>(__sndr), __as...);
- },
- *this);
+ [&__sndr, this](const _As&... __as) noexcept(
+ __nothrow_callable<const _Fun&, _Sender, const _As&...>)
+ -> __call_result_t<const _Fun&, _Sender, const _As&...> {
+ return __fun_(static_cast<_Sender&&>(__sndr), __as...);
+ },
+ *this);
#endif
- }
-};
-} // namespace __closure
+ }
+ };
+ } // namespace __closure
-using __closure::__binder_back;
+ using __closure::__binder_back;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__sender_introspection.hpp b/include/sdbusplus/async/stdexec/__detail/__sender_introspection.hpp
index 1c76e81..10ac46d 100644
--- a/include/sdbusplus/async/stdexec/__detail/__sender_introspection.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__sender_introspection.hpp
@@ -17,100 +17,94 @@
#include "__execution_fwd.hpp"
-namespace stdexec
-{
-namespace __detail
-{
-// A function object that is to senders what std::apply is to tuples:
-struct __sexpr_apply_t
-{
- template <class _Sender, class _ApplyFn>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Sender&& __sndr, _ApplyFn&& __fun) const //
- noexcept(noexcept(__sndr.apply(static_cast<_Sender&&>(__sndr),
- static_cast<_ApplyFn&&>(__fun)))) //
- -> decltype(__sndr.apply(static_cast<_Sender&&>(__sndr),
- static_cast<_ApplyFn&&>(__fun)))
- {
- return __sndr.apply(static_cast<_Sender&&>(__sndr),
- static_cast<_ApplyFn&&>(__fun)); //
- }
-};
+namespace stdexec {
+ namespace __detail {
+ // Accessor for the "data" field of a sender
+ struct __get_data {
+ template <class _Data>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(__ignore, _Data&& __data, auto&&...) const noexcept -> _Data&& {
+ return static_cast<_Data&&>(__data);
+ }
+ };
-// A type that describes a sender's metadata
-template <class _Tag, class _Data, class... _Child>
-struct __desc
-{
- using __tag = _Tag;
- using __data = _Data;
- using __children = __types<_Child...>;
+ // A function object that is to senders what std::apply is to tuples:
+ struct __sexpr_apply_t {
+ template <class _Sender, class _ApplyFn>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Sender&& __sndr, _ApplyFn&& __fun) const
+ noexcept(noexcept(__sndr
+ .apply(static_cast<_Sender&&>(__sndr), static_cast<_ApplyFn&&>(__fun))))
+ -> decltype(__sndr
+ .apply(static_cast<_Sender&&>(__sndr), static_cast<_ApplyFn&&>(__fun))) {
+ return __sndr.apply(static_cast<_Sender&&>(__sndr), static_cast<_ApplyFn&&>(__fun));
+ }
+ };
+
+ // A type that describes a sender's metadata
+ template <class _Tag, class _Data, class... _Child>
+ struct __desc {
+ using __tag = _Tag;
+ using __data = _Data;
+ using __children = __types<_Child...>;
+
+ template <class _Fn>
+ using __f = __minvoke<_Fn, _Tag, _Data, _Child...>;
+ };
template <class _Fn>
- using __f = __minvoke<_Fn, _Tag, _Data, _Child...>;
-};
-
-template <class _Fn>
-struct __sexpr_uncurry_fn
-{
- template <class _Tag, class _Data, class... _Child>
- constexpr auto operator()(_Tag, _Data&&, _Child&&...) const noexcept
+ struct __sexpr_uncurry_fn {
+ template <class _Tag, class _Data, class... _Child>
+ constexpr auto operator()(_Tag, _Data&&, _Child&&...) const noexcept
-> __minvoke<_Fn, _Tag, _Data, _Child...>;
-};
+ };
-template <class _CvrefSender, class _Fn>
-using __sexpr_uncurry =
- __call_result_t<__sexpr_apply_t, _CvrefSender, __sexpr_uncurry_fn<_Fn>>;
+ template <class _CvrefSender, class _Fn>
+ using __sexpr_uncurry = __call_result_t<__sexpr_apply_t, _CvrefSender, __sexpr_uncurry_fn<_Fn>>;
-template <class _Sender>
-using __desc_of = __sexpr_uncurry<_Sender, __q<__desc>>;
+ template <class _Sender>
+ using __desc_of = __sexpr_uncurry<_Sender, __q<__desc>>;
-using __get_desc = __sexpr_uncurry_fn<__q<__desc>>;
-} // namespace __detail
+ using __get_desc = __sexpr_uncurry_fn<__q<__desc>>;
+ } // namespace __detail
-using __detail::__sexpr_apply_t;
-inline constexpr __sexpr_apply_t __sexpr_apply{};
+ using __detail::__sexpr_apply_t;
+ inline constexpr __sexpr_apply_t __sexpr_apply{};
-template <class _Sender, class _ApplyFn>
-using __sexpr_apply_result_t =
- __call_result_t<__sexpr_apply_t, _Sender, _ApplyFn>;
+ template <class _Sender, class _ApplyFn>
+ using __sexpr_apply_result_t = __call_result_t<__sexpr_apply_t, _Sender, _ApplyFn>;
-template <class _Sender>
-using tag_of_t = typename __detail::__desc_of<_Sender>::__tag;
+ template <class _Sender>
+ using tag_of_t = __detail::__desc_of<_Sender>::__tag;
-template <class _Sender>
-using __data_of = typename __detail::__desc_of<_Sender>::__data;
+ template <class _Sender>
+ using __data_of = __detail::__desc_of<_Sender>::__data;
-template <class _Sender, class _Continuation = __q<__types>>
-using __children_of = //
- __mapply<_Continuation, typename __detail::__desc_of<_Sender>::__children>;
+ template <class _Sender, class _Continuation = __q<__types>>
+ using __children_of = __mapply<_Continuation, typename __detail::__desc_of<_Sender>::__children>;
-template <class _Ny, class _Sender>
-using __nth_child_of = __children_of<_Sender, __mbind_front_q<__m_at, _Ny>>;
+ template <class _Ny, class _Sender>
+ using __nth_child_of = __children_of<_Sender, __mbind_front_q<__m_at, _Ny>>;
-template <std::size_t _Ny, class _Sender>
-using __nth_child_of_c =
- __children_of<_Sender, __mbind_front_q<__m_at, __msize_t<_Ny>>>;
+ template <std::size_t _Ny, class _Sender>
+ using __nth_child_of_c = __children_of<_Sender, __mbind_front_q<__m_at, __msize_t<_Ny>>>;
-template <class _Sender>
-using __child_of = __children_of<_Sender, __q<__mfront>>;
+ template <class _Sender>
+ using __child_of = __children_of<_Sender, __q<__mfront>>;
-template <class _Sender>
-inline constexpr std::size_t __nbr_children_of =
- __v<__children_of<_Sender, __msize>>;
+ template <class _Sender>
+ inline constexpr std::size_t __nbr_children_of = __v<__children_of<_Sender, __msize>>;
-template <class _Tp>
+ template <class _Tp>
requires __mvalid<tag_of_t, _Tp>
-struct __muncurry_<_Tp>
-{
+ struct __muncurry_<_Tp> {
template <class _Fn>
using __f = __detail::__sexpr_uncurry<_Tp, _Fn>;
-};
+ };
-template <class _Sender>
-concept sender_expr = //
- __mvalid<tag_of_t, _Sender>;
+ template <class _Sender>
+ concept sender_expr = __mvalid<tag_of_t, _Sender>;
-template <class _Sender, class _Tag>
-concept sender_expr_for = //
- sender_expr<_Sender> && same_as<tag_of_t<_Sender>, _Tag>;
+ template <class _Sender, class _Tag>
+ concept sender_expr_for = sender_expr<_Sender> && same_as<tag_of_t<_Sender>, _Tag>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__senders.hpp b/include/sdbusplus/async/stdexec/__detail/__senders.hpp
index 16218cf..21a945a 100644
--- a/include/sdbusplus/async/stdexec/__detail/__senders.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__senders.hpp
@@ -27,396 +27,323 @@
#include "__operation_states.hpp"
#include "__receivers.hpp"
#include "__senders_core.hpp"
+#include "__tag_invoke.hpp"
#include "__transform_completion_signatures.hpp"
#include "__transform_sender.hpp"
#include "__type_traits.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.get_completion_signatures]
-namespace __detail
-{
-struct __dependent_completions
-{};
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.get_completion_signatures]
+ namespace __detail {
+ struct __dependent_completions { };
-template <class _Completions>
-concept __well_formed_sender =
- __valid_completion_signatures<_Completions> ||
- __same_as<_Completions, _ERROR_<__dependent_completions>>;
-} // namespace __detail
+ using dependent_completions = _ERROR_<__detail::__dependent_completions>;
-using dependent_completions = _ERROR_<__detail::__dependent_completions>;
+ template <class _Completions>
+ concept __well_formed_completions_helper = __valid_completion_signatures<_Completions>
+ || __same_as<_Completions, dependent_completions>;
-namespace __sigs
-{
-template <class _Sender, class _Env>
-using __tfx_sender =
- transform_sender_result_t<__late_domain_of_t<_Sender, _Env>, _Sender, _Env>;
+ template <class _Completions>
+ inline constexpr bool __well_formed_completions_v =
+ __well_formed_completions_helper<_Completions>;
-template <class _Sender, class... _Env>
-using __member_result_t =
- decltype(__declval<_Sender>().get_completion_signatures(
- __declval<_Env>()...));
+ template <class _Completions>
+ concept __well_formed_completions = __well_formed_completions_v<_Completions>;
+ } // namespace __detail
-template <class _Sender, class... _Env>
-using __static_member_result_t = //
- decltype(STDEXEC_REMOVE_REFERENCE(_Sender) //
- ::get_completion_signatures(__declval<_Sender>(),
- __declval<_Env>()...));
+ using __detail::dependent_completions;
-template <class _Sender, class... _Env>
-concept __with_member = __mvalid<__member_result_t, _Sender, _Env...>;
+ namespace __sigs {
+ template <class _Sender, class _Env>
+ using __tfx_sender =
+ transform_sender_result_t<__late_domain_of_t<_Sender, _Env>, _Sender, _Env>;
-template <class _Sender, class... _Env>
-concept __with_static_member =
- __mvalid<__static_member_result_t, _Sender, _Env...>;
-
-template <class _Sender, class... _Env>
-concept __with_tag_invoke = //
- tag_invocable<get_completion_signatures_t, _Sender, _Env...>;
-
-template <class _Sender, class... _Env>
-concept __with_legacy_tag_invoke = //
- (sizeof...(_Env) == 0) &&
- tag_invocable<get_completion_signatures_t, _Sender, empty_env>;
-
-template <class _Sender>
-using __member_alias_t = //
- typename __decay_t<_Sender>::completion_signatures;
-
-template <class _Sender>
-concept __with_member_alias = __mvalid<__member_alias_t, _Sender>;
-
-struct get_completion_signatures_t
-{
template <class _Sender, class... _Env>
+ using __member_result_t = decltype(__declval<_Sender>()
+ .get_completion_signatures(__declval<_Env>()...));
+
+ template <class _Sender, class... _Env>
+ using __static_member_result_t = decltype(STDEXEC_REMOVE_REFERENCE(
+ _Sender)::get_completion_signatures(__declval<_Sender>(), __declval<_Env>()...));
+
+ template <class _Sender, class... _Env>
+ concept __with_member = __mvalid<__member_result_t, _Sender, _Env...>;
+
+ template <class _Sender, class... _Env>
+ concept __with_static_member = __mvalid<__static_member_result_t, _Sender, _Env...>;
+
+ template <class _Sender, class... _Env>
+ concept __with_tag_invoke = tag_invocable<get_completion_signatures_t, _Sender, _Env...>;
+
+ template <class _Sender, class... _Env>
+ concept __with_legacy_tag_invoke = (sizeof...(_Env) == 0)
+ && tag_invocable<get_completion_signatures_t, _Sender, env<>>;
+
+ template <class _Sender>
+ using __member_alias_t = __decay_t<_Sender>::completion_signatures;
+
+ template <class _Sender>
+ concept __with_member_alias = __mvalid<__member_alias_t, _Sender>;
+
+ struct get_completion_signatures_t {
+ template <class _Sender, class... _Env>
requires(sizeof...(_Env) <= 1)
- static auto __impl()
- {
+ static auto __impl() {
// Compute the type of the transformed sender:
- using __tfx_fn =
- __if_c<sizeof...(_Env) == 0, __mconst<_Sender>, __q<__tfx_sender>>;
+ using __tfx_fn = __if_c<sizeof...(_Env) == 0, __mconst<_Sender>, __q<__tfx_sender>>;
using _TfxSender = __minvoke<__tfx_fn, _Sender, _Env...>;
- if constexpr (__merror<_TfxSender>)
- {
- // Computing the type of the transformed sender returned an error
- // type. Propagate it.
- return static_cast<_TfxSender (*)()>(nullptr);
+ if constexpr (__merror<_TfxSender>) {
+ // Computing the type of the transformed sender returned an error type. Propagate it.
+ return static_cast<_TfxSender (*)()>(nullptr);
+ } else if constexpr (__with_member_alias<_TfxSender>) {
+ using _Result = __member_alias_t<_TfxSender>;
+ return static_cast<_Result (*)()>(nullptr);
+ } else if constexpr (__with_static_member<_TfxSender, _Env...>) {
+ using _Result = __static_member_result_t<_TfxSender, _Env...>;
+ return static_cast<_Result (*)()>(nullptr);
+ } else if constexpr (__with_member<_TfxSender, _Env...>) {
+ using _Result = __member_result_t<_TfxSender, _Env...>;
+ return static_cast<_Result (*)()>(nullptr);
+ } else if constexpr (__with_tag_invoke<_TfxSender, _Env...>) {
+ using _Result = tag_invoke_result_t<get_completion_signatures_t, _TfxSender, _Env...>;
+ return static_cast<_Result (*)()>(nullptr);
+ } else if constexpr (__with_legacy_tag_invoke<_TfxSender, _Env...>) {
+ // This branch is strictly for backwards compatibility
+ using _Result = tag_invoke_result_t<get_completion_signatures_t, _Sender, env<>>;
+ return static_cast<_Result (*)()>(nullptr);
+ // [WAR] The explicit cast to bool below is to work around a bug in nvc++ (nvbug#4707793)
+ } else if constexpr (bool(__awaitable<_TfxSender, __env::__promise<_Env>...>)) {
+ using _AwaitResult = __await_result_t<_TfxSender, __env::__promise<_Env>...>;
+ using _Result = completion_signatures<
+ // set_value_t() or set_value_t(T)
+ __minvoke<__mremove<void, __qf<set_value_t>>, _AwaitResult>,
+ set_error_t(std::exception_ptr),
+ set_stopped_t()
+ >;
+ return static_cast<_Result (*)()>(nullptr);
+ } else if constexpr (sizeof...(_Env) == 0) {
+ // It's possible this is a dependent sender.
+ return static_cast<dependent_completions (*)()>(nullptr);
+ } else if constexpr ((__is_debug_env<_Env> || ...)) {
+ // This ought to cause a hard error that indicates where the problem is.
+ using _Completions [[maybe_unused]] =
+ decltype(std::remove_reference_t<_TfxSender>::get_completion_signatures(
+ __declval<_TfxSender>(), __declval<_Env>()...));
+ return static_cast<__debug::__completion_signatures (*)()>(nullptr);
+ } else {
+ using _Result = __mexception<
+ _UNRECOGNIZED_SENDER_TYPE_<>,
+ _WITH_SENDER_<_Sender>,
+ _WITH_ENVIRONMENT_<_Env>...
+ >;
+ return static_cast<_Result (*)()>(nullptr);
}
- else if constexpr (__with_member_alias<_TfxSender>)
- {
- using _Result = __member_alias_t<_TfxSender>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else if constexpr (__with_static_member<_TfxSender, _Env...>)
- {
- using _Result = __static_member_result_t<_TfxSender, _Env...>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else if constexpr (__with_member<_TfxSender, _Env...>)
- {
- using _Result = __member_result_t<_TfxSender, _Env...>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else if constexpr (__with_tag_invoke<_TfxSender, _Env...>)
- {
- using _Result = tag_invoke_result_t<get_completion_signatures_t,
- _TfxSender, _Env...>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else if constexpr (__with_legacy_tag_invoke<_TfxSender, _Env...>)
- {
- // This branch is strictly for backwards compatibility
- using _Result = tag_invoke_result_t<get_completion_signatures_t,
- _Sender, empty_env>;
- return static_cast<_Result (*)()>(nullptr);
- // [WAR] The explicit cast to bool below is to work around a bug in
- // nvc++ (nvbug#4707793)
- }
- else if constexpr (bool(__awaitable<_TfxSender,
- __env::__promise<_Env>...>))
- {
- using _AwaitResult =
- __await_result_t<_TfxSender, __env::__promise<_Env>...>;
- using _Result = completion_signatures<
- // set_value_t() or set_value_t(T)
- __minvoke<__mremove<void, __qf<set_value_t>>, _AwaitResult>,
- set_error_t(std::exception_ptr), set_stopped_t()>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else if constexpr (sizeof...(_Env) == 0)
- {
- // It's possible this is a dependent sender.
- return static_cast<dependent_completions (*)()>(nullptr);
- }
- else if constexpr ((__is_debug_env<_Env> || ...))
- {
- using __tag_invoke::tag_invoke;
- // This ought to cause a hard error that indicates where the problem
- // is.
- using _Completions [[maybe_unused]] =
- tag_invoke_result_t<get_completion_signatures_t, _Sender,
- _Env...>;
- return static_cast<__debug::__completion_signatures (*)()>(nullptr);
- }
- else
- {
- using _Result = __mexception<_UNRECOGNIZED_SENDER_TYPE_<>,
- _WITH_SENDER_<_Sender>,
- _WITH_ENVIRONMENT_<_Env>...>;
- return static_cast<_Result (*)()>(nullptr);
- }
- }
+ }
- // NOT TO SPEC: if we're unable to compute the completion signatures,
- // return an error type instead of SFINAE.
- template <class _Sender, class... _Env>
+ // NOT TO SPEC: if we're unable to compute the completion signatures,
+ // return an error type instead of SFINAE.
+ template <class _Sender, class... _Env>
requires(sizeof...(_Env) <= 1)
- constexpr auto operator()(_Sender&&, _Env&&...) const noexcept //
- -> decltype(__impl<_Sender, _Env...>()())
- {
+ constexpr auto
+ operator()(_Sender&&, _Env&&...) const noexcept -> decltype(__impl<_Sender, _Env...>()()) {
return {};
- }
-};
-} // namespace __sigs
+ }
+ };
+ } // namespace __sigs
-using __sigs::get_completion_signatures_t;
-inline constexpr get_completion_signatures_t get_completion_signatures{};
+ using __sigs::get_completion_signatures_t;
+ inline constexpr get_completion_signatures_t get_completion_signatures{};
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.connect]
-namespace __connect
-{
-template <class _Sender, class _Receiver>
-using __tfx_sender = //
- transform_sender_result_t<__late_domain_of_t<_Sender, env_of_t<_Receiver>>,
- _Sender, env_of_t<_Receiver>>;
-
-template <class _Sender, class _Receiver>
-using __member_result_t =
- decltype(__declval<_Sender>().connect(__declval<_Receiver>()));
-
-template <class _Sender, class _Receiver>
-using __static_member_result_t =
- decltype(STDEXEC_REMOVE_REFERENCE(_Sender) //
- ::connect(__declval<_Sender>(), __declval<_Receiver>()));
-
-template <class _Sender, class _Receiver>
-concept __with_member = __mvalid<__member_result_t, _Sender, _Receiver>;
-
-template <class _Sender, class _Receiver>
-concept __with_static_member =
- __mvalid<__static_member_result_t, _Sender, _Receiver>;
-
-template <class _Sender, class _Receiver>
-concept __with_tag_invoke = tag_invocable<connect_t, _Sender, _Receiver>;
-
-template <class _Sender, class _Receiver>
-concept __with_co_await = __callable<__connect_awaitable_t, _Sender, _Receiver>;
-
-struct connect_t
-{
- template <class _Sender, class _Env>
- static constexpr auto __check_signatures() -> bool
- {
- if constexpr (sender_in<_Sender, _Env>)
- {
- // Instantiate __debug_sender via completion_signatures_of_t to
- // check that the actual completions match the expected completions.
- //
- // Instantiate completion_signatures_of_t only if sender_in is true
- // to workaround Clang not implementing CWG#2369 yet (connect() does
- // not have a constraint for _Sender satisfying sender_in).
- using __checked_signatures
- [[maybe_unused]] = completion_signatures_of_t<_Sender, _Env>;
- }
- return true;
- }
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.connect]
+ namespace __connect {
+ template <class _Sender, class _Receiver>
+ using __tfx_sender = __mmemoize_q<
+ transform_sender_result_t,
+ __late_domain_of_t<_Sender, env_of_t<_Receiver>>,
+ _Sender,
+ env_of_t<_Receiver>
+ >;
template <class _Sender, class _Receiver>
- static constexpr auto __select_impl() noexcept
- {
+ using __member_result_t = decltype(__declval<_Sender>().connect(__declval<_Receiver>()));
+
+ template <class _Sender, class _Receiver>
+ using __static_member_result_t = decltype(STDEXEC_REMOVE_REFERENCE(
+ _Sender)::connect(__declval<_Sender>(), __declval<_Receiver>()));
+
+ template <class _Sender, class _Receiver>
+ concept __with_member = __mvalid<__member_result_t, _Sender, _Receiver>;
+
+ template <class _Sender, class _Receiver>
+ concept __with_static_member = __mvalid<__static_member_result_t, _Sender, _Receiver>;
+
+ template <class _Sender, class _Receiver>
+ concept __with_tag_invoke = tag_invocable<connect_t, _Sender, _Receiver>;
+
+ template <class _Sender, class _Receiver>
+ concept __with_co_await = __callable<__connect_awaitable_t, _Sender, _Receiver>;
+
+ struct _NO_USABLE_CONNECT_CUSTOMIZATION_FOUND_ {
+ void operator()() const noexcept = delete;
+ };
+
+ struct connect_t {
+ template <class _Sender, class _Receiver>
+ requires sender_in<_Sender, env_of_t<_Receiver>> && __receiver_from<_Receiver, _Sender>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static constexpr auto __type_check_arguments() -> bool {
+ if constexpr (sender_in<_Sender, env_of_t<_Receiver>>) {
+ // Instantiate __debug_sender via completion_signatures_of_t to check that the actual
+ // completions match the expected completions.
+ using __checked_signatures
+ [[maybe_unused]] = completion_signatures_of_t<_Sender, env_of_t<_Receiver>>;
+ } else {
+ __diagnose_sender_concept_failure<_Sender, env_of_t<_Receiver>>();
+ }
+ return true;
+ }
+
+ template <class _OpState>
+ static constexpr void __check_operation_state() noexcept {
+ static_assert(operation_state<_OpState>, STDEXEC_ERROR_CANNOT_CONNECT_SENDER_TO_RECEIVER);
+ }
+
+ template <class _Sender, class _Receiver>
+ static constexpr auto __select_impl() noexcept {
using _Domain = __late_domain_of_t<_Sender, env_of_t<_Receiver>>;
using _TfxSender = __tfx_sender<_Sender, _Receiver>;
constexpr bool _NothrowTfxSender =
- __nothrow_callable<transform_sender_t, _Domain, _Sender,
- env_of_t<_Receiver>>;
+ __nothrow_callable<transform_sender_t, _Domain, _Sender, env_of_t<_Receiver>>;
+ static_assert(sender<_Sender>, "The first argument to stdexec::connect must be a sender");
+ static_assert(
+ receiver<_Receiver>, "The second argument to stdexec::connect must be a receiver");
#if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING()
- static_assert(__check_signatures<_TfxSender, env_of_t<_Receiver>>());
+ static_assert(__type_check_arguments<_TfxSender, _Receiver>());
#endif
- if constexpr (__with_static_member<_TfxSender, _Receiver>)
- {
- using _Result = __static_member_result_t<_TfxSender, _Receiver>;
- constexpr bool _Nothrow = //
- _NothrowTfxSender &&
- noexcept(__declval<_TfxSender>().connect(
- __declval<_TfxSender>(), __declval<_Receiver>()));
- return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
+ if constexpr (__with_static_member<_TfxSender, _Receiver>) {
+ using _Result = __static_member_result_t<_TfxSender, _Receiver>;
+ __check_operation_state<_Result>();
+ constexpr bool _Nothrow = _NothrowTfxSender
+ && noexcept(
+ __declval<_TfxSender>()
+ .connect(__declval<_TfxSender>(), __declval<_Receiver>()));
+ return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (__with_member<_TfxSender, _Receiver>) {
+ using _Result = __member_result_t<_TfxSender, _Receiver>;
+ __check_operation_state<_Result>();
+ constexpr bool _Nothrow = _NothrowTfxSender
+ && noexcept(__declval<_TfxSender>()
+ .connect(__declval<_Receiver>()));
+ return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (__with_tag_invoke<_TfxSender, _Receiver>) {
+ using _Result = tag_invoke_result_t<connect_t, _TfxSender, _Receiver>;
+ __check_operation_state<_Result>();
+ constexpr bool _Nothrow = _NothrowTfxSender
+ && nothrow_tag_invocable<connect_t, _TfxSender, _Receiver>;
+ return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (__with_co_await<_TfxSender, _Receiver>) {
+ using _Result = __call_result_t<__connect_awaitable_t, _TfxSender, _Receiver>;
+ return static_cast<_Result (*)()>(nullptr);
+ } else if constexpr (__is_debug_env<env_of_t<_Receiver>>) {
+ using _Result = __debug::__debug_operation;
+ return static_cast<_Result (*)() noexcept(_NothrowTfxSender)>(nullptr);
+ } else {
+ return _NO_USABLE_CONNECT_CUSTOMIZATION_FOUND_();
}
- else if constexpr (__with_member<_TfxSender, _Receiver>)
- {
- using _Result = __member_result_t<_TfxSender, _Receiver>;
- constexpr bool _Nothrow = //
- _NothrowTfxSender && noexcept(__declval<_TfxSender>().connect(
- __declval<_Receiver>()));
- return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
- }
- else if constexpr (__with_tag_invoke<_TfxSender, _Receiver>)
- {
- using _Result =
- tag_invoke_result_t<connect_t, _TfxSender, _Receiver>;
- constexpr bool _Nothrow = //
- _NothrowTfxSender &&
- nothrow_tag_invocable<connect_t, _TfxSender, _Receiver>;
- return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
- }
- else if constexpr (__with_co_await<_TfxSender, _Receiver>)
- {
- using _Result =
- __call_result_t<__connect_awaitable_t, _TfxSender, _Receiver>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else
- {
- using _Result = __debug::__debug_operation;
- return static_cast<_Result (*)() noexcept(_NothrowTfxSender)>(
- nullptr);
- }
- }
+ }
- template <class _Sender, class _Receiver>
- using __select_impl_t = decltype(__select_impl<_Sender, _Receiver>());
+ template <class _Sender, class _Receiver>
+ using __select_impl_t = decltype(__select_impl<_Sender, _Receiver>());
- template <sender _Sender, receiver _Receiver>
- requires __with_static_member<__tfx_sender<_Sender, _Receiver>,
- _Receiver> ||
- __with_member<__tfx_sender<_Sender, _Receiver>, _Receiver> ||
- __with_tag_invoke<__tfx_sender<_Sender, _Receiver>,
- _Receiver> ||
- __with_co_await<__tfx_sender<_Sender, _Receiver>, _Receiver> ||
- __is_debug_env<env_of_t<_Receiver>>
- auto operator()(_Sender&& __sndr, _Receiver&& __rcvr) const
+ template <class _Sender, class _Receiver>
+ auto operator()(_Sender&& __sndr, _Receiver&& __rcvr) const
noexcept(__nothrow_callable<__select_impl_t<_Sender, _Receiver>>)
- -> __call_result_t<__select_impl_t<_Sender, _Receiver>>
- {
+ -> __call_result_t<__select_impl_t<_Sender, _Receiver>> {
+
+ static_assert(sender_in<_Sender, env_of_t<_Receiver>>);
+ static_assert(__receiver_from<_Receiver, _Sender>);
+
using _TfxSender = __tfx_sender<_Sender, _Receiver>;
auto&& __env = get_env(__rcvr);
auto __domain = __get_late_domain(__sndr, __env);
- if constexpr (__with_static_member<_TfxSender, _Receiver>)
- {
- static_assert(
- operation_state<
- __static_member_result_t<_TfxSender, _Receiver>>,
- "Sender::connect(sender, receiver) must return a type that "
- "satisfies the operation_state concept");
- auto&& __tfx_sndr = transform_sender(
- __domain, static_cast<_Sender&&>(__sndr), __env);
- return __tfx_sndr.connect(static_cast<_TfxSender&&>(__tfx_sndr),
- static_cast<_Receiver&&>(__rcvr));
+ if constexpr (__with_static_member<_TfxSender, _Receiver>) {
+ auto&& __tfx_sndr = transform_sender(__domain, static_cast<_Sender&&>(__sndr), __env);
+ return __tfx_sndr
+ .connect(static_cast<_TfxSender&&>(__tfx_sndr), static_cast<_Receiver&&>(__rcvr));
+ } else if constexpr (__with_member<_TfxSender, _Receiver>) { // NOLINT(bugprone-branch-clone)
+ return transform_sender(__domain, static_cast<_Sender&&>(__sndr), __env)
+ .connect(static_cast<_Receiver&&>(__rcvr));
+ } else if constexpr (__with_tag_invoke<_TfxSender, _Receiver>) {
+ return tag_invoke(
+ connect_t(),
+ transform_sender(__domain, static_cast<_Sender&&>(__sndr), __env),
+ static_cast<_Receiver&&>(__rcvr));
+ } else if constexpr (__with_co_await<_TfxSender, _Receiver>) {
+ return __connect_awaitable(
+ transform_sender(__domain, static_cast<_Sender&&>(__sndr), __env),
+ static_cast<_Receiver&&>(__rcvr));
+ } else {
+ // This should generate an instantiation backtrace that contains useful
+ // debugging information.
+ return transform_sender(__domain, static_cast<_Sender&&>(__sndr), __env)
+ .connect(static_cast<_Receiver&&>(__rcvr));
}
- else if constexpr (__with_member<_TfxSender, _Receiver>)
- {
- static_assert(
- operation_state<__member_result_t<_TfxSender, _Receiver>>,
- "sender.connect(receiver) must return a type that "
- "satisfies the operation_state concept");
- return transform_sender(__domain, static_cast<_Sender&&>(__sndr),
- __env)
- .connect(static_cast<_Receiver&&>(__rcvr));
- }
- else if constexpr (__with_tag_invoke<_TfxSender, _Receiver>)
- {
- static_assert(
- operation_state<
- tag_invoke_result_t<connect_t, _TfxSender, _Receiver>>,
- "stdexec::connect(sender, receiver) must return a type that "
- "satisfies the operation_state concept");
- return tag_invoke(
- connect_t(),
- transform_sender(__domain, static_cast<_Sender&&>(__sndr),
- __env),
- static_cast<_Receiver&&>(__rcvr));
- }
- else if constexpr (__with_co_await<_TfxSender, _Receiver>)
- {
- return __connect_awaitable( //
- transform_sender(__domain, static_cast<_Sender&&>(__sndr),
- __env),
- static_cast<_Receiver&&>(__rcvr));
- }
- else
- {
- // This should generate an instantiation backtrace that contains
- // useful debugging information.
- using __tag_invoke::tag_invoke;
- tag_invoke(*this,
- transform_sender(__domain,
- static_cast<_Sender&&>(__sndr), __env),
- static_cast<_Receiver&&>(__rcvr));
- }
- }
+ }
- static constexpr auto query(forwarding_query_t) noexcept -> bool
- {
+ static constexpr auto query(forwarding_query_t) noexcept -> bool {
return false;
- }
-};
-} // namespace __connect
-
-using __connect::connect_t;
-inline constexpr __connect::connect_t connect{};
-
-/////////////////////////////////////////////////////////////////////////////
-// [exec.snd]
-template <class _Sender, class _Receiver>
-concept sender_to = //
- receiver<_Receiver> //
- && sender_in<_Sender, env_of_t<_Receiver>> //
- && __receiver_from<_Receiver, _Sender> //
- && requires(_Sender&& __sndr, _Receiver&& __rcvr) {
- connect(static_cast<_Sender&&>(__sndr),
- static_cast<_Receiver&&>(__rcvr));
- };
-
-template <class _Tag, class... _Args>
-auto __tag_of_sig_(_Tag (*)(_Args...)) -> _Tag;
-template <class _Sig>
-using __tag_of_sig_t =
- decltype(stdexec::__tag_of_sig_(static_cast<_Sig*>(nullptr)));
-
-template <class _Sender, class _SetSig, class _Env = empty_env>
-concept sender_of = //
- sender_in<_Sender, _Env> //
- &&
- same_as<
- __types<_SetSig>,
- __gather_completions_of<
- __tag_of_sig_t<_SetSig>, _Sender, _Env,
- __mcompose_q<__types, __qf<__tag_of_sig_t<_SetSig>>::template __f>,
- __mconcat<__qq<__types>>>>;
-
-template <class _Error>
- requires false
-using __nofail_t = _Error;
-
-template <class _Sender, class _Env = empty_env>
-concept __nofail_sender =
- sender_in<_Sender, _Env> &&
- requires {
- typename __gather_completion_signatures<
- __completion_signatures_of_t<_Sender, _Env>, set_error_t,
- __nofail_t, __sigs::__default_completion, __types>;
+ }
};
+ } // namespace __connect
-/////////////////////////////////////////////////////////////////////////////
-// early sender type-checking
-template <class _Sender>
-concept __well_formed_sender = __detail::__well_formed_sender<__minvoke<
- __with_default_q<__completion_signatures_of_t, dependent_completions>,
- _Sender>>;
+ using __connect::connect_t;
+ inline constexpr __connect::connect_t connect{};
+
+ /////////////////////////////////////////////////////////////////////////////
+ // [exec.snd]
+ template <class _Tag, class... _Args>
+ auto __tag_of_sig_(_Tag (*)(_Args...)) -> _Tag;
+ template <class _Sig>
+ using __tag_of_sig_t = decltype(stdexec::__tag_of_sig_(static_cast<_Sig*>(nullptr)));
+
+ template <class _Sender, class _SetSig, class _Env = env<>>
+ concept sender_of = sender_in<_Sender, _Env>
+ && same_as<
+ __types<_SetSig>,
+ __gather_completions_of<
+ __tag_of_sig_t<_SetSig>,
+ _Sender,
+ _Env,
+ __mcompose_q<__types, __qf<__tag_of_sig_t<_SetSig>>::template __f>,
+ __mconcat<__qq<__types>>
+ >
+ >;
+
+ template <class _Error>
+ requires false
+ using __nofail_t = _Error;
+
+ template <class _Sender, class _Env = env<>>
+ concept __nofail_sender = sender_in<_Sender, _Env> && requires {
+ typename __gather_completion_signatures<
+ __completion_signatures_of_t<_Sender, _Env>,
+ set_error_t,
+ __nofail_t,
+ __sigs::__default_completion,
+ __types
+ >;
+ };
+
+ /////////////////////////////////////////////////////////////////////////////
+ // early sender type-checking
+ template <class _Sender>
+ concept __well_formed_sender = __detail::__well_formed_completions<
+ __minvoke<__with_default_q<__completion_signatures_of_t, dependent_completions>, _Sender>
+ >;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__senders_core.hpp b/include/sdbusplus/async/stdexec/__detail/__senders_core.hpp
index e711b06..d6943f1 100644
--- a/include/sdbusplus/async/stdexec/__detail/__senders_core.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__senders_core.hpp
@@ -21,48 +21,91 @@
#include "__awaitable.hpp"
#include "__completion_signatures.hpp"
#include "__concepts.hpp"
+#include "__diagnostics.hpp"
#include "__domain.hpp"
#include "__env.hpp"
#include "__receivers.hpp"
#include "__type_traits.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders]
-struct sender_t
-{
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders]
+ struct sender_t {
using sender_concept = sender_t;
-};
+ };
-namespace __detail
-{
-template <class _Sender>
-concept __enable_sender = //
- derived_from<typename _Sender::sender_concept, sender_t> ||
- requires { typename _Sender::is_sender; } // NOT TO SPEC back compat
- || __awaitable<_Sender, __env::__promise<empty_env>>;
-} // namespace __detail
+ namespace __detail {
+ template <class _Sender>
+ concept __enable_sender = derived_from<typename _Sender::sender_concept, sender_t>
+ || requires { typename _Sender::is_sender; } // NOT TO SPEC back compat
+ || __awaitable<_Sender, __env::__promise<env<>>>;
+ } // namespace __detail
-template <class _Sender>
-inline constexpr bool enable_sender = __detail::__enable_sender<_Sender>;
+ template <class _Sender>
+ inline constexpr bool enable_sender = __detail::__enable_sender<_Sender>;
-template <class _Sender>
-concept sender = //
- enable_sender<__decay_t<_Sender>> //
- && environment_provider<__cref_t<_Sender>> //
- && __detail::__consistent_completion_domains<_Sender> //
- && move_constructible<__decay_t<_Sender>> //
- && constructible_from<__decay_t<_Sender>, _Sender>;
+ template <class _Sender>
+ concept sender = enable_sender<__decay_t<_Sender>> && environment_provider<__cref_t<_Sender>>
+ && __detail::__consistent_completion_domains<_Sender>
+ && move_constructible<__decay_t<_Sender>>
+ && constructible_from<__decay_t<_Sender>, _Sender>;
-template <class _Sender, class... _Env>
-concept sender_in =
- (sizeof...(_Env) <= 1) //
- && sender<_Sender> //
- && requires(_Sender&& __sndr, _Env&&... __env) {
- {
- get_completion_signatures(static_cast<_Sender&&>(__sndr),
- static_cast<_Env&&>(__env)...)
- } -> __valid_completion_signatures;
- };
+ template <class _Sender, class... _Env>
+ concept sender_in =
+ (sizeof...(_Env) <= 1) && sender<_Sender> && requires(_Sender &&__sndr, _Env &&...__env) {
+ {
+ get_completion_signatures(static_cast<_Sender &&>(__sndr), static_cast<_Env &&>(__env)...)
+ } -> __valid_completion_signatures;
+ };
+
+ /////////////////////////////////////////////////////////////////////////////
+ // [exec.snd]
+ template <class _Sender, class _Receiver>
+ concept sender_to = receiver<_Receiver> && sender_in<_Sender, env_of_t<_Receiver>>
+ && __receiver_from<_Receiver, _Sender>
+ && requires(_Sender &&__sndr, _Receiver &&__rcvr) {
+ connect(static_cast<_Sender &&>(__sndr), static_cast<_Receiver &&>(__rcvr));
+ };
+
+ template <class _Sender, class _Receiver>
+ using connect_result_t = __call_result_t<connect_t, _Sender, _Receiver>;
+
+ // Used to report a meaningful error message when the sender_in<Sndr, Env>
+ // concept check fails.
+ template <class _Sender, class... _Env>
+ auto __diagnose_sender_concept_failure() {
+ if constexpr (!enable_sender<__decay_t<_Sender>>) {
+ static_assert(enable_sender<_Sender>, STDEXEC_ERROR_ENABLE_SENDER_IS_FALSE);
+ } else if constexpr (!__detail::__consistent_completion_domains<_Sender>) {
+ static_assert(
+ __detail::__consistent_completion_domains<_Sender>,
+ "The completion schedulers of the sender do not have "
+ "consistent domains. This is likely a "
+ "bug in the sender implementation.");
+ } else if constexpr (!move_constructible<__decay_t<_Sender>>) {
+ static_assert(
+ move_constructible<__decay_t<_Sender>>, "The sender type is not move-constructible.");
+ } else if constexpr (!constructible_from<__decay_t<_Sender>, _Sender>) {
+ static_assert(
+ constructible_from<__decay_t<_Sender>, _Sender>,
+ "The sender cannot be decay-copied. Did you forget a std::move?");
+ } else {
+ using _Completions = __completion_signatures_of_t<_Sender, _Env...>;
+ if constexpr (__same_as<_Completions, __unrecognized_sender_error<_Sender, _Env...>>) {
+ static_assert(__mnever<_Completions>, STDEXEC_ERROR_CANNOT_COMPUTE_COMPLETION_SIGNATURES);
+ } else if constexpr (__merror<_Completions>) {
+ static_assert(
+ !__merror<_Completions>, STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_RETURNED_AN_ERROR);
+ } else {
+ static_assert(
+ __valid_completion_signatures<_Completions>,
+ STDEXEC_ERROR_GET_COMPLETION_SIGNATURES_HAS_INVALID_RETURN_TYPE);
+ }
+#if STDEXEC_MSVC() || STDEXEC_NVHPC()
+ // MSVC and NVHPC need more encouragement to print the type of the
+ // error.
+ _Completions __what = 0;
+#endif
+ }
+ }
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__shared.hpp b/include/sdbusplus/async/stdexec/__detail/__shared.hpp
index 0922594..1adbceb 100644
--- a/include/sdbusplus/async/stdexec/__detail/__shared.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__shared.hpp
@@ -18,24 +18,24 @@
#include "__execution_fwd.hpp"
// include these after __execution_fwd.hpp
-#include "../functional.hpp"
-#include "../stop_token.hpp"
#include "__basic_sender.hpp"
-#include "__cpo.hpp"
#include "__env.hpp"
-#include "__intrusive_ptr.hpp"
#include "__intrusive_slist.hpp"
-#include "__meta.hpp"
#include "__optional.hpp"
+#include "__meta.hpp"
+#include "__receivers.hpp"
#include "__transform_completion_signatures.hpp"
#include "__tuple.hpp"
-#include "__variant.hpp"
+#include "__variant.hpp" // IWYU pragma: keep
+#include "../stop_token.hpp"
+
+#include <atomic>
#include <exception>
#include <mutex>
+#include <type_traits>
+#include <utility>
-namespace stdexec
-{
////////////////////////////////////////////////////////////////////////////
// shared components of split and ensure_started
//
@@ -56,199 +56,171 @@
// The shared state should add-ref itself when the input async
// operation is started and release itself when its completion
// is notified.
-namespace __shared
-{
-template <class _BaseEnv>
-using __env_t = //
- __env::__join_t<prop<get_stop_token_t, inplace_stop_token>,
- _BaseEnv>; // BUGBUG NOT TO SPEC
+namespace stdexec::__shared {
+ template <class _BaseEnv>
+ using __env_t = __join_env_t<
+ prop<get_stop_token_t, inplace_stop_token>,
+ _BaseEnv
+ >; // BUGBUG NOT TO SPEC
-template <class _Receiver>
-auto __make_notify_visitor(_Receiver& __rcvr) noexcept
-{
+ template <class _Receiver>
+ struct __notify_fn {
+ template <class _Tag, class... _Args>
+ void operator()(_Tag __tag, _Args&&... __args) const noexcept {
+ __tag(static_cast<_Receiver&&>(__rcvr_), static_cast<_Args&&>(__args)...);
+ }
+
+ _Receiver& __rcvr_;
+ };
+
+ template <class _Receiver>
+ auto __make_notify_visitor(_Receiver& __rcvr) noexcept {
return [&]<class _Tuple>(_Tuple&& __tupl) noexcept -> void {
- __tupl.apply(
- [&](auto __tag, auto&&... __args) noexcept -> void {
- __tag(static_cast<_Receiver&&>(__rcvr),
- __forward_like<_Tuple>(__args)...);
- },
- __tupl);
+ __tupl.apply(__notify_fn<_Receiver>{__rcvr}, static_cast<_Tuple&&>(__tupl));
};
-}
+ }
-struct __local_state_base : __immovable
-{
+ struct __local_state_base : __immovable {
using __notify_fn = void(__local_state_base*) noexcept;
+ void __notify() noexcept {
+ __notify_(this);
+ }
+
__notify_fn* __notify_{};
__local_state_base* __next_{};
-};
+ };
-template <class _CvrefSender, class _Env>
-struct __shared_state;
+ template <class _CvrefSender, class _Env>
+ struct __shared_state;
-// The operation state of ensure_started, and each operation state of split, has
-// one of these, created when the sender is connected. There are 0 or more of
-// them for each underlying async operation. It is what ensure_started- and
-// split-sender's `get_state` fn returns. It holds a ref count to the shared
-// state.
-template <class _CvrefSender, class _Receiver>
-struct __local_state :
- __local_state_base,
- __enable_receiver_from_this<_CvrefSender, _Receiver,
- __local_state<_CvrefSender, _Receiver>>
-{
+ // The operation state of ensure_started, and each operation state of split, has one of these,
+ // created when the sender is connected. There are 0 or more of them for each underlying async
+ // operation. It is what ensure_started- and split-sender's `get_state` fn returns. It holds a
+ // ref count to the shared state.
+ template <class _CvrefSender, class _Receiver>
+ struct __local_state
+ : __local_state_base
+ , __enable_receiver_from_this<_CvrefSender, _Receiver, __local_state<_CvrefSender, _Receiver>> {
using __tag_t = tag_of_t<_CvrefSender>;
using __stok_t = stop_token_of_t<env_of_t<_Receiver>>;
- static_assert(__one_of<__tag_t, __split::__split_t,
- __ensure_started::__ensure_started_t>);
+ static_assert(__one_of<__tag_t, __split::__split_t, __ensure_started::__ensure_started_t>);
- explicit __local_state(_CvrefSender&& __sndr) noexcept :
- __local_state::__local_state_base{{},
- &__notify<tag_of_t<_CvrefSender>>},
- __sh_state_(__get_sh_state(__sndr))
- {}
+ explicit __local_state(_CvrefSender&& __sndr) noexcept
+ : __local_state::__local_state_base{{}, &__notify<tag_of_t<_CvrefSender>>}
+ , __sh_state_(__get_sh_state(__sndr)) {
+ }
- ~__local_state()
- {
- __sh_state_t::__detach(__sh_state_);
+ ~__local_state() {
+ if (__sh_state_) {
+ __sh_state_->__detach();
+ }
}
// Stop request callback:
- void operator()() noexcept
- {
- // We reach here when a split/ensure_started sender has received a stop
- // request from the receiver to which it is connected.
- if (std::unique_lock __lock{__sh_state_->__mutex_})
- {
- // Remove this operation from the waiters list. Removal can fail if:
- // 1. It was already removed by another thread, or
- // 2. It hasn't been added yet (see `start` below), or
- // 3. The underlying operation has already completed.
- //
- // In each case, the right thing to do is nothing. If (1) then we
- // raced with another thread and lost. In that case, the other
- // thread will take care of it. If (2) then `start` will take care
- // of it. If (3) then this stop request is safe to ignore.
- if (!__sh_state_->__waiters_.remove(this))
- return;
- }
+ void operator()() noexcept {
+ // We reach here when a split/ensure_started sender has received a stop request from the
+ // receiver to which it is connected.
+ if (std::unique_lock __lock{__sh_state_->__mutex_}) {
+ // Remove this operation from the waiters list. Removal can fail if:
+ // 1. It was already removed by another thread, or
+ // 2. It hasn't been added yet (see `start` below), or
+ // 3. The underlying operation has already completed.
- // The following code and the __notify function cannot both execute.
- // This is because the
- // __notify function is called from the shared state's __notify_waiters
- // function, which first sets __waiters_ to the completed state. As a
- // result, the attempt to remove `this` from the waiters list above will
- // fail and this stop request is ignored.
- __sh_state_t::__detach(__sh_state_);
- stdexec::set_stopped(static_cast<_Receiver&&>(this->__receiver()));
+ // In each case, the right thing to do is nothing. If (1) then we raced with another
+ // thread and lost. In that case, the other thread will take care of it. If (2) then
+ // `start` will take care of it. If (3) then this stop request is safe to ignore.
+ if (!__sh_state_->__waiters_.remove(this))
+ return;
+ }
+
+ // The following code and the __notify function cannot both execute. This is because the
+ // __notify function is called from the shared state's __notify_waiters function, which
+ // first sets __waiters_ to the completed state. As a result, the attempt to remove `this`
+ // from the waiters list above will fail and this stop request is ignored.
+ std::exchange(__sh_state_, nullptr)->__detach();
+ stdexec::set_stopped(static_cast<_Receiver&&>(this->__receiver()));
}
- // This is called from __shared_state::__notify_waiters when the input async
- // operation completes; or, if it has already completed when start is
- // called, it is called from start:
- // __notify cannot race with __on_stop_request. See comment in
- // __on_stop_request.
+ // This is called from __shared_state::__notify_waiters when the input async operation
+ // completes; or, if it has already completed when start is called, it is called from start:
+ // __notify cannot race with __local_state::operator(). See comment in
+ // __local_state::operator().
template <class _Tag>
- static void __notify(__local_state_base* __base) noexcept
- {
- auto* const __self = static_cast<__local_state*>(__base);
+ static void __notify(__local_state_base* __base) noexcept {
+ auto* const __self = static_cast<__local_state*>(__base);
- // The split algorithm sends by T const&. ensure_started sends by T&&.
- constexpr bool __is_split = same_as<__split::__split_t, _Tag>;
- using __variant_t = decltype(__self->__sh_state_->__results_);
- using __cv_variant_t =
- __if_c<__is_split, const __variant_t&, __variant_t>;
+ // The split algorithm sends by T const&. ensure_started sends by T&&.
+ constexpr bool __is_split = same_as<__split::__split_t, _Tag>;
+ using __variant_t = decltype(__self->__sh_state_->__results_);
+ using __cv_variant_t = __if_c<__is_split, const __variant_t&, __variant_t>;
- __self->__on_stop_.reset();
+ __self->__on_stop_.reset();
- auto __visitor = __make_notify_visitor(__self->__receiver());
- __variant_t::visit(__visitor, static_cast<__cv_variant_t&&>(
- __self->__sh_state_->__results_));
+ auto __visitor = __make_notify_visitor(__self->__receiver());
+ __variant_t::visit(__visitor, static_cast<__cv_variant_t&&>(__self->__sh_state_->__results_));
}
- static auto __get_sh_state(_CvrefSender& __sndr) noexcept
- {
- return __sndr
- .apply(static_cast<_CvrefSender&&>(__sndr), __detail::__get_data())
- .__sh_state_;
+ static auto __get_sh_state(_CvrefSender& __sndr) noexcept {
+ auto __box = __sndr.apply(static_cast<_CvrefSender&&>(__sndr), __detail::__get_data());
+ return std::exchange(__box.__sh_state_, nullptr);
}
using __sh_state_ptr_t = __result_of<__get_sh_state, _CvrefSender&>;
- using __sh_state_t = typename __sh_state_ptr_t::element_type;
+ using __sh_state_t = std::remove_pointer_t<__sh_state_ptr_t>;
__optional<stop_callback_for_t<__stok_t, __local_state&>> __on_stop_{};
__sh_state_ptr_t __sh_state_;
-};
+ };
-template <class _CvrefSenderId, class _EnvId>
-struct __receiver
-{
+ template <class _CvrefSenderId, class _EnvId>
+ struct __receiver {
using _CvrefSender = stdexec::__cvref_t<_CvrefSenderId>;
using _Env = stdexec::__t<_EnvId>;
- struct __t
- {
- using receiver_concept = receiver_t;
- using __id = __receiver;
+ struct __t {
+ using receiver_concept = receiver_t;
+ using __id = __receiver;
- template <class... _As>
- STDEXEC_ATTRIBUTE((always_inline))
- void set_value(_As&&... __as) noexcept
- {
- __sh_state_->__complete(set_value_t(), static_cast<_As&&>(__as)...);
- }
+ template <class... _As>
+ STDEXEC_ATTRIBUTE(always_inline)
+ void set_value(_As&&... __as) noexcept {
+ __sh_state_->__complete(set_value_t(), static_cast<_As&&>(__as)...);
+ }
- template <class _Error>
- STDEXEC_ATTRIBUTE((always_inline))
- void set_error(_Error&& __err) noexcept
- {
- __sh_state_->__complete(set_error_t(),
- static_cast<_Error&&>(__err));
- }
+ template <class _Error>
+ STDEXEC_ATTRIBUTE(always_inline)
+ void set_error(_Error&& __err) noexcept {
+ __sh_state_->__complete(set_error_t(), static_cast<_Error&&>(__err));
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- void set_stopped() noexcept
- {
- __sh_state_->__complete(set_stopped_t());
- }
+ STDEXEC_ATTRIBUTE(always_inline) void set_stopped() noexcept {
+ __sh_state_->__complete(set_stopped_t());
+ }
- auto get_env() const noexcept -> const __env_t<_Env>&
- {
- return __sh_state_->__env_;
- }
+ auto get_env() const noexcept -> const __env_t<_Env>& {
+ return __sh_state_->__env_;
+ }
- // The receiver does not hold a reference to the shared state.
- __shared_state<_CvrefSender, _Env>* __sh_state_;
+ // The receiver does not hold a reference to the shared state.
+ __shared_state<_CvrefSender, _Env>* __sh_state_;
};
-};
+ };
-inline __local_state_base* __get_tombstone() noexcept
-{
- static __local_state_base __tombstone_{{}, nullptr, nullptr};
- return &__tombstone_;
-}
-
-//! Heap-allocatable shared state for things like `stdexec::split`.
-template <class _CvrefSender, class _Env>
-struct __shared_state :
- private __enable_intrusive_from_this<__shared_state<_CvrefSender, _Env>, 2>
-{
+ //! Heap-allocatable shared state for things like `stdexec::split`.
+ template <class _CvrefSender, class _Env>
+ struct __shared_state {
using __receiver_t = __t<__receiver<__cvref_id<_CvrefSender>, __id<_Env>>>;
using __waiters_list_t = __intrusive_slist<&__local_state_base::__next_>;
- using __variant_t = //
- __transform_completion_signatures<
- __completion_signatures_of_t<_CvrefSender, _Env>,
- __mbind_front_q<__decayed_tuple, set_value_t>::__f,
- __mbind_front_q<__decayed_tuple, set_error_t>::__f,
- __tuple_for<set_error_t, std::exception_ptr>,
- __munique<__mbind_front_q<__variant_for,
- __tuple_for<set_stopped_t>>>::__f,
- __tuple_for<set_error_t, std::exception_ptr>>;
-
- static constexpr std::size_t __started_bit = 0;
- static constexpr std::size_t __completed_bit = 1;
+ using __variant_t = __transform_completion_signatures<
+ __completion_signatures_of_t<_CvrefSender, _Env>,
+ __mbind_front_q<__decayed_tuple, set_value_t>::__f,
+ __mbind_front_q<__decayed_tuple, set_error_t>::__f,
+ __tuple_for<set_error_t, std::exception_ptr>,
+ __munique<__mbind_front_q<__variant_for, __tuple_for<set_stopped_t>>>::__f,
+ __tuple_for<set_error_t, std::exception_ptr>
+ >;
inplace_stop_source __stop_source_{};
__env_t<_Env> __env_;
@@ -256,290 +228,253 @@
std::mutex __mutex_; // This mutex guards access to __waiters_.
__waiters_list_t __waiters_{};
connect_result_t<_CvrefSender, __receiver_t> __shared_op_;
+ std::atomic_flag __started_{};
+ std::atomic<std::size_t> __ref_count_{2};
+ __local_state_base __tombstone_{};
- explicit __shared_state(_CvrefSender&& __sndr, _Env __env) :
- __env_(__env::__join(prop{get_stop_token, __stop_source_.get_token()},
- static_cast<_Env&&>(__env))),
- __shared_op_(
- connect(static_cast<_CvrefSender&&>(__sndr), __receiver_t{this}))
- {
- // add one ref count to account for the case where there are no watchers
- // left but the shared op is still running.
- this->__inc_ref();
+ // Let a "consumer" be either a split/ensure_started sender, or an operation
+ // state created by connecting a split/ensure_started sender to a receiver.
+ // Let is_running be 1 if the shared operation is currently executing (after
+ // start has been called but before the receiver's completion functions have
+ // executed), and 0 otherwise. Then __ref_count_ is equal to:
+
+ // (2 * (nbr of consumers)) + is_running
+
+ explicit __shared_state(_CvrefSender&& __sndr, _Env __env)
+ : __env_(
+ __env::__join(
+ prop{get_stop_token, __stop_source_.get_token()},
+ static_cast<_Env&&>(__env)))
+ , __shared_op_(connect(static_cast<_CvrefSender&&>(__sndr), __receiver_t{this})) {
}
- // The caller of this wants to release their reference to the shared state.
- // The ref count must be at least 2 at this point: one owned by the caller,
- // and one added in the
- // __shared_state ctor.
- static void __detach(__intrusive_ptr<__shared_state, 2>& __ptr) noexcept
- {
- // Ask the intrusive ptr to stop managing the reference count so we can
- // manage it manually.
- if (auto* __self = __ptr.__release_())
- {
- auto __old = __self->__dec_ref();
- STDEXEC_ASSERT(__count(__old) >= 2);
-
- if (__count(__old) == 2)
- {
- // The last watcher has released its reference. Asked the shared
- // op to stop.
- static_cast<__shared_state*>(__self)
- ->__stop_source_.request_stop();
-
- // Additionally, if the shared op was never started, or if it
- // has already completed, then the shared state is no longer
- // needed. Decrement the ref count to 0 here, which will delete
- // __self.
- if (!__bit<__started_bit>(__old) ||
- __bit<__completed_bit>(__old))
- {
- __self->__dec_ref();
- }
- }
- }
+ void __inc_ref() noexcept {
+ __ref_count_.fetch_add(2ul, std::memory_order_relaxed);
}
- /// @post The started bit is set in the shared state's ref count, OR the
- /// __waiters_ list is set to the known "tombstone" value indicating
- /// completion.
- void __try_start() noexcept
- {
- // With the split algorithm, multiple split senders can be started
- // simultaneously, but only one should start the shared async operation.
- // If the "started" bit is set, then someone else has already started
- // the shared operation. Do nothing.
- if (this->template __is_set<__started_bit>())
- {
- return;
+ void __dec_ref() noexcept {
+ if (2ul == __ref_count_.fetch_sub(2ul, std::memory_order_acq_rel)) {
+ delete this;
+ }
+ }
+
+ auto __set_started() noexcept -> bool {
+ if (__started_.test_and_set(std::memory_order_acq_rel)) {
+ return false; // already started
+ }
+ __ref_count_.fetch_add(1ul, std::memory_order_relaxed);
+ return true;
+ }
+
+ void __set_completed() noexcept {
+ if (1ul == __ref_count_.fetch_sub(1ul, std::memory_order_acq_rel)) {
+ delete this;
+ }
+ }
+
+ void __detach() noexcept {
+ if (__ref_count_.load() < 4ul) {
+ // We are the final "consumer", and we are about to release our reference
+ // to the shared state. Ask the operation to stop early.
+ __stop_source_.request_stop();
+ }
+ __dec_ref();
+ }
+
+ /// @post The "is running" bit is set in the shared state's ref count, OR the __waiters_ list
+ /// is set to the known "tombstone" value indicating completion.
+ void __try_start() noexcept {
+ // With the split algorithm, multiple split senders can be started simultaneously, but
+ // only one should start the shared async operation. If the low bit is set, then
+ // someone else has already started the shared operation. Do nothing.
+ if (__set_started()) {
+ // we are the first to start the underlying operation
+ if (__stop_source_.stop_requested()) {
+ // Stop has already been requested. Rather than starting the operation, complete with
+ // set_stopped immediately.
+ // 1. Sets __waiters_ to a known "tombstone" value.
+ // 2. Notifies all the waiters that the operation has stopped.
+ // 3. Sets the "is running" bit in the ref count to 0.
+ __notify_waiters();
+ } else {
+ stdexec::start(__shared_op_);
}
- else if (__bit<__started_bit>(
- this->template __set_bit<__started_bit>()))
- {
- return;
- }
- else if (__stop_source_.stop_requested())
- {
- // Stop has already been requested. Rather than starting the
- // operation, complete with set_stopped immediately.
- // 1. Sets __waiters_ to a known "tombstone" value
- // 2. Notifies all the waiters that the operation has stopped
- // 3. Sets the "completed" bit in the ref count.
- __notify_waiters();
- return;
- }
- else
- {
- stdexec::start(__shared_op_);
- }
+ }
}
template <class _StopToken>
- bool __try_add_waiter(__local_state_base* __waiter,
- _StopToken __stok) noexcept
- {
- std::unique_lock __lock{__mutex_};
- if (__waiters_.front() == __get_tombstone())
- {
- // The work has already completed. Notify the waiter immediately.
- __lock.unlock();
- __waiter->__notify_(__waiter);
- return true;
- }
- else if (__stok.stop_requested())
- {
- // Stop has been requested. Do not add the waiter.
- return false;
- }
- else
- {
- // Add the waiter to the list.
- __waiters_.push_front(__waiter);
- return true;
- }
+ auto __try_add_waiter(__local_state_base* __waiter, _StopToken __stok) noexcept -> bool {
+ std::unique_lock __lock{__mutex_};
+ if (__waiters_.front() == &__tombstone_) {
+ // The work has already completed. Notify the waiter immediately.
+ __lock.unlock();
+ __waiter->__notify();
+ return true;
+ } else if (__stok.stop_requested()) {
+ // Stop has been requested. Do not add the waiter.
+ return false;
+ } else {
+ // Add the waiter to the list.
+ __waiters_.push_front(__waiter);
+ return true;
+ }
}
/// @brief This is called when the shared async operation completes.
/// @post __waiters_ is set to a known "tombstone" value.
template <class _Tag, class... _As>
- void __complete(_Tag, _As&&... __as) noexcept
- {
- try
- {
- using __tuple_t = __decayed_tuple<_Tag, _As...>;
- __results_.template emplace<__tuple_t>(_Tag(),
- static_cast<_As&&>(__as)...);
- }
- catch (...)
- {
- using __tuple_t = __decayed_tuple<set_error_t, std::exception_ptr>;
- __results_.template emplace<__tuple_t>(set_error,
- std::current_exception());
- }
+ void __complete(_Tag, _As&&... __as) noexcept {
+ STDEXEC_TRY {
+ using __tuple_t = __decayed_tuple<_Tag, _As...>;
+ __results_.template emplace<__tuple_t>(_Tag(), static_cast<_As&&>(__as)...);
+ }
+ STDEXEC_CATCH_ALL {
+ using __tuple_t = __decayed_tuple<set_error_t, std::exception_ptr>;
+ __results_.template emplace<__tuple_t>(set_error, std::current_exception());
+ }
- __notify_waiters();
+ __notify_waiters();
}
/// @brief This is called when the shared async operation completes.
/// @post __waiters_ is set to a known "tombstone" value.
- void __notify_waiters() noexcept
- {
- __waiters_list_t __waiters_copy{__get_tombstone()};
+ void __notify_waiters() noexcept {
+ __waiters_list_t __waiters_copy{&__tombstone_};
- // Set the waiters list to a known "tombstone" value that we can check
- // later.
- {
- std::lock_guard __lock{__mutex_};
- __waiters_.swap(__waiters_copy);
- }
+ // Set the waiters list to a known "tombstone" value that we can check later.
+ {
+ std::lock_guard __lock{__mutex_};
+ __waiters_.swap(__waiters_copy);
+ }
- STDEXEC_ASSERT(__waiters_copy.front() != __get_tombstone());
- for (auto __itr = __waiters_copy.begin();
- __itr != __waiters_copy.end();)
- {
- __local_state_base* __item = *__itr;
+ STDEXEC_ASSERT(__waiters_copy.front() != &__tombstone_);
+ for (auto __itr = __waiters_copy.begin(); __itr != __waiters_copy.end();) {
+ __local_state_base* __item = *__itr;
- // We must increment the iterator before calling notify, since
- // notify may end up triggering *__item to be destructed on another
- // thread, and the intrusive slist's iterator increment relies on
- // __item.
- ++__itr;
+ // We must increment the iterator before calling notify, since notify may end up
+ // triggering *__item to be destructed on another thread, and the intrusive slist's
+ // iterator increment relies on __item.
+ ++__itr;
+ __item->__notify();
+ }
- __item->__notify_(__item);
- }
-
- // Set the "completed" bit in the ref count. If the ref count is 1, then
- // there are no more waiters. Release the final reference.
- if (__count(this->template __set_bit<__completed_bit>()) == 1)
- {
- this->__dec_ref(); // release the extra ref count, deletes this
- }
+ // Set the "is running" bit in the ref count to zero. Delete the shared state if the
+ // ref-count is now zero.
+ __set_completed();
}
-};
+ };
-template <class _Cvref, class _CvrefSender, class _Env>
-using __make_completions = //
- __try_make_completion_signatures<
- // NOT TO SPEC:
- // See https://github.com/cplusplus/sender-receiver/issues/23
- _CvrefSender, __env_t<_Env>,
- completion_signatures<set_error_t(
- __minvoke<_Cvref, std::exception_ptr>),
- set_stopped_t()>, // NOT TO SPEC
- __mtransform<_Cvref,
- __mcompose<__q<completion_signatures>, __qf<set_value_t>>>,
- __mtransform<
- _Cvref, __mcompose<__q<completion_signatures>, __qf<set_error_t>>>>;
+ template <class _CvrefSender, class _Env>
+ __shared_state(_CvrefSender&&, _Env) -> __shared_state<_CvrefSender, _Env>;
-// split completes with const T&. ensure_started completes with T&&.
-template <class _Tag>
-using __cvref_results_t = //
- __mcompose<__if_c<same_as<_Tag, __split::__split_t>, __cpclr, __cp>,
- __q<__decay_t>>;
+ template <class _Cvref, class _CvrefSender, class _Env>
+ using __make_completions = __try_make_completion_signatures<
+ // NOT TO SPEC:
+ // See https://github.com/cplusplus/sender-receiver/issues/23
+ _CvrefSender,
+ __env_t<_Env>,
+ completion_signatures<
+ set_error_t(__minvoke<_Cvref, std::exception_ptr>),
+ set_stopped_t()
+ >, // NOT TO SPEC
+ __mtransform<_Cvref, __mcompose<__q<completion_signatures>, __qf<set_value_t>>>,
+ __mtransform<_Cvref, __mcompose<__q<completion_signatures>, __qf<set_error_t>>>
+ >;
-// NOTE: the use of __mapply in the return type below takes advantage of the
-// fact that _ShState denotes an instance of the __shared_state template, which
-// is parameterized on the cvref-qualified sender and the environment.
-template <class _Tag, class _ShState>
-using __completions = //
- __mapply<__mbind_front_q<__make_completions, __cvref_results_t<_Tag>>,
- _ShState>;
+ // split completes with const T&. ensure_started completes with T&&.
+ template <class _Tag>
+ using __cvref_results_t =
+ __mcompose<__if_c<same_as<_Tag, __split::__split_t>, __cpclr, __cp>, __q<__decay_t>>;
-template <class _CvrefSender, class _Env, bool _Copyable = true>
-struct __box
-{
- using __tag_t = __if_c<_Copyable, __split::__split_t,
- __ensure_started::__ensure_started_t>;
+ // NOTE: the use of __mapply in the return type below takes advantage of the fact that _ShState
+ // denotes an instance of the __shared_state template, which is parameterized on the
+ // cvref-qualified sender and the environment.
+ template <class _Tag, class _ShState>
+ using __completions =
+ __mapply<__mbind_front_q<__make_completions, __cvref_results_t<_Tag>>, _ShState>;
+
+ template <class _CvrefSender, class _Env, bool _Copyable = true>
+ struct __box {
+ using __tag_t = __if_c<_Copyable, __split::__split_t, __ensure_started::__ensure_started_t>;
using __sh_state_t = __shared_state<_CvrefSender, _Env>;
- __box(__tag_t, __intrusive_ptr<__sh_state_t, 2> __sh_state) noexcept :
- __sh_state_(std::move(__sh_state))
- {}
-
- __box(__box&&) noexcept = default;
- __box(const __box&) noexcept
- requires _Copyable
- = default;
-
- ~__box()
- {
- __sh_state_t::__detach(__sh_state_);
+ __box(__tag_t, __sh_state_t* __sh_state) noexcept
+ : __sh_state_(__sh_state) {
}
- __intrusive_ptr<__sh_state_t, 2> __sh_state_;
-};
+ __box(__box&& __other) noexcept
+ : __sh_state_(std::exchange(__other.__sh_state_, nullptr)) {
+ }
-template <class _CvrefSender, class _Env>
-__box(__split::__split_t,
- __intrusive_ptr<__shared_state<_CvrefSender, _Env>, 2>) //
- ->__box<_CvrefSender, _Env, true>;
+ __box(const __box& __other) noexcept
+ requires _Copyable
+ : __sh_state_(__other.__sh_state_) {
+ __sh_state_->__inc_ref();
+ }
-template <class _CvrefSender, class _Env>
-__box(__ensure_started::__ensure_started_t,
- __intrusive_ptr<__shared_state<_CvrefSender, _Env>, 2>)
+ ~__box() {
+ if (__sh_state_) {
+ __sh_state_->__detach();
+ }
+ }
+
+ __sh_state_t* __sh_state_;
+ };
+
+ template <class _CvrefSender, class _Env>
+ __box(__split::__split_t, __shared_state<_CvrefSender, _Env>*) -> __box<_CvrefSender, _Env, true>;
+
+ template <class _CvrefSender, class _Env>
+ __box(__ensure_started::__ensure_started_t, __shared_state<_CvrefSender, _Env>*)
-> __box<_CvrefSender, _Env, false>;
-template <class _Tag>
-struct __shared_impl : __sexpr_defaults
-{
- static constexpr auto get_state = //
- []<class _CvrefSender, class _Receiver>(
- _CvrefSender&& __sndr,
- _Receiver&) noexcept -> __local_state<_CvrefSender, _Receiver> {
- static_assert(sender_expr_for<_CvrefSender, _Tag>);
- return __local_state<_CvrefSender, _Receiver>{
- static_cast<_CvrefSender&&>(__sndr)};
+ template <class _Tag>
+ struct __shared_impl : __sexpr_defaults {
+ static constexpr auto get_state =
+ []<class _CvrefSender, class _Receiver>(_CvrefSender&& __sndr, _Receiver&) noexcept
+ -> __local_state<_CvrefSender, _Receiver> {
+ static_assert(sender_expr_for<_CvrefSender, _Tag>);
+ return __local_state<_CvrefSender, _Receiver>{static_cast<_CvrefSender&&>(__sndr)};
};
- static constexpr auto get_completion_signatures = //
- []<class _Self>(const _Self&, auto&&...) noexcept
- -> __completions<_Tag, typename __data_of<_Self>::__sh_state_t> {
- static_assert(sender_expr_for<_Self, _Tag>);
- return {};
+ static constexpr auto get_completion_signatures =
+ []<class _Self>(const _Self&, auto&&...) noexcept
+ -> __completions<_Tag, typename __data_of<_Self>::__sh_state_t> {
+ static_assert(sender_expr_for<_Self, _Tag>);
+ return {};
};
- static constexpr auto start = //
- []<class _Sender, class _Receiver>(
- __local_state<_Sender, _Receiver>& __self,
- _Receiver& __rcvr) noexcept -> void {
- using __sh_state_t =
- typename __local_state<_Sender, _Receiver>::__sh_state_t;
- // Scenario: there are no more split senders, this is the only operation
- // state, the underlying operation has not yet been started, and the
- // receiver's stop token is already in the "stop requested" state. Then
- // registering the stop callback will call
- // __on_stop_request on __self synchronously. It may also be called
- // asynchronously at any point after the callback is registered. Beware.
- // We are guaranteed, however, that
- // __on_stop_request will not complete the operation or decrement the
- // shared state's ref count until after __self has been added to the
- // waiters list.
- const auto __stok = stdexec::get_stop_token(stdexec::get_env(__rcvr));
- __self.__on_stop_.emplace(__stok, __self);
+ static constexpr auto start = []<class _Sender, class _Receiver>(
+ __local_state<_Sender, _Receiver>& __self,
+ _Receiver& __rcvr) noexcept -> void {
+ // Scenario: there are no more split senders, this is the only operation state, the
+ // underlying operation has not yet been started, and the receiver's stop token is already
+ // in the "stop requested" state. Then registering the stop callback will call
+ // __local_state::operator() on __self synchronously. It may also be called asynchronously
+ // at any point after the callback is registered. Beware. We are guaranteed, however, that
+ // __local_state::operator() will not complete the operation or decrement the shared state's
+ // ref count until after __self has been added to the waiters list.
+ const auto __stok = stdexec::get_stop_token(stdexec::get_env(__rcvr));
+ __self.__on_stop_.emplace(__stok, __self);
- // We haven't put __self in the waiters list yet and we are holding a
- // ref count to
- // __sh_state_, so nothing can happen to the __sh_state_ here.
+ // We haven't put __self in the waiters list yet and we are holding a ref count to
+ // __sh_state_, so nothing can happen to the __sh_state_ here.
- // Start the shared op. As an optimization, skip it if the receiver's
- // stop token has already been signaled.
- if (!__stok.stop_requested())
- {
- __self.__sh_state_->__try_start();
- if (__self.__sh_state_->__try_add_waiter(&__self, __stok))
- {
- // successfully added the waiter
- return;
- }
+ // Start the shared op. As an optimization, skip it if the receiver's stop token has already
+ // been signaled.
+ if (!__stok.stop_requested()) {
+ __self.__sh_state_->__try_start();
+ if (__self.__sh_state_->__try_add_waiter(&__self, __stok)) {
+ // successfully added the waiter
+ return;
}
+ }
- // Otherwise, failed to add the waiter because of a stop-request.
- // Complete synchronously with set_stopped().
- __self.__on_stop_.reset();
- __sh_state_t::__detach(__self.__sh_state_);
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
+ // Otherwise, failed to add the waiter because of a stop-request.
+ // Complete synchronously with set_stopped().
+ __self.__on_stop_.reset();
+ std::exchange(__self.__sh_state_, nullptr)->__detach();
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
};
-};
-} // namespace __shared
-} // namespace stdexec
+ };
+} // namespace stdexec::__shared
diff --git a/include/sdbusplus/async/stdexec/__detail/__spin_loop_pause.hpp b/include/sdbusplus/async/stdexec/__detail/__spin_loop_pause.hpp
index bef1fae..d1d4dce 100644
--- a/include/sdbusplus/async/stdexec/__detail/__spin_loop_pause.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__spin_loop_pause.hpp
@@ -18,51 +18,41 @@
#include "../../stdexec/__detail/__config.hpp"
-// The below code for spin_loop_pause is taken from
-// https://github.com/max0x7ba/atomic_queue/blob/master/include/atomic_queue/defs.h
+// The below code for spin_loop_pause is taken from https://github.com/max0x7ba/atomic_queue/blob/master/include/atomic_queue/defs.h
// Copyright (c) 2019 Maxim Egorushkin. MIT License.
-#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || \
- defined(_M_IX86)
-#if STDEXEC_MSVC_HEADERS()
-#include <intrin.h>
-#endif
-namespace stdexec
-{
-STDEXEC_ATTRIBUTE((always_inline))
-static void __spin_loop_pause() noexcept
-{
-#if STDEXEC_MSVC_HEADERS()
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+# if STDEXEC_MSVC_HEADERS()
+# include <intrin.h>
+# endif
+namespace stdexec {
+ STDEXEC_ATTRIBUTE(always_inline) static void __spin_loop_pause() noexcept {
+# if STDEXEC_MSVC_HEADERS()
_mm_pause();
-#else
+# else
__builtin_ia32_pause();
-#endif
-}
+# endif
+ }
} // namespace stdexec
#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM64)
-namespace stdexec
-{
-STDEXEC_ATTRIBUTE((always_inline))
-static void __spin_loop_pause() noexcept
-{
-#if (defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || \
- defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) || \
- defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || \
- defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || \
- defined(__ARM_ARCH_7S__) || defined(__ARM_ARCH_8A__) || \
- defined(__aarch64__))
+namespace stdexec {
+ STDEXEC_ATTRIBUTE(always_inline) static void __spin_loop_pause() noexcept {
+# if ( \
+ defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) \
+ || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
+ || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) \
+ || defined(__ARM_ARCH_8A__) || defined(__aarch64__))
asm volatile("yield" ::: "memory");
-#elif defined(_M_ARM64)
+# elif defined(_M_ARM64)
__yield();
-#else
+# else
asm volatile("nop" ::: "memory");
-#endif
-}
+# endif
+ }
} // namespace stdexec
#else
-namespace stdexec
-{
-STDEXEC_ATTRIBUTE((always_inline))
-static void __spin_loop_pause() noexcept {}
+namespace stdexec {
+ STDEXEC_ATTRIBUTE(always_inline) static void __spin_loop_pause() noexcept {
+ }
} // namespace stdexec
-#endif
+#endif
\ No newline at end of file
diff --git a/include/sdbusplus/async/stdexec/__detail/__split.hpp b/include/sdbusplus/async/stdexec/__detail/__split.hpp
index 137ce49..752e825 100644
--- a/include/sdbusplus/async/stdexec/__detail/__split.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__split.hpp
@@ -20,7 +20,6 @@
// include these after __execution_fwd.hpp
#include "__basic_sender.hpp"
#include "__concepts.hpp"
-#include "__intrusive_ptr.hpp"
#include "__meta.hpp"
#include "__sender_adaptor_closure.hpp"
#include "__senders.hpp"
@@ -28,88 +27,60 @@
#include "__transform_sender.hpp"
#include "__type_traits.hpp"
-#include <utility>
+namespace stdexec {
+ ////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.split]
+ namespace __split {
+ using namespace __shared;
-namespace stdexec
-{
-////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.split]
-namespace __split
-{
-using namespace __shared;
+ struct __split_t { };
-struct __split_t
-{};
-
-struct split_t
-{
- template <sender _Sender, class _Env = empty_env>
+ struct split_t {
+ template <sender _Sender, class _Env = env<>>
requires sender_in<_Sender, _Env> && __decay_copyable<env_of_t<_Sender>>
- auto operator()(_Sender&& __sndr, _Env&& __env = {}) const
- -> __well_formed_sender auto
- {
- auto __domain = __get_late_domain(__sndr, __env);
+ auto operator()(_Sender&& __sndr, _Env&& __env = {}) const -> __well_formed_sender auto {
+ auto __domain = __get_late_domain(__sndr, __env, __get_early_domain(__sndr));
return stdexec::transform_sender(
- __domain, __make_sexpr<split_t>(static_cast<_Env&&>(__env),
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<split_t>(static_cast<_Env&&>(__env), static_cast<_Sender&&>(__sndr)));
+ }
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()() const noexcept -> __binder_back<split_t>
- {
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()() const noexcept -> __binder_back<split_t> {
return {{}, {}, {}};
- }
+ }
- using _Sender = __1;
- using __legacy_customizations_t = //
- __types<tag_invoke_t(split_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(const _Sender&)),
- _Sender),
- tag_invoke_t(split_t, _Sender)>;
+ template <class _CvrefSender, class _Env>
+ using __receiver_t = __t<__meval<__receiver, __cvref_id<_CvrefSender>, __id<_Env>>>;
- template <class _CvrefSender, class _Env>
- using __receiver_t =
- __t<__meval<__receiver, __cvref_id<_CvrefSender>, __id<_Env>>>;
-
- template <class _Sender>
- static auto transform_sender(_Sender&& __sndr)
- {
- using _Receiver =
- __receiver_t<__child_of<_Sender>, __decay_t<__data_of<_Sender>>>;
+ template <class _Sender>
+ static auto transform_sender(_Sender&& __sndr) {
+ using _Receiver = __receiver_t<__child_of<_Sender>, __decay_t<__data_of<_Sender>>>;
static_assert(sender_to<__child_of<_Sender>, _Receiver>);
return __sexpr_apply(
- static_cast<_Sender&&>(__sndr),
- [&]<class _Env, class _Child>(__ignore, _Env&& __env,
- _Child&& __child) {
- // The shared state starts life with a ref-count of one.
- auto __sh_state =
- __make_intrusive<__shared_state<_Child, __decay_t<_Env>>,
- 2>(static_cast<_Child&&>(__child),
- static_cast<_Env&&>(__env));
+ static_cast<_Sender&&>(__sndr),
+ [&]<class _Env, class _Child>(__ignore, _Env&& __env, _Child&& __child) {
+ // The shared state starts life with a ref-count of one.
+ auto* __sh_state =
+ new __shared_state{static_cast<_Child&&>(__child), static_cast<_Env&&>(__env)};
- return __make_sexpr<__split_t>(
- __box{__split_t(), std::move(__sh_state)});
- });
- }
-};
-} // namespace __split
+ return __make_sexpr<__split_t>(__box{__split_t(), __sh_state});
+ });
+ }
+ };
+ } // namespace __split
-using __split::split_t;
-inline constexpr split_t split{};
+ using __split::split_t;
+ inline constexpr split_t split{};
-template <>
-struct __sexpr_impl<__split::__split_t> :
- __shared::__shared_impl<__split::__split_t>
-{};
+ template <>
+ struct __sexpr_impl<__split::__split_t> : __shared::__shared_impl<__split::__split_t> { };
-template <>
-struct __sexpr_impl<split_t> : __sexpr_defaults
-{
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {};
-};
+ template <>
+ struct __sexpr_impl<split_t> : __sexpr_defaults {
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
+ };
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__start_detached.hpp b/include/sdbusplus/async/stdexec/__detail/__start_detached.hpp
index f22bf39..6d5d78c 100644
--- a/include/sdbusplus/async/stdexec/__detail/__start_detached.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__start_detached.hpp
@@ -15,97 +15,189 @@
*/
#pragma once
-#include "__cpo.hpp"
-#include "__env.hpp"
#include "__execution_fwd.hpp"
+
+#include <memory>
+
#include "__meta.hpp"
+#include "__env.hpp"
#include "__receivers.hpp"
-#include "__senders.hpp"
+#include "__env.hpp"
+#include "__scope.hpp"
#include "__submit.hpp"
#include "__transform_sender.hpp"
-#include "__type_traits.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.consumer.start_detached]
-namespace __start_detached
-{
-template <class _EnvId>
-struct __detached_receiver
-{
- using _Env = stdexec::__t<_EnvId>;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.consumer.start_detached]
+ namespace __start_detached {
+ struct __submit_receiver {
+ using receiver_concept = receiver_t;
+ using __t = __submit_receiver;
+ using __id = __submit_receiver;
- struct __t
- {
+ template <class... _As>
+ void set_value(_As&&...) noexcept {
+ }
+
+ template <class _Error>
+ [[noreturn]]
+ void set_error(_Error&&) noexcept {
+ // A detached operation failed. There is noplace for the error to go.
+ // This is unrecoverable, so we terminate.
+ std::terminate();
+ }
+
+ void set_stopped() noexcept {
+ }
+
+ [[nodiscard]]
+ auto get_env() const noexcept -> __root_env {
+ return {};
+ }
+ };
+
+ template <class _SenderId, class _EnvId>
+ struct __operation : __immovable {
+ using _Sender = __cvref_t<_SenderId>;
+ using _Env = __t<_EnvId>;
+
+ explicit __operation(connect_t, _Sender&& __sndr, _Env __env)
+ : __env_(static_cast<_Env&&>(__env))
+ , __op_data_(static_cast<_Sender&&>(__sndr), __receiver{this}) {
+ }
+
+ explicit __operation(_Sender&& __sndr, _Env __env)
+ : __operation(connect, static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env)) {
+ // If the operation completes synchronously, then the following line will cause
+ // the destruction of *this, which is not a problem because we used a delegating
+ // constructor, so *this is considered fully constructed.
+ __op_data_.submit(static_cast<_Sender&&>(__sndr), __receiver{this});
+ }
+
+ static void __destroy_delete(__operation* __self) noexcept {
+ if constexpr (__callable<get_allocator_t, _Env>) {
+ auto __alloc = stdexec::get_allocator(__self->__env_);
+ using _Alloc = decltype(__alloc);
+ using _OpAlloc = std::allocator_traits<_Alloc>::template rebind_alloc<__operation>;
+ _OpAlloc __op_alloc{__alloc};
+ std::allocator_traits<_OpAlloc>::destroy(__op_alloc, __self);
+ std::allocator_traits<_OpAlloc>::deallocate(__op_alloc, __self, 1);
+ } else {
+ delete __self;
+ }
+ }
+
+ // The start_detached receiver deletes the operation state.
+ struct __receiver {
using receiver_concept = receiver_t;
- using __id = __detached_receiver;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Env __env_;
+ using __t = __receiver;
+ using __id = __receiver;
template <class... _As>
- void set_value(_As&&...) noexcept
- {}
+ void set_value(_As&&...) noexcept {
+ __operation::__destroy_delete(__op_); // NB: invalidates *this
+ }
template <class _Error>
- [[noreturn]] void set_error(_Error&&) noexcept
- {
- std::terminate();
+ [[noreturn]]
+ void set_error(_Error&&) noexcept {
+ // A detached operation failed. There is noplace for the error to go.
+ // This is unrecoverable, so we terminate.
+ std::terminate();
}
- void set_stopped() noexcept {}
-
- auto get_env() const noexcept -> const _Env&
- {
- // BUGBUG NOT TO SPEC
- return __env_;
+ void set_stopped() noexcept {
+ __operation::__destroy_delete(__op_); // NB: invalidates *this
}
+
+ auto get_env() const noexcept -> const _Env& {
+ return __op_->__env_;
+ }
+
+ __operation* __op_;
+ };
+
+ STDEXEC_ATTRIBUTE(no_unique_address) _Env __env_;
+ STDEXEC_ATTRIBUTE(no_unique_address) submit_result<_Sender, __receiver> __op_data_;
};
-};
-template <class _Env = empty_env>
-using __detached_receiver_t = __t<__detached_receiver<__id<__decay_t<_Env>>>>;
+ template <class _Sender, class _Env>
+ concept __use_submit = __submittable<_Sender, __submit_receiver> && __same_as<_Env, __root_env>
+ && __same_as<void, __submit_result_t<_Sender, __submit_receiver>>;
-struct start_detached_t
-{
- template <sender_in<__root_env> _Sender>
- requires __callable<apply_sender_t, __early_domain_of_t<_Sender>,
- start_detached_t, _Sender>
- void operator()(_Sender&& __sndr) const
- {
- auto __domain = __get_early_domain(__sndr);
+ struct start_detached_t {
+ template <sender_in<__root_env> _Sender>
+ requires __callable<
+ apply_sender_t,
+ __late_domain_of_t<_Sender, __root_env, __early_domain_of_t<_Sender>>,
+ start_detached_t,
+ _Sender
+ >
+ void operator()(_Sender&& __sndr) const {
+ auto __domain = __get_late_domain(__sndr, __root_env{}, __get_early_domain(__sndr));
stdexec::apply_sender(__domain, *this, static_cast<_Sender&&>(__sndr));
- }
+ }
- template <class _Env, sender_in<__as_root_env_t<_Env>> _Sender>
- requires __callable<apply_sender_t,
- __late_domain_of_t<_Sender, __as_root_env_t<_Env>>,
- start_detached_t, _Sender, __as_root_env_t<_Env>>
- void operator()(_Sender&& __sndr, _Env&& __env) const
- {
- auto __domain = __get_late_domain(__sndr, __env);
- stdexec::apply_sender(__domain, *this, static_cast<_Sender&&>(__sndr),
- __as_root_env(static_cast<_Env&&>(__env)));
- }
+ template <class _Env, sender_in<__as_root_env_t<_Env>> _Sender>
+ requires __callable<
+ apply_sender_t,
+ __late_domain_of_t<_Sender, __as_root_env_t<_Env>, __early_domain_of_t<_Sender>>,
+ start_detached_t,
+ _Sender,
+ __as_root_env_t<_Env>
+ >
+ void operator()(_Sender&& __sndr, _Env&& __env) const {
+ auto __env2 = __as_root_env(static_cast<_Env&&>(__env));
+ auto __domain = __get_late_domain(__sndr, __env2, __get_early_domain(__sndr));
+ stdexec::apply_sender(__domain, *this, static_cast<_Sender&&>(__sndr), __env2);
+ }
- using _Sender = __0;
- using __legacy_customizations_t =
- __types<tag_invoke_t(start_detached_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(const _Sender&)),
- _Sender),
- tag_invoke_t(start_detached_t, _Sender)>;
+ // Below is the default implementation for `start_detached`.
+ template <class _Sender, class _Env = __root_env>
+ requires sender_in<_Sender, __as_root_env_t<_Env>>
+ void apply_sender(_Sender&& __sndr, _Env&& __env = {}) const noexcept(false) {
+ using _Op = __operation<__cvref_id<_Sender>, __id<__decay_t<_Env>>>;
- template <class _Sender, class _Env = __root_env>
- requires sender_to<_Sender, __detached_receiver_t<_Env>>
- void apply_sender(_Sender&& __sndr, _Env&& __env = {}) const
- {
- __submit(static_cast<_Sender&&>(__sndr),
- __detached_receiver_t<_Env>{static_cast<_Env&&>(__env)});
- }
-};
-} // namespace __start_detached
+#if !STDEXEC_APPLE_CLANG() // There seems to be a codegen bug in apple clang that causes
+ // `start_detached` to segfault when the code path below is
+ // taken.
+ // BUGBUG NOT TO SPEC: the use of the non-standard `submit` algorithm here is a
+ // conforming extension.
+ if constexpr (__use_submit<_Sender, _Env>) {
+ // If submit(sndr, rcvr) returns void, then no state needs to be kept alive
+ // for the operation. We can just call submit and return.
+ stdexec::__submit::__submit(static_cast<_Sender&&>(__sndr), __submit_receiver{});
+ } else
+#endif
+ if constexpr (__callable<get_allocator_t, _Env>) {
+ // Use the provided allocator if any to allocate the operation state.
+ auto __alloc = get_allocator(__env);
+ using _Alloc = decltype(__alloc);
+ using _OpAlloc = std::allocator_traits<_Alloc>::template rebind_alloc<_Op>;
+ // We use the allocator to allocate the op state and also to construct it.
+ _OpAlloc __op_alloc{__alloc};
+ _Op* __op = std::allocator_traits<_OpAlloc>::allocate(__op_alloc, 1);
+ __scope_guard __g{[__op, &__op_alloc]() noexcept {
+ std::allocator_traits<_OpAlloc>::deallocate(__op_alloc, __op, 1);
+ }};
+ // This can potentially throw. If it does, the scope guard will deallocate the
+ // storage automatically.
+ std::allocator_traits<_OpAlloc>::construct(
+ __op_alloc, __op, static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env));
+ // The operation state is now constructed, dismiss the scope guard.
+ __g.__dismiss();
+ } else {
+ // The caller did not provide an allocator, so we use the default allocator.
+ [[maybe_unused]]
+ _Op* __op = new _Op(static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env));
+ // The operation has now started and is responsible for deleting itself when it
+ // completes.
+ }
+ }
+ };
+ } // namespace __start_detached
-using __start_detached::start_detached_t;
-inline constexpr start_detached_t start_detached{};
+ using __start_detached::start_detached_t;
+ inline constexpr start_detached_t start_detached{};
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__starts_on.hpp b/include/sdbusplus/async/stdexec/__detail/__starts_on.hpp
index 8a2135a..6c5c8ab 100644
--- a/include/sdbusplus/async/stdexec/__detail/__starts_on.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__starts_on.hpp
@@ -22,106 +22,80 @@
#include "__diagnostics.hpp"
#include "__domain.hpp"
#include "__env.hpp"
+#include "__just.hpp"
#include "__let.hpp"
-#include "__meta.hpp"
#include "__schedulers.hpp"
#include "__senders_core.hpp"
-#include "__tag_invoke.hpp"
#include "__transform_sender.hpp"
#include "__utility.hpp"
-namespace stdexec
-{
-namespace __detail
-{
-//! Constant function object always returning `__val_`.
-template <class _Ty, class = __name_of<__decay_t<_Ty>>>
-struct __always
-{
- _Ty __val_;
+namespace stdexec {
+ namespace __detail {
+ //! Constant function object always returning `__val_`.
+ template <class _Ty, class = __name_of<__decay_t<_Ty>>>
+ struct __always {
+ _Ty __val_;
- auto operator()() noexcept -> _Ty
- {
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr auto operator()() noexcept(__nothrow_constructible_from<_Ty, _Ty>) -> _Ty {
return static_cast<_Ty&&>(__val_);
- }
-};
+ }
+ };
-template <class _Ty>
-__always(_Ty) -> __always<_Ty>;
-} // namespace __detail
+ template <class _Ty>
+ __always(_Ty) -> __always<_Ty>;
+ } // namespace __detail
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.starts_on]
-namespace __starts_on_ns
-{
-struct starts_on_t
-{
- using _Sender = __1;
- using _Scheduler = __0;
- using __legacy_customizations_t =
- __types<tag_invoke_t(starts_on_t, _Scheduler, _Sender)>;
-
- template <scheduler _Scheduler, sender _Sender>
- auto operator()(_Scheduler&& __sched, _Sender&& __sndr) const
- -> __well_formed_sender auto
- {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.starts_on]
+ namespace __starts_on_ns {
+ struct starts_on_t {
+ template <scheduler _Scheduler, sender _Sender>
+ auto operator()(_Scheduler&& __sched, _Sender&& __sndr) const -> __well_formed_sender auto {
auto __domain = query_or(get_domain, __sched, default_domain());
return stdexec::transform_sender(
- __domain,
- __make_sexpr<starts_on_t>(static_cast<_Scheduler&&>(__sched),
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<starts_on_t>(
+ static_cast<_Scheduler&&>(__sched), static_cast<_Sender&&>(__sndr)));
+ }
- template <class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto __transform_env_fn(_Env&& __env) noexcept
- {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static auto __transform_env_fn(_Env&& __env) noexcept {
return [&](__ignore, auto __sched, __ignore) noexcept {
- return __detail::__mkenv_sched(static_cast<_Env&&>(__env), __sched);
+ return __env::__join(__sched_env{__sched}, static_cast<_Env&&>(__env));
};
- }
+ }
- template <class _Sender, class _Env>
- static auto transform_env(const _Sender& __sndr, _Env&& __env) noexcept
- {
- return __sexpr_apply(__sndr,
- __transform_env_fn(static_cast<_Env&&>(__env)));
- }
+ template <class _Sender, class _Env>
+ static auto transform_env(const _Sender& __sndr, _Env&& __env) noexcept {
+ return __sexpr_apply(__sndr, __transform_env_fn(static_cast<_Env&&>(__env)));
+ }
- template <class _Sender, class _Env>
- static auto transform_sender(_Sender&& __sndr, const _Env&)
- {
+ template <class _Sender, class _Env>
+ static auto transform_sender(_Sender&& __sndr, const _Env&) {
return __sexpr_apply(
- static_cast<_Sender&&>(__sndr),
- []<class _Data, class _Child>(__ignore, _Data&& __data,
- _Child&& __child) {
- // This is the heart of starts_on: It uses `let_value` to
- // schedule `__child` on the given scheduler:
- return let_value(
- schedule(__data),
- __detail::__always{static_cast<_Child&&>(__child)});
- });
- }
-};
-} // namespace __starts_on_ns
-
-using __starts_on_ns::starts_on_t;
-inline constexpr starts_on_t starts_on{};
-
-using on_t = starts_on_t;
-inline constexpr starts_on_t on{};
-
-using start_on_t = starts_on_t;
-inline constexpr starts_on_t start_on{};
-
-template <>
-struct __sexpr_impl<starts_on_t> : __sexpr_defaults
-{
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {
- return {};
+ static_cast<_Sender&&>(__sndr),
+ []<class _Data, class _Child>(__ignore, _Data&& __data, _Child&& __child) -> auto {
+ // This is the heart of starts_on: It uses `let_value` to schedule `__child` on the given scheduler:
+ return let_value(
+ continues_on(just(), __data), __detail::__always{static_cast<_Child&&>(__child)});
+ });
+ }
};
-};
+ } // namespace __starts_on_ns
+
+ using __starts_on_ns::starts_on_t;
+ inline constexpr starts_on_t starts_on{};
+
+ using start_on_t = starts_on_t;
+ inline constexpr starts_on_t start_on{};
+
+ template <>
+ struct __sexpr_impl<starts_on_t> : __sexpr_defaults {
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
+ return {};
+ };
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__stop_token.hpp b/include/sdbusplus/async/stdexec/__detail/__stop_token.hpp
index e0b7065..e4df4fa 100644
--- a/include/sdbusplus/async/stdexec/__detail/__stop_token.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__stop_token.hpp
@@ -16,48 +16,62 @@
*/
#pragma once
-#include "__concepts.hpp"
#include "__execution_fwd.hpp"
-namespace stdexec
-{
-namespace __stok
-{
-template <template <class> class>
-struct __check_type_alias_exists;
-} // namespace __stok
+#include "__concepts.hpp"
-template <class _Token, class _Callback>
-using stop_callback_for_t = typename _Token::template callback_type<_Callback>;
+namespace stdexec {
+ namespace __stok {
+ template <template <class> class>
+ struct __check_type_alias_exists;
+ } // namespace __stok
-template <class _Token>
-concept stoppable_token =
- __nothrow_copy_constructible<_Token> //
- && __nothrow_move_constructible<_Token> //
- && equality_comparable<_Token> //
- && requires(const _Token& __token) {
- { __token.stop_requested() } noexcept -> __boolean_testable_;
- { __token.stop_possible() } noexcept -> __boolean_testable_;
+ template <class _Token, class _Callback>
+ using stop_callback_for_t = _Token::template callback_type<_Callback>;
+
+ template <class _Token>
+ concept stoppable_token =
+ __nothrow_copy_constructible<_Token> && __nothrow_move_constructible<_Token>
+ && equality_comparable<_Token> && requires(const _Token& __token) {
+ { __token.stop_requested() } noexcept -> __boolean_testable_;
+ { __token.stop_possible() } noexcept -> __boolean_testable_;
// workaround ICE in appleclang 13.1
#if !defined(__clang__)
- typename __stok::__check_type_alias_exists<
- _Token::template callback_type>;
+ typename __stok::__check_type_alias_exists<_Token::template callback_type>;
#endif
};
-template <class _Token, typename _Callback, typename _Initializer = _Callback>
-concept stoppable_token_for =
- stoppable_token<_Token> //
- && __callable<_Callback> //
- && requires { typename stop_callback_for_t<_Token, _Callback>; } &&
- constructible_from<_Callback, _Initializer> &&
- constructible_from<stop_callback_for_t<_Token, _Callback>, const _Token&,
- _Initializer>;
+ template <class _Token, typename _Callback, typename _Initializer = _Callback>
+ concept stoppable_token_for =
+ stoppable_token<_Token> && __callable<_Callback>
+ && requires { typename stop_callback_for_t<_Token, _Callback>; }
+ && constructible_from<_Callback, _Initializer>
+ && constructible_from<stop_callback_for_t<_Token, _Callback>, const _Token&, _Initializer>;
-template <class _Token>
-concept unstoppable_token = //
- stoppable_token<_Token> && //
- requires {
- { _Token::stop_possible() } -> __boolean_testable_;
- } && (!_Token::stop_possible());
+ template <class _Token>
+ concept unstoppable_token = stoppable_token<_Token> && requires {
+ { _Token::stop_possible() } -> __boolean_testable_;
+ } && (!_Token::stop_possible());
+
+ // [stoptoken.never], class never_stop_token
+ struct never_stop_token {
+ private:
+ struct __callback_type {
+ explicit __callback_type(never_stop_token, __ignore) noexcept {
+ }
+ };
+ public:
+ template <class>
+ using callback_type = __callback_type;
+
+ static constexpr auto stop_requested() noexcept -> bool {
+ return false;
+ }
+
+ static constexpr auto stop_possible() noexcept -> bool {
+ return false;
+ }
+
+ auto operator==(const never_stop_token&) const noexcept -> bool = default;
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__stopped_as_error.hpp b/include/sdbusplus/async/stdexec/__detail/__stopped_as_error.hpp
index f222fc9..6f6af47 100644
--- a/include/sdbusplus/async/stdexec/__detail/__stopped_as_error.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__stopped_as_error.hpp
@@ -19,39 +19,33 @@
// include these after __execution_fwd.hpp
#include "__concepts.hpp"
-#include "__just.hpp"
-#include "__let.hpp"
#include "__sender_adaptor_closure.hpp"
+#include "__let.hpp"
+#include "__just.hpp"
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.stopped_as_error]
-namespace __sae
-{
-struct stopped_as_error_t
-{
- template <sender _Sender, __movable_value _Error>
- auto operator()(_Sender&& __sndr, _Error __err) const
- {
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.stopped_as_error]
+ namespace __sae {
+ struct stopped_as_error_t {
+ template <sender _Sender, __movable_value _Error>
+ auto operator()(_Sender&& __sndr, _Error __err) const {
return let_stopped(
- static_cast<_Sender&&>(__sndr),
- [__err2 = static_cast<_Error&&>(__err)]() mutable noexcept(
- __nothrow_move_constructible<_Error>) {
- return just_error(static_cast<_Error&&>(__err2));
- });
- }
+ static_cast<_Sender&&>(__sndr),
+ [__err2 = static_cast<_Error&&>(__err)]() mutable noexcept(
+ __nothrow_move_constructible<_Error>) {
+ return just_error(static_cast<_Error&&>(__err2));
+ });
+ }
- template <__movable_value _Error>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Error __err) const
- -> __binder_back<stopped_as_error_t, _Error>
- {
+ template <__movable_value _Error>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Error __err) const -> __binder_back<stopped_as_error_t, _Error> {
return {{static_cast<_Error&&>(__err)}, {}, {}};
- }
-};
-} // namespace __sae
+ }
+ };
+ } // namespace __sae
-using __sae::stopped_as_error_t;
-inline constexpr stopped_as_error_t stopped_as_error{};
+ using __sae::stopped_as_error_t;
+ inline constexpr stopped_as_error_t stopped_as_error{};
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__stopped_as_optional.hpp b/include/sdbusplus/async/stdexec/__detail/__stopped_as_optional.hpp
index c84d59e..1f4bfa7 100644
--- a/include/sdbusplus/async/stdexec/__detail/__stopped_as_optional.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__stopped_as_optional.hpp
@@ -21,9 +21,9 @@
#include "__basic_sender.hpp"
#include "__completion_signatures.hpp"
#include "__concepts.hpp"
-#include "__env.hpp"
-#include "__receivers.hpp"
+#include "__diagnostics.hpp"
#include "__sender_adaptor_closure.hpp"
+#include "__receivers.hpp"
#include "__senders_core.hpp"
#include "__transform_completion_signatures.hpp"
#include "__type_traits.hpp"
@@ -31,95 +31,94 @@
#include <exception>
#include <optional>
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.stopped_as_optional]
-namespace __sao
-{
-struct stopped_as_optional_t
-{
- template <sender _Sender>
- auto operator()(_Sender&& __sndr) const
- {
- return __make_sexpr<stopped_as_optional_t>(
- __(), static_cast<_Sender&&>(__sndr));
- }
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.stopped_as_optional]
+ namespace __sao {
+ struct _SENDER_MUST_HAVE_EXACTLY_ONE_VALUE_COMPLETION_WITH_ONE_ARGUMENT_;
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()() const noexcept -> __binder_back<stopped_as_optional_t>
- {
+ struct stopped_as_optional_t {
+ template <sender _Sender>
+ auto operator()(_Sender&& __sndr) const {
+ return __make_sexpr<stopped_as_optional_t>(__(), static_cast<_Sender&&>(__sndr));
+ }
+
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()() const noexcept -> __binder_back<stopped_as_optional_t> {
return {{}, {}, {}};
- }
-};
+ }
+ };
-struct __stopped_as_optional_impl : __sexpr_defaults
-{
- template <class... _Tys>
+ struct __stopped_as_optional_impl : __sexpr_defaults {
+ template <class... _Tys>
requires(sizeof...(_Tys) == 1)
- using __set_value_t =
- completion_signatures<set_value_t(std::optional<__decay_t<_Tys>>...)>;
+ using __set_value_t = completion_signatures<set_value_t(std::optional<__decay_t<_Tys>>...)>;
- template <class _Ty>
- using __set_error_t = completion_signatures<set_error_t(_Ty)>;
+ template <class _Ty>
+ using __set_error_t = completion_signatures<set_error_t(_Ty)>;
- static constexpr auto get_completion_signatures = //
- []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept //
- -> transform_completion_signatures<
- __completion_signatures_of_t<__child_of<_Self>, _Env...>,
+ static constexpr auto get_completion_signatures =
+ []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept
+ requires __mvalid<__completion_signatures_of_t, __child_of<_Self>, _Env...>
+ {
+ static_assert(sender_expr_for<_Self, stopped_as_optional_t>);
+ using _Completions = __completion_signatures_of_t<__child_of<_Self>, _Env...>;
+ if constexpr (!__valid_completion_signatures<_Completions>) {
+ return _Completions();
+ } else if constexpr (__single_value_sender<__child_of<_Self>, _Env...>) {
+ return transform_completion_signatures<
+ _Completions,
completion_signatures<set_error_t(std::exception_ptr)>,
- __set_value_t, __set_error_t, completion_signatures<>> {
- static_assert(sender_expr_for<_Self, stopped_as_optional_t>);
- return {};
- };
+ __set_value_t,
+ __set_error_t,
+ completion_signatures<>
+ >();
+ } else {
+ return _ERROR_<
+ _WHAT_<>(_SENDER_MUST_HAVE_EXACTLY_ONE_VALUE_COMPLETION_WITH_ONE_ARGUMENT_),
+ _IN_ALGORITHM_(stopped_as_optional_t),
+ _WITH_SENDER_<__child_of<_Self>>
+ >();
+ }
+ };
- static constexpr auto get_state = //
- []<class _Self, class _Receiver>(_Self&&, _Receiver&) noexcept
- requires __single_value_sender<__child_of<_Self>, env_of_t<_Receiver>>
- {
- static_assert(sender_expr_for<_Self, stopped_as_optional_t>);
- using _Value = __decay_t<
- __single_sender_value_t<__child_of<_Self>, env_of_t<_Receiver>>>;
- return __mtype<_Value>();
- };
+ static constexpr auto get_state =
+ []<class _Self, class _Receiver>(_Self&&, _Receiver&) noexcept {
+ static_assert(sender_expr_for<_Self, stopped_as_optional_t>);
+ using _Value = __decay_t<__single_sender_value_t<__child_of<_Self>, env_of_t<_Receiver>>>;
+ return __mtype<_Value>();
+ };
- static constexpr auto complete = //
+ static constexpr auto complete =
[]<class _State, class _Receiver, class _Tag, class... _Args>(
- __ignore, _State&, _Receiver& __rcvr, _Tag,
- _Args&&... __args) noexcept -> void {
- if constexpr (__same_as<_Tag, set_value_t>)
- {
- try
- {
- static_assert(constructible_from<__t<_State>, _Args...>);
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr),
- std::optional<__t<_State>>{
- static_cast<_Args&&>(__args)...});
- }
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- std::current_exception());
- }
+ __ignore,
+ _State&,
+ _Receiver& __rcvr,
+ _Tag,
+ _Args&&... __args) noexcept -> void {
+ if constexpr (__same_as<_Tag, set_value_t>) {
+ STDEXEC_TRY {
+ static_assert(constructible_from<__t<_State>, _Args...>);
+ stdexec::set_value(
+ static_cast<_Receiver&&>(__rcvr),
+ std::optional<__t<_State>>{static_cast<_Args&&>(__args)...});
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
+ }
+ } else if constexpr (__same_as<_Tag, set_error_t>) {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
+ } else {
+ stdexec::set_value(
+ static_cast<_Receiver&&>(__rcvr), std::optional<__t<_State>>{std::nullopt});
}
- else if constexpr (__same_as<_Tag, set_error_t>)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
- }
- else
- {
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr),
- std::optional<__t<_State>>{std::nullopt});
- }
+ };
};
-};
-} // namespace __sao
+ } // namespace __sao
-using __sao::stopped_as_optional_t;
-inline constexpr stopped_as_optional_t stopped_as_optional{};
+ using __sao::stopped_as_optional_t;
+ inline constexpr stopped_as_optional_t stopped_as_optional{};
-template <>
-struct __sexpr_impl<stopped_as_optional_t> : __sao::__stopped_as_optional_impl
-{};
+ template <>
+ struct __sexpr_impl<stopped_as_optional_t> : __sao::__stopped_as_optional_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__submit.hpp b/include/sdbusplus/async/stdexec/__detail/__submit.hpp
index 20fd264..ddc964b 100644
--- a/include/sdbusplus/async/stdexec/__detail/__submit.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__submit.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021-2024 NVIDIA Corporation
+ * Copyright (c) 2021-2025 NVIDIA Corporation
*
* Licensed under the Apache License Version 2.0 with LLVM Exceptions
* (the "License"); you may not use this file except in compliance with
@@ -15,153 +15,181 @@
*/
#pragma once
-#include "__concepts.hpp"
-#include "__env.hpp"
#include "__execution_fwd.hpp"
-#include "__meta.hpp"
-#include "__receivers.hpp"
+
+#include "__manual_lifetime.hpp"
+#include "__operation_states.hpp"
+#include "__optional.hpp"
#include "__senders.hpp"
#include "__type_traits.hpp"
-#include <memory>
+namespace stdexec {
+ namespace __submit {
+ template <class _Sender, class _Receiver>
+ concept __has_memfn = requires(_Sender && (*__sndr)(), _Receiver && (*__rcvr)()) {
+ __sndr().submit(__rcvr());
+ };
-namespace stdexec
-{
-namespace
-{
-inline constexpr auto __ref = []<class _Ty>(_Ty& __ty) noexcept {
- return [__ty = &__ty]() noexcept -> decltype(auto) { return (*__ty); };
-};
-} // namespace
+ template <class _Sender, class _Receiver>
+ concept __has_static_memfn = requires(_Sender && (*__sndr)(), _Receiver && (*__rcvr)()) {
+ __decay_t<_Sender>::submit(__sndr(), __rcvr());
+ };
-template <class _Ty>
-using __ref_t = decltype(__ref(__declval<_Ty&>()));
+ // submit is a combination of connect and start. it is customizable for times when it
+ // can be done more efficiently than by calling connect and start directly.
+ struct __submit_t {
+ struct __void { };
-/////////////////////////////////////////////////////////////////////////////
-// NOT TO SPEC: __submit
-namespace __submit_
-{
-template <class _OpRef>
-struct __receiver
-{
- using receiver_concept = receiver_t;
- using __t = __receiver;
- using __id = __receiver;
-
- using _Operation = __decay_t<__call_result_t<_OpRef>>;
- using _Receiver = stdexec::__t<__mapply<__q<__msecond>, _Operation>>;
-
- _OpRef __opref_;
-
- void __delete_op() noexcept
- {
- _Operation* __op = &__opref_();
- if constexpr (__callable<get_allocator_t, env_of_t<_Receiver>>)
- {
- auto&& __env = stdexec::get_env(__op->__rcvr_);
- auto __alloc = stdexec::get_allocator(__env);
- using _Alloc = decltype(__alloc);
- using _OpAlloc = typename std::allocator_traits<
- _Alloc>::template rebind_alloc<_Operation>;
- _OpAlloc __op_alloc{__alloc};
- std::allocator_traits<_OpAlloc>::destroy(__op_alloc, __op);
- std::allocator_traits<_OpAlloc>::deallocate(__op_alloc, __op, 1);
+ // This implementation is used if the sender has a non-static submit member function.
+ template <class _Sender, class _Receiver, class _Default = __void>
+ requires sender_to<_Sender, _Receiver> && __submit::__has_memfn<_Sender, _Receiver>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto
+ operator()(_Sender&& __sndr, _Receiver __rcvr, [[maybe_unused]] _Default __def = {}) const
+ noexcept(noexcept(static_cast<_Sender&&>(__sndr)
+ .submit(static_cast<_Receiver&&>(__rcvr)))) {
+ using __result_t = decltype(static_cast<_Sender&&>(__sndr)
+ .submit(static_cast<_Receiver&&>(__rcvr)));
+ if constexpr (__same_as<__result_t, void> && !__same_as<_Default, __void>) {
+ static_cast<_Sender&&>(__sndr).submit(static_cast<_Receiver&&>(__rcvr));
+ return __def;
+ } else {
+ return static_cast<_Sender&&>(__sndr).submit(static_cast<_Receiver&&>(__rcvr));
}
- else
- {
- delete __op;
+ }
+
+ // This implementation is used if the sender has a static submit member function.
+ template <class _Sender, class _Receiver, class _Default = __void>
+ requires sender_to<_Sender, _Receiver> && __submit::__has_static_memfn<_Sender, _Receiver>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto
+ operator()(_Sender&& __sndr, _Receiver __rcvr, [[maybe_unused]] _Default __def = {}) const
+ noexcept(noexcept(
+ __sndr.submit(static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr)))) {
+ using __result_t =
+ decltype(__sndr.submit(static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr)));
+ if constexpr (__same_as<__result_t, void> && !__same_as<_Default, __void>) {
+ __sndr.submit(static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr));
+ return __def;
+ } else {
+ return __sndr.submit(static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr));
}
+ }
+ };
+
+ inline constexpr __submit_t __submit{};
+ } // namespace __submit
+
+ template <class _Sender, class _Receiver, class _Default = __submit::__submit_t::__void>
+ using __submit_result_t = __call_result_t<__submit::__submit_t, _Sender, _Receiver, _Default>;
+
+ template <class _Sender, class _Receiver>
+ concept __submittable = requires(_Sender&& __sndr, _Receiver&& __rcvr) {
+ __submit::__submit(static_cast<_Sender &&>(__sndr), static_cast<_Receiver &&>(__rcvr));
+ };
+
+ template <class _Sender, class _Receiver>
+ concept __nothrow_submittable =
+ __submittable<_Sender, _Receiver> && requires(_Sender&& __sndr, _Receiver&& __rcvr) {
+ {
+ __submit::__submit(static_cast<_Sender &&>(__sndr), static_cast<_Receiver &&>(__rcvr))
+ } noexcept;
+ };
+
+ enum class __submit_result_kind {
+ __connect,
+ __submit,
+ __submit_void,
+ __submit_nothrow,
+ };
+
+ template <class _Sender, class _Receiver>
+ constexpr auto __get_submit_result_kind() noexcept -> __submit_result_kind {
+ if constexpr (__submittable<_Sender, _Receiver>) {
+ using __result_t = __submit_result_t<_Sender, _Receiver>;
+ constexpr std::size_t __opstate_size = sizeof(connect_result_t<_Sender, _Receiver>);
+
+ if constexpr (std::is_void_v<__result_t>) {
+ return __submit_result_kind::__submit_void;
+ } else if constexpr (__nothrow_submittable<_Sender, _Receiver>) {
+ return __opstate_size > sizeof(__result_t) ? __submit_result_kind::__submit_nothrow
+ : __submit_result_kind::__connect;
+ } else {
+ return __opstate_size > sizeof(__optional<__result_t>) ? __submit_result_kind::__submit
+ : __submit_result_kind::__connect;
+ }
+ }
+ return __submit_result_kind::__connect;
+ }
+
+ template <
+ class _Sender,
+ class _Receiver,
+ __submit_result_kind _Kind = __get_submit_result_kind<_Sender, _Receiver>()
+ >
+ struct submit_result {
+ using __result_t = connect_result_t<_Sender, _Receiver>;
+
+ explicit submit_result(_Sender&& __sndr, _Receiver&& __rcvr)
+ noexcept(__nothrow_connectable<_Sender, _Receiver>)
+ : __result_(connect(static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr))) {
}
- // Forward all the receiver ops, and delete the operation state.
- template <class... _As>
- void set_value(_As&&... __as) noexcept
- {
- stdexec::set_value(static_cast<_Receiver&&>(__opref_().__rcvr_),
- static_cast<_As&&>(__as)...);
- __delete_op();
+ void submit(_Sender&&, _Receiver&&) noexcept {
+ stdexec::start(__result_);
}
- template <class _Error>
- void set_error(_Error&& __err) noexcept
- {
- stdexec::set_error(static_cast<_Receiver&&>(__opref_().__rcvr_),
- static_cast<_Error&&>(__err));
- __delete_op();
+ __result_t __result_;
+ };
+
+ template <class _Sender, class _Receiver>
+ struct submit_result<_Sender, _Receiver, __submit_result_kind::__submit> {
+ using __result_t = __submit_result_t<_Sender, _Receiver>;
+
+ submit_result(_Sender&&, _Receiver&&) noexcept {
}
- void set_stopped() noexcept
- {
- stdexec::set_stopped(__opref_().__rcvr_);
- __delete_op();
+ void submit(_Sender&& __sndr, _Receiver&& __rcvr) {
+ __result_.__emplace_from(
+ __submit::__submit, static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr));
}
- // Forward all receiever queries.
- auto get_env() const noexcept -> env_of_t<_Receiver&>
- {
- return stdexec::get_env(__opref_().__rcvr_);
+ __optional<__result_t> __result_;
+ };
+
+ template <class _Sender, class _Receiver>
+ struct submit_result<_Sender, _Receiver, __submit_result_kind::__submit_void> {
+ using __result_t = __submit_result_t<_Sender, _Receiver>;
+
+ explicit submit_result(_Sender&&, _Receiver&&) noexcept {
}
-};
-template <class _SenderId, class _ReceiverId>
-struct __operation
-{
- using _Sender = stdexec::__t<_SenderId>;
- using _Receiver = stdexec::__t<_ReceiverId>;
- using __receiver_t = __receiver<__ref_t<__operation>>;
-
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Receiver __rcvr_;
- connect_result_t<_Sender, __receiver_t> __op_state_;
-
- __operation(_Sender&& __sndr, _Receiver __rcvr) :
- __rcvr_(static_cast<_Receiver&&>(__rcvr)),
- __op_state_(
- connect(static_cast<_Sender&&>(__sndr), __receiver_t{__ref(*this)}))
- {}
-};
-
-struct __submit_t
-{
- template <receiver _Receiver, sender_to<_Receiver> _Sender>
- void operator()(_Sender&& __sndr, _Receiver __rcvr) const noexcept(false)
- {
- if constexpr (__callable<get_allocator_t, env_of_t<_Receiver>>)
- {
- auto&& __env = get_env(__rcvr);
- auto __alloc = get_allocator(__env);
- using _Alloc = decltype(__alloc);
- using _Op = __operation<__id<_Sender>, __id<_Receiver>>;
- using _OpAlloc = typename std::allocator_traits<
- _Alloc>::template rebind_alloc<_Op>;
- _OpAlloc __op_alloc{__alloc};
- auto __op =
- std::allocator_traits<_OpAlloc>::allocate(__op_alloc, 1);
- try
- {
- std::allocator_traits<_OpAlloc>::construct(
- __op_alloc, __op, static_cast<_Sender&&>(__sndr),
- static_cast<_Receiver&&>(__rcvr));
- stdexec::start(__op->__op_state_);
- }
- catch (...)
- {
- std::allocator_traits<_OpAlloc>::deallocate(__op_alloc, __op,
- 1);
- throw;
- }
- }
- else
- {
- start((new __operation<__id<_Sender>, __id<_Receiver>>{
- static_cast<_Sender&&>(__sndr),
- static_cast<_Receiver&&>(__rcvr)})
- ->__op_state_);
- }
+ void submit(_Sender&& __sndr, _Receiver&& __rcvr)
+ noexcept(__nothrow_submittable<_Sender, _Receiver>) {
+ __submit::__submit(static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr));
}
-};
-} // namespace __submit_
+ };
-using __submit_::__submit_t;
-inline constexpr __submit_t __submit{};
+ template <class _Sender, class _Receiver>
+ struct submit_result<_Sender, _Receiver, __submit_result_kind::__submit_nothrow> {
+ using __result_t = __submit_result_t<_Sender, _Receiver>;
+
+ submit_result(_Sender&&, _Receiver&&) noexcept {
+ }
+
+ void submit(_Sender&& __sndr, _Receiver&& __rcvr) noexcept {
+ __result_.__construct_from(
+ __submit::__submit, static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr));
+ }
+
+ ~submit_result() {
+ __result_.__destroy();
+ }
+
+ __manual_lifetime<__result_t> __result_;
+ };
+
+ template <class _Sender, class _Receiver>
+ submit_result(_Sender&&, _Receiver) -> submit_result<_Sender, _Receiver>;
+
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__sync_wait.hpp b/include/sdbusplus/async/stdexec/__detail/__sync_wait.hpp
index d1e016d..35bf13f 100644
--- a/include/sdbusplus/async/stdexec/__detail/__sync_wait.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__sync_wait.hpp
@@ -19,267 +19,233 @@
// include these after __execution_fwd.hpp
#include "__concepts.hpp"
-#include "__cpo.hpp"
-#include "__debug.hpp"
+#include "__debug.hpp" // IWYU pragma: keep
#include "__diagnostics.hpp"
#include "__domain.hpp"
#include "__env.hpp"
#include "__into_variant.hpp"
#include "__meta.hpp"
-#include "__receivers.hpp"
-#include "__run_loop.hpp"
#include "__senders.hpp"
+#include "__receivers.hpp"
#include "__transform_completion_signatures.hpp"
#include "__transform_sender.hpp"
+#include "__run_loop.hpp"
#include "__type_traits.hpp"
#include <exception>
-#include <optional>
#include <system_error>
+#include <optional>
#include <tuple>
#include <variant>
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.consumers.sync_wait]
-// [execution.senders.consumers.sync_wait_with_variant]
-namespace __sync_wait
-{
-struct __env
-{
- run_loop* __loop_ = nullptr;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.consumers.sync_wait]
+ // [execution.senders.consumers.sync_wait_with_variant]
+ namespace __sync_wait {
+ struct __env {
+ using __t = __env;
+ using __id = __env;
- auto query(get_scheduler_t) const noexcept -> run_loop::__scheduler
- {
+ run_loop* __loop_ = nullptr;
+
+ [[nodiscard]]
+ auto query(get_scheduler_t) const noexcept -> run_loop::__scheduler {
return __loop_->get_scheduler();
- }
+ }
- auto query(get_delegation_scheduler_t) const noexcept
- -> run_loop::__scheduler
- {
+ [[nodiscard]]
+ auto query(get_delegation_scheduler_t) const noexcept -> run_loop::__scheduler {
return __loop_->get_scheduler();
- }
+ }
- // static constexpr auto query(__debug::__is_debug_env_t) noexcept -> bool {
- // return true;
- // }
-};
+ [[nodiscard]]
+ constexpr auto query(__root_t) const noexcept -> bool {
+ return true;
+ }
-// What should sync_wait(just_stopped()) return?
-template <class _Sender, class _Continuation>
-using __sync_wait_result_impl = //
- __value_types_of_t<_Sender, __env,
- __mtransform<__q<__decay_t>, _Continuation>,
- __q<__msingle>>;
+ // static constexpr auto query(__debug::__is_debug_env_t) noexcept -> bool
+ // {
+ // return true;
+ // }
+ };
-template <class _Sender>
-using __sync_wait_result_t =
- __mtry_eval<__sync_wait_result_impl, _Sender, __qq<std::tuple>>;
+ // What should sync_wait(just_stopped()) return?
+ template <class _Sender, class _Continuation>
+ using __sync_wait_result_impl = __value_types_of_t<
+ _Sender,
+ __env,
+ __mtransform<__q<__decay_t>, _Continuation>,
+ __q<__msingle>
+ >;
-template <class _Sender>
-using __sync_wait_with_variant_result_t =
- __mtry_eval<__sync_wait_result_impl, __result_of<into_variant, _Sender>,
- __q<__midentity>>;
+ template <class _Sender>
+ using __sync_wait_result_t = __mtry_eval<__sync_wait_result_impl, _Sender, __qq<std::tuple>>;
-struct __state
-{
- std::exception_ptr __eptr_;
- run_loop __loop_;
-};
+ template <class _Sender>
+ using __sync_wait_with_variant_result_t =
+ __mtry_eval<__sync_wait_result_impl, __result_of<into_variant, _Sender>, __q<__midentity>>;
-template <class... _Values>
-struct __receiver
-{
- struct __t
- {
+ struct __state {
+ std::exception_ptr __eptr_;
+ run_loop __loop_;
+ };
+
+ template <class... _Values>
+ struct __receiver {
+ struct __t {
using receiver_concept = receiver_t;
using __id = __receiver;
__state* __state_;
std::optional<std::tuple<_Values...>>* __values_;
template <class... _As>
- requires constructible_from<std::tuple<_Values...>, _As...>
- void set_value(_As&&... __as) noexcept
- {
- try
- {
- __values_->emplace(static_cast<_As&&>(__as)...);
- }
- catch (...)
- {
- __state_->__eptr_ = std::current_exception();
- }
- __state_->__loop_.finish();
+ requires constructible_from<std::tuple<_Values...>, _As...>
+ void set_value(_As&&... __as) noexcept {
+ STDEXEC_TRY {
+ __values_->emplace(static_cast<_As&&>(__as)...);
+ }
+ STDEXEC_CATCH_ALL {
+ __state_->__eptr_ = std::current_exception();
+ }
+ __state_->__loop_.finish();
}
template <class _Error>
- void set_error(_Error __err) noexcept
- {
- if constexpr (__same_as<_Error, std::exception_ptr>)
- {
- STDEXEC_ASSERT(
- __err != nullptr); // std::exception_ptr must not be null.
- __state_->__eptr_ = static_cast<_Error&&>(__err);
- }
- else if constexpr (__same_as<_Error, std::error_code>)
- {
- __state_->__eptr_ =
- std::make_exception_ptr(std::system_error(__err));
- }
- else
- {
- __state_->__eptr_ =
- std::make_exception_ptr(static_cast<_Error&&>(__err));
- }
- __state_->__loop_.finish();
+ void set_error(_Error __err) noexcept {
+ if constexpr (__same_as<_Error, std::exception_ptr>) {
+ STDEXEC_ASSERT(__err != nullptr); // std::exception_ptr must not be null.
+ __state_->__eptr_ = static_cast<_Error&&>(__err);
+ } else if constexpr (__same_as<_Error, std::error_code>) {
+ __state_->__eptr_ = std::make_exception_ptr(std::system_error(__err));
+ } else {
+ __state_->__eptr_ = std::make_exception_ptr(static_cast<_Error&&>(__err));
+ }
+ __state_->__loop_.finish();
}
- void set_stopped() noexcept
- {
- __state_->__loop_.finish();
+ void set_stopped() noexcept {
+ __state_->__loop_.finish();
}
- auto get_env() const noexcept -> __env
- {
- return __env{&__state_->__loop_};
+ [[nodiscard]]
+ auto get_env() const noexcept -> __env {
+ return __env{&__state_->__loop_};
}
+ };
};
-};
-template <class _Sender>
-using __receiver_t = __t<__sync_wait_result_impl<_Sender, __q<__receiver>>>;
+ template <class _Sender>
+ using __receiver_t = __t<__sync_wait_result_impl<_Sender, __q<__receiver>>>;
-// These are for hiding the metaprogramming in diagnostics
-template <class _Sender>
-struct __sync_receiver_for
-{
- using __t = __receiver_t<_Sender>;
-};
-template <class _Sender>
-using __sync_receiver_for_t = __t<__sync_receiver_for<_Sender>>;
+ // These are for hiding the metaprogramming in diagnostics
+ template <class _Sender>
+ struct __sync_receiver_for {
+ using __t = __receiver_t<_Sender>;
+ };
+ template <class _Sender>
+ using __sync_receiver_for_t = __t<__sync_receiver_for<_Sender>>;
-template <class _Sender>
-struct __value_tuple_for
-{
- using __t = __sync_wait_result_t<_Sender>;
-};
-template <class _Sender>
-using __value_tuple_for_t = __t<__value_tuple_for<_Sender>>;
+ template <class _Sender>
+ struct __value_tuple_for {
+ using __t = __sync_wait_result_t<_Sender>;
+ };
+ template <class _Sender>
+ using __value_tuple_for_t = __t<__value_tuple_for<_Sender>>;
-template <class _Sender>
-struct __variant_for
-{
- using __t = __sync_wait_with_variant_result_t<_Sender>;
-};
-template <class _Sender>
-using __variant_for_t = __t<__variant_for<_Sender>>;
+ template <class _Sender>
+ struct __variant_for {
+ using __t = __sync_wait_with_variant_result_t<_Sender>;
+ };
+ template <class _Sender>
+ using __variant_for_t = __t<__variant_for<_Sender>>;
-inline constexpr __mstring __sync_wait_context_diag = //
- "In stdexec::sync_wait()..."_mstr;
-inline constexpr __mstring __too_many_successful_completions_diag =
- "The argument to stdexec::sync_wait() is a sender that can complete successfully in more "
- "than one way. Use stdexec::sync_wait_with_variant() instead."_mstr;
+ inline constexpr __mstring __sync_wait_context_diag = "In stdexec::sync_wait()..."_mstr;
+ inline constexpr __mstring __too_many_successful_completions_diag =
+ "The argument to stdexec::sync_wait() is a sender that can complete successfully in more "
+ "than one way. Use stdexec::sync_wait_with_variant() instead."_mstr;
-template <__mstring _Context, __mstring _Diagnostic>
-struct _INVALID_ARGUMENT_TO_SYNC_WAIT_;
+ template <__mstring _Context, __mstring _Diagnostic>
+ struct _INVALID_ARGUMENT_TO_SYNC_WAIT_;
-template <__mstring _Diagnostic>
-using __invalid_argument_to_sync_wait =
- _INVALID_ARGUMENT_TO_SYNC_WAIT_<__sync_wait_context_diag, _Diagnostic>;
+ template <__mstring _Diagnostic>
+ using __invalid_argument_to_sync_wait =
+ _INVALID_ARGUMENT_TO_SYNC_WAIT_<__sync_wait_context_diag, _Diagnostic>;
-template <__mstring _Diagnostic, class _Sender, class _Env = __env>
-using __sync_wait_error =
- __mexception<__invalid_argument_to_sync_wait<_Diagnostic>,
- _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>;
+ template <__mstring _Diagnostic, class _Sender, class _Env = __env>
+ using __sync_wait_error = __mexception<
+ __invalid_argument_to_sync_wait<_Diagnostic>,
+ _WITH_SENDER_<_Sender>,
+ _WITH_ENVIRONMENT_<_Env>
+ >;
-template <class _Sender, class>
-using __too_many_successful_completions_error =
- __sync_wait_error<__too_many_successful_completions_diag, _Sender>;
+ template <class _Sender, class>
+ using __too_many_successful_completions_error =
+ __sync_wait_error<__too_many_successful_completions_diag, _Sender>;
-template <class _Sender>
-concept __valid_sync_wait_argument =
- __ok<__minvoke<__mtry_catch_q<__single_value_variant_sender_t,
- __q<__too_many_successful_completions_error>>,
- _Sender, __env>>;
+ template <class _Sender>
+ concept __valid_sync_wait_argument = __ok<__minvoke<
+ __mtry_catch_q<__single_value_variant_sender_t, __q<__too_many_successful_completions_error>>,
+ _Sender,
+ __env
+ >>;
-#if STDEXEC_EDG()
-// It requires some hoop-jumping to get the NVHPC compiler to report a
-// meaningful diagnostic for SFINAE failures.
-template <class _Sender>
-auto __diagnose_error()
-{
- if constexpr (!sender_in<_Sender, __env>)
- {
- using _Completions = __completion_signatures_of_t<_Sender, __env>;
- if constexpr (__merror<_Completions>)
- {
- return _Completions();
+ ////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.consumers.sync_wait]
+ struct sync_wait_t {
+ template <class _Sender>
+ auto operator()(_Sender&& __sndr) const {
+ if constexpr (!sender_in<_Sender, __env>) {
+ stdexec::__diagnose_sender_concept_failure<_Sender, __env>();
+ } else {
+ using __early_domain_t = __early_domain_of_t<_Sender>;
+ using __domain_t = __late_domain_of_t<_Sender, __env, __early_domain_t>;
+ constexpr auto __success_completion_count =
+ __v<value_types_of_t<_Sender, __env, __types, __msize::__f>>;
+ static_assert(
+ __success_completion_count != 0,
+ "The argument to stdexec::sync_wait() is a sender that cannot complete successfully. "
+ "stdexec::sync_wait() requires a sender that can complete successfully in exactly one "
+ "way. In other words, the sender's completion signatures must include exactly one "
+ "signature of the form `set_value_t(value-types...)`.");
+ static_assert(
+ __success_completion_count <= 1,
+ "The sender passed to stdexec::sync_wait() can complete successfully in "
+ "more than one way. Use stdexec::sync_wait_with_variant() instead.");
+ if constexpr (1 == __success_completion_count) {
+ using __sync_wait_receiver = __receiver_t<_Sender>;
+ constexpr bool __no_custom_sync_wait = __same_as<__domain_t, default_domain>;
+ if constexpr (__no_custom_sync_wait && sender_to<_Sender, __sync_wait_receiver>) {
+ // using __connect_result = connect_result_t<_Sender, __sync_wait_receiver>;
+ // if constexpr (!operation_state<__connect_result>) {
+ // static_assert(
+ // operation_state<__connect_result>,
+ // "The `connect` member function of the sender passed to stdexec::sync_wait() does "
+ // "not return an operation state. An operation state is required to have a "
+ // "no-throw .start() member function.");
+ // } else
+ {
+ // success path, dispatch to the default domain's sync_wait
+ return default_domain().apply_sender(*this, static_cast<_Sender&&>(__sndr));
+ }
+ } else if constexpr (__no_custom_sync_wait) {
+ static_assert(
+ sender_to<_Sender, __sync_wait_receiver>,
+ STDEXEC_ERROR_SYNC_WAIT_CANNOT_CONNECT_SENDER_TO_RECEIVER);
+ } else if constexpr (!__has_implementation_for<sync_wait_t, __domain_t, _Sender>) {
+ static_assert(
+ __has_implementation_for<sync_wait_t, __domain_t, _Sender>,
+ "The sender passed to stdexec::sync_wait() has a domain that does not provide a "
+ "usable implementation for sync_wait().");
+ } else {
+ // success path, dispatch to the custom domain's sync_wait
+ return stdexec::apply_sender(__domain_t(), *this, static_cast<_Sender&&>(__sndr));
+ }
+ }
}
- else
- {
- constexpr __mstring __diag =
- "The stdexec::sender_in<Sender, Environment> concept check has failed."_mstr;
- return __sync_wait_error<__diag, _Sender>();
- }
- }
- else if constexpr (!__valid_sync_wait_argument<_Sender>)
- {
- return __sync_wait_error<__too_many_successful_completions_diag,
- _Sender>();
- }
- else if constexpr (!sender_to<_Sender, __sync_receiver_for_t<_Sender>>)
- {
- constexpr __mstring __diag =
- "Failed to connect the given sender to sync_wait's internal receiver. "
- "The stdexec::connect(Sender, Receiver) expression is ill-formed."_mstr;
- return __sync_wait_error<__diag, _Sender>();
- }
- else
- {
- constexpr __mstring __diag = "Unknown concept check failure."_mstr;
- return __sync_wait_error<__diag, _Sender>();
- }
-}
+ }
-template <class _Sender>
-using __error_description_t =
- decltype(__sync_wait::__diagnose_error<_Sender>());
-#endif
-
-////////////////////////////////////////////////////////////////////////////
-// [execution.senders.consumers.sync_wait]
-struct sync_wait_t
-{
- template <sender_in<__env> _Sender>
- requires __valid_sync_wait_argument<_Sender> &&
- __has_implementation_for<sync_wait_t,
- __early_domain_of_t<_Sender>, _Sender>
- auto operator()(_Sender&& __sndr) const
- -> std::optional<__value_tuple_for_t<_Sender>>
- {
- auto __domain = __get_early_domain(__sndr);
- return stdexec::apply_sender(__domain, *this,
- static_cast<_Sender&&>(__sndr));
- }
-
-#if STDEXEC_EDG()
- // This is needed to get sensible diagnostics from nvc++
- template <class _Sender, class _Error = __error_description_t<_Sender>>
- auto operator()(_Sender&&, [[maybe_unused]] _Error __diagnostic = {}) const
- -> std::optional<std::tuple<int>> = delete;
-#endif
-
- using _Sender = __0;
- using __legacy_customizations_t = __types<
- // For legacy reasons:
- tag_invoke_t(
- sync_wait_t,
- get_completion_scheduler_t<set_value_t>(get_env_t(const _Sender&)),
- _Sender),
- tag_invoke_t(sync_wait_t, _Sender)>;
-
- // clang-format off
+ // clang-format off
/// @brief Synchronously wait for the result of a sender, blocking the
/// current thread.
///
@@ -303,91 +269,72 @@
/// @throws std::system_error(error) if the error has type
/// `std::error_code`.
/// @throws error otherwise
- // clang-format on
- template <sender_in<__env> _Sender>
- auto apply_sender(_Sender&& __sndr) const
- -> std::optional<__sync_wait_result_t<_Sender>>
- {
+ // clang-format on
+
+ template <sender_in<__env> _Sender>
+ auto apply_sender(_Sender&& __sndr) const -> std::optional<__sync_wait_result_t<_Sender>> {
__state __local_state{};
std::optional<__sync_wait_result_t<_Sender>> __result{};
- // Launch the sender with a continuation that will fill in the __result
- // optional or set the exception_ptr in __local_state.
- auto __op_state =
- connect(static_cast<_Sender&&>(__sndr),
- __receiver_t<_Sender>{&__local_state, &__result});
- stdexec::start(__op_state);
+ // Launch the sender with a continuation that will fill in the __result optional or set the
+ // exception_ptr in __local_state.
+ [[maybe_unused]]
+ auto __op = stdexec::connect(
+ static_cast<_Sender&&>(__sndr), __receiver_t<_Sender>{&__local_state, &__result});
+ stdexec::start(__op);
// Wait for the variant to be filled in.
__local_state.__loop_.run();
- if (__local_state.__eptr_)
- {
- std::rethrow_exception(
- static_cast<std::exception_ptr&&>(__local_state.__eptr_));
+ if (__local_state.__eptr_) {
+ std::rethrow_exception(static_cast<std::exception_ptr&&>(__local_state.__eptr_));
}
return __result;
- }
-};
+ }
+ };
-////////////////////////////////////////////////////////////////////////////
-// [execution.senders.consumers.sync_wait_with_variant]
-struct sync_wait_with_variant_t
-{
- struct __impl;
+ ////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.consumers.sync_wait_with_variant]
+ struct sync_wait_with_variant_t {
+ struct __impl;
- template <sender_in<__env> _Sender>
- requires __callable<apply_sender_t, __early_domain_of_t<_Sender>,
- sync_wait_with_variant_t, _Sender>
- auto operator()(_Sender&& __sndr) const -> decltype(auto)
- {
- using __result_t =
- __call_result_t<apply_sender_t, __early_domain_of_t<_Sender>,
- sync_wait_with_variant_t, _Sender>;
+ template <sender_in<__env> _Sender>
+ requires __callable<
+ apply_sender_t,
+ __early_domain_of_t<_Sender>,
+ sync_wait_with_variant_t,
+ _Sender
+ >
+ auto operator()(_Sender&& __sndr) const -> decltype(auto) {
+ using __result_t = __call_result_t<
+ apply_sender_t,
+ __early_domain_of_t<_Sender>,
+ sync_wait_with_variant_t,
+ _Sender
+ >;
static_assert(__is_instance_of<__result_t, std::optional>);
- using __variant_t = typename __result_t::value_type;
+ using __variant_t = __result_t::value_type;
static_assert(__is_instance_of<__variant_t, std::variant>);
- auto __domain = __get_early_domain(__sndr);
- return stdexec::apply_sender(__domain, *this,
- static_cast<_Sender&&>(__sndr));
- }
+ using _Domain = __late_domain_of_t<_Sender, __env>;
+ return stdexec::apply_sender(_Domain(), *this, static_cast<_Sender&&>(__sndr));
+ }
-#if STDEXEC_EDG()
- template <class _Sender, class _Error = __error_description_t<
- __result_of<into_variant, _Sender>>>
- auto operator()(_Sender&&, [[maybe_unused]] _Error __diagnostic = {}) const
- -> std::optional<std::tuple<std::variant<std::tuple<>>>> = delete;
-#endif
-
- using _Sender = __0;
- using __legacy_customizations_t = __types<
- // For legacy reasons:
- tag_invoke_t(
- sync_wait_with_variant_t,
- get_completion_scheduler_t<set_value_t>(get_env_t(const _Sender&)),
- _Sender),
- tag_invoke_t(sync_wait_with_variant_t, _Sender)>;
-
- template <class _Sender>
+ template <class _Sender>
requires __callable<sync_wait_t, __result_of<into_variant, _Sender>>
- auto apply_sender(_Sender&& __sndr) const
- -> std::optional<__variant_for_t<_Sender>>
- {
- if (auto __opt_values =
- sync_wait_t()(into_variant(static_cast<_Sender&&>(__sndr))))
- {
- return std::move(std::get<0>(*__opt_values));
+ auto apply_sender(_Sender&& __sndr) const -> std::optional<__variant_for_t<_Sender>> {
+ if (auto __opt_values = sync_wait_t()(into_variant(static_cast<_Sender&&>(__sndr)))) {
+ return std::move(std::get<0>(*__opt_values));
}
return std::nullopt;
- }
-};
-} // namespace __sync_wait
+ }
+ };
+ } // namespace __sync_wait
-using __sync_wait::sync_wait_t;
-inline constexpr sync_wait_t sync_wait{};
+ using __sync_wait::sync_wait_t;
+ inline constexpr sync_wait_t sync_wait{};
-using __sync_wait::sync_wait_with_variant_t;
-inline constexpr sync_wait_with_variant_t sync_wait_with_variant{};
+ using __sync_wait::sync_wait_with_variant_t;
+ inline constexpr sync_wait_with_variant_t sync_wait_with_variant{};
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__tag_invoke.hpp b/include/sdbusplus/async/stdexec/__detail/__tag_invoke.hpp
index 1c41200..ac761c2 100644
--- a/include/sdbusplus/async/stdexec/__detail/__tag_invoke.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__tag_invoke.hpp
@@ -16,126 +16,87 @@
#pragma once
#include "__concepts.hpp"
-#include "__meta.hpp"
-namespace stdexec::__std_concepts
-{
+namespace stdexec::__std_concepts {
#if STDEXEC_HAS_STD_CONCEPTS_HEADER()
-using std::invocable;
+ using std::invocable;
#else
-template <class _Fun, class... _As>
-concept invocable = //
- requires(_Fun&& __f, _As&&... __as) {
- std::invoke(static_cast<_Fun&&>(__f), static_cast<_As&&>(__as)...);
- };
+ template <class _Fun, class... _As>
+ concept invocable = requires(_Fun&& __f, _As&&... __as) {
+ std::invoke(static_cast<_Fun &&>(__f), static_cast<_As &&>(__as)...);
+ };
#endif
} // namespace stdexec::__std_concepts
-namespace std
-{
-using namespace stdexec::__std_concepts;
+namespace std {
+ using namespace stdexec::__std_concepts;
} // namespace std
-namespace stdexec
-{
-// [func.tag_invoke], tag_invoke
-namespace __tag_invoke
-{
-void tag_invoke();
+namespace stdexec {
+ // [func.tag_invoke], tag_invoke
+ namespace __tag_invoke {
+ void tag_invoke();
-// For handling queryables with a static constexpr query member function:
-template <class _Tag, class _Env>
- requires true // so this overload is preferred over the one below
-STDEXEC_ATTRIBUTE((always_inline)) constexpr auto tag_invoke(
- _Tag, const _Env&) noexcept -> __mconstant<_Env::query(_Tag())>
-{
- return {};
-}
-
-// For handling queryables with a query member function:
-template <class _Tag, class _Env>
-STDEXEC_ATTRIBUTE((always_inline))
-constexpr auto tag_invoke(_Tag, const _Env& __env) noexcept(
- noexcept(__env.query(_Tag()))) -> decltype(__env.query(_Tag()))
-{
- return __env.query(_Tag());
-}
-
-// NOT TO SPEC: Don't require tag_invocable to subsume invocable.
-// std::invoke is more expensive at compile time than necessary,
-// and results in diagnostics that are more verbose than necessary.
-template <class _Tag, class... _Args>
-concept tag_invocable = //
- requires(_Tag __tag, _Args&&... __args) {
- tag_invoke(static_cast<_Tag&&>(__tag), static_cast<_Args&&>(__args)...);
- };
-
-template <class _Ret, class _Tag, class... _Args>
-concept __tag_invocable_r = //
- requires(_Tag __tag, _Args&&... __args) {
- {
- static_cast<_Ret>(tag_invoke(static_cast<_Tag&&>(__tag),
- static_cast<_Args&&>(__args)...))
- };
- };
-
-// NOT TO SPEC: nothrow_tag_invocable subsumes tag_invocable
-template <class _Tag, class... _Args>
-concept nothrow_tag_invocable =
- tag_invocable<_Tag, _Args...> && //
- requires(_Tag __tag, _Args&&... __args) {
- {
- tag_invoke(static_cast<_Tag&&>(__tag),
- static_cast<_Args&&>(__args)...)
- } noexcept;
- };
-
-template <class _Tag, class... _Args>
-using tag_invoke_result_t =
- decltype(tag_invoke(__declval<_Tag>(), __declval<_Args>()...));
-
-template <class _Tag, class... _Args>
-struct tag_invoke_result
-{};
-
-template <class _Tag, class... _Args>
- requires tag_invocable<_Tag, _Args...>
-struct tag_invoke_result<_Tag, _Args...>
-{
- using type = tag_invoke_result_t<_Tag, _Args...>;
-};
-
-struct tag_invoke_t
-{
+ // NOT TO SPEC: Don't require tag_invocable to subsume invocable.
+ // std::invoke is more expensive at compile time than necessary,
+ // and results in diagnostics that are more verbose than necessary.
template <class _Tag, class... _Args>
+ concept tag_invocable = requires(_Tag __tag, _Args&&... __args) {
+ tag_invoke(static_cast<_Tag &&>(__tag), static_cast<_Args &&>(__args)...);
+ };
+
+ template <class _Ret, class _Tag, class... _Args>
+ concept __tag_invocable_r = requires(_Tag __tag, _Args&&... __args) {
+ {
+ static_cast<_Ret>(tag_invoke(static_cast<_Tag &&>(__tag), static_cast<_Args &&>(__args)...))
+ };
+ };
+
+ // NOT TO SPEC: nothrow_tag_invocable subsumes tag_invocable
+ template <class _Tag, class... _Args>
+ concept nothrow_tag_invocable =
+ tag_invocable<_Tag, _Args...> && requires(_Tag __tag, _Args&&... __args) {
+ { tag_invoke(static_cast<_Tag &&>(__tag), static_cast<_Args &&>(__args)...) } noexcept;
+ };
+
+ template <class _Tag, class... _Args>
+ using tag_invoke_result_t = decltype(tag_invoke(__declval<_Tag>(), __declval<_Args>()...));
+
+ template <class _Tag, class... _Args>
+ struct tag_invoke_result { };
+
+ template <class _Tag, class... _Args>
+ requires tag_invocable<_Tag, _Args...>
+ struct tag_invoke_result<_Tag, _Args...> {
+ using type = tag_invoke_result_t<_Tag, _Args...>;
+ };
+
+ struct tag_invoke_t {
+ template <class _Tag, class... _Args>
requires tag_invocable<_Tag, _Args...>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Tag __tag, _Args&&... __args) const
- noexcept(nothrow_tag_invocable<_Tag, _Args...>)
- -> tag_invoke_result_t<_Tag, _Args...>
- {
- return tag_invoke(static_cast<_Tag&&>(__tag),
- static_cast<_Args&&>(__args)...);
- }
-};
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr auto operator()(_Tag __tag, _Args&&... __args) const
+ noexcept(nothrow_tag_invocable<_Tag, _Args...>) -> tag_invoke_result_t<_Tag, _Args...> {
+ return tag_invoke(static_cast<_Tag&&>(__tag), static_cast<_Args&&>(__args)...);
+ }
+ };
-} // namespace __tag_invoke
+ } // namespace __tag_invoke
-using __tag_invoke::tag_invoke_t;
+ using __tag_invoke::tag_invoke_t;
-namespace __ti
-{
-inline constexpr tag_invoke_t tag_invoke{};
-} // namespace __ti
+ namespace __ti {
+ inline constexpr tag_invoke_t tag_invoke{};
+ } // namespace __ti
-using namespace __ti;
+ using namespace __ti;
-template <auto& _Tag>
-using tag_t = __decay_t<decltype(_Tag)>;
+ template <auto& _Tag>
+ using tag_t = __decay_t<decltype(_Tag)>;
-using __tag_invoke::__tag_invocable_r;
-using __tag_invoke::nothrow_tag_invocable;
-using __tag_invoke::tag_invocable;
-using __tag_invoke::tag_invoke_result;
-using __tag_invoke::tag_invoke_result_t;
+ using __tag_invoke::tag_invocable;
+ using __tag_invoke::__tag_invocable_r;
+ using __tag_invoke::nothrow_tag_invocable;
+ using __tag_invoke::tag_invoke_result_t;
+ using __tag_invoke::tag_invoke_result;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__then.hpp b/include/sdbusplus/async/stdexec/__detail/__then.hpp
index 946fcd9..f35e69c 100644
--- a/include/sdbusplus/async/stdexec/__detail/__then.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__then.hpp
@@ -15,104 +15,89 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__basic_sender.hpp"
#include "__diagnostics.hpp"
#include "__domain.hpp"
-#include "__execution_fwd.hpp"
#include "__meta.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
#include "__senders_core.hpp"
+#include "__sender_adaptor_closure.hpp"
#include "__transform_completion_signatures.hpp"
#include "__transform_sender.hpp"
+#include "__senders.hpp"
// include these after __execution_fwd.hpp
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.then]
-namespace __then
-{
-inline constexpr __mstring __then_context =
- "In stdexec::then(Sender, Function)..."_mstr;
-using __on_not_callable = __callable_error<__then_context>;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.then]
+ namespace __then {
+ inline constexpr __mstring __then_context = "In stdexec::then(Sender, Function)..."_mstr;
+ using __on_not_callable = __callable_error<__then_context>;
-template <class _Fun, class _CvrefSender, class... _Env>
-using __completions_t = //
- transform_completion_signatures<
- __completion_signatures_of_t<_CvrefSender, _Env...>,
- __with_error_invoke_t<__on_not_callable, set_value_t, _Fun,
- _CvrefSender, _Env...>,
- __mbind_front<__mtry_catch_q<__set_value_invoke_t, __on_not_callable>,
- _Fun>::template __f>;
+ template <class _Fun, class _CvrefSender, class... _Env>
+ using __completions_t = transform_completion_signatures<
+ __completion_signatures_of_t<_CvrefSender, _Env...>,
+ __with_error_invoke_t<__on_not_callable, set_value_t, _Fun, _CvrefSender, _Env...>,
+ __mbind_front<__mtry_catch_q<__set_value_invoke_t, __on_not_callable>, _Fun>::template __f
+ >;
-////////////////////////////////////////////////////////////////////////////////////////////////
-struct then_t
-{
- template <sender _Sender, __movable_value _Fun>
- auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender
- auto
- {
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ struct then_t {
+ template <sender _Sender, __movable_value _Fun>
+ auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain, __make_sexpr<then_t>(static_cast<_Fun&&>(__fun),
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<then_t>(static_cast<_Fun&&>(__fun), static_cast<_Sender&&>(__sndr)));
+ }
- template <__movable_value _Fun>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Fun __fun) const -> __binder_back<then_t, _Fun>
- {
+ template <__movable_value _Fun>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Fun __fun) const -> __binder_back<then_t, _Fun> {
return {{static_cast<_Fun&&>(__fun)}, {}, {}};
- }
+ }
+ };
- using _Sender = __1;
- using _Fun = __0;
- using __legacy_customizations_t =
- __types<tag_invoke_t(then_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(_Sender&)),
- _Sender, _Fun),
- tag_invoke_t(then_t, _Sender, _Fun)>;
-};
+ struct __then_impl : __sexpr_defaults {
+ static constexpr auto get_attrs = []<class _Child>(__ignore, const _Child& __child) noexcept {
+ return __sync_attrs{__child};
+ };
-struct __then_impl : __sexpr_defaults
-{
- static constexpr auto get_completion_signatures = //
+ static constexpr auto get_completion_signatures =
[]<class _Sender, class... _Env>(_Sender&&, _Env&&...) noexcept
- -> __completions_t<__decay_t<__data_of<_Sender>>, __child_of<_Sender>,
- _Env...> {
+ -> __completions_t<__decay_t<__data_of<_Sender>>, __child_of<_Sender>, _Env...> {
static_assert(sender_expr_for<_Sender, then_t>);
return {};
- };
+ };
- static constexpr auto complete = //
- []<class _Tag, class _State, class _Receiver, class... _Args>(
- __ignore, _State& __state, _Receiver& __rcvr, _Tag,
- _Args&&... __args) noexcept -> void {
- if constexpr (__same_as<_Tag, set_value_t>)
- {
- stdexec::__set_value_invoke(static_cast<_Receiver&&>(__rcvr),
- static_cast<_State&&>(__state),
- static_cast<_Args&&>(__args)...);
+ struct __complete_fn {
+ template <class _Tag, class _State, class _Receiver, class... _Args>
+ STDEXEC_ATTRIBUTE(host, device)
+ void operator()(__ignore, _State& __state, _Receiver& __rcvr, _Tag, _Args&&... __args)
+ const noexcept {
+ if constexpr (__same_as<_Tag, set_value_t>) {
+ stdexec::__set_value_invoke(
+ static_cast<_Receiver&&>(__rcvr),
+ static_cast<_State&&>(__state),
+ static_cast<_Args&&>(__args)...);
+ } else {
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
+ }
}
- else
- {
- _Tag()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
- }
+ };
+
+ static constexpr auto complete = __complete_fn{};
};
-};
-} // namespace __then
+ } // namespace __then
-using __then::then_t;
+ using __then::then_t;
-/// @brief The then sender adaptor, which invokes a function with the result of
-/// a sender, making the result available to the next receiver.
-/// @hideinitializer
-inline constexpr then_t then{};
+ /// @brief The then sender adaptor, which invokes a function with the result of
+ /// a sender, making the result available to the next receiver.
+ /// @hideinitializer
+ inline constexpr then_t then{};
-template <>
-struct __sexpr_impl<then_t> : __then::__then_impl
-{};
+ template <>
+ struct __sexpr_impl<then_t> : __then::__then_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__transfer_just.hpp b/include/sdbusplus/async/stdexec/__detail/__transfer_just.hpp
index 9f7a9d0..d6492a5 100644
--- a/include/sdbusplus/async/stdexec/__detail/__transfer_just.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__transfer_just.hpp
@@ -25,116 +25,73 @@
#include "__env.hpp"
#include "__just.hpp"
#include "__meta.hpp"
-#include "__schedule_from.hpp"
#include "__schedulers.hpp"
#include "__sender_introspection.hpp"
-#include "__tag_invoke.hpp"
#include "__transform_sender.hpp"
#include "__tuple.hpp"
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.transfer_just]
-namespace __transfer_just
-{
-// This is a helper for finding legacy cusutomizations of transfer_just.
-inline auto __transfer_just_tag_invoke()
-{
- return []<class... _Ts>(
- _Ts&&... __ts) -> tag_invoke_result_t<transfer_just_t, _Ts...> {
- return tag_invoke(transfer_just, static_cast<_Ts&&>(__ts)...);
- };
-}
-
-template <class _Env>
-auto __make_transform_fn(const _Env&)
-{
- return [&]<class _Scheduler, class... _Values>(_Scheduler&& __sched,
- _Values&&... __vals) {
- return continues_on(just(static_cast<_Values&&>(__vals)...),
- static_cast<_Scheduler&&>(__sched));
- };
-}
-
-template <class _Env>
-auto __transform_sender_fn(const _Env& __env)
-{
- return [&]<class _Data>(__ignore, _Data&& __data) {
- return __data.apply(__make_transform_fn(__env),
- static_cast<_Data&&>(__data));
- };
-}
-
-struct __legacy_customization_fn
-{
- template <class _Data>
- auto operator()(_Data&& __data) const
- -> decltype(__data.apply(__transfer_just_tag_invoke(),
- static_cast<_Data&&>(__data)))
- {
- return __data.apply(__transfer_just_tag_invoke(),
- static_cast<_Data&&>(__data));
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.transfer_just]
+ namespace __transfer_just {
+ template <class _Env>
+ auto __make_transform_fn(const _Env&) {
+ return [&]<class _Scheduler, class... _Values>(_Scheduler&& __sched, _Values&&... __vals) {
+ return continues_on(
+ just(static_cast<_Values&&>(__vals)...), static_cast<_Scheduler&&>(__sched));
+ };
}
-};
-struct transfer_just_t
-{
- using _Data = __0;
- using __legacy_customizations_t = //
- __types<__legacy_customization_fn(_Data)>;
+ template <class _Env>
+ auto __transform_sender_fn(const _Env& __env) {
+ return [&]<class _Data>(__ignore, _Data&& __data) {
+ return __data.apply(__make_transform_fn(__env), static_cast<_Data&&>(__data));
+ };
+ }
- template <scheduler _Scheduler, __movable_value... _Values>
- auto operator()(_Scheduler&& __sched, _Values&&... __vals) const
- -> __well_formed_sender auto
- {
+ struct transfer_just_t {
+ template <scheduler _Scheduler, __movable_value... _Values>
+ auto
+ operator()(_Scheduler&& __sched, _Values&&... __vals) const -> __well_formed_sender auto {
auto __domain = query_or(get_domain, __sched, default_domain());
return stdexec::transform_sender(
- __domain, __make_sexpr<transfer_just_t>(
- __tuple{static_cast<_Scheduler&&>(__sched),
- static_cast<_Values&&>(__vals)...}));
- }
+ __domain,
+ __make_sexpr<transfer_just_t>(
+ __tuple{static_cast<_Scheduler&&>(__sched), static_cast<_Values&&>(__vals)...}));
+ }
- template <class _Sender, class _Env>
- static auto transform_sender(_Sender&& __sndr, const _Env& __env)
- {
- return __sexpr_apply(static_cast<_Sender&&>(__sndr),
- __transform_sender_fn(__env));
- }
-};
-
-inline auto __make_env_fn() noexcept
-{
- return []<class _Scheduler>(const _Scheduler& __sched,
- const auto&...) noexcept {
- using _Env = __t<__schfr::__environ<__id<_Scheduler>>>;
- return _Env{__sched};
+ template <class _Sender, class _Env>
+ static auto transform_sender(_Sender&& __sndr, const _Env& __env) {
+ return __sexpr_apply(static_cast<_Sender&&>(__sndr), __transform_sender_fn(__env));
+ }
};
-}
-struct __transfer_just_impl : __sexpr_defaults
-{
- static constexpr auto get_attrs = //
- []<class _Data>(const _Data& __data) noexcept {
- return __data.apply(__make_env_fn(), __data);
- };
+ inline auto __make_attrs_fn() noexcept {
+ return []<class _Scheduler>(const _Scheduler& __sched, const auto&...) noexcept {
+ static_assert(scheduler<_Scheduler>, "transfer_just requires a scheduler");
+ return __sched_attrs{std::cref(__sched)};
+ };
+ }
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {};
-};
-} // namespace __transfer_just
+ struct __transfer_just_impl : __sexpr_defaults {
+ static constexpr auto get_attrs = []<class _Data>(const _Data& __data) noexcept {
+ return __data.apply(__make_attrs_fn(), __data);
+ };
-using __transfer_just::transfer_just_t;
-inline constexpr transfer_just_t transfer_just{};
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
+ };
+ };
+ } // namespace __transfer_just
-template <>
-struct __sexpr_impl<transfer_just_t> : __transfer_just::__transfer_just_impl
-{};
+ using __transfer_just::transfer_just_t;
+ inline constexpr transfer_just_t transfer_just{};
+
+ template <>
+ struct __sexpr_impl<transfer_just_t> : __transfer_just::__transfer_just_impl { };
} // namespace stdexec
STDEXEC_PRAGMA_POP()
diff --git a/include/sdbusplus/async/stdexec/__detail/__transform_completion_signatures.hpp b/include/sdbusplus/async/stdexec/__detail/__transform_completion_signatures.hpp
index 5c62037..056d150 100644
--- a/include/sdbusplus/async/stdexec/__detail/__transform_completion_signatures.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__transform_completion_signatures.hpp
@@ -20,458 +20,518 @@
// include these after __execution_fwd.hpp
#include "__completion_signatures.hpp"
#include "__concepts.hpp"
-#include "__debug.hpp"
-#include "__diagnostics.hpp"
-#include "__meta.hpp"
+#include "__debug.hpp" // IWYU pragma: keep
#include "__senders_core.hpp"
+#include "__meta.hpp"
+#include <exception>
#include <tuple>
#include <variant>
-namespace stdexec
-{
+namespace stdexec {
#if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING()
-// __checked_completion_signatures is for catching logic bugs in a sender's
-// metadata. If sender<S> and sender_in<S, Ctx> are both true, then they had
-// better report the same metadata. This completion signatures wrapper enforces
-// that at compile time.
-template <class _Sender, class... _Env>
-auto __checked_completion_signatures(_Sender&& __sndr, _Env&&... __env) noexcept
-{
+ // __checked_completion_signatures is for catching logic bugs in a sender's metadata. If sender<S>
+ // and sender_in<S, Ctx> are both true, then they had better report the same metadata. This
+ // completion signatures wrapper enforces that at compile time.
+ template <class _Sender, class... _Env>
+ auto __checked_completion_signatures(_Sender &&__sndr, _Env &&...__env) noexcept {
using __completions_t = __completion_signatures_of_t<_Sender, _Env...>;
- stdexec::__debug_sender(static_cast<_Sender&&>(__sndr), __env...);
+ stdexec::__debug_sender(static_cast<_Sender &&>(__sndr), __env...);
return __completions_t{};
-}
+ }
-template <class _Sender, class... _Env>
+ template <class _Sender, class... _Env>
requires sender_in<_Sender, _Env...>
-using completion_signatures_of_t =
- decltype(stdexec::__checked_completion_signatures(__declval<_Sender>(),
- __declval<_Env>()...));
+ using completion_signatures_of_t =
+ decltype(stdexec::__checked_completion_signatures(__declval<_Sender>(), __declval<_Env>()...));
#else
-template <class _Sender, class... _Env>
+ template <class _Sender, class... _Env>
requires sender_in<_Sender, _Env...>
-using completion_signatures_of_t =
- __completion_signatures_of_t<_Sender, _Env...>;
+ using completion_signatures_of_t = __completion_signatures_of_t<_Sender, _Env...>;
#endif
-struct __not_a_variant
-{
+ struct __not_a_variant {
__not_a_variant() = delete;
-};
+ };
-template <class... _Ts>
-using __std_variant = //
- __minvoke_if_c<sizeof...(_Ts) != 0,
- __mtransform<__q1<__decay_t>, __munique<__qq<std::variant>>>,
- __mconst<__not_a_variant>, _Ts...>;
+ template <class... _Ts>
+ using __std_variant = __minvoke_if_c<
+ sizeof...(_Ts) != 0,
+ __mtransform<__q1<__decay_t>, __munique<__qq<std::variant>>>,
+ __mconst<__not_a_variant>,
+ _Ts...
+ >;
-template <class... _Ts>
-using __nullable_std_variant =
- __mcall<__munique<__mbind_front<__qq<std::variant>, std::monostate>>,
- __decay_t<_Ts>...>;
+ template <class... _Ts>
+ using __nullable_std_variant =
+ __mcall<__munique<__mbind_front<__qq<std::variant>, std::monostate>>, __decay_t<_Ts>...>;
-template <class... _Ts>
-using __decayed_std_tuple = __meval<std::tuple, __decay_t<_Ts>...>;
+ template <class... _Ts>
+ using __decayed_std_tuple = __meval<std::tuple, __decay_t<_Ts>...>;
-namespace __sigs
-{
-// The following code is used to normalize completion signatures.
-// "Normalization" means that that rvalue-references are stripped from the types
-// in the completion signatures. For example, the completion signature
-// `set_value_t(int &&)` would be normalized to `set_value_t(int)`, but
-// `set_value_t(int)` and `set_value_t(int &)` would remain unchanged.
-template <class _Tag, class... _Args>
-auto __normalize_sig_impl(_Args&&...) -> _Tag (*)(_Args...);
+ namespace __sigs {
+ // The following code is used to normalize completion signatures. "Normalization" means that
+ // that rvalue-references are stripped from the types in the completion signatures. For example,
+ // the completion signature `set_value_t(int &&)` would be normalized to `set_value_t(int)`,
+ // but `set_value_t(int)` and `set_value_t(int &)` would remain unchanged.
+ template <class _Tag, class... _Args>
+ auto __normalize_sig_impl(_Args &&...) -> _Tag (*)(_Args...);
-template <class _Tag, class... _Args>
-auto __normalize_sig(_Tag (*)(_Args...))
- -> decltype(__sigs::__normalize_sig_impl<_Tag>(__declval<_Args>()...));
+ template <class _Tag, class... _Args>
+ auto __normalize_sig(_Tag (*)(_Args...))
+ -> decltype(__sigs::__normalize_sig_impl<_Tag>(__declval<_Args>()...));
-template <class... _Sigs>
-auto __repack_completions(_Sigs*...) -> completion_signatures<_Sigs...>;
+ template <class... _Sigs>
+ auto __repack_completions(_Sigs *...) -> completion_signatures<_Sigs...>;
-template <class... _Sigs>
-auto __normalize_completions(completion_signatures<_Sigs...>*)
- -> decltype(__sigs::__repack_completions(
- __sigs::__normalize_sig(static_cast<_Sigs*>(nullptr))...));
+ template <class... _Sigs>
+ auto __normalize_completions(completion_signatures<_Sigs...> *)
+ -> decltype(__sigs::__repack_completions(
+ __sigs::__normalize_sig(static_cast<_Sigs *>(nullptr))...));
-template <class _Completions>
-using __normalize_completions_t = decltype(__sigs::__normalize_completions(
- static_cast<_Completions*>(nullptr)));
-} // namespace __sigs
+ template <class _Completions>
+ using __normalize_completions_t = decltype(__sigs::__normalize_completions(
+ static_cast<_Completions *>(nullptr)));
+ } // namespace __sigs
-template <class... _SigPtrs>
-using __completion_signature_ptrs = //
- decltype(__sigs::__repack_completions(static_cast<_SigPtrs>(nullptr)...));
+ template <class... _SigPtrs>
+ using __completion_signature_ptrs = decltype(__sigs::__repack_completions(
+ static_cast<_SigPtrs>(nullptr)...));
-template <class... _Sigs>
-using __concat_completion_signatures = //
- __mconcat<__qq<completion_signatures>>::__f<
- __mconcat<__qq<__mmake_set>>::__f<_Sigs...>>;
+ template <class... _Sigs>
+ using __concat_completion_signatures =
+ __mconcat<__qq<completion_signatures>>::__f<__mconcat<__qq<__mmake_set>>::__f<_Sigs...>>;
-namespace __sigs
-{
-//////////////////////////////////////////////////////////////////////////////////////////////////
-template <template <class...> class _Tuple, class _Tag, class... _Args>
-auto __for_each_sig(_Tag (*)(_Args...)) -> _Tuple<_Tag, _Args...>;
+ namespace __sigs {
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ template <template <class...> class _Tuple, class _Tag, class... _Args>
+ auto __for_each_sig(_Tag (*)(_Args...)) -> _Tuple<_Tag, _Args...>;
-template <class _Sig, template <class...> class _Tuple>
-using __for_each_sig_t =
- decltype(__sigs::__for_each_sig<_Tuple>(static_cast<_Sig*>(nullptr)));
+ template <class _Sig, template <class...> class _Tuple>
+ using __for_each_sig_t = decltype(__sigs::__for_each_sig<_Tuple>(static_cast<_Sig *>(nullptr)));
-template <template <class...> class _Tuple, template <class...> class _Variant,
- class... _More, class _What, class... _With>
-auto __for_each_completion_signature_fn(_ERROR_<_What, _With...>**)
- -> _ERROR_<_What, _With...>;
+ template <
+ template <class...> class _Tuple,
+ template <class...> class _Variant,
+ class... _More,
+ class _What,
+ class... _With
+ >
+ auto
+ __for_each_completion_signature_fn(_ERROR_<_What, _With...> **) -> _ERROR_<_What, _With...>;
-template <template <class...> class _Tuple, template <class...> class _Variant,
- class... _More, class... _Sigs>
-auto __for_each_completion_signature_fn(completion_signatures<_Sigs...>**)
- -> _Variant<__for_each_sig_t<_Sigs, _Tuple>..., _More...>;
-} // namespace __sigs
+ template <
+ template <class...> class _Tuple,
+ template <class...> class _Variant,
+ class... _More,
+ class... _Sigs
+ >
+ auto __for_each_completion_signature_fn(completion_signatures<_Sigs...> **)
+ -> _Variant<__for_each_sig_t<_Sigs, _Tuple>..., _More...>;
+ } // namespace __sigs
-template <class _Sigs, template <class...> class _Tuple,
- template <class...> class _Variant, class... _More>
-using __for_each_completion_signature =
- decltype(__sigs::__for_each_completion_signature_fn<
- _Tuple, _Variant, _More...>(static_cast<_Sigs**>(nullptr)));
+ template <
+ class _Sigs,
+ template <class...> class _Tuple,
+ template <class...> class _Variant,
+ class... _More
+ >
+ using __for_each_completion_signature =
+ decltype(__sigs::__for_each_completion_signature_fn<_Tuple, _Variant, _More...>(
+ static_cast<_Sigs **>(nullptr)));
-namespace __sigs
-{
-////////////////////////////////////////////////////////////////////////////////////////////////
-template <template <class...> class _SetVal, template <class...> class _SetErr,
- class _SetStp, class... _Values>
-auto __transform_sig(set_value_t (*)(_Values...)) -> _SetVal<_Values...>;
+ namespace __sigs {
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ template <
+ template <class...> class _SetVal,
+ template <class...> class _SetErr,
+ class _SetStp,
+ class... _Values
+ >
+ auto __transform_sig(set_value_t (*)(_Values...)) -> _SetVal<_Values...>;
-template <template <class...> class _SetVal, template <class...> class _SetErr,
- class _SetStp, class _Error>
-auto __transform_sig(set_error_t (*)(_Error)) -> _SetErr<_Error>;
+ template <
+ template <class...> class _SetVal,
+ template <class...> class _SetErr,
+ class _SetStp,
+ class _Error
+ >
+ auto __transform_sig(set_error_t (*)(_Error)) -> _SetErr<_Error>;
-template <template <class...> class _SetVal, template <class...> class _SetErr,
- class _SetStp>
-auto __transform_sig(set_stopped_t (*)()) -> _SetStp;
+ template <template <class...> class _SetVal, template <class...> class _SetErr, class _SetStp>
+ auto __transform_sig(set_stopped_t (*)()) -> _SetStp;
-template <class _Sig, template <class...> class _SetVal,
- template <class...> class _SetErr, class _SetStp>
-using __transform_sig_t =
- decltype(__sigs::__transform_sig<_SetVal, _SetErr, _SetStp>(
- static_cast<_Sig*>(nullptr)));
+ template <
+ class _Sig,
+ template <class...> class _SetVal,
+ template <class...> class _SetErr,
+ class _SetStp
+ >
+ using __transform_sig_t = decltype(__sigs::__transform_sig<_SetVal, _SetErr, _SetStp>(
+ static_cast<_Sig *>(nullptr)));
-template <template <class...> class _SetVal, template <class...> class _SetErr,
- class _SetStp, template <class...> class _Variant, class... _More,
- class _What, class... _With>
-auto __transform_sigs_fn(_ERROR_<_What, _With...>**)
- -> _ERROR_<_What, _With...>;
+ template <
+ template <class...> class _SetVal,
+ template <class...> class _SetErr,
+ class _SetStp,
+ template <class...> class _Variant,
+ class... _More,
+ class _What,
+ class... _With
+ >
+ auto __transform_sigs_fn(_ERROR_<_What, _With...> **) -> _ERROR_<_What, _With...>;
-template <template <class...> class _SetVal, template <class...> class _SetErr,
- class _SetStp, template <class...> class _Variant, class... _More,
- class... _Sigs>
-auto __transform_sigs_fn(completion_signatures<_Sigs...>**) //
- -> _Variant<__transform_sig_t<_Sigs, _SetVal, _SetErr, _SetStp>...,
- _More...>;
-} // namespace __sigs
+ template <
+ template <class...> class _SetVal,
+ template <class...> class _SetErr,
+ class _SetStp,
+ template <class...> class _Variant,
+ class... _More,
+ class... _Sigs
+ >
+ auto __transform_sigs_fn(completion_signatures<_Sigs...> **)
+ -> _Variant<__transform_sig_t<_Sigs, _SetVal, _SetErr, _SetStp>..., _More...>;
+ } // namespace __sigs
-template <class _Sigs, template <class...> class _SetVal,
- template <class...> class _SetErr, class _SetStp,
- template <class...> class _Variant,
- class... _More>
-using __transform_completion_signatures = //
- decltype(__sigs::__transform_sigs_fn<_SetVal, _SetErr, _SetStp, _Variant,
- _More...>(
- static_cast<_Sigs**>(nullptr)));
+ template <
+ class _Sigs,
+ template <class...> class _SetVal,
+ template <class...> class _SetErr,
+ class _SetStp,
+ template <class...> class _Variant,
+ class... _More
+ >
+ using __transform_completion_signatures =
+ decltype(__sigs::__transform_sigs_fn<_SetVal, _SetErr, _SetStp, _Variant, _More...>(
+ static_cast<_Sigs **>(nullptr)));
-namespace __sigs
-{
-////////////////////////////////////////////////////////////////////////////////////////////////
-template <class _WantedTag>
-struct __gather_sigs_fn;
+ namespace __sigs {
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ template <class _WantedTag>
+ struct __gather_sigs_fn;
-template <>
-struct __gather_sigs_fn<set_value_t>
-{
- template <class _Sigs, template <class...> class _Then,
- template <class...> class _Else,
- template <class...> class _Variant, class... _More>
- using __f = __transform_completion_signatures<
- _Sigs, _Then, __mbind_front_q<_Else, set_error_t>::template __f,
- _Else<set_stopped_t>, _Variant, _More...>;
-};
+ template <>
+ struct __gather_sigs_fn<set_value_t> {
+ template <
+ class _Sigs,
+ template <class...> class _Then,
+ template <class...> class _Else,
+ template <class...> class _Variant,
+ class... _More
+ >
+ using __f = __transform_completion_signatures<
+ _Sigs,
+ _Then,
+ __mbind_front_q<_Else, set_error_t>::template __f,
+ _Else<set_stopped_t>,
+ _Variant,
+ _More...
+ >;
+ };
-template <>
-struct __gather_sigs_fn<set_error_t>
-{
- template <class _Sigs, template <class...> class _Then,
- template <class...> class _Else,
- template <class...> class _Variant, class... _More>
- using __f = __transform_completion_signatures<
- _Sigs, __mbind_front_q<_Else, set_value_t>::template __f, _Then,
- _Else<set_stopped_t>, _Variant, _More...>;
-};
+ template <>
+ struct __gather_sigs_fn<set_error_t> {
+ template <
+ class _Sigs,
+ template <class...> class _Then,
+ template <class...> class _Else,
+ template <class...> class _Variant,
+ class... _More
+ >
+ using __f = __transform_completion_signatures<
+ _Sigs,
+ __mbind_front_q<_Else, set_value_t>::template __f,
+ _Then,
+ _Else<set_stopped_t>,
+ _Variant,
+ _More...
+ >;
+ };
-template <>
-struct __gather_sigs_fn<set_stopped_t>
-{
- template <class _Sigs, template <class...> class _Then,
- template <class...> class _Else,
- template <class...> class _Variant, class... _More>
- using __f = __transform_completion_signatures<
- _Sigs, __mbind_front_q<_Else, set_value_t>::template __f,
- __mbind_front_q<_Else, set_error_t>::template __f, _Then<>, _Variant,
- _More...>;
-};
+ template <>
+ struct __gather_sigs_fn<set_stopped_t> {
+ template <
+ class _Sigs,
+ template <class...> class _Then,
+ template <class...> class _Else,
+ template <class...> class _Variant,
+ class... _More
+ >
+ using __f = __transform_completion_signatures<
+ _Sigs,
+ __mbind_front_q<_Else, set_value_t>::template __f,
+ __mbind_front_q<_Else, set_error_t>::template __f,
+ _Then<>,
+ _Variant,
+ _More...
+ >;
+ };
-template <class... _Values>
-using __default_set_value = completion_signatures<set_value_t(_Values...)>;
+ template <class... _Values>
+ using __default_set_value = completion_signatures<set_value_t(_Values...)>;
-template <class... _Error>
-using __default_set_error = completion_signatures<set_error_t(_Error...)>;
+ template <class... _Error>
+ using __default_set_error = completion_signatures<set_error_t(_Error...)>;
-template <class _Tag, class... _Args>
-using __default_completion = completion_signatures<_Tag(_Args...)>;
-} // namespace __sigs
+ template <class _Tag, class... _Args>
+ using __default_completion = completion_signatures<_Tag(_Args...)>;
+ } // namespace __sigs
-template <class _Sigs, class _WantedTag, template <class...> class _Then,
- template <class...> class _Else, template <class...> class _Variant,
- class... _More>
-using __gather_completion_signatures = typename __sigs::__gather_sigs_fn<
- _WantedTag>::template __f<_Sigs, _Then, _Else, _Variant, _More...>;
+ template <
+ class _Sigs,
+ class _WantedTag,
+ template <class...> class _Then,
+ template <class...> class _Else,
+ template <class...> class _Variant,
+ class... _More
+ >
+ using __gather_completion_signatures =
+ __sigs::__gather_sigs_fn<_WantedTag>::template __f<_Sigs, _Then, _Else, _Variant, _More...>;
-/////////////////////////////////////////////////////////////////////////////
-// transform_completion_signatures
-// ==========================
-//
-// `transform_completion_signatures` takes a sender, and environment, and a
-// bunch of other template arguments for munging the completion signatures of a
-// sender in interesting ways.
-//
-// ```c++
-// template <class... Args>
-// using __default_set_value = completion_signatures<set_value_t(Args...)>;
-//
-// template <class Err>
-// using __default_set_error = completion_signatures<set_error_t(Err)>;
-//
-// template <
-// class Completions,
-// class AdditionalSigs = completion_signatures<>,
-// template <class...> class SetValue = __default_set_value,
-// template <class> class SetError = __default_set_error,
-// class SetStopped = completion_signatures<set_stopped_t()>>
-// using transform_completion_signatures =
-// completion_signatures< ... >;
-// ```
-//
-// * `SetValue` : an alias template that accepts a set of value types and
-// returns an instance of
-// `completion_signatures`.
-//
-// * `SetError` : an alias template that accepts an error types and returns a
-// an instance of
-// `completion_signatures`.
-//
-// * `SetStopped` : an instantiation of `completion_signatures` with a list of
-// completion
-// signatures `Sigs...` to the added to the list if the sender can complete
-// with a stopped signal.
-//
-// * `AdditionalSigs` : an instantiation of `completion_signatures` with a list
-// of completion
-// signatures `Sigs...` to the added to the list unconditionally.
-//
-// `transform_completion_signatures` does the following:
-//
-// * Let `VCs...` be a pack of the `completion_signatures` types in the
-// `__typelist` named by
-// `value_types_of_t<Sndr, Env, SetValue, __typelist>`, and let `Vs...` be
-// the concatenation of the packs that are template arguments to each
-// `completion_signature` in `VCs...`.
-//
-// * Let `ECs...` be a pack of the `completion_signatures` types in the
-// `__typelist` named by
-// `error_types_of_t<Sndr, Env, __errorlist>`, where `__errorlist` is an
-// alias template such that `__errorlist<Ts...>` names
-// `__typelist<SetError<Ts>...>`, and let `Es...` be the concatenation of the
-// packs that are the template arguments to each `completion_signature` in
-// `ECs...`.
-//
-// * Let `Ss...` be an empty pack if `sends_stopped<Sndr, Env>` is `false`;
-// otherwise, a pack
-// containing the template arguments of the `completion_signatures`
-// instantiation named by `SetStopped`.
-//
-// * Let `MoreSigs...` be a pack of the template arguments of the
-// `completion_signatures`
-// instantiation named by `AdditionalSigs`.
-//
-// Then `transform_completion_signatures<Completions, AdditionalSigs, SetValue,
-// SetError, SendsStopped>` names the type `completion_signatures< Sigs... >`
-// where `Sigs...` is the unique set of types in `[Vs..., Es..., Ss...,
-// MoreSigs...]`.
-//
-// If any of the above type computations are ill-formed,
-// `transform_completion_signatures<Sndr, Env, AdditionalSigs, SetValue,
-// SetError, SendsStopped>` is ill-formed.
-template <
- class _Sigs, class _MoreSigs = completion_signatures<>,
- template <class...> class _ValueTransform = __sigs::__default_set_value,
- template <class...> class _ErrorTransform = __sigs::__default_set_error,
- class _StoppedSigs = completion_signatures<set_stopped_t()>>
-using transform_completion_signatures = //
- __transform_completion_signatures<
- _Sigs, _ValueTransform, _ErrorTransform, _StoppedSigs,
- __mtry_q<__concat_completion_signatures>::__f, _MoreSigs>;
+ /////////////////////////////////////////////////////////////////////////////
+ // transform_completion_signatures
+ // ==========================
-template <
- class _Sndr, class _Env = empty_env,
+ // `transform_completion_signatures` takes a sender, and environment, and a bunch of other
+ // template arguments for munging the completion signatures of a sender in interesting ways.
+
+ // ```c++
+ // template <class... Args>
+ // using __default_set_value = completion_signatures<set_value_t(Args...)>;
+
+ // template <class Err>
+ // using __default_set_error = completion_signatures<set_error_t(Err)>;
+
+ // template <
+ // class Completions,
+ // class AdditionalSigs = completion_signatures<>,
+ // template <class...> class SetValue = __default_set_value,
+ // template <class> class SetError = __default_set_error,
+ // class SetStopped = completion_signatures<set_stopped_t()>>
+ // using transform_completion_signatures =
+ // completion_signatures< ... >;
+ // ```
+
+ // * `SetValue` : an alias template that accepts a set of value types and returns an instance of
+ // `completion_signatures`.
+
+ // * `SetError` : an alias template that accepts an error types and returns a an instance of
+ // `completion_signatures`.
+
+ // * `SetStopped` : an instantiation of `completion_signatures` with a list of completion
+ // signatures `Sigs...` to the added to the list if the sender can complete with a stopped
+ // signal.
+
+ // * `AdditionalSigs` : an instantiation of `completion_signatures` with a list of completion
+ // signatures `Sigs...` to the added to the list unconditionally.
+
+ // `transform_completion_signatures` does the following:
+
+ // * Let `VCs...` be a pack of the `completion_signatures` types in the `__typelist` named by
+ // `value_types_of_t<Sndr, Env, SetValue, __typelist>`, and let `Vs...` be the concatenation of
+ // the packs that are template arguments to each `completion_signature` in `VCs...`.
+
+ // * Let `ECs...` be a pack of the `completion_signatures` types in the `__typelist` named by
+ // `error_types_of_t<Sndr, Env, __errorlist>`, where `__errorlist` is an alias template such
+ // that `__errorlist<Ts...>` names `__typelist<SetError<Ts>...>`, and let `Es...` be the
+ // concatenation of the packs that are the template arguments to each `completion_signature` in
+ // `ECs...`.
+
+ // * Let `Ss...` be an empty pack if `sends_stopped<Sndr, Env>` is `false`; otherwise, a pack
+ // containing the template arguments of the `completion_signatures` instantiation named by
+ // `SetStopped`.
+
+ // * Let `MoreSigs...` be a pack of the template arguments of the `completion_signatures`
+ // instantiation named by `AdditionalSigs`.
+
+ // Then `transform_completion_signatures<Completions, AdditionalSigs, SetValue, SetError,
+ // SendsStopped>` names the type `completion_signatures< Sigs... >` where `Sigs...` is the unique
+ // set of types in `[Vs..., Es..., Ss..., MoreSigs...]`.
+
+ // If any of the above type computations are ill-formed, `transform_completion_signatures<Sndr,
+ // Env, AdditionalSigs, SetValue, SetError, SendsStopped>` is ill-formed.
+ template <
+ class _Sigs,
class _MoreSigs = completion_signatures<>,
template <class...> class _ValueTransform = __sigs::__default_set_value,
template <class...> class _ErrorTransform = __sigs::__default_set_error,
- class _StoppedSigs = completion_signatures<set_stopped_t()>>
-using transform_completion_signatures_of = //
- transform_completion_signatures<completion_signatures_of_t<_Sndr, _Env>,
- _MoreSigs, _ValueTransform, _ErrorTransform,
- _StoppedSigs>;
+ class _StoppedSigs = completion_signatures<set_stopped_t()>
+ >
+ using transform_completion_signatures = __transform_completion_signatures<
+ _Sigs,
+ _ValueTransform,
+ _ErrorTransform,
+ _StoppedSigs,
+ __mtry_q<__concat_completion_signatures>::__f,
+ _MoreSigs
+ >;
-using __eptr_completion =
- completion_signatures<set_error_t(std::exception_ptr)>;
+ template <
+ class _Sndr,
+ class _Env = env<>,
+ class _MoreSigs = completion_signatures<>,
+ template <class...> class _ValueTransform = __sigs::__default_set_value,
+ template <class...> class _ErrorTransform = __sigs::__default_set_error,
+ class _StoppedSigs = completion_signatures<set_stopped_t()>
+ >
+ using transform_completion_signatures_of = transform_completion_signatures<
+ completion_signatures_of_t<_Sndr, _Env>,
+ _MoreSigs,
+ _ValueTransform,
+ _ErrorTransform,
+ _StoppedSigs
+ >;
-template <class _NoExcept>
-using __eptr_completion_if_t =
- __if<_NoExcept, completion_signatures<>, __eptr_completion>;
+ using __eptr_completion = completion_signatures<set_error_t(std::exception_ptr)>;
-template <bool _NoExcept>
-using __eptr_completion_if = __eptr_completion_if_t<__mbool<_NoExcept>>;
+ template <class _NoExcept>
+ using __eptr_completion_if_t = __if<_NoExcept, completion_signatures<>, __eptr_completion>;
-template < //
- class _Sender, //
- class _Env = empty_env, //
- class _More = completion_signatures<>, //
- class _SetValue = __qq<__sigs::__default_set_value>, //
- class _SetError = __qq<__sigs::__default_set_error>, //
- class _SetStopped = completion_signatures<set_stopped_t()>> //
-using __try_make_completion_signatures = //
- __transform_completion_signatures<
- __completion_signatures_of_t<_Sender, _Env>, _SetValue::template __f,
- _SetError::template __f, _SetStopped,
- __mtry_q<__concat_completion_signatures>::__f, _More>;
+ template <bool _NoExcept>
+ using __eptr_completion_if = __eptr_completion_if_t<__mbool<_NoExcept>>;
-template <class _SetTag, class _Completions, class _Tuple,
- class _Variant>
-using __gather_completions = //
- __gather_completion_signatures<
- _Completions, _SetTag,
- __mcompose_q<__types, _Tuple::template __f>::template __f,
- __mconst<__types<>>::__f, __mconcat<_Variant>::template __f>;
+ template <
+ class _Sender,
+ class _Env = env<>,
+ class _More = completion_signatures<>,
+ class _SetValue = __qq<__sigs::__default_set_value>,
+ class _SetError = __qq<__sigs::__default_set_error>,
+ class _SetStopped = completion_signatures<set_stopped_t()>
+ >
+ using __try_make_completion_signatures = __transform_completion_signatures<
+ __completion_signatures_of_t<_Sender, _Env>,
+ _SetValue::template __f,
+ _SetError::template __f,
+ _SetStopped,
+ __mtry_q<__concat_completion_signatures>::__f,
+ _More
+ >;
-template <class _SetTag, class _Sender, class _Env, class _Tuple,
- class _Variant>
-using __gather_completions_of = //
- __gather_completions<_SetTag, __completion_signatures_of_t<_Sender, _Env>,
- _Tuple, _Variant>;
+ template <class _SetTag, class _Completions, class _Tuple, class _Variant>
+ using __gather_completions = __gather_completion_signatures<
+ _Completions,
+ _SetTag,
+ __mcompose_q<__types, _Tuple::template __f>::template __f,
+ __mconst<__types<>>::__f,
+ __mconcat<_Variant>::template __f
+ >;
-template < //
- class _Sender, //
- class _Env = empty_env, //
- class _Sigs = completion_signatures<>, //
- template <class...> class _SetValue = __sigs::__default_set_value, //
- template <class...> class _SetError = __sigs::__default_set_error, //
- class _SetStopped = completion_signatures<set_stopped_t()>>
-using make_completion_signatures =
- transform_completion_signatures_of<_Sender, _Env, _Sigs, _SetValue,
- _SetError, _SetStopped>;
+ template <class _SetTag, class _Sender, class _Env, class _Tuple, class _Variant>
+ using __gather_completions_of =
+ __gather_completions<_SetTag, __completion_signatures_of_t<_Sender, _Env>, _Tuple, _Variant>;
-template < //
- class _Sigs, //
- class _Tuple = __q<__decayed_std_tuple>, //
- class _Variant = __q<__std_variant>>
-using __value_types_t = //
- __gather_completions<set_value_t, _Sigs, _Tuple, _Variant>;
+ template <
+ class _Sender,
+ class _Env = env<>,
+ class _Sigs = completion_signatures<>,
+ template <class...> class _SetValue = __sigs::__default_set_value,
+ template <class...> class _SetError = __sigs::__default_set_error,
+ class _SetStopped = completion_signatures<set_stopped_t()>
+ >
+ using make_completion_signatures =
+ transform_completion_signatures_of<_Sender, _Env, _Sigs, _SetValue, _SetError, _SetStopped>;
-template < //
- class _Sender, //
- class _Env = empty_env, //
- class _Tuple = __q<__decayed_std_tuple>, //
- class _Variant = __q<__std_variant>>
-using __value_types_of_t = //
- __value_types_t<__completion_signatures_of_t<_Sender, _Env>, _Tuple,
- _Variant>;
+ template <
+ class _Sigs,
+ class _Tuple = __q<__decayed_std_tuple>,
+ class _Variant = __q<__std_variant>
+ >
+ using __value_types_t = __gather_completions<set_value_t, _Sigs, _Tuple, _Variant>;
-template <class _Sigs, class _Variant = __q<__std_variant>>
-using __error_types_t =
- __gather_completions<set_error_t, _Sigs, __q<__midentity>, _Variant>;
+ template <
+ class _Sender,
+ class _Env = env<>,
+ class _Tuple = __q<__decayed_std_tuple>,
+ class _Variant = __q<__std_variant>
+ >
+ using __value_types_of_t =
+ __value_types_t<__completion_signatures_of_t<_Sender, _Env>, _Tuple, _Variant>;
-template <class _Sender, class _Env = empty_env,
- class _Variant = __q<__std_variant>>
-using __error_types_of_t =
- __error_types_t<__completion_signatures_of_t<_Sender, _Env>, _Variant>;
+ template <class _Sigs, class _Variant = __q<__std_variant>>
+ using __error_types_t = __gather_completions<set_error_t, _Sigs, __q<__midentity>, _Variant>;
-template < //
- class _Sender, //
- class _Env = empty_env, //
- template <class...> class _Tuple = __decayed_std_tuple, //
- template <class...> class _Variant = __std_variant>
-using value_types_of_t =
- __value_types_of_t<_Sender, _Env, __q<_Tuple>, __q<_Variant>>;
+ template <class _Sender, class _Env = env<>, class _Variant = __q<__std_variant>>
+ using __error_types_of_t = __error_types_t<__completion_signatures_of_t<_Sender, _Env>, _Variant>;
-template <class _Sender, class _Env = empty_env,
- template <class...> class _Variant = __std_variant>
-using error_types_of_t = __error_types_of_t<_Sender, _Env, __q<_Variant>>;
+ template <
+ class _Sender,
+ class _Env = env<>,
+ template <class...> class _Tuple = __decayed_std_tuple,
+ template <class...> class _Variant = __std_variant
+ >
+ using value_types_of_t = __value_types_of_t<_Sender, _Env, __q<_Tuple>, __q<_Variant>>;
-template <class _Tag, class _Sender, class... _Env>
-using __count_of = //
- __gather_completion_signatures<
- __completion_signatures_of_t<_Sender, _Env...>, _Tag,
- __mconst<__msize_t<1>>::__f, __mconst<__msize_t<0>>::__f, __mplus_t>;
+ template <class _Sender, class _Env = env<>, template <class...> class _Variant = __std_variant>
+ using error_types_of_t = __error_types_of_t<_Sender, _Env, __q<_Variant>>;
-template <class _Tag, class _Sender, class... _Env>
+ template <class _Tag, class _Sender, class... _Env>
+ using __count_of = __gather_completion_signatures<
+ __completion_signatures_of_t<_Sender, _Env...>,
+ _Tag,
+ __mconst<__msize_t<1>>::__f,
+ __mconst<__msize_t<0>>::__f,
+ __mplus_t
+ >;
+
+ template <class _Tag, class _Sender, class... _Env>
requires sender_in<_Sender, _Env...>
-inline constexpr bool __sends = //
- __v<__gather_completion_signatures<
- __completion_signatures_of_t<_Sender, _Env...>, _Tag,
- __mconst<__mtrue>::__f, __mconst<__mfalse>::__f, __mor_t>>;
+ inline constexpr bool __sends = __v<__gather_completion_signatures<
+ __completion_signatures_of_t<_Sender, _Env...>,
+ _Tag,
+ __mconst<__mtrue>::__f,
+ __mconst<__mfalse>::__f,
+ __mor_t
+ >>;
-template <class _Sender, class... _Env>
-concept sends_stopped = //
- sender_in<_Sender, _Env...> && __sends<set_stopped_t, _Sender, _Env...>;
+ template <class _Sender, class... _Env>
+ concept sends_stopped = sender_in<_Sender, _Env...> && __sends<set_stopped_t, _Sender, _Env...>;
-template <class _Sender, class... _Env>
-using __single_sender_value_t =
- __value_types_t<__completion_signatures_of_t<_Sender, _Env...>,
- __msingle_or<void>, __q<__msingle>>;
+ template <class _Sender, class... _Env>
+ using __single_sender_value_t =
+ __value_types_t<__completion_signatures_of_t<_Sender, _Env...>, __q<__msingle>, __q<__msingle>>;
-template <class _Sender, class... _Env>
-concept __single_value_sender = //
- sender_in<_Sender, _Env...> && //
- requires { typename __single_sender_value_t<_Sender, _Env...>; };
+ template <class _Sender, class... _Env>
+ concept __single_value_sender = sender_in<_Sender, _Env...>
+ && requires { typename __single_sender_value_t<_Sender, _Env...>; };
-template <class _Sender, class... _Env>
-using __single_value_variant_sender_t =
- __value_types_t<__completion_signatures_of_t<_Sender, _Env...>,
- __qq<__types>, __q<__msingle>>;
+ template <class _Sender, class... _Env>
+ using __single_value_variant_sender_t =
+ __value_types_t<__completion_signatures_of_t<_Sender, _Env...>, __qq<__types>, __q<__msingle>>;
-template <class _Sender, class... _Env>
-concept __single_value_variant_sender = //
- sender_in<_Sender, _Env...> && //
- requires { typename __single_value_variant_sender_t<_Sender, _Env...>; };
+ template <class _Sender, class... _Env>
+ concept __single_value_variant_sender = sender_in<_Sender, _Env...> && requires {
+ typename __single_value_variant_sender_t<_Sender, _Env...>;
+ };
-// The following utilities are needed fairly often:
-template <class _Fun, class... _Args>
+ // The following utilities are needed fairly often:
+ template <class _Fun, class... _Args>
requires __invocable<_Fun, _Args...>
-using __nothrow_invocable_t = __mbool<__nothrow_invocable<_Fun, _Args...>>;
+ using __nothrow_invocable_t = __mbool<__nothrow_invocable<_Fun, _Args...>>;
-template <class _Catch, class _Tag, class _Fun, class _Sender, class... _Env>
-using __with_error_invoke_t = //
- __if<__gather_completion_signatures<
- __completion_signatures_of_t<_Sender, _Env...>, _Tag,
- __mbind_front<__mtry_catch_q<__nothrow_invocable_t, _Catch>,
- _Fun>::template __f,
- __mconst<__mbool<true>>::__f, __mand>,
- completion_signatures<>, __eptr_completion>;
+ template <class _Catch, class _Tag, class _Fun, class _Sender, class... _Env>
+ using __with_error_invoke_t = __if<
+ __gather_completion_signatures<
+ __completion_signatures_of_t<_Sender, _Env...>,
+ _Tag,
+ __mbind_front<__mtry_catch_q<__nothrow_invocable_t, _Catch>, _Fun>::template __f,
+ __mconst<__mbool<true>>::__f,
+ __mand
+ >,
+ completion_signatures<>,
+ __eptr_completion
+ >;
-template <class _Fun, class... _Args>
+ template <class _Fun, class... _Args>
requires __invocable<_Fun, _Args...>
-using __set_value_invoke_t = //
- completion_signatures<__minvoke<__mremove<void, __qf<set_value_t>>,
- __invoke_result_t<_Fun, _Args...>>>;
+ using __set_value_invoke_t = completion_signatures<
+ __minvoke<__mremove<void, __qf<set_value_t>>, __invoke_result_t<_Fun, _Args...>>
+ >;
+
+ template <class _Completions>
+ using __decay_copyable_results_t =
+ __for_each_completion_signature<_Completions, __decay_copyable_t, __mand_t>;
+
+ template <class _Completions>
+ using __nothrow_decay_copyable_results_t =
+ __for_each_completion_signature<_Completions, __nothrow_decay_copyable_t, __mand_t>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__transform_sender.hpp b/include/sdbusplus/async/stdexec/__detail/__transform_sender.hpp
index db1dbe3..e979e12 100644
--- a/include/sdbusplus/async/stdexec/__detail/__transform_sender.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__transform_sender.hpp
@@ -30,283 +30,189 @@
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_EDG(type_qualifiers_ignored_on_reference)
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// dependent_domain
-struct dependent_domain
-{
- template <class _Sender, class _Env>
- static constexpr auto __is_nothrow_transform_sender() noexcept -> bool;
-
- template <sender_expr _Sender, class _Env>
- requires same_as<__early_domain_of_t<_Sender>, dependent_domain>
- STDEXEC_ATTRIBUTE((always_inline))
- decltype(auto) transform_sender(_Sender&& __sndr, const _Env& __env) const
- noexcept(__is_nothrow_transform_sender<_Sender, _Env>());
-};
-
-/////////////////////////////////////////////////////////////////////////////
-// [execution.transform_sender]
-namespace __domain
-{
-struct __transform_env
-{
- template <class _Domain, class _Sender, class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- /*constexpr*/
- decltype(auto) operator()(_Domain __dom, _Sender&& __sndr,
- _Env&& __env) const noexcept
- {
- if constexpr (__domain::__has_transform_env<_Domain, _Sender, _Env>)
- {
- return __dom.transform_env(static_cast<_Sender&&>(__sndr),
- static_cast<_Env&&>(__env));
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.transform_sender]
+ namespace __detail {
+ struct __transform_env {
+ template <class _Domain, class _Sender, class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto
+ operator()(_Domain __dom, _Sender&& __sndr, _Env&& __env) const noexcept -> decltype(auto) {
+ if constexpr (__detail::__has_transform_env<_Domain, _Sender, _Env>) {
+ return __dom.transform_env(static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env));
+ } else {
+ return default_domain()
+ .transform_env(static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env));
}
- else
- {
- return default_domain().transform_env(
- static_cast<_Sender&&>(__sndr), static_cast<_Env&&>(__env));
- }
- }
-};
+ }
+ };
-struct __transform_sender_1
-{
- template <class _Domain, class _Sender, class... _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static constexpr bool __is_nothrow() noexcept
- {
- if constexpr (__domain::__has_transform_sender<_Domain, _Sender,
- _Env...>)
- {
- return noexcept(__declval<_Domain&>().transform_sender(
- __declval<_Sender>(), __declval<const _Env&>()...));
+ struct __transform_sender_1 {
+ template <class _Domain, class _Sender, class... _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static constexpr auto __is_nothrow() noexcept -> bool {
+ if constexpr (__detail::__has_transform_sender<_Domain, _Sender, _Env...>) {
+ return noexcept(__declval<_Domain&>()
+ .transform_sender(__declval<_Sender>(), __declval<const _Env&>()...));
+ } else {
+ return noexcept(default_domain()
+ .transform_sender(__declval<_Sender>(), __declval<const _Env&>()...));
}
- else
- {
- return //
- noexcept(default_domain().transform_sender(
- __declval<_Sender>(), __declval<const _Env&>()...));
- }
- }
+ }
- template <class _Domain, class _Sender, class... _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- /*constexpr*/
- decltype(auto) operator()(_Domain __dom, _Sender&& __sndr,
- const _Env&... __env) const
- noexcept(__is_nothrow<_Domain, _Sender, const _Env&...>())
- {
- if constexpr (__domain::__has_transform_sender<_Domain, _Sender,
- _Env...>)
- {
- return __dom.transform_sender(static_cast<_Sender&&>(__sndr),
- __env...);
+ template <class _Domain, class _Sender, class... _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Domain __dom, _Sender&& __sndr, const _Env&... __env) const
+ noexcept(__is_nothrow<_Domain, _Sender, const _Env&...>()) -> decltype(auto) {
+ if constexpr (__detail::__has_transform_sender<_Domain, _Sender, _Env...>) {
+ return __dom.transform_sender(static_cast<_Sender&&>(__sndr), __env...);
+ } else {
+ return default_domain().transform_sender(static_cast<_Sender&&>(__sndr), __env...);
}
- else
- {
- return default_domain().transform_sender(
- static_cast<_Sender&&>(__sndr), __env...);
- }
- }
-};
+ }
+ };
-template <class _Ty, class _Uy>
-concept __decay_same_as = same_as<__decay_t<_Ty>, __decay_t<_Uy>>;
+ template <class _Ty, class _Uy>
+ concept __decay_same_as = same_as<__decay_t<_Ty>, __decay_t<_Uy>>;
-struct __transform_sender
-{
- template <class _Self = __transform_sender, class _Domain, class _Sender,
- class... _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- /*constexpr*/
- decltype(auto) operator()(_Domain __dom, _Sender&& __sndr,
- const _Env&... __env) const
- noexcept(__nothrow_callable<__transform_sender_1, _Domain, _Sender,
- const _Env&...>)
- {
- using _Sender2 = __call_result_t<__transform_sender_1, _Domain, _Sender,
- const _Env&...>;
+ struct __transform_sender {
+ template <class _Self = __transform_sender, class _Domain, class _Sender, class... _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Domain __dom, _Sender&& __sndr, const _Env&... __env) const
+ noexcept(__nothrow_callable<__transform_sender_1, _Domain, _Sender, const _Env&...>)
+ -> decltype(auto) {
+ using _Sender2 = __call_result_t<__transform_sender_1, _Domain, _Sender, const _Env&...>;
// If the transformation doesn't change the sender's type, then do not
// apply the transform recursively.
- if constexpr (__decay_same_as<_Sender, _Sender2>)
- {
- return __transform_sender_1()(__dom, static_cast<_Sender&&>(__sndr),
- __env...);
- }
- else
- {
- // We transformed the sender and got back a different sender.
- // Transform that one too.
- return _Self()(__dom,
- __transform_sender_1()(
- __dom, static_cast<_Sender&&>(__sndr), __env...),
- __env...);
- }
- }
-};
-
-struct __transform_dependent_sender
-{
- // If we are doing a lazy customization of a type whose domain is
- // value-dependent (e.g., let_value), first transform the sender to
- // determine the domain. Then continue transforming the sender with the
- // requested domain.
- template <class _Domain, sender_expr _Sender, class _Env>
- requires same_as<__early_domain_of_t<_Sender>, dependent_domain>
- /*constexpr*/ auto operator()(_Domain __dom, _Sender&& __sndr,
- const _Env& __env) const
- noexcept(noexcept(__transform_sender()(
+ if constexpr (__decay_same_as<_Sender, _Sender2>) {
+ return __transform_sender_1()(__dom, static_cast<_Sender&&>(__sndr), __env...);
+ } else {
+ // We transformed the sender and got back a different sender. Transform that one too.
+ return _Self()(
__dom,
- dependent_domain().transform_sender(static_cast<_Sender&&>(__sndr),
- __env),
- __env))) -> decltype(auto)
- {
+ __transform_sender_1()(__dom, static_cast<_Sender&&>(__sndr), __env...),
+ __env...);
+ }
+ }
+ };
+
+ struct __transform_dependent_sender {
+ // If we are doing a lazy customization of a type whose domain is value-dependent (e.g.,
+ // let_value), first transform the sender to determine the domain. Then continue transforming
+ // the sender with the requested domain.
+ template <class _Domain, sender_expr _Sender, class _Env>
+ requires same_as<__early_domain_of_t<_Sender>, dependent_domain>
+ auto operator()(_Domain __dom, _Sender&& __sndr, const _Env& __env) const
+ noexcept(noexcept(__transform_sender()(
+ __dom,
+ dependent_domain().transform_sender(static_cast<_Sender&&>(__sndr), __env),
+ __env))) -> decltype(auto) {
static_assert(__none_of<_Domain, dependent_domain>);
- return __transform_sender()(__dom,
- dependent_domain().transform_sender(
- static_cast<_Sender&&>(__sndr), __env),
- __env);
- }
-};
-} // namespace __domain
+ return __transform_sender()(
+ __dom, dependent_domain().transform_sender(static_cast<_Sender&&>(__sndr), __env), __env);
+ }
+ };
+ } // namespace __detail
-/////////////////////////////////////////////////////////////////////////////
-// [execution.transform_sender]
-inline constexpr struct transform_sender_t :
- __domain::__transform_sender,
- __domain::__transform_dependent_sender
-{
- using __domain::__transform_sender::operator();
- using __domain::__transform_dependent_sender::operator();
-} transform_sender{};
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.transform_sender]
+ inline constexpr struct transform_sender_t
+ : __detail::__transform_sender
+ , __detail::__transform_dependent_sender {
+ using __detail::__transform_sender::operator();
+ using __detail::__transform_dependent_sender::operator();
+ } transform_sender{};
-template <class _Domain, class _Sender, class... _Env>
-using transform_sender_result_t =
- __call_result_t<transform_sender_t, _Domain, _Sender, _Env...>;
+ inline constexpr __detail::__transform_env transform_env{};
-inline constexpr __domain::__transform_env transform_env{};
+ struct _CHILD_SENDERS_WITH_DIFFERENT_DOMAINS_ { };
-struct _CHILD_SENDERS_WITH_DIFFERENT_DOMAINS_
-{};
-
-template <class _Sender, class _Env>
-constexpr auto dependent_domain::__is_nothrow_transform_sender() noexcept
- -> bool
-{
- using _Env2 = __call_result_t<__domain::__transform_env, dependent_domain&,
- _Sender, _Env>;
+ template <class _Sender, class _Env>
+ constexpr auto dependent_domain::__is_nothrow_transform_sender() noexcept -> bool {
+ using _Env2 = __call_result_t<__detail::__transform_env, dependent_domain&, _Sender, _Env>;
return __v<decltype(__sexpr_apply(
- __declval<_Sender>(), []<class _Tag, class _Data, class... _Childs>(
- _Tag, _Data&&, _Childs&&...) {
- constexpr bool __first_transform_is_nothrow =
- noexcept(__make_sexpr<_Tag>(
- __declval<_Data>(),
- __domain::__transform_sender()(
- __declval<dependent_domain&>(), __declval<_Childs>(),
- __declval<const _Env2&>())...));
- using _Sender2 = decltype(__make_sexpr<_Tag>(
- __declval<_Data>(),
- __domain::__transform_sender()(__declval<dependent_domain&>(),
- __declval<_Childs>(),
- __declval<const _Env2&>())...));
- using _Domain2 = decltype(__sexpr_apply(
- __declval<_Sender2&>(), __domain::__common_domain_fn()));
- constexpr bool __second_transform_is_nothrow =
- noexcept(__domain::__transform_sender()(
- __declval<_Domain2&>(), __declval<_Sender2>(),
- __declval<const _Env&>()));
- return __mbool<__first_transform_is_nothrow &&
- __second_transform_is_nothrow>();
- }))>;
-}
+ __declval<_Sender>(),
+ []<class _Tag, class _Data, class... _Childs>(_Tag, _Data&&, _Childs&&...) {
+ constexpr bool __first_transform_is_nothrow = noexcept(__make_sexpr<_Tag>(
+ __declval<_Data>(),
+ __detail::__transform_sender()(
+ __declval<dependent_domain&>(), __declval<_Childs>(), __declval<const _Env2&>())...));
+ using _Sender2 = decltype(__make_sexpr<_Tag>(
+ __declval<_Data>(),
+ __detail::__transform_sender()(
+ __declval<dependent_domain&>(), __declval<_Childs>(), __declval<const _Env2&>())...));
+ using _Domain2 =
+ decltype(__sexpr_apply(__declval<_Sender2&>(), __detail::__common_domain_fn()));
+ constexpr bool __second_transform_is_nothrow = noexcept(__detail::__transform_sender()(
+ __declval<_Domain2&>(), __declval<_Sender2>(), __declval<const _Env&>()));
+ return __mbool<__first_transform_is_nothrow && __second_transform_is_nothrow>();
+ }))>;
+ }
-template <sender_expr _Sender, class _Env>
+ template <sender_expr _Sender, class _Env>
requires same_as<__early_domain_of_t<_Sender>, dependent_domain>
-auto dependent_domain::transform_sender(_Sender&& __sndr,
- const _Env& __env) const
- noexcept(__is_nothrow_transform_sender<_Sender, _Env>()) -> decltype(auto)
-{
+ auto dependent_domain::transform_sender(_Sender&& __sndr, const _Env& __env) const
+ noexcept(__is_nothrow_transform_sender<_Sender, _Env>()) -> decltype(auto) {
// apply any algorithm-specific transformation to the environment
- const auto& __env2 =
- transform_env(*this, static_cast<_Sender&&>(__sndr), __env);
+ const auto& __env2 = transform_env(*this, static_cast<_Sender&&>(__sndr), __env);
// recursively transform the sender to determine the domain
return __sexpr_apply(
- static_cast<_Sender&&>(__sndr),
- [&]<class _Tag, class _Data, class... _Childs>(_Tag, _Data&& __data,
- _Childs&&... __childs) {
- // TODO: propagate meta-exceptions here:
- auto __sndr2 = __make_sexpr<_Tag>(
- static_cast<_Data&&>(__data),
- __domain::__transform_sender()(
- *this, static_cast<_Childs&&>(__childs), __env2)...);
- using _Sender2 = decltype(__sndr2);
+ static_cast<_Sender&&>(__sndr),
+ [&]<class _Tag, class _Data, class... _Childs>(_Tag, _Data&& __data, _Childs&&... __childs) {
+ // TODO: propagate meta-exceptions here:
+ auto __sndr2 = __make_sexpr<_Tag>(
+ static_cast<_Data&&>(__data),
+ __detail::__transform_sender()(*this, static_cast<_Childs&&>(__childs), __env2)...);
+ using _Sender2 = decltype(__sndr2);
- auto __domain2 =
- __sexpr_apply(__sndr2, __domain::__common_domain_fn());
- using _Domain2 = decltype(__domain2);
+ auto __domain2 = __sexpr_apply(__sndr2, __detail::__common_domain_fn());
+ using _Domain2 = decltype(__domain2);
- if constexpr (same_as<_Domain2, __none_such>)
- {
- return __mexception<_CHILD_SENDERS_WITH_DIFFERENT_DOMAINS_,
- _WITH_SENDER_<_Sender2>>();
- }
- else
- {
- return __domain::__transform_sender()(
- __domain2, std::move(__sndr2), __env);
- }
- });
-}
+ if constexpr (same_as<_Domain2, __none_such>) {
+ return __mexception<_CHILD_SENDERS_WITH_DIFFERENT_DOMAINS_, _WITH_SENDER_<_Sender2>>();
+ } else {
+ return __detail::__transform_sender()(__domain2, std::move(__sndr2), __env);
+ }
+ });
+ }
-/////////////////////////////////////////////////////////////////////////////
-template <class _Tag, class _Domain, class _Sender, class... _Args>
-concept __has_implementation_for =
- __domain::__has_apply_sender<_Domain, _Tag, _Sender, _Args...> ||
- __domain::__has_apply_sender<default_domain, _Tag, _Sender, _Args...>;
+ /////////////////////////////////////////////////////////////////////////////
+ template <class _Tag, class _Domain, class _Sender, class... _Args>
+ concept __has_implementation_for =
+ __detail::__has_apply_sender<_Domain, _Tag, _Sender, _Args...>
+ || __detail::__has_apply_sender<default_domain, _Tag, _Sender, _Args...>;
-/////////////////////////////////////////////////////////////////////////////
-// [execution.apply_sender]
-inline constexpr struct apply_sender_t
-{
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.apply_sender]
+ inline constexpr struct apply_sender_t {
template <class _Domain, class _Tag, class _Sender, class... _Args>
- requires __has_implementation_for<_Tag, _Domain, _Sender, _Args...>
- STDEXEC_ATTRIBUTE((always_inline))
- /*constexpr*/
- decltype(auto) operator()(_Domain __dom, _Tag, _Sender&& __sndr,
- _Args&&... __args) const
- {
- if constexpr (__domain::__has_apply_sender<_Domain, _Tag, _Sender,
- _Args...>)
- {
- return __dom.apply_sender(_Tag(), static_cast<_Sender&&>(__sndr),
- static_cast<_Args&&>(__args)...);
- }
- else
- {
- return default_domain().apply_sender(
- _Tag(), static_cast<_Sender&&>(__sndr),
- static_cast<_Args&&>(__args)...);
- }
+ requires __has_implementation_for<_Tag, _Domain, _Sender, _Args...>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto
+ operator()(_Domain __dom, _Tag, _Sender&& __sndr, _Args&&... __args) const -> decltype(auto) {
+ if constexpr (__detail::__has_apply_sender<_Domain, _Tag, _Sender, _Args...>) {
+ return __dom
+ .apply_sender(_Tag(), static_cast<_Sender&&>(__sndr), static_cast<_Args&&>(__args)...);
+ } else {
+ return default_domain()
+ .apply_sender(_Tag(), static_cast<_Sender&&>(__sndr), static_cast<_Args&&>(__args)...);
+ }
}
-} apply_sender{};
+ } apply_sender{};
-template <class _Domain, class _Tag, class _Sender, class... _Args>
-using apply_sender_result_t =
- __call_result_t<apply_sender_t, _Domain, _Tag, _Sender, _Args...>;
+ template <class _Domain, class _Tag, class _Sender, class... _Args>
+ using apply_sender_result_t = __call_result_t<apply_sender_t, _Domain, _Tag, _Sender, _Args...>;
-/////////////////////////////////////////////////////////////////////////////
-template <class _Sender, class _Scheduler, class _Tag = set_value_t>
-concept __completes_on = __decays_to<
- __call_result_t<get_completion_scheduler_t<_Tag>, env_of_t<_Sender>>,
- _Scheduler>;
+ /////////////////////////////////////////////////////////////////////////////
+ template <class _Sender, class _Scheduler, class _Tag = set_value_t>
+ concept __completes_on =
+ __decays_to<__call_result_t<get_completion_scheduler_t<_Tag>, env_of_t<_Sender>>, _Scheduler>;
-/////////////////////////////////////////////////////////////////////////////
-template <class _Sender, class _Scheduler, class _Env>
-concept __starts_on =
- __decays_to<__call_result_t<get_scheduler_t, _Env>, _Scheduler>;
+ /////////////////////////////////////////////////////////////////////////////
+ template <class _Sender, class _Scheduler, class _Env>
+ concept __starts_on = __decays_to<__call_result_t<get_scheduler_t, _Env>, _Scheduler>;
} // namespace stdexec
STDEXEC_PRAGMA_POP()
diff --git a/include/sdbusplus/async/stdexec/__detail/__tuple.hpp b/include/sdbusplus/async/stdexec/__detail/__tuple.hpp
index 3c5f2d2..ece94ff 100644
--- a/include/sdbusplus/async/stdexec/__detail/__tuple.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__tuple.hpp
@@ -15,196 +15,242 @@
*/
#pragma once
-#include "__concepts.hpp"
#include "__config.hpp"
-#include "__meta.hpp"
+#include "__concepts.hpp"
#include "__type_traits.hpp"
+#include "__meta.hpp"
#include <cstddef>
-namespace stdexec
-{
-namespace __tup
-{
-template <class _Ty, std::size_t _Idx>
-struct __box
-{
- // See https://github.com/llvm/llvm-project/issues/93563
- // STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
- _Ty __value;
-};
-
-template <class _Ty>
-concept __empty = //
- STDEXEC_IS_EMPTY(_Ty) && STDEXEC_IS_TRIVIALLY_CONSTRUCTIBLE(_Ty);
-
-template <__empty _Ty>
-inline _Ty __value{};
-
-// A specialization for empty types so that they don't take up space.
-template <__empty _Ty, std::size_t _Idx>
-struct __box<_Ty, _Idx>
-{
- __box() = default;
-
- constexpr __box(__not_decays_to<__box> auto&&) noexcept {}
-
- static constexpr _Ty& __value = __tup::__value<_Ty>;
-};
-
-template <auto _Idx, class... _Ts>
-struct __tuple;
-
-template <std::size_t... _Is, __indices<_Is...> _Idx, class... _Ts>
-struct __tuple<_Idx, _Ts...> : __box<_Ts, _Is>...
-{
- template <class... _Us>
- static __tuple __convert_from(__tuple<_Idx, _Us...>&& __tup)
- {
- return __tuple{{static_cast<_Us&&>(__tup.__box<_Us, _Is>::__value)}...};
- }
-
- template <class... _Us>
- static __tuple __convert_from(const __tuple<_Idx, _Us...>& __tup)
- {
- return __tuple{{__tup.__box<_Us, _Is>::__value}...};
- }
-
- template <class _Fn, class _Self, class... _Us>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- static auto apply(_Fn&& __fn, _Self&& __self, _Us&&... __us) //
- noexcept(noexcept(static_cast<_Fn&&>(__fn)(
- static_cast<_Us&&>(__us)...,
- static_cast<_Self&&>(__self).__box<_Ts, _Is>::__value...)))
- -> decltype(static_cast<_Fn&&>(__fn)(
- static_cast<_Us&&>(__us)...,
- static_cast<_Self&&>(__self).__box<_Ts, _Is>::__value...))
- {
- return static_cast<_Fn&&>(
- __fn)(static_cast<_Us&&>(__us)...,
- static_cast<_Self&&>(__self).__box<_Ts, _Is>::__value...);
- }
-
- template <class _Fn, class _Self, class... _Us>
- requires(__callable<_Fn, _Us..., __copy_cvref_t<_Self, _Ts>> && ...)
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- static auto for_each(_Fn&& __fn, _Self&& __self, _Us&&... __us) //
- noexcept((__nothrow_callable<_Fn, _Us..., __copy_cvref_t<_Self, _Ts>> &&
- ...)) -> void
- {
- return (static_cast<_Fn&&>(__fn)(
- static_cast<_Us&&>(__us)...,
- static_cast<_Self&&>(__self).__box<_Ts, _Is>::__value),
- ...);
- }
-};
-
-template <class... _Ts>
-STDEXEC_ATTRIBUTE((host, device))
-__tuple(_Ts...) -> __tuple<__indices_for<_Ts...>{}, _Ts...>;
-
-template <class _Fn, class _Tuple, class... _Us>
-using __apply_result_t = //
- decltype(__declval<_Tuple>().apply(__declval<_Fn>(), __declval<_Tuple>(),
- __declval<_Us>()...));
-
-template <class _Fn, class _Tuple, class... _Us>
-concept __applicable =
- requires { typename __apply_result_t<_Fn, _Tuple, _Us...>; };
-
-template <class _Fn, class _Tuple, class... _Us>
-concept __nothrow_applicable =
- __applicable<_Fn, _Tuple, _Us...> &&
- noexcept(__declval<_Tuple>().apply(__declval<_Fn>(), __declval<_Tuple>(),
- __declval<_Us>()...));
-
-#if STDEXEC_GCC()
-template <class... _Ts>
-struct __mk_tuple
-{
- using __t = __tuple<__indices_for<_Ts...>{}, _Ts...>;
-};
+#if STDEXEC_GCC() || STDEXEC_NVHPC()
+// GCC (as of v14) does not implement the resolution of CWG1835
+// https://cplusplus.github.io/CWG/issues/1835.html
+// See: https://godbolt.org/z/TzxrhK6ea
+# define STDEXEC_NO_CWG1835
#endif
-template <std::size_t _Idx, class _Ty>
-STDEXEC_ATTRIBUTE((host, device, always_inline))
-constexpr _Ty&& get(__box<_Ty, _Idx>&& __self) noexcept
-{
- return static_cast<_Ty&&>(__self.__value);
-}
-
-template <std::size_t _Idx, class _Ty>
-STDEXEC_ATTRIBUTE((host, device, always_inline))
-constexpr _Ty& get(__box<_Ty, _Idx>& __self) noexcept
-{
- return __self.__value;
-}
-
-template <std::size_t _Idx, class _Ty>
-STDEXEC_ATTRIBUTE((host, device, always_inline))
-constexpr const _Ty& get(const __box<_Ty, _Idx>& __self) noexcept
-{
- return __self.__value;
-}
-
-template <class _Fn, class _Tuple>
-STDEXEC_ATTRIBUTE((host, device, always_inline))
-auto operator<<(_Tuple&& __tup,
- _Fn __fn) noexcept(__nothrow_move_constructible<_Fn>)
-{
- return [&__tup, __fn]<class... _Us>(_Us&&... __us) //
- noexcept(__nothrow_applicable<_Fn, _Tuple, _Us...>)
- -> __apply_result_t<_Fn, _Tuple, _Us...> {
- return __tup.apply(__fn, static_cast<_Tuple&&>(__tup),
- static_cast<_Us&&>(__us)...);
- };
-}
-
-template <class _Fn, class... _Tuples>
-auto __cat_apply(_Fn __fn, _Tuples&&... __tups) //
- noexcept(noexcept((static_cast<_Tuples&&>(__tups) << ... << __fn)())) //
- -> decltype((static_cast<_Tuples&&>(__tups) << ... << __fn)())
-{
- return (static_cast<_Tuples&&>(__tups) << ... << __fn)();
-}
-
-STDEXEC_PRAGMA_PUSH()
-STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
-
-inline constexpr struct __mktuple_t
-{
- template <class... _Ts>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- auto operator()(_Ts&&... __ts) const
- noexcept(noexcept(__tuple{static_cast<_Ts&&>(__ts)...}))
- -> decltype(__tuple{static_cast<_Ts&&>(__ts)...})
- {
- return __tuple{static_cast<_Ts&&>(__ts)...};
- }
-} __mktuple{};
-
-STDEXEC_PRAGMA_POP()
-
-} // namespace __tup
-
-using __tup::__tuple;
-
-#if STDEXEC_GCC()
-template <class... _Ts>
-using __tuple_for = __t<__tup::__mk_tuple<_Ts...>>;
+#ifdef STDEXEC_NO_CWG1835
+# define STDEXEC_CWG1835_TEMPLATE
#else
-template <class... _Ts>
-using __tuple_for = __tuple<__indices_for<_Ts...>{}, _Ts...>;
+# define STDEXEC_CWG1835_TEMPLATE template
#endif
-template <class... _Ts>
-using __decayed_tuple = __tuple_for<__decay_t<_Ts>...>;
+namespace stdexec {
+ namespace __tup {
+ template <class _Ty, std::size_t _Idx>
+ struct __box {
+ STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
+ _Ty __value;
+ };
-// So we can use __tuple as a typelist
-template <auto _Idx, class... _Ts>
-struct __muncurry_<__tuple<_Idx, _Ts...>>
-{
+ template <class _Ty>
+ concept __empty = STDEXEC_IS_EMPTY(_Ty) && STDEXEC_IS_TRIVIALLY_CONSTRUCTIBLE(_Ty)
+ && STDEXEC_IS_TRIVIALLY_COPYABLE(_Ty);
+
+ template <__empty _Ty>
+ inline _Ty __value{};
+
+ // A specialization for empty types so that they don't take up space.
+ template <__empty _Ty, std::size_t _Idx>
+ struct __box<_Ty, _Idx> {
+ __box() = default;
+
+ constexpr __box(__not_decays_to<__box> auto &&) noexcept {
+ }
+
+ static constexpr _Ty &__value = __tup::__value<_Ty>;
+ };
+
+ template <std::size_t _Idx, class _Ty>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto __get(__box<_Ty, _Idx> &&__self) noexcept -> _Ty && {
+ return static_cast<_Ty &&>(__self.__value);
+ }
+
+ template <std::size_t _Idx, class _Ty>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto __get(__box<_Ty, _Idx> &__self) noexcept -> _Ty & {
+ return __self.__value;
+ }
+
+ template <std::size_t _Idx, class _Ty>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto __get(const __box<_Ty, _Idx> &__self) noexcept -> const _Ty & {
+ return __self.__value;
+ }
+
+ template <auto _Idx, class... _Ts>
+ struct __tuple;
+
+ template <std::size_t... _Is, __indices<_Is...> _Idx, class... _Ts>
+ requires(sizeof...(_Ts) - 1 > 3) // intentional unsigned wrap-around for sizeof...(Ts) is zero
+ struct __tuple<_Idx, _Ts...> : __box<_Ts, _Is>... {
+ template <class... _Us>
+ static constexpr auto __convert_from(__tuple<_Idx, _Us...> &&__tup) -> __tuple {
+ return __tuple{
+ {static_cast<_Us &&>(__tup.STDEXEC_CWG1835_TEMPLATE __box<_Us, _Is>::__value)}...};
+ }
+
+ template <class... _Us>
+ static constexpr auto __convert_from(__tuple<_Idx, _Us...> const &__tup) -> __tuple {
+ return __tuple{{__tup.STDEXEC_CWG1835_TEMPLATE __box<_Us, _Is>::__value}...};
+ }
+
+ template <std::size_t _Np, class _Self>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ static constexpr auto __get(_Self &&__self) noexcept
+ -> decltype(__tup::__get<_Np>(static_cast<_Self &&>(__self))) {
+ return __tup::__get<_Np>(static_cast<_Self &&>(__self));
+ }
+
+ // clang-format off
+ template <class _Fn, class _Self, class... _Us>
+ STDEXEC_ATTRIBUTE(host, device, always_inline) static constexpr auto apply(_Fn &&__fn, _Self &&__self, _Us &&...__us)
+ STDEXEC_AUTO_RETURN(
+ static_cast<_Fn &&>(__fn)(
+ static_cast<_Us &&>(__us)...,
+ static_cast<_Self &&>(__self).STDEXEC_CWG1835_TEMPLATE __box<_Ts, _Is>::__value...))
+
+ template <class _Fn, class _Self, class... _Us>
+ STDEXEC_ATTRIBUTE(host, device, always_inline) static constexpr auto for_each(_Fn &&__fn, _Self &&__self)
+ STDEXEC_AUTO_RETURN(
+ (static_cast<void>(
+ __fn(static_cast<_Self &&>(__self).STDEXEC_CWG1835_TEMPLATE __box<_Ts, _Is>::__value)),
+ ...))
+ // clang-format on
+ };
+
+ // unroll the tuple implementation for up to 4 elements
+
+#define STDEXEC_TPARAM_DEFN(_N) , class _T##_N
+#define STDEXEC_TPARAM_USE(_N) , _T##_N
+#define STDEXEC_TPARAM_OTHER_DEFN(_N) , class _U##_N
+#define STDEXEC_TPARAM_OTHER_USE(_N) , _U##_N
+#define STDEXEC_TUPLE_ELEM_DEFN(_N) _T##_N __elem##_N;
+#define STDEXEC_TUPLE_ELEM_USE(_N) , static_cast<_Self &&>(__self).__elem##_N
+#define STDEXEC_TUPLE_OTHER_ELEM_RVALUE(_N) , static_cast<_U##_N &&>(__tup.__elem##_N)
+#define STDEXEC_TUPLE_OTHER_ELEM_LVALUE(_N) , __tup.__elem##_N
+#define STDEXEC_TUPLE_FOR_EACH_ELEM(_N) \
+ , static_cast<void>(static_cast<_Fn &&>(__fn)(__self.__elem##_N))
+#define STDEXEC_TUPLE_GET_ELEM(_N) \
+ if constexpr (_Np == _N) \
+ return (static_cast<_Self &&>(__self).__elem##_N); \
+ else
+
+ // clang-format off
+#define STDEXEC_TUPLE_DEFN(_N) \
+ template <std::size_t... _Is, __indices<_Is...> _Idx STDEXEC_REPEAT(_N, STDEXEC_TPARAM_DEFN)> \
+ struct __tuple<_Idx STDEXEC_REPEAT(_N, STDEXEC_TPARAM_USE)> { \
+ STDEXEC_REPEAT(_N, STDEXEC_TUPLE_ELEM_DEFN) \
+ \
+ template <STDEXEC_EVAL(STDEXEC_TAIL, STDEXEC_REPEAT(_N, STDEXEC_TPARAM_OTHER_DEFN))> \
+ static constexpr auto __convert_from(__tuple<_Idx STDEXEC_REPEAT(_N, STDEXEC_TPARAM_OTHER_USE)> &&__tup) \
+ -> __tuple { \
+ return __tuple{ \
+ STDEXEC_EVAL(STDEXEC_TAIL, STDEXEC_REPEAT(_N, STDEXEC_TUPLE_OTHER_ELEM_RVALUE))}; \
+ } \
+ \
+ template <STDEXEC_EVAL(STDEXEC_TAIL, STDEXEC_REPEAT(_N, STDEXEC_TPARAM_OTHER_DEFN))> \
+ static constexpr auto __convert_from( \
+ __tuple<_Idx STDEXEC_REPEAT(_N, STDEXEC_TPARAM_OTHER_USE)> const &__tup) -> __tuple { \
+ return __tuple{ \
+ STDEXEC_EVAL(STDEXEC_TAIL, STDEXEC_REPEAT(_N, STDEXEC_TUPLE_OTHER_ELEM_LVALUE))}; \
+ } \
+ \
+ template <std::size_t _Np, class _Self> \
+ STDEXEC_ATTRIBUTE(host, device, always_inline) \
+ static constexpr auto __get(_Self &&__self) noexcept -> decltype(auto) requires(_Np < _N) { \
+ STDEXEC_REPEAT(_N, STDEXEC_TUPLE_GET_ELEM); \
+ } \
+ \
+ template <class _Fn, class _Self, class... _Us> \
+ STDEXEC_ATTRIBUTE(host, device, always_inline) \
+ static constexpr auto apply(_Fn &&__fn, _Self &&__self, _Us &&...__us) STDEXEC_AUTO_RETURN( \
+ static_cast<_Fn &&>(__fn)(static_cast<_Us &&>(__us)... \
+ STDEXEC_REPEAT(_N, STDEXEC_TUPLE_ELEM_USE))) \
+ \
+ template <class _Fn, class _Self> \
+ STDEXEC_ATTRIBUTE(host, device, always_inline) \
+ static constexpr auto for_each(_Fn &&__fn, _Self &&__self) STDEXEC_AUTO_RETURN( \
+ STDEXEC_EVAL(STDEXEC_TAIL, STDEXEC_REPEAT(_N, STDEXEC_TUPLE_FOR_EACH_ELEM))) \
+ };
+ // clang-format on
+
+ STDEXEC_TUPLE_DEFN(1)
+ STDEXEC_TUPLE_DEFN(2)
+ STDEXEC_TUPLE_DEFN(3)
+ STDEXEC_TUPLE_DEFN(4)
+
+ template <class... _Ts>
+ STDEXEC_ATTRIBUTE(host, device)
+ __tuple(_Ts...) -> __tuple<__indices_for<_Ts...>{}, _Ts...>;
+
+ template <class _Fn, class _Tuple, class... _Us>
+ using __apply_result_t =
+ decltype(__declval<_Tuple>()
+ .apply(__declval<_Fn>(), __declval<_Tuple>(), __declval<_Us>()...));
+
+ template <class _Fn, class _Tuple, class... _Us>
+ concept __applicable = requires { typename __apply_result_t<_Fn, _Tuple, _Us...>; };
+
+ template <class _Fn, class _Tuple, class... _Us>
+ concept __nothrow_applicable =
+ __applicable<_Fn, _Tuple, _Us...>
+ && noexcept(__declval<_Tuple>()
+ .apply(__declval<_Fn>(), __declval<_Tuple>(), __declval<_Us>()...));
+
+#if STDEXEC_GCC()
+ template <class... _Ts>
+ struct __mk_tuple {
+ using __t = __tuple<__indices_for<_Ts...>{}, _Ts...>;
+ };
+#endif
+
+ template <class _Fn, class _Tuple>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto
+ operator<<(_Tuple &&__tup, _Fn __fn) noexcept(__nothrow_move_constructible<_Fn>) {
+ return [&__tup, __fn = static_cast<_Fn &&>(__fn)]<class... _Us>(_Us &&...__us) noexcept(
+ __nothrow_applicable<_Fn, _Tuple, _Us...>) -> __apply_result_t<_Fn, _Tuple, _Us...> {
+ return __tup.apply(__fn, static_cast<_Tuple &&>(__tup), static_cast<_Us &&>(__us)...);
+ };
+ }
+
+ template <class _Fn, class... _Tuples>
+ constexpr auto __cat_apply(_Fn __fn, _Tuples &&...__tups)
+ STDEXEC_AUTO_RETURN((static_cast<_Tuples &&>(__tups) << ... << __fn)())
+
+ STDEXEC_PRAGMA_PUSH() STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
+
+ inline constexpr struct __mktuple_t {
+ template <class... _Ts>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_Ts &&...__ts) const noexcept(noexcept(__tuple{static_cast<_Ts &&>(__ts)...}))
+ -> decltype(__tuple{static_cast<_Ts &&>(__ts)...}) {
+ return __tuple{static_cast<_Ts &&>(__ts)...};
+ }
+ } __mktuple{};
+
+ STDEXEC_PRAGMA_POP()
+ } // namespace __tup
+
+ using __tup::__tuple;
+
+#if STDEXEC_GCC()
+ template <class... _Ts>
+ using __tuple_for = __t<__tup::__mk_tuple<_Ts...>>;
+#else
+ template <class... _Ts>
+ using __tuple_for = __tuple<__indices_for<_Ts...>{}, _Ts...>;
+#endif
+
+ template <class... _Ts>
+ using __decayed_tuple = __tuple_for<__decay_t<_Ts>...>;
+
+ // So we can use __tuple as a typelist
+ template <auto _Idx, class... _Ts>
+ struct __muncurry_<__tuple<_Idx, _Ts...>> {
template <class _Fn>
using __f = __minvoke<_Fn, _Ts...>;
-};
+ };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__type_traits.hpp b/include/sdbusplus/async/stdexec/__detail/__type_traits.hpp
index 8c6cc67..713f12c 100644
--- a/include/sdbusplus/async/stdexec/__detail/__type_traits.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__type_traits.hpp
@@ -17,205 +17,205 @@
#include "__config.hpp"
-#include <type_traits>
+#include <type_traits> // IWYU pragma: keep
+#include <utility> // IWYU pragma: keep
-namespace stdexec
-{
+namespace stdexec {
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// A very simple std::declval replacement that doesn't handle void
-template <class _Tp>
-extern auto (*__declval)() noexcept -> _Tp&&;
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // A very simple std::declval replacement that doesn't handle void
+ template <class _Tp, bool _Noexcept = true>
+ using __declfn = auto (*)() noexcept(_Noexcept) -> _Tp;
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// __decay_t: An efficient implementation for std::decay
+ template <class _Tp>
+ extern __declfn<_Tp &&> __declval;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // __decay_t: An efficient implementation for std::decay
#if STDEXEC_HAS_BUILTIN(__decay)
-namespace __tt
-{
-template <class>
-struct __wrap;
+ namespace __tt {
+ template <class>
+ struct __wrap;
-template <bool>
-struct __decay_
-{
- template <class _Ty>
- using __f = __decay(_Ty);
-};
-} // namespace __tt
-template <class _Ty>
-using __decay_t = typename __tt::__decay_<sizeof(__tt::__wrap<_Ty>*) ==
- ~0ul>::template __f<_Ty>;
+ template <bool>
+ struct __decay_ {
+ template <class _Ty>
+ using __f = __decay(_Ty);
+ };
+ } // namespace __tt
+ template <class _Ty>
+ using __decay_t = __tt::__decay_<sizeof(__tt::__wrap<_Ty> *) == ~0ul>::template __f<_Ty>;
#elif STDEXEC_EDG()
-template <class _Ty>
-using __decay_t = std::decay_t<_Ty>;
+ template <class _Ty>
+ using __decay_t = std::decay_t<_Ty>;
#else
-namespace __tt
-{
-struct __decay_object
-{
+ namespace __tt {
+ struct __decay_object {
+ template <class _Ty>
+ static _Ty __g(_Ty const &);
+ template <class _Ty>
+ using __f = decltype(__g(__declval<_Ty>()));
+ };
+
+ struct __decay_default {
+ template <class _Ty>
+ static _Ty __g(_Ty);
+ template <class _Ty>
+ using __f = decltype(__g(__declval<_Ty>()));
+ };
+
+ struct __decay_abominable {
+ template <class _Ty>
+ using __f = _Ty;
+ };
+
+ struct __decay_void {
+ template <class _Ty>
+ using __f = void;
+ };
+
template <class _Ty>
- static _Ty __g(const _Ty&);
+ extern __decay_object __mdecay;
+
+ template <class _Ty, class... Us>
+ extern __decay_default __mdecay<_Ty(Us...)>;
+
+ template <class _Ty, class... Us>
+ extern __decay_default __mdecay<_Ty(Us...) noexcept>;
+
+ template <class _Ty, class... Us>
+ extern __decay_default __mdecay<_Ty (&)(Us...)>;
+
+ template <class _Ty, class... Us>
+ extern __decay_default __mdecay<_Ty (&)(Us...) noexcept>;
+
+ template <class _Ty, class... Us>
+ extern __decay_abominable __mdecay<_Ty(Us...) const>;
+
+ template <class _Ty, class... Us>
+ extern __decay_abominable __mdecay<_Ty(Us...) const noexcept>;
+
+ template <class _Ty, class... Us>
+ extern __decay_abominable __mdecay<_Ty(Us...) const &>;
+
+ template <class _Ty, class... Us>
+ extern __decay_abominable __mdecay<_Ty(Us...) const & noexcept>;
+
+ template <class _Ty, class... Us>
+ extern __decay_abominable __mdecay<_Ty(Us...) const &&>;
+
+ template <class _Ty, class... Us>
+ extern __decay_abominable __mdecay<_Ty(Us...) const && noexcept>;
+
template <class _Ty>
- using __f = decltype(__g(__declval<_Ty>()));
-};
+ extern __decay_default __mdecay<_Ty[]>;
-struct __decay_default
-{
- template <class _Ty>
- static _Ty __g(_Ty);
- template <class _Ty>
- using __f = decltype(__g(__declval<_Ty>()));
-};
+ template <class _Ty, std::size_t N>
+ extern __decay_default __mdecay<_Ty[N]>;
-struct __decay_abominable
-{
- template <class _Ty>
- using __f = _Ty;
-};
+ template <class _Ty, std::size_t N>
+ extern __decay_default __mdecay<_Ty (&)[N]>;
-struct __decay_void
-{
- template <class _Ty>
- using __f = void;
-};
+ template <>
+ inline __decay_void __mdecay<void>;
-template <class _Ty>
-extern __decay_object __mdecay;
+ template <>
+ inline __decay_void __mdecay<void const>;
+ } // namespace __tt
-template <class _Ty, class... Us>
-extern __decay_default __mdecay<_Ty(Us...)>;
-
-template <class _Ty, class... Us>
-extern __decay_default __mdecay<_Ty(Us...) noexcept>;
-
-template <class _Ty, class... Us>
-extern __decay_default __mdecay<_Ty (&)(Us...)>;
-
-template <class _Ty, class... Us>
-extern __decay_default __mdecay<_Ty (&)(Us...) noexcept>;
-
-template <class _Ty, class... Us>
-extern __decay_abominable __mdecay<_Ty(Us...) const>;
-
-template <class _Ty, class... Us>
-extern __decay_abominable __mdecay<_Ty(Us...) const noexcept>;
-
-template <class _Ty, class... Us>
-extern __decay_abominable __mdecay<_Ty(Us...) const&>;
-
-template <class _Ty, class... Us>
-extern __decay_abominable __mdecay<_Ty(Us...) const & noexcept>;
-
-template <class _Ty, class... Us>
-extern __decay_abominable __mdecay<_Ty(Us...) const&&>;
-
-template <class _Ty, class... Us>
-extern __decay_abominable __mdecay<_Ty(Us...) const && noexcept>;
-
-template <class _Ty>
-extern __decay_default __mdecay<_Ty[]>;
-
-template <class _Ty, std::size_t N>
-extern __decay_default __mdecay<_Ty[N]>;
-
-template <class _Ty, std::size_t N>
-extern __decay_default __mdecay<_Ty (&)[N]>;
-
-template <>
-inline __decay_void __mdecay<void>;
-
-template <>
-inline __decay_void __mdecay<const void>;
-} // namespace __tt
-
-template <class _Ty>
-using __decay_t = typename decltype(__tt::__mdecay<_Ty>)::template __f<_Ty>;
+ template <class _Ty>
+ using __decay_t = decltype(__tt::__mdecay<_Ty>)::template __f<_Ty>;
#endif
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// __copy_cvref_t: For copying cvref from one type to another
-struct __cp
-{
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // __copy_cvref_t: For copying cvref from one type to another
+ struct __cp {
template <class _Tp>
using __f = _Tp;
-};
+ };
-struct __cpc
-{
+ struct __cpc {
template <class _Tp>
using __f = const _Tp;
-};
+ };
-struct __cplr
-{
+ struct __cplr {
template <class _Tp>
- using __f = _Tp&;
-};
+ using __f = _Tp &;
+ };
-struct __cprr
-{
+ struct __cprr {
template <class _Tp>
- using __f = _Tp&&;
-};
+ using __f = _Tp &&;
+ };
-struct __cpclr
-{
+ struct __cpclr {
template <class _Tp>
- using __f = const _Tp&;
-};
+ using __f = const _Tp &;
+ };
-struct __cpcrr
-{
+ struct __cpcrr {
template <class _Tp>
- using __f = const _Tp&&;
-};
+ using __f = const _Tp &&;
+ };
-template <class>
-extern __cp __cpcvr;
-template <class _Tp>
-extern __cpc __cpcvr<const _Tp>;
-template <class _Tp>
-extern __cplr __cpcvr<_Tp&>;
-template <class _Tp>
-extern __cprr __cpcvr<_Tp&&>;
-template <class _Tp>
-extern __cpclr __cpcvr<const _Tp&>;
-template <class _Tp>
-extern __cpcrr __cpcvr<const _Tp&&>;
-template <class _Tp>
-using __copy_cvref_fn = decltype(__cpcvr<_Tp>);
+ template <class>
+ extern __cp __cpcvr;
+ template <class _Tp>
+ extern __cpc __cpcvr<const _Tp>;
+ template <class _Tp>
+ extern __cplr __cpcvr<_Tp &>;
+ template <class _Tp>
+ extern __cprr __cpcvr<_Tp &&>;
+ template <class _Tp>
+ extern __cpclr __cpcvr<const _Tp &>;
+ template <class _Tp>
+ extern __cpcrr __cpcvr<const _Tp &&>;
+ template <class _Tp>
+ using __copy_cvref_fn = decltype(__cpcvr<_Tp>);
-template <class _From, class _To>
-using __copy_cvref_t = typename __copy_cvref_fn<_From>::template __f<_To>;
+ template <class _From, class _To>
+ using __copy_cvref_t = __copy_cvref_fn<_From>::template __f<_To>;
-template <class>
-inline constexpr bool __is_const_ = false;
-template <class _Up>
-inline constexpr bool __is_const_<const _Up> = true;
+ template <class>
+ inline constexpr bool __is_const_ = false;
+ template <class _Up>
+ inline constexpr bool __is_const_<_Up const> = true;
-namespace __tt
-{
-template <class _Ty>
-auto __remove_rvalue_reference_fn(_Ty&&) -> _Ty;
-} // namespace __tt
-
-template <class _Ty>
-using __remove_rvalue_reference_t =
- decltype(__tt::__remove_rvalue_reference_fn(__declval<_Ty>()));
-
-// Implemented as a class instead of a free function
-// because of a bizarre nvc++ compiler bug:
-struct __cref_fn
-{
+ namespace __tt {
template <class _Ty>
- auto operator()(const _Ty&) -> const _Ty&;
-};
-template <class _Ty>
-using __cref_t = decltype(__cref_fn{}(__declval<_Ty>()));
+ auto __remove_rvalue_reference_fn(_Ty &&) -> _Ty;
+ } // namespace __tt
+
+ template <class _Ty>
+ using __remove_rvalue_reference_t = decltype(__tt::__remove_rvalue_reference_fn(
+ __declval<_Ty>()));
+
+ // Implemented as a class instead of a free function
+ // because of a bizarre nvc++ compiler bug:
+ struct __cref_fn {
+ template <class _Ty>
+ auto operator()(const _Ty &) -> const _Ty &;
+ };
+ template <class _Ty>
+ using __cref_t = decltype(__cref_fn{}(__declval<_Ty>()));
+
+ // Because of nvc++ nvbugs#4679848, we can't make __mbool a simple alias for __mconstant,
+ // and because of nvc++ nvbugs#4668709 it can't be a simple alias for std::bool_constant,
+ // either. :-(
+ // template <bool _Bp>
+ // using __mbool = __mconstant<_Bp>;
+
+ template <bool _Bp>
+ struct __mbool : std::bool_constant<_Bp> { };
+
+ using __mtrue = __mbool<true>;
+ using __mfalse = __mbool<false>;
+
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__unstoppable.hpp b/include/sdbusplus/async/stdexec/__detail/__unstoppable.hpp
new file mode 100644
index 0000000..b67f9d0
--- /dev/null
+++ b/include/sdbusplus/async/stdexec/__detail/__unstoppable.hpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "__execution_fwd.hpp"
+
+// include these after __execution_fwd.hpp
+#include "__env.hpp"
+#include "__write_env.hpp"
+#include "../stop_token.hpp"
+
+namespace stdexec {
+ inline constexpr auto unstoppable = write_env(prop{get_stop_token, never_stop_token{}});
+} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__upon_error.hpp b/include/sdbusplus/async/stdexec/__detail/__upon_error.hpp
index eb71faa..497f5f1 100644
--- a/include/sdbusplus/async/stdexec/__detail/__upon_error.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__upon_error.hpp
@@ -15,102 +15,82 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__basic_sender.hpp"
#include "__diagnostics.hpp"
#include "__domain.hpp"
-#include "__execution_fwd.hpp"
#include "__meta.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
#include "__senders_core.hpp"
+#include "__sender_adaptor_closure.hpp"
#include "__transform_completion_signatures.hpp"
#include "__transform_sender.hpp"
+#include "__senders.hpp" // IWYU pragma: keep for __well_formed_sender
// include these after __execution_fwd.hpp
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.upon_error]
-namespace __upon_error
-{
-inline constexpr __mstring __upon_error_context =
- "In stdexec::upon_error(Sender, Function)..."_mstr;
-using __on_not_callable = __callable_error<__upon_error_context>;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.upon_error]
+ namespace __upon_error {
+ inline constexpr __mstring __upon_error_context =
+ "In stdexec::upon_error(Sender, Function)..."_mstr;
+ using __on_not_callable = __callable_error<__upon_error_context>;
-template <class _Fun, class _CvrefSender, class... _Env>
-using __completion_signatures_t = //
- transform_completion_signatures<
- __completion_signatures_of_t<_CvrefSender, _Env...>,
- __with_error_invoke_t<__on_not_callable, set_error_t, _Fun,
- _CvrefSender, _Env...>,
- __sigs::__default_set_value,
- __mbind_front<__mtry_catch_q<__set_value_invoke_t, __on_not_callable>,
- _Fun>::template __f>;
+ template <class _Fun, class _CvrefSender, class... _Env>
+ using __completion_signatures_t = transform_completion_signatures<
+ __completion_signatures_of_t<_CvrefSender, _Env...>,
+ __with_error_invoke_t<__on_not_callable, set_error_t, _Fun, _CvrefSender, _Env...>,
+ __sigs::__default_set_value,
+ __mbind_front<__mtry_catch_q<__set_value_invoke_t, __on_not_callable>, _Fun>::template __f
+ >;
-////////////////////////////////////////////////////////////////////////////////////////////////
-struct upon_error_t
-{
- template <sender _Sender, __movable_value _Fun>
- auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender
- auto
- {
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ struct upon_error_t {
+ template <sender _Sender, __movable_value _Fun>
+ auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain,
- __make_sexpr<upon_error_t>(static_cast<_Fun&&>(__fun),
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<upon_error_t>(static_cast<_Fun&&>(__fun), static_cast<_Sender&&>(__sndr)));
+ }
- template <__movable_value _Fun>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Fun __fun) const -> __binder_back<upon_error_t, _Fun>
- {
+ template <__movable_value _Fun>
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Fun __fun) const -> __binder_back<upon_error_t, _Fun> {
return {{static_cast<_Fun&&>(__fun)}, {}, {}};
- }
+ }
+ };
- using _Sender = __1;
- using _Fun = __0;
- using __legacy_customizations_t =
- __types<tag_invoke_t(upon_error_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(_Sender&)),
- _Sender, _Fun),
- tag_invoke_t(upon_error_t, _Sender, _Fun)>;
-};
-
-struct __upon_error_impl : __sexpr_defaults
-{
- static constexpr auto get_completion_signatures = //
+ struct __upon_error_impl : __sexpr_defaults {
+ static constexpr auto get_completion_signatures =
[]<class _Sender, class... _Env>(_Sender&&, _Env&&...) noexcept
- -> __completion_signatures_t<__decay_t<__data_of<_Sender>>,
- __child_of<_Sender>, _Env...> {
+ -> __completion_signatures_t<__decay_t<__data_of<_Sender>>, __child_of<_Sender>, _Env...> {
static_assert(sender_expr_for<_Sender, upon_error_t>);
return {};
- };
+ };
- static constexpr auto complete = //
+ static constexpr auto complete =
[]<class _Tag, class _State, class _Receiver, class... _Args>(
- __ignore, _State& __state, _Receiver& __rcvr, _Tag,
- _Args&&... __args) noexcept -> void {
- if constexpr (__same_as<_Tag, set_error_t>)
- {
- stdexec::__set_value_invoke(static_cast<_Receiver&&>(__rcvr),
- static_cast<_State&&>(__state),
- static_cast<_Args&&>(__args)...);
+ __ignore,
+ _State& __state,
+ _Receiver& __rcvr,
+ _Tag,
+ _Args&&... __args) noexcept -> void {
+ if constexpr (__same_as<_Tag, set_error_t>) {
+ stdexec::__set_value_invoke(
+ static_cast<_Receiver&&>(__rcvr),
+ static_cast<_State&&>(__state),
+ static_cast<_Args&&>(__args)...);
+ } else {
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
}
- else
- {
- _Tag()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
- }
+ };
};
-};
-} // namespace __upon_error
+ } // namespace __upon_error
-using __upon_error::upon_error_t;
-inline constexpr upon_error_t upon_error{};
+ using __upon_error::upon_error_t;
+ inline constexpr upon_error_t upon_error{};
-template <>
-struct __sexpr_impl<upon_error_t> : __upon_error::__upon_error_impl
-{};
+ template <>
+ struct __sexpr_impl<upon_error_t> : __upon_error::__upon_error_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__upon_stopped.hpp b/include/sdbusplus/async/stdexec/__detail/__upon_stopped.hpp
index 04b2299..5dc7c8e 100644
--- a/include/sdbusplus/async/stdexec/__detail/__upon_stopped.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__upon_stopped.hpp
@@ -15,104 +15,86 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__basic_sender.hpp"
#include "__diagnostics.hpp"
#include "__domain.hpp"
-#include "__execution_fwd.hpp"
#include "__meta.hpp"
-#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
#include "__senders_core.hpp"
+#include "__sender_adaptor_closure.hpp"
#include "__transform_completion_signatures.hpp"
#include "__transform_sender.hpp"
+#include "__senders.hpp" // IWYU pragma: keep for __well_formed_sender
// include these after __execution_fwd.hpp
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.upon_stopped]
-namespace __upon_stopped
-{
-inline constexpr __mstring __upon_stopped_context =
- "In stdexec::upon_stopped(Sender, Function)..."_mstr;
-using __on_not_callable = __callable_error<__upon_stopped_context>;
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.upon_stopped]
+ namespace __upon_stopped {
+ inline constexpr __mstring __upon_stopped_context =
+ "In stdexec::upon_stopped(Sender, Function)..."_mstr;
+ using __on_not_callable = __callable_error<__upon_stopped_context>;
-template <class _Fun, class _CvrefSender, class... _Env>
-using __completion_signatures_t = //
- transform_completion_signatures<
- __completion_signatures_of_t<_CvrefSender, _Env...>,
- __with_error_invoke_t<__on_not_callable, set_stopped_t, _Fun,
- _CvrefSender, _Env...>,
- __sigs::__default_set_value, __sigs::__default_set_error,
- __set_value_invoke_t<_Fun>>;
+ template <class _Fun, class _CvrefSender, class... _Env>
+ using __completion_signatures_t = transform_completion_signatures<
+ __completion_signatures_of_t<_CvrefSender, _Env...>,
+ __with_error_invoke_t<__on_not_callable, set_stopped_t, _Fun, _CvrefSender, _Env...>,
+ __sigs::__default_set_value,
+ __sigs::__default_set_error,
+ __set_value_invoke_t<_Fun>
+ >;
-////////////////////////////////////////////////////////////////////////////////////////////////
-struct upon_stopped_t
-{
- template <sender _Sender, __movable_value _Fun>
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ struct upon_stopped_t {
+ template <sender _Sender, __movable_value _Fun>
requires __callable<_Fun>
- auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender
- auto
- {
+ auto operator()(_Sender&& __sndr, _Fun __fun) const -> __well_formed_sender auto {
auto __domain = __get_early_domain(__sndr);
return stdexec::transform_sender(
- __domain,
- __make_sexpr<upon_stopped_t>(static_cast<_Fun&&>(__fun),
- static_cast<_Sender&&>(__sndr)));
- }
+ __domain,
+ __make_sexpr<upon_stopped_t>(static_cast<_Fun&&>(__fun), static_cast<_Sender&&>(__sndr)));
+ }
- template <__movable_value _Fun>
+ template <__movable_value _Fun>
requires __callable<_Fun>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Fun __fun) const -> __binder_back<upon_stopped_t, _Fun>
- {
+ STDEXEC_ATTRIBUTE(always_inline)
+ auto operator()(_Fun __fun) const -> __binder_back<upon_stopped_t, _Fun> {
return {{static_cast<_Fun&&>(__fun)}, {}, {}};
- }
+ }
+ };
- using _Sender = __1;
- using _Fun = __0;
- using __legacy_customizations_t =
- __types<tag_invoke_t(upon_stopped_t,
- get_completion_scheduler_t<set_value_t>(
- get_env_t(_Sender&)),
- _Sender, _Fun),
- tag_invoke_t(upon_stopped_t, _Sender, _Fun)>;
-};
-
-struct __upon_stopped_impl : __sexpr_defaults
-{
- static constexpr auto get_completion_signatures = //
+ struct __upon_stopped_impl : __sexpr_defaults {
+ static constexpr auto get_completion_signatures =
[]<class _Sender, class... _Env>(_Sender&&, _Env&&...) noexcept
- -> __completion_signatures_t<__decay_t<__data_of<_Sender>>,
- __child_of<_Sender>, _Env...> {
+ -> __completion_signatures_t<__decay_t<__data_of<_Sender>>, __child_of<_Sender>, _Env...> {
static_assert(sender_expr_for<_Sender, upon_stopped_t>);
return {};
- };
+ };
- static constexpr auto complete = //
+ static constexpr auto complete =
[]<class _Tag, class _State, class _Receiver, class... _Args>(
- __ignore, _State& __state, _Receiver& __rcvr, _Tag,
- _Args&&... __args) noexcept -> void {
- if constexpr (__same_as<_Tag, set_stopped_t>)
- {
- stdexec::__set_value_invoke(static_cast<_Receiver&&>(__rcvr),
- static_cast<_State&&>(__state),
- static_cast<_Args&&>(__args)...);
+ __ignore,
+ _State& __state,
+ _Receiver& __rcvr,
+ _Tag,
+ _Args&&... __args) noexcept -> void {
+ if constexpr (__same_as<_Tag, set_stopped_t>) {
+ stdexec::__set_value_invoke(
+ static_cast<_Receiver&&>(__rcvr),
+ static_cast<_State&&>(__state),
+ static_cast<_Args&&>(__args)...);
+ } else {
+ _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Args&&>(__args)...);
}
- else
- {
- _Tag()(static_cast<_Receiver&&>(__rcvr),
- static_cast<_Args&&>(__args)...);
- }
+ };
};
-};
-} // namespace __upon_stopped
+ } // namespace __upon_stopped
-using __upon_stopped::upon_stopped_t;
-inline constexpr upon_stopped_t upon_stopped{};
+ using __upon_stopped::upon_stopped_t;
+ inline constexpr upon_stopped_t upon_stopped{};
-template <>
-struct __sexpr_impl<upon_stopped_t> : __upon_stopped::__upon_stopped_impl
-{};
+ template <>
+ struct __sexpr_impl<upon_stopped_t> : __upon_stopped::__upon_stopped_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__utility.hpp b/include/sdbusplus/async/stdexec/__detail/__utility.hpp
index acbb9ad..709a106 100644
--- a/include/sdbusplus/async/stdexec/__detail/__utility.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__utility.hpp
@@ -15,67 +15,56 @@
*/
#pragma once
-#include "__concepts.hpp"
#include "__config.hpp"
+#include "__concepts.hpp"
#include "__type_traits.hpp"
#include <initializer_list>
-#include <memory> // for addressof
#include <type_traits>
-namespace stdexec
-{
-constexpr std::size_t __npos = ~0UL;
+namespace stdexec {
+ constexpr std::size_t __npos = ~0UL;
-template <class...>
-struct __undefined;
+ template <class...>
+ struct __undefined;
-struct __
-{};
+ struct __ { };
-struct __ignore
-{
+ struct __ignore {
__ignore() = default;
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr __ignore(auto&&...) noexcept {}
-};
+ STDEXEC_ATTRIBUTE(always_inline) constexpr __ignore(auto&&...) noexcept {
+ }
+ };
#if STDEXEC_MSVC()
-// MSVCBUG
-// https://developercommunity.visualstudio.com/t/Incorrect-function-template-argument-sub/10437827
+ // MSVCBUG https://developercommunity.visualstudio.com/t/Incorrect-function-template-argument-sub/10437827
-template <std::size_t>
-struct __ignore_t
-{
+ template <std::size_t>
+ struct __ignore_t {
__ignore_t() = default;
- constexpr __ignore_t(auto&&...) noexcept {}
-};
+ constexpr __ignore_t(auto&&...) noexcept {
+ }
+ };
#else
-template <std::size_t>
-using __ignore_t = __ignore;
+ template <std::size_t>
+ using __ignore_t = __ignore;
#endif
-struct __none_such
-{};
+ struct __none_such { };
-namespace
-{
-struct __anon
-{};
-} // namespace
+ namespace {
+ struct __anon { };
+ } // namespace
-struct __immovable
-{
+ struct __immovable {
__immovable() = default;
-
- private:
+ private:
STDEXEC_IMMOVABLE(__immovable);
-};
+ };
-struct __move_only
-{
+ struct __move_only {
__move_only() = default;
__move_only(__move_only&&) noexcept = default;
@@ -83,117 +72,110 @@
__move_only(const __move_only&) = delete;
auto operator=(const __move_only&) -> __move_only& = delete;
-};
+ };
-inline constexpr std::size_t __umax(
- std::initializer_list<std::size_t> __il) noexcept
-{
+ template <class... _Fns>
+ struct __overload : _Fns... {
+ using _Fns::operator()...;
+ };
+
+ template <class... _Fns>
+ __overload(_Fns...) -> __overload<_Fns...>;
+
+ inline constexpr auto __umax(std::initializer_list<std::size_t> __il) noexcept -> std::size_t {
std::size_t __m = 0;
- for (std::size_t __i : __il)
- {
- if (__i > __m)
- {
- __m = __i;
- }
+ for (std::size_t __i: __il) {
+ if (__i > __m) {
+ __m = __i;
+ }
}
return __m;
-}
+ }
-inline constexpr std::size_t __pos_of(const bool* const __first,
- const bool* const __last) noexcept
-{
- for (const bool* __where = __first; __where != __last; ++__where)
- {
- if (*__where)
- {
- return static_cast<std::size_t>(__where - __first);
- }
+ inline constexpr auto
+ __pos_of(const bool* const __first, const bool* const __last) noexcept -> std::size_t {
+ for (const bool* __where = __first; __where != __last; ++__where) {
+ if (*__where) {
+ return static_cast<std::size_t>(__where - __first);
+ }
}
return __npos;
-}
+ }
-template <class _Ty, class... _Ts>
-inline constexpr std::size_t __index_of() noexcept
-{
+ template <class _Ty, class... _Ts>
+ inline constexpr auto __index_of() noexcept -> std::size_t {
constexpr bool __same[] = {STDEXEC_IS_SAME(_Ty, _Ts)..., false};
return __pos_of(__same, __same + sizeof...(_Ts));
-}
+ }
-namespace __detail
-{
-template <class _Cpcvref>
-inline constexpr auto __forward_like =
- []<class _Uy>(_Uy&& __uy) noexcept -> auto&& {
- return static_cast<
- typename _Cpcvref::template __f<std::remove_reference_t<_Uy>>>(__uy);
-};
-} // namespace __detail
-
-template <class _Ty>
-inline constexpr const auto& __forward_like =
- __detail::__forward_like<__copy_cvref_fn<_Ty&&>>;
-
-STDEXEC_PRAGMA_PUSH()
-STDEXEC_PRAGMA_IGNORE_GNU("-Wold-style-cast")
-
-// A derived-to-base cast that works even when the base is not accessible from
-// derived.
-template <class _Tp, class _Up>
-STDEXEC_ATTRIBUTE((host, device))
-auto __c_upcast(_Up&& u) noexcept -> __copy_cvref_t<_Up&&, _Tp>
- requires __decays_to<_Tp, _Tp>
-{
- static_assert(STDEXEC_IS_BASE_OF(_Tp, __decay_t<_Up>));
- return (__copy_cvref_t<_Up&&, _Tp>)static_cast<_Up&&>(u);
-}
-
-// A base-to-derived cast that works even when the base is not accessible from
-// derived.
-template <class _Tp, class _Up>
-STDEXEC_ATTRIBUTE((host, device))
-auto __c_downcast(_Up&& u) noexcept -> __copy_cvref_t<_Up&&, _Tp>
- requires __decays_to<_Tp, _Tp>
-{
- static_assert(STDEXEC_IS_BASE_OF(__decay_t<_Up>, _Tp));
- return (__copy_cvref_t<_Up&&, _Tp>)static_cast<_Up&&>(u);
-}
-
-STDEXEC_PRAGMA_POP()
-
-template <class _Ty>
-_Ty __decay_copy(_Ty) noexcept;
-
-template <class _Ty>
-struct __indestructible
-{
- template <class... _Us>
- constexpr __indestructible(_Us&&... __us) noexcept(
- __nothrow_constructible_from<_Ty, _Us...>) :
- __value(static_cast<_Us&&>(__us)...)
- {}
-
- constexpr ~__indestructible() {}
-
- _Ty& get() noexcept
- {
- return __value;
- }
-
- const _Ty& get() const noexcept
- {
- return __value;
- }
-
- union
- {
- _Ty __value;
+ namespace __detail {
+ template <class _Cpcvref>
+ struct __forward_like_fn {
+ template <class _Uy>
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr auto operator()(_Uy&& __uy) const noexcept -> auto&& {
+ return static_cast<_Cpcvref::template __f<std::remove_reference_t<_Uy>>>(__uy);
+ }
};
-};
+ } // namespace __detail
+
+ template <class _Ty>
+ inline constexpr __detail::__forward_like_fn<__copy_cvref_fn<_Ty&&>> __forward_like{};
+
+ STDEXEC_PRAGMA_PUSH()
+ STDEXEC_PRAGMA_IGNORE_GNU("-Wold-style-cast")
+
+ // A derived-to-base cast that works even when the base is not accessible from derived.
+ template <class _Tp, class _Up>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto __c_upcast(_Up&& u) noexcept -> __copy_cvref_t<_Up&&, _Tp>
+ requires __decays_to<_Tp, _Tp>
+ {
+ static_assert(STDEXEC_IS_BASE_OF(_Tp, __decay_t<_Up>));
+ return (__copy_cvref_t<_Up&&, _Tp>) static_cast<_Up&&>(u);
+ }
+
+ // A base-to-derived cast that works even when the base is not accessible from derived.
+ template <class _Tp, class _Up>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto __c_downcast(_Up&& u) noexcept -> __copy_cvref_t<_Up&&, _Tp>
+ requires __decays_to<_Tp, _Tp>
+ {
+ static_assert(STDEXEC_IS_BASE_OF(__decay_t<_Up>, _Tp));
+ return (__copy_cvref_t<_Up&&, _Tp>) static_cast<_Up&&>(u);
+ }
+
+ STDEXEC_PRAGMA_POP()
+
+ template <class _Ty>
+ auto __decay_copy(_Ty) noexcept -> _Ty;
+
+ template <class _Ty>
+ struct __indestructible {
+ template <class... _Us>
+ constexpr __indestructible(_Us&&... __us) noexcept(__nothrow_constructible_from<_Ty, _Us...>)
+ : __value(static_cast<_Us&&>(__us)...) {
+ }
+
+ constexpr ~__indestructible() {
+ }
+
+ auto get() noexcept -> _Ty& {
+ return __value;
+ }
+
+ auto get() const noexcept -> const _Ty& {
+ return __value;
+ }
+
+ union {
+ _Ty __value;
+ };
+ };
} // namespace stdexec
-#if defined(__cpp_auto_cast) && (__cpp_auto_cast >= 202110UL)
-#define STDEXEC_DECAY_COPY(...) auto(__VA_ARGS__)
+#if defined(__cpp_auto_cast) && (__cpp_auto_cast >= 2021'10L)
+# define STDEXEC_DECAY_COPY(...) auto(__VA_ARGS__)
#else
-#define STDEXEC_DECAY_COPY(...) \
- (true ? (__VA_ARGS__) : stdexec::__decay_copy(__VA_ARGS__))
+# define STDEXEC_DECAY_COPY(...) (true ? (__VA_ARGS__) : stdexec::__decay_copy(__VA_ARGS__))
#endif
diff --git a/include/sdbusplus/async/stdexec/__detail/__variant.hpp b/include/sdbusplus/async/stdexec/__detail/__variant.hpp
index b49e4cf..5df4a56 100644
--- a/include/sdbusplus/async/stdexec/__detail/__variant.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__variant.hpp
@@ -18,230 +18,226 @@
#include "__meta.hpp"
#include "__type_traits.hpp"
#include "__utility.hpp"
+#include "__scope.hpp"
#include <cstddef>
-#include <memory>
#include <new>
-#include <type_traits>
+#include <utility>
/********************************************************************************/
-/* NB: The variant type implemented here default-constructs into the valueless
- */
-/* state. This is different from std::variant which default-constructs into the
- */
-/* first alternative. This is done to simplify the implementation and to avoid
- */
-/* the need for a default constructor for each alternative type. */
+/* NB: The variant type implemented here default-constructs into the valueless */
+/* state. This is different from std::variant which default-constructs into the */
+/* first alternative. This is done to simplify the implementation and to avoid */
+/* the need for a default constructor for each alternative type. */
/********************************************************************************/
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
-namespace stdexec
-{
-inline constexpr std::size_t __variant_npos = ~0UL;
+namespace stdexec {
+#if STDEXEC_NVHPC()
+ enum __variant_npos_t : std::size_t {
+ __variant_npos = ~0UL
+ };
+#else
+ STDEXEC_GLOBAL_CONSTANT std::size_t __variant_npos = ~0UL;
+#endif
-struct __monostate
-{};
+ struct __monostate { };
-namespace __var
-{
-template <auto _Idx, class... _Ts>
-class __variant;
+ namespace __var {
+ template <class _Ty>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ void __destroy_at(_Ty *ptr) noexcept {
+ ptr->~_Ty();
+ }
-template <>
-class __variant<__indices<>{}>
-{
- public:
- template <class _Fn, class... _Us>
- STDEXEC_ATTRIBUTE((host, device))
- void visit(_Fn&&, _Us&&...) const noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device)
+ inline auto __mk_index_guard(std::size_t &__index, std::size_t __new) noexcept {
+ __index = __new;
+ return __scope_guard{[&__index]() noexcept { __index = __variant_npos; }};
+ }
+
+ template <auto _Idx, class... _Ts>
+ class __variant;
+
+ template <>
+ class __variant<__indices<>{}> {
+ public:
+ template <class _Fn, class... _Us>
+ STDEXEC_ATTRIBUTE(host, device)
+ void visit(_Fn &&, _Us &&...) const noexcept {
STDEXEC_ASSERT(false);
- }
+ }
- STDEXEC_ATTRIBUTE((host, device))
- static constexpr std::size_t index() noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device) static constexpr auto index() noexcept -> std::size_t {
return __variant_npos;
- }
+ }
- STDEXEC_ATTRIBUTE((host, device))
- static constexpr bool is_valueless() noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device) static constexpr auto is_valueless() noexcept -> bool {
return true;
- }
-};
+ }
+ };
-template <std::size_t... _Is, __indices<_Is...> _Idx, class... _Ts>
-class __variant<_Idx, _Ts...>
-{
- static constexpr std::size_t __max_size = stdexec::__umax({sizeof(_Ts)...});
- static_assert(__max_size != 0);
- std::size_t __index_{__variant_npos};
- alignas(_Ts...) unsigned char __storage_[__max_size];
+ template <std::size_t... _Is, __indices<_Is...> _Idx, class... _Ts>
+ class __variant<_Idx, _Ts...> {
+ static constexpr std::size_t __max_size = stdexec::__umax({sizeof(_Ts)...});
+ static_assert(__max_size != 0);
+ std::size_t __index_{__variant_npos};
+ alignas(_Ts...) unsigned char __storage_[__max_size];
- STDEXEC_ATTRIBUTE((host, device))
- void __destroy() noexcept
- {
+ STDEXEC_ATTRIBUTE(host, device) void __destroy() noexcept {
auto __index = std::exchange(__index_, __variant_npos);
- if (__variant_npos != __index)
- {
- ((_Is == __index ? std::destroy_at(static_cast<_Ts*>(__get_ptr()))
- : void(0)),
- ...);
+ if (__variant_npos != __index) {
+ ((_Is == __index ? __var::__destroy_at(static_cast<_Ts *>(__get_ptr())) : void(0)), ...);
}
- }
+ }
- template <std::size_t _Ny>
- using __at = __m_at_c<_Ny, _Ts...>;
+ public:
- public:
- // immovable:
- __variant(__variant&&) = delete;
+ template <std::size_t _Ny>
+ using __at = __m_at_c<_Ny, _Ts...>;
- STDEXEC_ATTRIBUTE((host, device))
- __variant() noexcept {}
+ // immovable:
+ __variant(__variant &&) = delete;
- STDEXEC_ATTRIBUTE((host, device))
- ~__variant()
- {
+ STDEXEC_ATTRIBUTE(host, device) __variant() noexcept = default;
+
+ STDEXEC_ATTRIBUTE(host, device) ~__variant() {
__destroy();
- }
+ }
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- void* __get_ptr() noexcept
- {
+ [[nodiscard]]
+ STDEXEC_ATTRIBUTE(host, device, always_inline) auto __get_ptr() noexcept -> void * {
return __storage_;
- }
+ }
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- std::size_t index() const noexcept
- {
+ [[nodiscard]]
+ STDEXEC_ATTRIBUTE(host, device, always_inline) auto index() const noexcept -> std::size_t {
return __index_;
- }
+ }
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- bool is_valueless() const noexcept
- {
+ [[nodiscard]]
+ STDEXEC_ATTRIBUTE(host, device, always_inline) auto is_valueless() const noexcept -> bool {
return __index_ == __variant_npos;
- }
+ }
- template <class _Ty, class... _As>
- STDEXEC_ATTRIBUTE((host, device))
- _Ty& emplace(_As&&... __as) //
- noexcept(__nothrow_constructible_from<_Ty, _As...>)
- {
+ // The following emplace functions must take great care to avoid use-after-free bugs.
+ // If the object being constructed calls `start` on a newly created operation state
+ // (as does the object returned from `submit`), and if `start` completes inline, it
+ // could cause the destruction of the outer operation state that owns *this. The
+ // function below uses the following pattern to avoid this:
+ // 1. Store the new index in __index_.
+ // 2. Create a scope guard that will reset __index_ to __variant_npos if the
+ // constructor throws.
+ // 3. Construct the new object in the storage, which may cause the invalidation of
+ // *this. The emplace function must not access any members of *this after this point.
+ // 4. Dismiss the scope guard, which will leave __index_ set to the new index.
+ // 5. Return a reference to the new object -- which may be invalid! Calling code
+ // must be aware of the danger.
+ template <class _Ty, class... _As>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto emplace(_As &&...__as) noexcept(__nothrow_constructible_from<_Ty, _As...>) -> _Ty & {
constexpr std::size_t __new_index = stdexec::__index_of<_Ty, _Ts...>();
static_assert(__new_index != __variant_npos, "Type not in variant");
__destroy();
- ::new (__storage_) _Ty{static_cast<_As&&>(__as)...};
- __index_ = __new_index;
- return *std::launder(reinterpret_cast<_Ty*>(__storage_));
- }
+ auto __sg = __mk_index_guard(__index_, __new_index);
+ auto *__p = ::new (__storage_) _Ty{static_cast<_As &&>(__as)...};
+ __sg.__dismiss();
+ return *std::launder(__p);
+ }
- template <std::size_t _Ny, class... _As>
- STDEXEC_ATTRIBUTE((host, device))
- __at<_Ny>& emplace(_As&&... __as) //
- noexcept(__nothrow_constructible_from<__at<_Ny>, _As...>)
- {
+ template <std::size_t _Ny, class... _As>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto emplace(_As &&...__as) noexcept(__nothrow_constructible_from<__at<_Ny>, _As...>)
+ -> __at<_Ny> & {
static_assert(_Ny < sizeof...(_Ts), "variant index is too large");
__destroy();
- ::new (__storage_) __at<_Ny>{static_cast<_As&&>(__as)...};
- __index_ = _Ny;
- return *std::launder(reinterpret_cast<__at<_Ny>*>(__storage_));
- }
+ auto __sg = __mk_index_guard(__index_, _Ny);
+ auto *__p = ::new (__storage_) __at<_Ny>{static_cast<_As &&>(__as)...};
+ __sg.__dismiss();
+ return *std::launder(__p);
+ }
- template <std::size_t _Ny, class _Fn, class... _As>
- STDEXEC_ATTRIBUTE((host, device))
- __at<_Ny>& emplace_from_at(_Fn&& __fn, _As&&... __as) //
- noexcept(__nothrow_callable<_Fn, _As...>)
- {
- static_assert(__same_as<__call_result_t<_Fn, _As...>, __at<_Ny>>,
- "callable does not return the correct type");
+ template <std::size_t _Ny, class _Fn, class... _As>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto emplace_from_at(_Fn &&__fn, _As &&...__as) noexcept(__nothrow_callable<_Fn, _As...>)
+ -> __at<_Ny> & {
+ static_assert(
+ __same_as<__call_result_t<_Fn, _As...>, __at<_Ny>>,
+ "callable does not return the correct type");
__destroy();
- ::new (__storage_)
- __at<_Ny>(static_cast<_Fn&&>(__fn)(static_cast<_As&&>(__as)...));
- __index_ = _Ny;
- return *std::launder(reinterpret_cast<__at<_Ny>*>(__storage_));
- }
+ auto __sg = __mk_index_guard(__index_, _Ny);
+ auto *__p = ::new (__storage_)
+ __at<_Ny>(static_cast<_Fn &&>(__fn)(static_cast<_As &&>(__as)...));
+ __sg.__dismiss();
+ return *std::launder(__p);
+ }
- template <class _Fn, class... _As>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- auto emplace_from(_Fn&& __fn, _As&&... __as) //
- noexcept(__nothrow_callable<_Fn, _As...>)
- -> __call_result_t<_Fn, _As...>&
- {
+ template <class _Fn, class... _As>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto emplace_from(_Fn &&__fn, _As &&...__as) noexcept(__nothrow_callable<_Fn, _As...>)
+ -> __call_result_t<_Fn, _As...> & {
using __result_t = __call_result_t<_Fn, _As...>;
- constexpr std::size_t __new_index =
- stdexec::__index_of<__result_t, _Ts...>();
+ constexpr std::size_t __new_index = stdexec::__index_of<__result_t, _Ts...>();
static_assert(__new_index != __variant_npos, "Type not in variant");
- return emplace_from_at<__new_index>(static_cast<_Fn&&>(__fn),
- static_cast<_As&&>(__as)...);
- }
+ return emplace_from_at<__new_index>(
+ static_cast<_Fn &&>(__fn), static_cast<_As &&>(__as)...);
+ }
- template <class _Fn, class _Self, class... _As>
- STDEXEC_ATTRIBUTE((host, device))
- static void visit(_Fn&& __fn, _Self&& __self, _As&&... __as) //
- noexcept((__nothrow_callable<_Fn, _As..., __copy_cvref_t<_Self, _Ts>> &&
- ...))
- {
+ template <class _Fn, class _Self, class... _As>
+ STDEXEC_ATTRIBUTE(host, device)
+ static void visit(_Fn &&__fn, _Self &&__self, _As &&...__as)
+ noexcept((__nothrow_callable<_Fn, _As..., __copy_cvref_t<_Self, _Ts>> && ...)) {
STDEXEC_ASSERT(__self.__index_ != __variant_npos);
- auto __index = __self.__index_; // make it local so we don't access it
- // after it's deleted.
- ((_Is == __index ? static_cast<_Fn&&>(__fn)(
- static_cast<_As&&>(__as)...,
- static_cast<_Self&&>(__self).template get<_Is>())
- : void()),
+ auto __index = __self.__index_; // make it local so we don't access it after it's deleted.
+ ((_Is == __index
+ ? static_cast<_Fn &&>(__fn)(
+ static_cast<_As &&>(__as)..., static_cast<_Self &&>(__self).template get<_Is>())
+ : void()),
...);
- }
+ }
- template <std::size_t _Ny>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- decltype(auto) get() && noexcept
- {
+ template <std::size_t _Ny>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto get() && noexcept -> decltype(auto) {
STDEXEC_ASSERT(_Ny == __index_);
- return static_cast<__at<_Ny>&&>(
- *reinterpret_cast<__at<_Ny>*>(__storage_));
- }
+ return static_cast<__at<_Ny> &&>(*reinterpret_cast<__at<_Ny> *>(__storage_));
+ }
- template <std::size_t _Ny>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- decltype(auto) get() & noexcept
- {
+ template <std::size_t _Ny>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto get() & noexcept -> decltype(auto) {
STDEXEC_ASSERT(_Ny == __index_);
- return *reinterpret_cast<__at<_Ny>*>(__storage_);
- }
+ return *reinterpret_cast<__at<_Ny> *>(__storage_);
+ }
- template <std::size_t _Ny>
- STDEXEC_ATTRIBUTE((host, device, always_inline))
- decltype(auto) get() const& noexcept
- {
+ template <std::size_t _Ny>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto get() const & noexcept -> decltype(auto) {
STDEXEC_ASSERT(_Ny == __index_);
- return *reinterpret_cast<const __at<_Ny>*>(__storage_);
- }
-};
-} // namespace __var
+ return *reinterpret_cast<const __at<_Ny> *>(__storage_);
+ }
+ };
+ } // namespace __var
-using __var::__variant;
+ using __var::__variant;
-template <class... _Ts>
-using __variant_for = __variant<__indices_for<_Ts...>{}, _Ts...>;
+ template <class... _Ts>
+ using __variant_for = __variant<__indices_for<_Ts...>{}, _Ts...>;
-template <class... Ts>
-using __uniqued_variant_for =
- __mcall<__munique<__qq<__variant_for>>, __decay_t<Ts>...>;
+ template <class... Ts>
+ using __uniqued_variant_for = __mcall<__munique<__qq<__variant_for>>, __decay_t<Ts>...>;
-// So we can use __variant as a typelist
-template <auto _Idx, class... _Ts>
-struct __muncurry_<__variant<_Idx, _Ts...>>
-{
+ // So we can use __variant as a typelist
+ template <auto _Idx, class... _Ts>
+ struct __muncurry_<__variant<_Idx, _Ts...>> {
template <class _Fn>
using __f = __minvoke<_Fn, _Ts...>;
-};
+ };
} // namespace stdexec
STDEXEC_PRAGMA_POP()
diff --git a/include/sdbusplus/async/stdexec/__detail/__when_all.hpp b/include/sdbusplus/async/stdexec/__detail/__when_all.hpp
index 9e66351..77df38d 100644
--- a/include/sdbusplus/async/stdexec/__detail/__when_all.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__when_all.hpp
@@ -18,7 +18,6 @@
#include "__execution_fwd.hpp"
// include these after __execution_fwd.hpp
-#include "../stop_token.hpp"
#include "__basic_sender.hpp"
#include "__concepts.hpp"
#include "__continues_on.hpp"
@@ -37,605 +36,508 @@
#include "__utility.hpp"
#include "__variant.hpp"
+#include "../stop_token.hpp"
+
#include <atomic>
#include <exception>
-namespace stdexec
-{
-/////////////////////////////////////////////////////////////////////////////
-// [execution.senders.adaptors.when_all]
-// [execution.senders.adaptors.when_all_with_variant]
-namespace __when_all
-{
-enum __state_t
-{
- __started,
- __error,
- __stopped
-};
+namespace stdexec {
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.senders.adaptors.when_all]
+ // [execution.senders.adaptors.when_all_with_variant]
+ namespace __when_all {
+ enum __state_t {
+ __started,
+ __error,
+ __stopped
+ };
-struct __on_stop_request
-{
- inplace_stop_source& __stop_source_;
+ struct __on_stop_request {
+ inplace_stop_source& __stop_source_;
- void operator()() noexcept
- {
+ void operator()() noexcept {
__stop_source_.request_stop();
+ }
+ };
+
+ template <class _Env>
+ auto __mkenv(_Env&& __env, const inplace_stop_source& __stop_source) noexcept {
+ return __env::__join(
+ prop{get_stop_token, __stop_source.get_token()}, static_cast<_Env&&>(__env));
}
-};
-template <class _Env>
-auto __mkenv(_Env&& __env, const inplace_stop_source& __stop_source) noexcept
-{
- return __env::__join(prop{get_stop_token, __stop_source.get_token()},
- static_cast<_Env&&>(__env));
-}
+ template <class _Env>
+ using __env_t =
+ decltype(__when_all::__mkenv(__declval<_Env>(), __declval<inplace_stop_source&>()));
-template <class _Env>
-using __env_t = //
- decltype(__when_all::__mkenv(__declval<_Env>(),
- __declval<inplace_stop_source&>()));
+ template <class _Sender, class _Env>
+ concept __max1_sender =
+ sender_in<_Sender, _Env>
+ && __mvalid<__value_types_of_t, _Sender, _Env, __mconst<int>, __msingle_or<void>>;
-template <class _Sender, class _Env>
-concept __max1_sender =
- sender_in<_Sender, _Env> && __mvalid<__value_types_of_t, _Sender, _Env,
- __mconst<int>, __msingle_or<void>>;
-
-template <
- __mstring _Context = "In stdexec::when_all()..."_mstr,
- __mstring _Diagnostic =
+ template <
+ __mstring _Context = "In stdexec::when_all()..."_mstr,
+ __mstring _Diagnostic =
"The given sender can complete successfully in more that one way. "
- "Use stdexec::when_all_with_variant() instead."_mstr>
-struct _INVALID_WHEN_ALL_ARGUMENT_;
+ "Use stdexec::when_all_with_variant() instead."_mstr
+ >
+ struct _INVALID_WHEN_ALL_ARGUMENT_;
-template <class _Sender, class... _Env>
-using __too_many_value_completions_error =
- __mexception<_INVALID_WHEN_ALL_ARGUMENT_<>, _WITH_SENDER_<_Sender>,
- _WITH_ENVIRONMENT_<_Env>...>;
+ template <class _Sender, class... _Env>
+ using __too_many_value_completions_error = __mexception<
+ _INVALID_WHEN_ALL_ARGUMENT_<>,
+ _WITH_SENDER_<_Sender>,
+ _WITH_ENVIRONMENT_<_Env>...
+ >;
-template <class... _Args>
-using __all_nothrow_decay_copyable =
- __mbool<(__nothrow_decay_copyable<_Args> && ...)>;
+ template <class... _Args>
+ using __all_nothrow_decay_copyable = __mbool<(__nothrow_decay_copyable<_Args> && ...)>;
-template <class _Error>
-using __set_error_t = completion_signatures<set_error_t(__decay_t<_Error>)>;
+ template <class _Error>
+ using __set_error_t = completion_signatures<set_error_t(__decay_t<_Error>)>;
-template <class _Sender, class... _Env>
-using __nothrow_decay_copyable_results = //
- __for_each_completion_signature<
- __completion_signatures_of_t<_Sender, _Env...>,
- __all_nothrow_decay_copyable, __mand_t>;
+ template <class _Sender, class... _Env>
+ using __nothrow_decay_copyable_results = __for_each_completion_signature<
+ __completion_signatures_of_t<_Sender, _Env...>,
+ __all_nothrow_decay_copyable,
+ __mand_t
+ >;
-template <class... _Env>
-struct __completions_t
-{
- template <class... _Senders>
- using __all_nothrow_decay_copyable_results = //
+ template <class... _Env>
+ struct __completions_t {
+ template <class... _Senders>
+ using __all_nothrow_decay_copyable_results =
__mand<__nothrow_decay_copyable_results<_Senders, _Env...>...>;
- template <class _Sender, class _ValueTuple, class... _Rest>
- using __value_tuple_t =
- __minvoke<__if_c<(0 == sizeof...(_Rest)), __mconst<_ValueTuple>,
- __q<__too_many_value_completions_error>>,
- _Sender, _Env...>;
+ template <class _Sender, class _ValueTuple, class... _Rest>
+ using __value_tuple_t = __minvoke<
+ __if_c<
+ (0 == sizeof...(_Rest)),
+ __mconst<_ValueTuple>,
+ __q<__too_many_value_completions_error>
+ >,
+ _Sender,
+ _Env...
+ >;
- template <class _Sender>
- using __single_values_of_t = //
- __value_types_t<__completion_signatures_of_t<_Sender, _Env...>,
- __mtransform<__q<__decay_t>, __q<__types>>,
- __mbind_front_q<__value_tuple_t, _Sender>>;
+ template <class _Sender>
+ using __single_values_of_t = __value_types_t<
+ __completion_signatures_of_t<_Sender, _Env...>,
+ __mtransform<__q<__decay_t>, __q<__types>>,
+ __mbind_front_q<__value_tuple_t, _Sender>
+ >;
- template <class... _Senders>
- using __set_values_sig_t = //
- __meval<completion_signatures,
- __minvoke<__mconcat<__qf<set_value_t>>,
- __single_values_of_t<_Senders>...>>;
+ template <class... _Senders>
+ using __set_values_sig_t = __meval<
+ completion_signatures,
+ __minvoke<__mconcat<__qf<set_value_t>>, __single_values_of_t<_Senders>...>
+ >;
- template <class... _Senders>
- using __f = //
- __meval< //
- __concat_completion_signatures,
- __meval<__eptr_completion_if_t,
- __all_nothrow_decay_copyable_results<_Senders...>>,
- completion_signatures<set_stopped_t()>,
- __minvoke<__with_default<__qq<__set_values_sig_t>,
- completion_signatures<>>,
- _Senders...>,
- __transform_completion_signatures<
- __completion_signatures_of_t<_Senders, _Env...>,
- __mconst<completion_signatures<>>::__f, __set_error_t,
- completion_signatures<>, __concat_completion_signatures>...>;
-};
-
-template <class _Tag, class _Receiver>
-auto __complete_fn(_Tag, _Receiver& __rcvr) noexcept
-{
- return [&]<class... _Ts>(_Ts&... __ts) noexcept {
- _Tag()(static_cast<_Receiver&&>(__rcvr), static_cast<_Ts&&>(__ts)...);
+ template <class... _Senders>
+ using __f = __meval<
+ __concat_completion_signatures,
+ __meval<__eptr_completion_if_t, __all_nothrow_decay_copyable_results<_Senders...>>,
+ __minvoke<__with_default<__qq<__set_values_sig_t>, completion_signatures<>>, _Senders...>,
+ __transform_completion_signatures<
+ __completion_signatures_of_t<_Senders, _Env...>,
+ __mconst<completion_signatures<>>::__f,
+ __set_error_t,
+ completion_signatures<set_stopped_t()>,
+ __concat_completion_signatures
+ >...
+ >;
};
-}
-template <class _Receiver, class _ValuesTuple>
-void __set_values(_Receiver& __rcvr, _ValuesTuple& __values) noexcept
-{
- __values.apply(
- [&](auto&... __opt_vals) noexcept -> void {
- __tup::__cat_apply(__when_all::__complete_fn(set_value, __rcvr),
- *__opt_vals...);
+ template <class _Receiver, class _ValuesTuple>
+ void __set_values(_Receiver& __rcvr, _ValuesTuple& __values) noexcept {
+ __values.apply(
+ [&]<class... OptTuples>(OptTuples&&... __opt_vals) noexcept -> void {
+ __tup::__cat_apply(
+ __mk_completion_fn(set_value, __rcvr), *static_cast<OptTuples&&>(__opt_vals)...);
},
- __values);
-}
-
-template <class _Env, class _Sender>
-using __values_opt_tuple_t = //
- value_types_of_t<_Sender, __env_t<_Env>, __decayed_tuple, __optional>;
-
-template <class _Env, __max1_sender<__env_t<_Env>>... _Senders>
-struct __traits
-{
- // tuple<optional<tuple<Vs1...>>, optional<tuple<Vs2...>>, ...>
- using __values_tuple = //
- __minvoke<__with_default<
- __mtransform<__mbind_front_q<__values_opt_tuple_t, _Env>,
- __q<__tuple_for>>,
- __ignore>,
- _Senders...>;
-
- using __collect_errors = __mbind_front_q<__mset_insert, __mset<>>;
-
- using __errors_list = //
- __minvoke<
- __mconcat<>,
- __if<__mand<__nothrow_decay_copyable_results<_Senders, _Env>...>,
- __types<>, __types<std::exception_ptr>>,
- __error_types_of_t<_Senders, __env_t<_Env>, __q<__types>>...>;
-
- using __errors_variant =
- __mapply<__q<__uniqued_variant_for>, __errors_list>;
-};
-
-struct _INVALID_ARGUMENTS_TO_WHEN_ALL_
-{};
-
-template <class _ErrorsVariant, class _ValuesTuple, class _StopToken>
-struct __when_all_state
-{
- using __stop_callback_t =
- stop_callback_for_t<_StopToken, __on_stop_request>;
-
- template <class _Receiver>
- void __arrive(_Receiver& __rcvr) noexcept
- {
- if (1 == __count_.fetch_sub(1))
- {
- __complete(__rcvr);
- }
+ static_cast<_ValuesTuple&&>(__values));
}
- template <class _Receiver>
- void __complete(_Receiver& __rcvr) noexcept
- {
+ template <class _Env, class _Sender>
+ using __values_opt_tuple_t =
+ value_types_of_t<_Sender, __env_t<_Env>, __decayed_tuple, __optional>;
+
+ template <class _Env, __max1_sender<__env_t<_Env>>... _Senders>
+ struct __traits {
+ // tuple<optional<tuple<Vs1...>>, optional<tuple<Vs2...>>, ...>
+ using __values_tuple = __minvoke<
+ __with_default<
+ __mtransform<__mbind_front_q<__values_opt_tuple_t, _Env>, __q<__tuple_for>>,
+ __ignore
+ >,
+ _Senders...
+ >;
+
+ using __collect_errors = __mbind_front_q<__mset_insert, __mset<>>;
+
+ using __errors_list = __minvoke<
+ __mconcat<>,
+ __if<
+ __mand<__nothrow_decay_copyable_results<_Senders, _Env>...>,
+ __types<>,
+ __types<std::exception_ptr>
+ >,
+ __error_types_of_t<_Senders, __env_t<_Env>, __q<__types>>...
+ >;
+
+ using __errors_variant = __mapply<__q<__uniqued_variant_for>, __errors_list>;
+ };
+
+ struct _INVALID_ARGUMENTS_TO_WHEN_ALL_ { };
+
+ template <class _ErrorsVariant, class _ValuesTuple, class _StopToken, bool _SendsStopped>
+ struct __when_all_state {
+ using __stop_callback_t = stop_callback_for_t<_StopToken, __on_stop_request>;
+
+ template <class _Receiver>
+ void __arrive(_Receiver& __rcvr) noexcept {
+ if (1 == __count_.fetch_sub(1)) {
+ __complete(__rcvr);
+ }
+ }
+
+ template <class _Receiver>
+ void __complete(_Receiver& __rcvr) noexcept {
// Stop callback is no longer needed. Destroy it.
__on_stop_.reset();
// All child operations have completed and arrived at the barrier.
- switch (__state_.load(std::memory_order_relaxed))
- {
- case __started:
- if constexpr (!same_as<_ValuesTuple, __ignore>)
- {
- // All child operations completed successfully:
- __when_all::__set_values(__rcvr, __values_);
- }
- break;
- case __error:
- if constexpr (!__same_as<_ErrorsVariant, __variant_for<>>)
- {
- // One or more child operations completed with an error:
- __errors_.visit(__complete_fn(set_error, __rcvr),
- __errors_);
- }
- break;
- case __stopped:
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
- break;
- default:;
+ switch (__state_.load(std::memory_order_relaxed)) {
+ case __started:
+ if constexpr (!same_as<_ValuesTuple, __ignore>) {
+ // All child operations completed successfully:
+ __when_all::__set_values(__rcvr, __values_);
+ }
+ break;
+ case __error:
+ if constexpr (!__same_as<_ErrorsVariant, __variant_for<>>) {
+ // One or more child operations completed with an error:
+ __errors_.visit(
+ __mk_completion_fn(set_error, __rcvr), static_cast<_ErrorsVariant&&>(__errors_));
+ }
+ break;
+ case __stopped:
+ if constexpr (_SendsStopped) {
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
+ } else {
+ STDEXEC_UNREACHABLE();
+ }
+ break;
+ default:;
}
- }
+ }
- std::atomic<std::size_t> __count_;
- inplace_stop_source __stop_source_{};
- // Could be non-atomic here and atomic_ref everywhere except __completion_fn
- std::atomic<__state_t> __state_{__started};
- _ErrorsVariant __errors_{};
- STDEXEC_ATTRIBUTE((no_unique_address))
- _ValuesTuple __values_{};
- __optional<__stop_callback_t> __on_stop_{};
-};
+ std::atomic<std::size_t> __count_;
+ inplace_stop_source __stop_source_{};
+ // Could be non-atomic here and atomic_ref everywhere except __completion_fn
+ std::atomic<__state_t> __state_{__started};
+ _ErrorsVariant __errors_{};
+ STDEXEC_ATTRIBUTE(no_unique_address) _ValuesTuple __values_ { };
+ __optional<__stop_callback_t> __on_stop_{};
+ };
-template <class _Env>
-static auto __mk_state_fn(const _Env&) noexcept
-{
- return []<__max1_sender<__env_t<_Env>>... _Child>(__ignore, __ignore,
- _Child&&...) {
+ template <class _Env>
+ static auto __mk_state_fn(const _Env&) noexcept {
+ return []<__max1_sender<__env_t<_Env>>... _Child>(__ignore, __ignore, _Child&&...) {
using _Traits = __traits<_Env, _Child...>;
- using _ErrorsVariant = typename _Traits::__errors_variant;
- using _ValuesTuple = typename _Traits::__values_tuple;
- using _State = __when_all_state<_ErrorsVariant, _ValuesTuple,
- stop_token_of_t<_Env>>;
+ using _ErrorsVariant = _Traits::__errors_variant;
+ using _ValuesTuple = _Traits::__values_tuple;
+ using _State = __when_all_state<
+ _ErrorsVariant,
+ _ValuesTuple,
+ stop_token_of_t<_Env>,
+ (sends_stopped<_Child, _Env> || ...)>;
return _State{sizeof...(_Child)};
- };
-}
-
-template <class _Env>
-using __mk_state_fn_t = decltype(__when_all::__mk_state_fn(__declval<_Env>()));
-
-struct when_all_t
-{
- // Used by the default_domain to find legacy customizations:
- using _Sender = __1;
- using __legacy_customizations_t = //
- __types<tag_invoke_t(when_all_t, _Sender...)>;
-
- template <sender... _Senders>
- requires __domain::__has_common_domain<_Senders...>
- auto operator()(_Senders&&... __sndrs) const -> __well_formed_sender auto
- {
- auto __domain = __domain::__common_domain_t<_Senders...>();
- return stdexec::transform_sender(
- __domain, __make_sexpr<when_all_t>(
- __(), static_cast<_Senders&&>(__sndrs)...));
+ };
}
-};
-struct __when_all_impl : __sexpr_defaults
-{
- template <class _Self, class _Env>
- using __error_t = __mexception<_INVALID_ARGUMENTS_TO_WHEN_ALL_,
- __children_of<_Self, __q<_WITH_SENDERS_>>,
- _WITH_ENVIRONMENT_<_Env>>;
+ template <class _Env>
+ using __mk_state_fn_t = decltype(__when_all::__mk_state_fn(__declval<_Env>()));
- template <class _Self, class... _Env>
- using __completions =
- __children_of<_Self, __completions_t<__env_t<_Env>...>>;
-
- static constexpr auto get_attrs = //
- []<class... _Child>(__ignore, const _Child&...) noexcept {
- using _Domain = __domain::__common_domain_t<_Child...>;
- if constexpr (__same_as<_Domain, default_domain>)
- {
- return env();
- }
- else
- {
- return prop{get_domain, _Domain()};
- }
- };
-
- static constexpr auto get_completion_signatures = //
- []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept {
- static_assert(sender_expr_for<_Self, when_all_t>);
- return __minvoke<__mtry_catch<__q<__completions>, __q<__error_t>>,
- _Self, _Env...>();
- };
-
- static constexpr auto get_env = //
- []<class _State, class _Receiver>(__ignore, _State& __state,
- const _Receiver& __rcvr) noexcept //
- -> __env_t<env_of_t<const _Receiver&>> {
- return __mkenv(stdexec::get_env(__rcvr), __state.__stop_source_);
+ struct when_all_t {
+ template <sender... _Senders>
+ requires __has_common_domain<_Senders...>
+ auto operator()(_Senders&&... __sndrs) const -> __well_formed_sender auto {
+ auto __domain = __common_domain_t<_Senders...>();
+ return stdexec::transform_sender(
+ __domain, __make_sexpr<when_all_t>(__(), static_cast<_Senders&&>(__sndrs)...));
+ }
};
- static constexpr auto get_state = //
+ struct __when_all_impl : __sexpr_defaults {
+ template <class _Self, class _Env>
+ using __error_t = __mexception<
+ _INVALID_ARGUMENTS_TO_WHEN_ALL_,
+ __children_of<_Self, __q<_WITH_SENDERS_>>,
+ _WITH_ENVIRONMENT_<_Env>
+ >;
+
+ template <class _Self, class... _Env>
+ using __completions = __children_of<_Self, __completions_t<__env_t<_Env>...>>;
+
+ static constexpr auto get_attrs = []<class... _Child>(__ignore, const _Child&...) noexcept {
+ using _Domain = __common_domain_t<_Child...>;
+ if constexpr (__same_as<_Domain, default_domain>) {
+ return env();
+ } else {
+ return prop{get_domain, _Domain()};
+ }
+ };
+
+ static constexpr auto get_completion_signatures =
+ []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept {
+ static_assert(sender_expr_for<_Self, when_all_t>);
+ return __minvoke<__mtry_catch<__q<__completions>, __q<__error_t>>, _Self, _Env...>();
+ };
+
+ static constexpr auto get_env =
+ []<class _State, class _Receiver>(
+ __ignore,
+ _State& __state,
+ const _Receiver& __rcvr) noexcept -> __env_t<env_of_t<const _Receiver&>> {
+ return __mkenv(stdexec::get_env(__rcvr), __state.__stop_source_);
+ };
+
+ static constexpr auto get_state =
[]<class _Self, class _Receiver>(_Self&& __self, _Receiver& __rcvr)
-> __sexpr_apply_result_t<_Self, __mk_state_fn_t<env_of_t<_Receiver>>> {
return __sexpr_apply(
- static_cast<_Self&&>(__self),
- __when_all::__mk_state_fn(stdexec::get_env(__rcvr)));
- };
+ static_cast<_Self&&>(__self), __when_all::__mk_state_fn(stdexec::get_env(__rcvr)));
+ };
- static constexpr auto start = //
- []<class _State, class _Receiver, class... _Operations>(
- _State& __state, _Receiver& __rcvr,
- _Operations&... __child_ops) noexcept -> void {
+ static constexpr auto start = []<class _State, class _Receiver, class... _Operations>(
+ _State& __state,
+ _Receiver& __rcvr,
+ _Operations&... __child_ops) noexcept -> void {
// register stop callback:
- __state.__on_stop_.emplace(get_stop_token(stdexec::get_env(__rcvr)),
- __on_stop_request{__state.__stop_source_});
- if (__state.__stop_source_.stop_requested())
- {
- // Stop has already been requested. Don't bother starting
- // the child operations.
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
+ __state.__on_stop_.emplace(
+ get_stop_token(stdexec::get_env(__rcvr)), __on_stop_request{__state.__stop_source_});
+ (stdexec::start(__child_ops), ...);
+ if constexpr (sizeof...(__child_ops) == 0) {
+ __state.__complete(__rcvr);
}
- else
- {
- (stdexec::start(__child_ops), ...);
- if constexpr (sizeof...(__child_ops) == 0)
- {
- __state.__complete(__rcvr);
- }
- }
- };
+ };
- template <class _State, class _Receiver, class _Error>
- static void __set_error(_State& __state, _Receiver&,
- _Error&& __err) noexcept
- {
+ template <class _State, class _Receiver, class _Error>
+ static void __set_error(_State& __state, _Receiver&, _Error&& __err) noexcept {
+ // Transition to the "error" state and switch on the prior state.
// TODO: What memory orderings are actually needed here?
- if (__error != __state.__state_.exchange(__error))
- {
- __state.__stop_source_.request_stop();
- // We won the race, free to write the error into the operation
- // state without worry.
- if constexpr (__nothrow_decay_copyable<_Error>)
- {
- __state.__errors_.template emplace<__decay_t<_Error>>(
- static_cast<_Error&&>(__err));
+ switch (__state.__state_.exchange(__error)) {
+ case __started:
+ // We must request stop. When the previous state is __error or __stopped, then stop has
+ // already been requested.
+ __state.__stop_source_.request_stop();
+ [[fallthrough]];
+ case __stopped:
+ // We are the first child to complete with an error, so we must save the error. (Any
+ // subsequent errors are ignored.)
+ if constexpr (__nothrow_decay_copyable<_Error>) {
+ __state.__errors_.template emplace<__decay_t<_Error>>(static_cast<_Error&&>(__err));
+ } else {
+ STDEXEC_TRY {
+ __state.__errors_.template emplace<__decay_t<_Error>>(static_cast<_Error&&>(__err));
}
- else
- {
- try
- {
- __state.__errors_.template emplace<__decay_t<_Error>>(
- static_cast<_Error&&>(__err));
- }
- catch (...)
- {
- __state.__errors_.template emplace<std::exception_ptr>(
- std::current_exception());
- }
+ STDEXEC_CATCH_ALL {
+ __state.__errors_.template emplace<std::exception_ptr>(std::current_exception());
}
+ }
+ break;
+ case __error:; // We're already in the "error" state. Ignore the error.
}
- }
+ }
- static constexpr auto complete = //
- []<class _Index, class _State, class _Receiver, class _Set,
- class... _Args>(_Index, _State& __state, _Receiver& __rcvr, _Set,
- _Args&&... __args) noexcept -> void {
- if constexpr (__same_as<_Set, set_error_t>)
- {
- __set_error(__state, __rcvr, static_cast<_Args&&>(__args)...);
- }
- else if constexpr (__same_as<_Set, set_stopped_t>)
- {
- __state_t __expected = __started;
- // Transition to the "stopped" state if and only if we're in the
- // "started" state. (If this fails, it's because we're in an
- // error state, which trumps cancellation.)
- if (__state.__state_.compare_exchange_strong(__expected, __stopped))
- {
- __state.__stop_source_.request_stop();
+ static constexpr auto complete =
+ []<class _Index, class _State, class _Receiver, class _Set, class... _Args>(
+ _Index,
+ _State& __state,
+ _Receiver& __rcvr,
+ _Set,
+ _Args&&... __args) noexcept -> void {
+ using _ValuesTuple = decltype(_State::__values_);
+ if constexpr (__same_as<_Set, set_error_t>) {
+ __set_error(__state, __rcvr, static_cast<_Args&&>(__args)...);
+ } else if constexpr (__same_as<_Set, set_stopped_t>) {
+ __state_t __expected = __started;
+ // Transition to the "stopped" state if and only if we're in the
+ // "started" state. (If this fails, it's because we're in an
+ // error state, which trumps cancellation.)
+ if (__state.__state_.compare_exchange_strong(__expected, __stopped)) {
+ __state.__stop_source_.request_stop();
+ }
+ } else if constexpr (!__same_as<_ValuesTuple, __ignore>) {
+ // We only need to bother recording the completion values
+ // if we're not already in the "error" or "stopped" state.
+ if (__state.__state_.load() == __started) {
+ auto& __opt_values = _ValuesTuple::template __get<__v<_Index>>(__state.__values_);
+ using _Tuple = __decayed_tuple<_Args...>;
+ static_assert(
+ __same_as<decltype(*__opt_values), _Tuple&>,
+ "One of the senders in this when_all() is fibbing about what types it sends");
+ if constexpr ((__nothrow_decay_copyable<_Args> && ...)) {
+ __opt_values.emplace(_Tuple{static_cast<_Args&&>(__args)...});
+ } else {
+ STDEXEC_TRY {
+ __opt_values.emplace(_Tuple{static_cast<_Args&&>(__args)...});
+ }
+ STDEXEC_CATCH_ALL {
+ __set_error(__state, __rcvr, std::current_exception());
+ }
}
- }
- else if constexpr (!__same_as<decltype(_State::__values_), __ignore>)
- {
- // We only need to bother recording the completion values
- // if we're not already in the "error" or "stopped" state.
- if (__state.__state_.load() == __started)
- {
- auto& __opt_values = __tup::get<__v<_Index>>(__state.__values_);
- using _Tuple = __decayed_tuple<_Args...>;
- static_assert(
- __same_as<decltype(*__opt_values), _Tuple&>,
- "One of the senders in this when_all() is fibbing about what types it sends");
- if constexpr ((__nothrow_decay_copyable<_Args> && ...))
- {
- __opt_values.emplace(
- _Tuple{{static_cast<_Args&&>(__args)}...});
- }
- else
- {
- try
- {
- __opt_values.emplace(
- _Tuple{{static_cast<_Args&&>(__args)}...});
- }
- catch (...)
- {
- __set_error(__state, __rcvr, std::current_exception());
- }
- }
- }
+ }
}
__state.__arrive(__rcvr);
+ };
};
-};
-struct when_all_with_variant_t
-{
- using _Sender = __1;
- using __legacy_customizations_t = //
- __types<tag_invoke_t(when_all_with_variant_t, _Sender...)>;
-
- template <sender... _Senders>
- requires __domain::__has_common_domain<_Senders...>
- auto operator()(_Senders&&... __sndrs) const -> __well_formed_sender auto
- {
- auto __domain = __domain::__common_domain_t<_Senders...>();
+ struct when_all_with_variant_t {
+ template <sender... _Senders>
+ requires __has_common_domain<_Senders...>
+ auto operator()(_Senders&&... __sndrs) const -> __well_formed_sender auto {
+ auto __domain = __common_domain_t<_Senders...>();
return stdexec::transform_sender(
- __domain, __make_sexpr<when_all_with_variant_t>(
- __(), static_cast<_Senders&&>(__sndrs)...));
- }
+ __domain,
+ __make_sexpr<when_all_with_variant_t>(__(), static_cast<_Senders&&>(__sndrs)...));
+ }
- template <class _Sender, class _Env>
- static auto transform_sender(_Sender&& __sndr, const _Env&)
- {
- // transform the when_all_with_variant into a regular when_all (looking
- // for early when_all customizations), then transform it again to look
- // for late customizations.
+ template <class _Sender, class _Env>
+ static auto transform_sender(_Sender&& __sndr, const _Env&) {
+ // transform the when_all_with_variant into a regular when_all (looking for
+ // early when_all customizations), then transform it again to look for
+ // late customizations.
return __sexpr_apply(
- static_cast<_Sender&&>(__sndr),
- [&]<class... _Child>(__ignore, __ignore, _Child&&... __child) {
- return when_all_t()(
- into_variant(static_cast<_Child&&>(__child))...);
- });
- }
-};
-
-struct __when_all_with_variant_impl : __sexpr_defaults
-{
- static constexpr auto get_attrs = //
- []<class... _Child>(__ignore, const _Child&...) noexcept {
- using _Domain = __domain::__common_domain_t<_Child...>;
- if constexpr (same_as<_Domain, default_domain>)
- {
- return env();
- }
- else
- {
- return prop{get_domain, _Domain()};
- }
- };
-
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {
- return {};
+ static_cast<_Sender&&>(__sndr),
+ [&]<class... _Child>(__ignore, __ignore, _Child&&... __child) {
+ return when_all_t()(into_variant(static_cast<_Child&&>(__child))...);
+ });
+ }
};
-};
-struct transfer_when_all_t
-{
- using _Env = __0;
- using _Sender = __1;
- using __legacy_customizations_t = //
- __types<tag_invoke_t(
- transfer_when_all_t,
- get_completion_scheduler_t<set_value_t>(const _Env&), _Sender...)>;
+ struct __when_all_with_variant_impl : __sexpr_defaults {
+ static constexpr auto get_attrs = []<class... _Child>(__ignore, const _Child&...) noexcept {
+ using _Domain = __common_domain_t<_Child...>;
+ if constexpr (same_as<_Domain, default_domain>) {
+ return env();
+ } else {
+ return prop{get_domain, _Domain()};
+ }
+ };
- template <scheduler _Scheduler, sender... _Senders>
- requires __domain::__has_common_domain<_Senders...>
- auto operator()(_Scheduler&& __sched, _Senders&&... __sndrs) const
- -> __well_formed_sender auto
- {
- using _Env = __t<__schfr::__environ<__id<__decay_t<_Scheduler>>>>;
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
+ return {};
+ };
+ };
+
+ struct transfer_when_all_t {
+ template <scheduler _Scheduler, sender... _Senders>
+ requires __has_common_domain<_Senders...>
+ auto
+ operator()(_Scheduler __sched, _Senders&&... __sndrs) const -> __well_formed_sender auto {
auto __domain = query_or(get_domain, __sched, default_domain());
return stdexec::transform_sender(
- __domain, __make_sexpr<transfer_when_all_t>(
- _Env{static_cast<_Scheduler&&>(__sched)},
- static_cast<_Senders&&>(__sndrs)...));
- }
+ __domain,
+ __make_sexpr<transfer_when_all_t>(
+ static_cast<_Scheduler&&>(__sched), static_cast<_Senders&&>(__sndrs)...));
+ }
- template <class _Sender, class _Env>
- static auto transform_sender(_Sender&& __sndr, const _Env&)
- {
+ template <class _Sender, class _Env>
+ static auto transform_sender(_Sender&& __sndr, const _Env&) {
// transform the transfer_when_all into a regular transform | when_all
- // (looking for early customizations), then transform it again to look
- // for late customizations.
+ // (looking for early customizations), then transform it again to look for
+ // late customizations.
return __sexpr_apply(
- static_cast<_Sender&&>(__sndr),
- [&]<class _Data, class... _Child>(__ignore, _Data&& __data,
- _Child&&... __child) {
- return continues_on(
- when_all_t()(static_cast<_Child&&>(__child)...),
- get_completion_scheduler<set_value_t>(__data));
- });
- }
-};
-
-struct __transfer_when_all_impl : __sexpr_defaults
-{
- static constexpr auto get_attrs = //
- []<class _Data>(const _Data& __data,
- const auto&...) noexcept -> const _Data& {
- return __data;
+ static_cast<_Sender&&>(__sndr),
+ [&]<class _Data, class... _Child>(__ignore, _Data&& __data, _Child&&... __child) {
+ return continues_on(
+ when_all_t()(static_cast<_Child&&>(__child)...), static_cast<_Data&&>(__data));
+ });
+ }
};
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {
+ struct __transfer_when_all_impl : __sexpr_defaults {
+ static constexpr auto get_attrs = []<class _Scheduler, class... _Child>(
+ const _Scheduler& __sched,
+ const _Child&...) noexcept {
+ using __sndr_t = __call_result_t<when_all_t, _Child...>;
+ using __domain_t = __detail::__early_domain_of_t<__sndr_t, __none_such>;
+ return __sched_attrs{std::cref(__sched), __domain_t{}};
+ };
+
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
return {};
+ };
};
-};
-struct transfer_when_all_with_variant_t
-{
- using _Env = __0;
- using _Sender = __1;
- using __legacy_customizations_t = //
- __types<tag_invoke_t(
- transfer_when_all_with_variant_t,
- get_completion_scheduler_t<set_value_t>(const _Env&), _Sender...)>;
-
- template <scheduler _Scheduler, sender... _Senders>
- requires __domain::__has_common_domain<_Senders...>
- auto operator()(_Scheduler&& __sched, _Senders&&... __sndrs) const
- -> __well_formed_sender auto
- {
- using _Env = __t<__schfr::__environ<__id<__decay_t<_Scheduler>>>>;
+ struct transfer_when_all_with_variant_t {
+ template <scheduler _Scheduler, sender... _Senders>
+ requires __has_common_domain<_Senders...>
+ auto
+ operator()(_Scheduler&& __sched, _Senders&&... __sndrs) const -> __well_formed_sender auto {
auto __domain = query_or(get_domain, __sched, default_domain());
return stdexec::transform_sender(
- __domain, __make_sexpr<transfer_when_all_with_variant_t>(
- _Env{{static_cast<_Scheduler&&>(__sched)}},
- static_cast<_Senders&&>(__sndrs)...));
- }
+ __domain,
+ __make_sexpr<transfer_when_all_with_variant_t>(
+ static_cast<_Scheduler&&>(__sched), static_cast<_Senders&&>(__sndrs)...));
+ }
- template <class _Sender, class _Env>
- static auto transform_sender(_Sender&& __sndr, const _Env&)
- {
- // transform the transfer_when_all_with_variant into regular
- // transform_when_all and into_variant calls/ (looking for early
- // customizations), then transform it again to look for late
- // customizations.
+ template <class _Sender, class _Env>
+ static auto transform_sender(_Sender&& __sndr, const _Env&) {
+ // transform the transfer_when_all_with_variant into regular transform_when_all
+ // and into_variant calls/ (looking for early customizations), then transform it
+ // again to look for late customizations.
return __sexpr_apply(
- static_cast<_Sender&&>(__sndr),
- [&]<class _Data, class... _Child>(__ignore, _Data&& __data,
- _Child&&... __child) {
- return transfer_when_all_t()(
- get_completion_scheduler<set_value_t>(
- static_cast<_Data&&>(__data)),
- into_variant(static_cast<_Child&&>(__child))...);
- });
- }
-};
-
-struct __transfer_when_all_with_variant_impl : __sexpr_defaults
-{
- static constexpr auto get_attrs = //
- []<class _Data>(const _Data& __data,
- const auto&...) noexcept -> const _Data& {
- return __data;
+ static_cast<_Sender&&>(__sndr),
+ [&]<class _Data, class... _Child>(__ignore, _Data&& __data, _Child&&... __child) {
+ return transfer_when_all_t()(
+ static_cast<_Data&&>(__data), into_variant(static_cast<_Child&&>(__child))...);
+ });
+ }
};
- static constexpr auto get_completion_signatures = //
- []<class _Sender>(_Sender&&) noexcept //
- -> __completion_signatures_of_t< //
- transform_sender_result_t<default_domain, _Sender, empty_env>> {
+ struct __transfer_when_all_with_variant_impl : __sexpr_defaults {
+ static constexpr auto get_attrs = []<class _Scheduler, class... _Child>(
+ const _Scheduler& __sched,
+ const _Child&...) noexcept {
+ using __sndr_t = __call_result_t<when_all_with_variant_t, _Child...>;
+ using __domain_t = __detail::__early_domain_of_t<__sndr_t, __none_such>;
+ return __sched_attrs{std::cref(__sched), __domain_t{}};
+ };
+
+ static constexpr auto get_completion_signatures = []<class _Sender>(_Sender&&) noexcept
+ -> __completion_signatures_of_t<transform_sender_result_t<default_domain, _Sender, env<>>> {
return {};
+ };
};
-};
-} // namespace __when_all
+ } // namespace __when_all
-using __when_all::when_all_t;
-inline constexpr when_all_t when_all{};
+ using __when_all::when_all_t;
+ inline constexpr when_all_t when_all{};
-using __when_all::when_all_with_variant_t;
-inline constexpr when_all_with_variant_t when_all_with_variant{};
+ using __when_all::when_all_with_variant_t;
+ inline constexpr when_all_with_variant_t when_all_with_variant{};
-using __when_all::transfer_when_all_t;
-inline constexpr transfer_when_all_t transfer_when_all{};
+ using __when_all::transfer_when_all_t;
+ inline constexpr transfer_when_all_t transfer_when_all{};
-using __when_all::transfer_when_all_with_variant_t;
-inline constexpr transfer_when_all_with_variant_t
- transfer_when_all_with_variant{};
+ using __when_all::transfer_when_all_with_variant_t;
+ inline constexpr transfer_when_all_with_variant_t transfer_when_all_with_variant{};
-template <>
-struct __sexpr_impl<when_all_t> : __when_all::__when_all_impl
-{};
+ template <>
+ struct __sexpr_impl<when_all_t> : __when_all::__when_all_impl { };
-template <>
-struct __sexpr_impl<when_all_with_variant_t> :
- __when_all::__when_all_with_variant_impl
-{};
+ template <>
+ struct __sexpr_impl<when_all_with_variant_t> : __when_all::__when_all_with_variant_impl { };
-template <>
-struct __sexpr_impl<transfer_when_all_t> : __when_all::__transfer_when_all_impl
-{};
+ template <>
+ struct __sexpr_impl<transfer_when_all_t> : __when_all::__transfer_when_all_impl { };
-template <>
-struct __sexpr_impl<transfer_when_all_with_variant_t> :
- __when_all::__transfer_when_all_with_variant_impl
-{};
+ template <>
+ struct __sexpr_impl<transfer_when_all_with_variant_t>
+ : __when_all::__transfer_when_all_with_variant_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__with_awaitable_senders.hpp b/include/sdbusplus/async/stdexec/__detail/__with_awaitable_senders.hpp
index c522394..fa7a50d 100644
--- a/include/sdbusplus/async/stdexec/__detail/__with_awaitable_senders.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__with_awaitable_senders.hpp
@@ -15,139 +15,122 @@
*/
#pragma once
+#include "__execution_fwd.hpp"
+
#include "__as_awaitable.hpp"
#include "__concepts.hpp"
-#include "__execution_fwd.hpp"
+#include "../coroutine.hpp" // IWYU pragma: keep for __coro::coroutine_handle
#include <exception>
-namespace stdexec
-{
+namespace stdexec {
#if !STDEXEC_STD_NO_COROUTINES()
-namespace __was
-{
-template <class _Promise = void>
-class __continuation_handle;
+ namespace __was {
+ template <class _Promise = void>
+ class __coroutine_handle;
-template <>
-class __continuation_handle<void>
-{
- public:
- __continuation_handle() = default;
+ template <>
+ class __coroutine_handle<void> : __coro::coroutine_handle<> {
+ public:
+ __coroutine_handle() = default;
+
+ template <class _Promise>
+ __coroutine_handle(__coro::coroutine_handle<_Promise> __coro) noexcept
+ : __coro::coroutine_handle<>(__coro) {
+ if constexpr (requires(_Promise& __promise) { __promise.unhandled_stopped(); }) {
+ __stopped_callback_ = [](void* __address) noexcept -> __coro::coroutine_handle<> {
+ // This causes the rest of the coroutine (the part after the co_await
+ // of the sender) to be skipped and invokes the calling coroutine's
+ // stopped handler.
+ return __coro::coroutine_handle<_Promise>::from_address(__address)
+ .promise()
+ .unhandled_stopped();
+ };
+ }
+ // If _Promise doesn't implement unhandled_stopped(), then if a "stopped" unwind
+ // reaches this point, it's considered an unhandled exception and terminate()
+ // is called.
+ }
+
+ [[nodiscard]]
+ auto handle() const noexcept -> __coro::coroutine_handle<> {
+ return *this;
+ }
+
+ [[nodiscard]]
+ auto unhandled_stopped() const noexcept -> __coro::coroutine_handle<> {
+ return __stopped_callback_(address());
+ }
+
+ private:
+ using __stopped_callback_t = __coro::coroutine_handle<> (*)(void*) noexcept;
+
+ __stopped_callback_t __stopped_callback_ = [](void*) noexcept -> __coro::coroutine_handle<> {
+ std::terminate();
+ };
+ };
template <class _Promise>
- __continuation_handle(__coro::coroutine_handle<_Promise> __coro) noexcept :
- __coro_(__coro)
- {
- if constexpr (requires(_Promise& __promise) {
- __promise.unhandled_stopped();
- })
- {
- __stopped_callback_ =
- [](void* __address) noexcept -> __coro::coroutine_handle<> {
- // This causes the rest of the coroutine (the part after the
- // co_await of the sender) to be skipped and invokes the calling
- // coroutine's stopped handler.
- return __coro::coroutine_handle<_Promise>::from_address(
- __address)
- .promise()
- .unhandled_stopped();
- };
- }
- // If _Promise doesn't implement unhandled_stopped(), then if a
- // "stopped" unwind reaches this point, it's considered an unhandled
- // exception and terminate() is called.
- }
+ class __coroutine_handle : public __coroutine_handle<> {
+ public:
+ __coroutine_handle() = default;
- [[nodiscard]] auto handle() const noexcept -> __coro::coroutine_handle<>
- {
- return __coro_;
- }
+ __coroutine_handle(__coro::coroutine_handle<_Promise> __coro) noexcept
+ : __coroutine_handle<>{__coro} {
+ }
- [[nodiscard]] auto unhandled_stopped() const noexcept
- -> __coro::coroutine_handle<>
- {
- return __stopped_callback_(__coro_.address());
- }
+ static auto from_promise(_Promise& __promise) noexcept -> __coroutine_handle {
+ return __coroutine_handle(__coro::coroutine_handle<_Promise>::from_promise(__promise));
+ }
- private:
- using __stopped_callback_t = __coro::coroutine_handle<> (*)(void*) noexcept;
+ auto promise() const noexcept -> _Promise& {
+ return __coro::coroutine_handle<_Promise>::from_address(address()).promise();
+ }
- __coro::coroutine_handle<> __coro_{};
- __stopped_callback_t __stopped_callback_ =
- [](void*) noexcept -> __coro::coroutine_handle<> { std::terminate(); };
-};
+ auto handle() const noexcept -> __coro::coroutine_handle<_Promise> {
+ return __coro::coroutine_handle<_Promise>::from_address(address());
+ }
-template <class _Promise>
-class __continuation_handle
-{
- public:
- __continuation_handle() = default;
+ operator __coro::coroutine_handle<_Promise>() const noexcept {
+ return handle();
+ }
+ };
- __continuation_handle(__coro::coroutine_handle<_Promise> __coro) noexcept :
- __continuation_{__coro}
- {}
-
- auto handle() const noexcept -> __coro::coroutine_handle<_Promise>
- {
- return __coro::coroutine_handle<_Promise>::from_address(
- __continuation_.handle().address());
- }
-
- [[nodiscard]] auto unhandled_stopped() const noexcept
- -> __coro::coroutine_handle<>
- {
- return __continuation_.unhandled_stopped();
- }
-
- private:
- __continuation_handle<> __continuation_{};
-};
-
-struct __with_awaitable_senders_base
-{
- template <class _OtherPromise>
- void set_continuation(
- __coro::coroutine_handle<_OtherPromise> __hcoro) noexcept
- {
+ struct __with_awaitable_senders_base {
+ template <class _OtherPromise>
+ void set_continuation(__coro::coroutine_handle<_OtherPromise> __hcoro) noexcept {
static_assert(!__same_as<_OtherPromise, void>);
__continuation_ = __hcoro;
- }
+ }
- void set_continuation(__continuation_handle<> __continuation) noexcept
- {
+ void set_continuation(__coroutine_handle<> __continuation) noexcept {
__continuation_ = __continuation;
- }
+ }
- [[nodiscard]] auto continuation() const noexcept -> __continuation_handle<>
- {
+ [[nodiscard]]
+ auto continuation() const noexcept -> __coroutine_handle<> {
return __continuation_;
- }
+ }
- auto unhandled_stopped() noexcept -> __coro::coroutine_handle<>
- {
+ auto unhandled_stopped() noexcept -> __coro::coroutine_handle<> {
return __continuation_.unhandled_stopped();
- }
+ }
- private:
- __continuation_handle<> __continuation_{};
-};
+ private:
+ __coroutine_handle<> __continuation_{};
+ };
-template <class _Promise>
-struct with_awaitable_senders : __with_awaitable_senders_base
-{
- template <class _Value>
- auto await_transform(_Value&& __val)
- -> __call_result_t<as_awaitable_t, _Value, _Promise&>
- {
+ template <class _Promise>
+ struct with_awaitable_senders : __with_awaitable_senders_base {
+ template <class _Value>
+ auto await_transform(_Value&& __val) -> __call_result_t<as_awaitable_t, _Value, _Promise&> {
static_assert(derived_from<_Promise, with_awaitable_senders>);
- return as_awaitable(static_cast<_Value&&>(__val),
- static_cast<_Promise&>(*this));
- }
-};
-} // namespace __was
+ return as_awaitable(static_cast<_Value&&>(__val), static_cast<_Promise&>(*this));
+ }
+ };
+ } // namespace __was
-using __was::__continuation_handle;
-using __was::with_awaitable_senders;
+ using __was::with_awaitable_senders;
+ using __was::__coroutine_handle;
#endif
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/__detail/__write_env.hpp b/include/sdbusplus/async/stdexec/__detail/__write_env.hpp
index 67e08cf..740088b 100644
--- a/include/sdbusplus/async/stdexec/__detail/__write_env.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__write_env.hpp
@@ -21,73 +21,64 @@
#include "__basic_sender.hpp"
#include "__env.hpp"
#include "__sender_adaptor_closure.hpp"
-#include "__senders.hpp"
-#include "__transform_sender.hpp"
#include "__utility.hpp"
-namespace stdexec
-{
-//////////////////////////////////////////////////////////////////////////////////////////////////
-// __write adaptor
-namespace __write_
-{
-struct __write_env_t
-{
- template <sender _Sender, class _Env>
- auto operator()(_Sender&& __sndr, _Env __env) const
- {
- return __make_sexpr<__write_env_t>(static_cast<_Env&&>(__env),
- static_cast<_Sender&&>(__sndr));
- }
+namespace stdexec {
+ //////////////////////////////////////////////////////////////////////////////////////////////////
+ // __write adaptor
+ namespace __write {
+ struct write_env_t {
+ template <sender _Sender, class _Env>
+ constexpr auto operator()(_Sender&& __sndr, _Env __env) const {
+ return __make_sexpr<write_env_t>(
+ static_cast<_Env&&>(__env), static_cast<_Sender&&>(__sndr));
+ }
- template <class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- auto operator()(_Env __env) const -> __binder_back<__write_env_t, _Env>
- {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr auto operator()(_Env __env) const -> __binder_back<write_env_t, _Env> {
return {{static_cast<_Env&&>(__env)}, {}, {}};
- }
+ }
- template <class _Env>
- STDEXEC_ATTRIBUTE((always_inline))
- static auto __transform_env_fn(_Env&& __env) noexcept
- {
+ template <class _Env>
+ STDEXEC_ATTRIBUTE(always_inline)
+ static constexpr auto __transform_env_fn(_Env&& __env) noexcept {
return [&](__ignore, const auto& __state, __ignore) noexcept {
- return __env::__join(__state, static_cast<_Env&&>(__env));
+ return __env::__join(__state, static_cast<_Env&&>(__env));
};
- }
+ }
- template <sender_expr_for<__write_env_t> _Self, class _Env>
- static auto transform_env(const _Self& __self, _Env&& __env) noexcept
- {
- return __sexpr_apply(__self,
- __transform_env_fn(static_cast<_Env&&>(__env)));
- }
-};
-
-struct __write_env_impl : __sexpr_defaults
-{
- static constexpr auto get_env = //
- [](__ignore, const auto& __state, const auto& __rcvr) noexcept {
- return __env::__join(__state, stdexec::get_env(__rcvr));
- };
-
- static constexpr auto get_completion_signatures = //
- []<class _Self, class... _Env>(_Self&&, _Env&&...) noexcept
- -> __completion_signatures_of_t<
- __child_of<_Self>,
- __meval<__env::__join_t, const __decay_t<__data_of<_Self>>&,
- _Env...>> {
- static_assert(sender_expr_for<_Self, __write_env_t>);
- return {};
+ template <sender_expr_for<write_env_t> _Self, class _Env>
+ static constexpr auto transform_env(const _Self& __self, _Env&& __env) noexcept {
+ return __sexpr_apply(__self, __transform_env_fn(static_cast<_Env&&>(__env)));
+ }
};
-};
-} // namespace __write_
-using __write_::__write_env_t;
-inline constexpr __write_env_t __write{};
-inline constexpr __write_env_t __write_env{};
+ struct __write_env_impl : __sexpr_defaults {
+ static constexpr auto get_attrs = []<class _Child>(__ignore, const _Child& __child) noexcept {
+ return __sync_attrs{__child};
+ };
-template <>
-struct __sexpr_impl<__write_env_t> : __write_::__write_env_impl
-{};
+ static constexpr auto get_env = [](__ignore, const auto& __state, const auto& __rcvr) noexcept
+ -> decltype(__env::__join(__state, stdexec::get_env(__rcvr))) {
+ return __env::__join(__state, stdexec::get_env(__rcvr));
+ };
+
+ static constexpr auto get_completion_signatures =
+ []<class _Self, class... _Env>(_Self &&, _Env &&...) noexcept
+ -> __completion_signatures_of_t<
+ __child_of<_Self>,
+ __meval<__join_env_t, const __decay_t<__data_of<_Self>> &,
+ _Env>...> {
+ static_assert(sender_expr_for<_Self, write_env_t>);
+ return {};
+ };
+ };
+ } // namespace __write
+
+ using __write::write_env_t;
+ inline constexpr write_env_t write_env{};
+
+ template <>
+ struct __sexpr_impl<write_env_t> : __write::__write_env_impl { };
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/any_sender_of.hpp b/include/sdbusplus/async/stdexec/any_sender_of.hpp
index b009708..a9a2c49 100644
--- a/include/sdbusplus/async/stdexec/any_sender_of.hpp
+++ b/include/sdbusplus/async/stdexec/any_sender_of.hpp
@@ -15,1205 +15,1044 @@
*/
#pragma once
-#include "../stdexec/concepts.hpp"
#include "../stdexec/execution.hpp"
-#include "../stdexec/functional.hpp"
+#include "../stdexec/__detail/__any_receiver_ref.hpp"
+#include "../stdexec/__detail/__concepts.hpp"
+#include "../stdexec/__detail/__env.hpp"
+#include "../stdexec/__detail/__transform_completion_signatures.hpp"
-#include <sdbusplus/async/stdexec/sequence_senders.hpp>
+#include "sequence_senders.hpp"
#include <cstddef>
#include <utility>
-namespace exec
-{
-namespace __any
-{
-using namespace stdexec;
+namespace exec {
+ namespace __any {
+ using namespace stdexec;
-struct __create_vtable_t
-{
- template <class _VTable, class _Tp>
- requires __tag_invocable_r<const _VTable*, __create_vtable_t,
- __mtype<_VTable>, __mtype<_Tp>>
- constexpr auto operator()(__mtype<_VTable>, __mtype<_Tp>) const noexcept
- -> const _VTable*
- {
- return stdexec::tag_invoke(__create_vtable_t{}, __mtype<_VTable>{},
- __mtype<_Tp>{});
- }
-};
+ struct __create_vtable_t {
+ template <class _VTable, class _Tp>
+ requires __tag_invocable_r<const _VTable*, __create_vtable_t, __mtype<_VTable>, __mtype<_Tp>>
+ constexpr auto operator()(__mtype<_VTable>, __mtype<_Tp>) const noexcept -> const _VTable* {
+ return stdexec::tag_invoke(__create_vtable_t{}, __mtype<_VTable>{}, __mtype<_Tp>{});
+ }
+ };
-inline constexpr __create_vtable_t __create_vtable{};
+ inline constexpr __create_vtable_t __create_vtable{};
-template <class _Sig>
-struct __query_vfun;
+ template <class _Sig>
+ struct __query_vfun;
-template <class _Tag, class _Ret, class... _As>
-struct __query_vfun<_Tag (*const)(_Ret (*)(_As...))>
-{
- _Ret (*__fn_)(void*, _As...);
-
- auto operator()(_Tag, void* __rcvr, _As&&... __as) const -> _Ret
- {
- return __fn_(__rcvr, static_cast<_As&&>(__as)...);
- }
-};
-
-template <class _Tag, class _Ret, class... _As>
-struct __query_vfun<_Tag (*)(_Ret (*)(_As...))>
-{
- _Ret (*__fn_)(void*, _As...);
-
- auto operator()(_Tag, void* __rcvr, _As&&... __as) const -> _Ret
- {
- return __fn_(__rcvr, static_cast<_As&&>(__as)...);
- }
-};
-
-template <class _Tag, class _Ret, class... _As>
-struct __query_vfun<_Tag (*const)(_Ret (*)(_As...) noexcept)>
-{
- _Ret (*__fn_)(void*, _As...) noexcept;
-
- auto operator()(_Tag, void* __rcvr, _As&&... __as) const noexcept -> _Ret
- {
- return __fn_(__rcvr, static_cast<_As&&>(__as)...);
- }
-};
-
-template <class _Tag, class _Ret, class... _As>
-struct __query_vfun<_Tag (*)(_Ret (*)(_As...) noexcept)>
-{
- _Ret (*__fn_)(void*, _As...) noexcept;
-
- auto operator()(_Tag, void* __rcvr, _As&&... __as) const noexcept -> _Ret
- {
- return __fn_(__rcvr, static_cast<_As&&>(__as)...);
- }
-};
-
-template <class _Queryable, bool _IsEnvProvider = true>
-struct __query_vfun_fn;
-
-template <class _EnvProvider>
-struct __query_vfun_fn<_EnvProvider, true>
-{
template <class _Tag, class _Ret, class... _As>
+ struct __query_vfun<_Tag (*const)(_Ret (*)(_As...))> {
+ _Ret (*__fn_)(void*, _As...);
+
+ auto operator()(_Tag, void* __rcvr, _As&&... __as) const -> _Ret {
+ return __fn_(__rcvr, static_cast<_As&&>(__as)...);
+ }
+ };
+
+ template <class _Tag, class _Ret, class... _As>
+ struct __query_vfun<_Tag (*)(_Ret (*)(_As...))> {
+ _Ret (*__fn_)(void*, _As...);
+
+ auto operator()(_Tag, void* __rcvr, _As&&... __as) const -> _Ret {
+ return __fn_(__rcvr, static_cast<_As&&>(__as)...);
+ }
+ };
+
+ template <class _Tag, class _Ret, class... _As>
+ struct __query_vfun<_Tag (*const)(_Ret (*)(_As...) noexcept)> {
+ _Ret (*__fn_)(void*, _As...) noexcept;
+
+ auto operator()(_Tag, void* __rcvr, _As&&... __as) const noexcept -> _Ret {
+ return __fn_(__rcvr, static_cast<_As&&>(__as)...);
+ }
+ };
+
+ template <class _Tag, class _Ret, class... _As>
+ struct __query_vfun<_Tag (*)(_Ret (*)(_As...) noexcept)> {
+ _Ret (*__fn_)(void*, _As...) noexcept;
+
+ auto operator()(_Tag, void* __rcvr, _As&&... __as) const noexcept -> _Ret {
+ return __fn_(__rcvr, static_cast<_As&&>(__as)...);
+ }
+ };
+
+ template <class _Queryable, bool _IsEnvProvider = true>
+ struct __query_vfun_fn;
+
+ template <class _EnvProvider>
+ struct __query_vfun_fn<_EnvProvider, true> {
+ template <class _Tag, class _Ret, class... _As>
requires __callable<_Tag, env_of_t<const _EnvProvider&>, _As...>
- constexpr _Ret (*operator()(_Tag (*)(_Ret (*)(_As...)))
- const noexcept)(void*, _As...)
- {
+ constexpr auto
+ operator()(_Tag (*)(_Ret (*)(_As...))) const noexcept -> _Ret (*)(void*, _As...) {
return +[](void* __env_provider, _As... __as) -> _Ret {
- return _Tag{}(stdexec::get_env(*static_cast<const _EnvProvider*>(
- __env_provider)),
- static_cast<_As&&>(__as)...);
+ return _Tag{}(
+ stdexec::get_env(*static_cast<const _EnvProvider*>(__env_provider)),
+ static_cast<_As&&>(__as)...);
};
- }
+ }
- template <class _Tag, class _Ret, class... _As>
+ template <class _Tag, class _Ret, class... _As>
requires __callable<_Tag, env_of_t<const _EnvProvider&>, _As...>
- constexpr _Ret (*operator()(_Tag (*)(_Ret (*)(_As...) noexcept))
- const noexcept)(void*, _As...) noexcept
- {
+ constexpr auto operator()(_Tag (*)(_Ret (*)(_As...) noexcept)) const noexcept
+ -> _Ret (*)(void*, _As...) noexcept {
return +[](void* __env_provider, _As... __as) noexcept -> _Ret {
- static_assert(
- __nothrow_callable<_Tag, const env_of_t<_EnvProvider>&,
- _As...>);
- return _Tag{}(stdexec::get_env(*static_cast<const _EnvProvider*>(
- __env_provider)),
- static_cast<_As&&>(__as)...);
+ static_assert(__nothrow_callable<_Tag, const env_of_t<_EnvProvider>&, _As...>);
+ return _Tag{}(
+ stdexec::get_env(*static_cast<const _EnvProvider*>(__env_provider)),
+ static_cast<_As&&>(__as)...);
};
- }
-};
+ }
+ };
-template <class _Queryable>
-struct __query_vfun_fn<_Queryable, false>
-{
- template <class _Tag, class _Ret, class... _As>
+ template <class _Queryable>
+ struct __query_vfun_fn<_Queryable, false> {
+ template <class _Tag, class _Ret, class... _As>
requires __callable<_Tag, const _Queryable&, _As...>
- constexpr _Ret (*operator()(_Tag (*)(_Ret (*)(_As...)))
- const noexcept)(void*, _As...)
- {
+ constexpr auto
+ operator()(_Tag (*)(_Ret (*)(_As...))) const noexcept -> _Ret (*)(void*, _As...) {
return +[](void* __queryable, _As... __as) -> _Ret {
- return _Tag{}(*static_cast<const _Queryable*>(__queryable),
- static_cast<_As&&>(__as)...);
+ return _Tag{}(*static_cast<const _Queryable*>(__queryable), static_cast<_As&&>(__as)...);
};
- }
+ }
- template <class _Tag, class _Ret, class... _As>
+ template <class _Tag, class _Ret, class... _As>
requires __callable<_Tag, const _Queryable&, _As...>
- constexpr _Ret (*operator()(_Tag (*)(_Ret (*)(_As...) noexcept))
- const noexcept)(void*, _As...) noexcept
- {
+ constexpr auto operator()(_Tag (*)(_Ret (*)(_As...) noexcept)) const noexcept
+ -> _Ret (*)(void*, _As...) noexcept {
return +[](void* __env_provider, _As... __as) noexcept -> _Ret {
- static_assert(__nothrow_callable<_Tag, const _Queryable&, _As...>);
- return _Tag{}(*static_cast<const _Queryable*>(__env_provider),
- static_cast<_As&&>(__as)...);
+ static_assert(__nothrow_callable<_Tag, const _Queryable&, _As...>);
+ return _Tag{}(
+ *static_cast<const _Queryable*>(__env_provider), static_cast<_As&&>(__as)...);
};
- }
-};
+ }
+ };
-template <class _Sig>
-struct __storage_vfun;
+ template <class _Sig>
+ struct __storage_vfun;
-template <class _Tag, class... _As>
-struct __storage_vfun<_Tag(void (*)(_As...))>
-{
- void (*__fn_)(void*, _As...) = [](void*, _As...) {};
-
- void operator()(_Tag, void* __storage, _As&&... __as) const
- {
- return __fn_(__storage, static_cast<_As&&>(__as)...);
- }
-};
-
-template <class _Tag, class... _As>
-struct __storage_vfun<_Tag(void (*)(_As...) noexcept)>
-{
- void (*__fn_)(void*, _As...) noexcept = [](void*, _As...) noexcept {};
-
- void operator()(_Tag, void* __storage, _As&&... __as) const noexcept
- {
- return __fn_(__storage, static_cast<_As&&>(__as)...);
- }
-};
-
-template <class _Storage, class _Tp>
-struct __storage_vfun_fn
-{
template <class _Tag, class... _As>
+ struct __storage_vfun<_Tag(void (*)(_As...))> {
+ void (*__fn_)(void*, _As...) = [](void*, _As...) {
+ };
+
+ void operator()(_Tag, void* __storage, _As&&... __as) const {
+ return __fn_(__storage, static_cast<_As&&>(__as)...);
+ }
+ };
+
+ template <class _Tag, class... _As>
+ struct __storage_vfun<_Tag(void (*)(_As...) noexcept)> {
+ void (*__fn_)(void*, _As...) noexcept = [](void*, _As...) noexcept {
+ };
+
+ void operator()(_Tag, void* __storage, _As&&... __as) const noexcept {
+ return __fn_(__storage, static_cast<_As&&>(__as)...);
+ }
+ };
+
+ template <class _Storage, class _Tp>
+ struct __storage_vfun_fn {
+ template <class _Tag, class... _As>
requires __callable<_Tag, __mtype<_Tp>, _Storage&, _As...>
- constexpr void (*operator()(_Tag (*)(void (*)(_As...)))
- const noexcept)(void*, _As...)
- {
+ constexpr auto
+ operator()(_Tag (*)(void (*)(_As...))) const noexcept -> void (*)(void*, _As...) {
return +[](void* __storage, _As... __as) -> void {
- return _Tag{}(__mtype<_Tp>{}, *static_cast<_Storage*>(__storage),
- static_cast<_As&&>(__as)...);
+ return _Tag{}(
+ __mtype<_Tp>{}, *static_cast<_Storage*>(__storage), static_cast<_As&&>(__as)...);
};
- }
+ }
- template <class _Tag, class... _As>
+ template <class _Tag, class... _As>
requires __callable<_Tag, __mtype<_Tp>, _Storage&, _As...>
- constexpr void (*operator()(_Tag (*)(void (*)(_As...) noexcept))
- const noexcept)(void*, _As...) noexcept
- {
+ constexpr auto operator()(_Tag (*)(void (*)(_As...) noexcept)) const noexcept
+ -> void (*)(void*, _As...) noexcept {
return +[](void* __storage, _As... __as) noexcept -> void {
- static_assert(
- __nothrow_callable<_Tag, __mtype<_Tp>, _Storage&, _As...>);
- return _Tag{}(__mtype<_Tp>{}, *static_cast<_Storage*>(__storage),
- static_cast<_As&&>(__as)...);
+ static_assert(__nothrow_callable<_Tag, __mtype<_Tp>, _Storage&, _As...>);
+ return _Tag{}(
+ __mtype<_Tp>{}, *static_cast<_Storage*>(__storage), static_cast<_As&&>(__as)...);
};
- }
-};
+ }
+ };
-struct __delete_t
-{
- template <class _Storage, class _Tp>
+ struct __delete_t {
+ template <class _Storage, class _Tp>
requires tag_invocable<__delete_t, __mtype<_Tp>, _Storage&>
- void operator()(__mtype<_Tp>, _Storage& __storage) noexcept
- {
- static_assert(
- nothrow_tag_invocable<__delete_t, __mtype<_Tp>, _Storage&>);
+ void operator()(__mtype<_Tp>, _Storage& __storage) noexcept {
+ static_assert(nothrow_tag_invocable<__delete_t, __mtype<_Tp>, _Storage&>);
stdexec::tag_invoke(__delete_t{}, __mtype<_Tp>{}, __storage);
+ }
+ };
+
+ inline constexpr __delete_t __delete{};
+
+ struct __copy_construct_t {
+ template <class _Storage, class _Tp>
+ requires tag_invocable<__copy_construct_t, __mtype<_Tp>, _Storage&, const _Storage&>
+ void operator()(__mtype<_Tp>, _Storage& __self, const _Storage& __from) noexcept(
+ nothrow_tag_invocable<__copy_construct_t, __mtype<_Tp>, _Storage&, const _Storage&>) {
+ stdexec::tag_invoke(__copy_construct_t{}, __mtype<_Tp>{}, __self, __from);
+ }
+ };
+
+ inline constexpr __copy_construct_t __copy_construct{};
+
+ struct __move_construct_t {
+ template <class _Storage, class _Tp>
+ requires tag_invocable<__move_construct_t, __mtype<_Tp>, _Storage&, _Storage&&>
+ void operator()(__mtype<_Tp>, _Storage& __self, __midentity<_Storage&&> __from) noexcept {
+ static_assert(
+ nothrow_tag_invocable<__move_construct_t, __mtype<_Tp>, _Storage&, _Storage&&>);
+ stdexec::tag_invoke(
+ __move_construct_t{}, __mtype<_Tp>{}, __self, static_cast<_Storage&&>(__from));
+ }
+ };
+
+ inline constexpr __move_construct_t __move_construct{};
+
+ template <class _ParentVTable, class... _StorageCPOs>
+ struct __storage_vtable;
+
+ template <class _ParentVTable, class... _StorageCPOs>
+ requires requires { _ParentVTable::operator(); }
+ struct __storage_vtable<_ParentVTable, _StorageCPOs...>
+ : _ParentVTable
+ , __storage_vfun<_StorageCPOs>... {
+ using _ParentVTable::operator();
+ using __storage_vfun<_StorageCPOs>::operator()...;
+ };
+
+ template <class _ParentVTable, class... _StorageCPOs>
+ requires(!requires { _ParentVTable::operator(); })
+ struct __storage_vtable<_ParentVTable, _StorageCPOs...>
+ : _ParentVTable
+ , __storage_vfun<_StorageCPOs>... {
+ using __storage_vfun<_StorageCPOs>::operator()...;
+ };
+
+ template <class _ParentVTable, class... _StorageCPOs>
+ inline constexpr __storage_vtable<_ParentVTable, _StorageCPOs...> __null_storage_vtbl{};
+
+ template <class _ParentVTable, class... _StorageCPOs>
+ constexpr auto
+ __default_storage_vtable(__storage_vtable<_ParentVTable, _StorageCPOs...>*) noexcept
+ -> const __storage_vtable<_ParentVTable, _StorageCPOs...>* {
+ return &__null_storage_vtbl<_ParentVTable, _StorageCPOs...>;
}
-};
-inline constexpr __delete_t __delete{};
+ template <class _Storage, class _Tp, class _ParentVTable, class... _StorageCPOs>
+ static const __storage_vtable<_ParentVTable, _StorageCPOs...> __storage_vtbl{
+ {*__create_vtable(__mtype<_ParentVTable>{}, __mtype<_Tp>{})},
+ {__storage_vfun_fn<_Storage, _Tp>{}(static_cast<_StorageCPOs*>(nullptr))}...};
-struct __copy_construct_t
-{
- template <class _Storage, class _Tp>
- requires tag_invocable<__copy_construct_t, __mtype<_Tp>, _Storage&,
- const _Storage&>
- void operator()(__mtype<_Tp>, _Storage& __self, const _Storage& __from) //
- noexcept(nothrow_tag_invocable<__copy_construct_t, __mtype<_Tp>,
- _Storage&, const _Storage&>)
- {
- stdexec::tag_invoke(__copy_construct_t{}, __mtype<_Tp>{}, __self,
- __from);
- }
-};
+ template <
+ class _Vtable,
+ class _Allocator,
+ bool _Copyable = false,
+ std::size_t _InlineSize = 3 * sizeof(void*),
+ std::size_t _Alignment = alignof(std::max_align_t)
+ >
+ struct __storage {
+ class __t;
+ };
-inline constexpr __copy_construct_t __copy_construct{};
-
-struct __move_construct_t
-{
- template <class _Storage, class _Tp>
- requires tag_invocable<__move_construct_t, __mtype<_Tp>, _Storage&,
- _Storage&&>
- void operator()(__mtype<_Tp>, _Storage& __self,
- __midentity<_Storage&&> __from) noexcept
- {
- static_assert(nothrow_tag_invocable<__move_construct_t, __mtype<_Tp>,
- _Storage&, _Storage&&>);
- stdexec::tag_invoke(__move_construct_t{}, __mtype<_Tp>{}, __self,
- static_cast<_Storage&&>(__from));
- }
-};
-
-inline constexpr __move_construct_t __move_construct{};
-
-template <class _ParentVTable, class... _StorageCPOs>
-struct __storage_vtable;
-
-template <class _ParentVTable, class... _StorageCPOs>
- requires requires { _ParentVTable::operator(); }
-struct __storage_vtable<_ParentVTable, _StorageCPOs...> :
- _ParentVTable,
- __storage_vfun<_StorageCPOs>...
-{
- using _ParentVTable::operator();
- using __storage_vfun<_StorageCPOs>::operator()...;
-};
-
-template <class _ParentVTable, class... _StorageCPOs>
- requires(!requires { _ParentVTable::operator(); })
-struct __storage_vtable<_ParentVTable, _StorageCPOs...> :
- _ParentVTable,
- __storage_vfun<_StorageCPOs>...
-{
- using __storage_vfun<_StorageCPOs>::operator()...;
-};
-
-template <class _ParentVTable, class... _StorageCPOs>
-inline constexpr __storage_vtable<_ParentVTable, _StorageCPOs...>
- __null_storage_vtbl{};
-
-template <class _ParentVTable, class... _StorageCPOs>
-constexpr auto __default_storage_vtable(
- __storage_vtable<_ParentVTable, _StorageCPOs...>*) noexcept
- -> const __storage_vtable<_ParentVTable, _StorageCPOs...>*
-{
- return &__null_storage_vtbl<_ParentVTable, _StorageCPOs...>;
-}
-
-template <class _Storage, class _Tp, class _ParentVTable, class... _StorageCPOs>
-static const __storage_vtable<_ParentVTable, _StorageCPOs...> __storage_vtbl{
- {*__create_vtable(__mtype<_ParentVTable>{}, __mtype<_Tp>{})},
- {__storage_vfun_fn<_Storage, _Tp>{}(
- static_cast<_StorageCPOs*>(nullptr))}...};
-
-template <class _Vtable, class _Allocator, bool _Copyable = false,
- std::size_t _InlineSize = 3 * sizeof(void*),
- std::size_t _Alignment = alignof(std::max_align_t)>
-struct __storage
-{
- class __t;
-};
-
-template <class _Vtable, class _Allocator,
- std::size_t _InlineSize = 3 * sizeof(void*),
- std::size_t _Alignment = alignof(std::max_align_t)>
-struct __immovable_storage
-{
- class __t : __immovable
- {
- static constexpr std::size_t __buffer_size =
- std::max(_InlineSize, sizeof(void*));
- static constexpr std::size_t __alignment =
- std::max(_Alignment, alignof(void*));
+ template <
+ class _Vtable,
+ class _Allocator,
+ std::size_t _InlineSize = 3 * sizeof(void*),
+ std::size_t _Alignment = alignof(std::max_align_t)
+ >
+ struct __immovable_storage {
+ class __t : __immovable {
+ static constexpr std::size_t __buffer_size = std::max(_InlineSize, sizeof(void*));
+ static constexpr std::size_t __alignment = std::max(_Alignment, alignof(void*));
using __with_delete = __delete_t(void() noexcept);
using __vtable_t = __storage_vtable<_Vtable, __with_delete>;
template <class _Tp>
- static constexpr bool __is_small =
- sizeof(_Tp) <= __buffer_size && alignof(_Tp) <= __alignment;
+ static constexpr bool __is_small = sizeof(_Tp) <= __buffer_size
+ && alignof(_Tp) <= __alignment;
template <class _Tp>
- static constexpr auto __get_vtable_of_type() noexcept
- -> const __vtable_t*
- {
- return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete>;
+ static constexpr auto __get_vtable_of_type() noexcept -> const __vtable_t* {
+ return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete>;
}
-
- public:
+ public:
using __id = __immovable_storage;
__t() = default;
template <__not_decays_to<__t> _Tp>
- requires __callable<__create_vtable_t, __mtype<_Vtable>,
- __mtype<__decay_t<_Tp>>>
- __t(_Tp&& __object) : __vtable_{__get_vtable_of_type<_Tp>()}
- {
- using _Dp = __decay_t<_Tp>;
- if constexpr (__is_small<_Dp>)
- {
- __construct_small<_Dp>(static_cast<_Tp&&>(__object));
- }
- else
- {
- __construct_large<_Dp>(static_cast<_Tp&&>(__object));
- }
+ requires __callable<__create_vtable_t, __mtype<_Vtable>, __mtype<__decay_t<_Tp>>>
+ __t(_Tp&& __object)
+ : __vtable_{__get_vtable_of_type<_Tp>()} {
+ using _Dp = __decay_t<_Tp>;
+ if constexpr (__is_small<_Dp>) {
+ __construct_small<_Dp>(static_cast<_Tp&&>(__object));
+ } else {
+ __construct_large<_Dp>(static_cast<_Tp&&>(__object));
+ }
}
template <class _Tp, class... _Args>
- requires __callable<__create_vtable_t, __mtype<_Vtable>,
- __mtype<_Tp>>
- __t(std::in_place_type_t<_Tp>, _Args&&... __args) :
- __vtable_{__get_vtable_of_type<_Tp>()}
- {
- if constexpr (__is_small<_Tp>)
- {
- __construct_small<_Tp>(static_cast<_Args&&>(__args)...);
- }
- else
- {
- __construct_large<_Tp>(static_cast<_Args&&>(__args)...);
- }
+ requires __callable<__create_vtable_t, __mtype<_Vtable>, __mtype<_Tp>>
+ __t(std::in_place_type_t<_Tp>, _Args&&... __args)
+ : __vtable_{__get_vtable_of_type<_Tp>()} {
+ if constexpr (__is_small<_Tp>) {
+ __construct_small<_Tp>(static_cast<_Args&&>(__args)...);
+ } else {
+ __construct_large<_Tp>(static_cast<_Args&&>(__args)...);
+ }
}
- ~__t()
- {
- __reset();
+ ~__t() {
+ __reset();
}
- void __reset() noexcept
- {
- (*__vtable_)(__delete, this);
- __object_pointer_ = nullptr;
- __vtable_ =
- __default_storage_vtable(static_cast<__vtable_t*>(nullptr));
+ void __reset() noexcept {
+ (*__vtable_)(__delete, this);
+ __object_pointer_ = nullptr;
+ __vtable_ = __default_storage_vtable(static_cast<__vtable_t*>(nullptr));
}
- [[nodiscard]] auto __get_vtable() const noexcept -> const _Vtable*
- {
- return __vtable_;
+ [[nodiscard]]
+ auto __get_vtable() const noexcept -> const _Vtable* {
+ return __vtable_;
}
- [[nodiscard]] auto __get_object_pointer() const noexcept -> void*
- {
- return __object_pointer_;
+ [[nodiscard]]
+ auto __get_object_pointer() const noexcept -> void* {
+ return __object_pointer_;
}
- private:
+ private:
template <class _Tp, class... _As>
- void __construct_small(_As&&... __args)
- {
- static_assert(sizeof(_Tp) <= __buffer_size &&
- alignof(_Tp) <= __alignment);
- _Tp* __pointer =
- static_cast<_Tp*>(static_cast<void*>(&__buffer_[0]));
- using _Alloc = typename std::allocator_traits<
- _Allocator>::template rebind_alloc<_Tp>;
- _Alloc __alloc{__allocator_};
+ void __construct_small(_As&&... __args) {
+ static_assert(sizeof(_Tp) <= __buffer_size && alignof(_Tp) <= __alignment);
+ _Tp* __pointer = reinterpret_cast<_Tp*>(&__buffer_[0]);
+ using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+ _Alloc __alloc{__allocator_};
+ std::allocator_traits<_Alloc>::construct(
+ __alloc, __pointer, static_cast<_As&&>(__args)...);
+ __object_pointer_ = __pointer;
+ }
+
+ template <class _Tp, class... _As>
+ void __construct_large(_As&&... __args) {
+ using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+ _Alloc __alloc{__allocator_};
+ _Tp* __pointer = std::allocator_traits<_Alloc>::allocate(__alloc, 1);
+ STDEXEC_TRY {
std::allocator_traits<_Alloc>::construct(
- __alloc, __pointer, static_cast<_As&&>(__args)...);
- __object_pointer_ = __pointer;
- }
-
- template <class _Tp, class... _As>
- void __construct_large(_As&&... __args)
- {
- using _Alloc = typename std::allocator_traits<
- _Allocator>::template rebind_alloc<_Tp>;
- _Alloc __alloc{__allocator_};
- _Tp* __pointer =
- std::allocator_traits<_Alloc>::allocate(__alloc, 1);
- try
- {
- std::allocator_traits<_Alloc>::construct(
- __alloc, __pointer, static_cast<_As&&>(__args)...);
- }
- catch (...)
- {
- std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer,
- 1);
- throw;
- }
- __object_pointer_ = __pointer;
+ __alloc, __pointer, static_cast<_As&&>(__args)...);
+ }
+ STDEXEC_CATCH_ALL {
+ std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, 1);
+ STDEXEC_THROW();
+ }
+ __object_pointer_ = __pointer;
}
template <class _Tp>
- STDEXEC_MEMFN_DECL(void __delete)(this __mtype<_Tp>,
- __t& __self) noexcept
- {
- if (!__self.__object_pointer_)
- {
- return;
- }
- using _Alloc = typename std::allocator_traits<
- _Allocator>::template rebind_alloc<_Tp>;
- _Alloc __alloc{__self.__allocator_};
- _Tp* __pointer = static_cast<_Tp*>(
- std::exchange(__self.__object_pointer_, nullptr));
- std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
- if constexpr (!__is_small<_Tp>)
- {
- std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer,
- 1);
- }
+ STDEXEC_MEMFN_DECL(void __delete)(this __mtype<_Tp>, __t& __self) noexcept {
+ if (!__self.__object_pointer_) {
+ return;
+ }
+ using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+ _Alloc __alloc{__self.__allocator_};
+ _Tp* __pointer = static_cast<_Tp*>(std::exchange(__self.__object_pointer_, nullptr));
+ std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
+ if constexpr (!__is_small<_Tp>) {
+ std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, 1);
+ }
}
-
- private:
- const __vtable_t* __vtable_{
- __default_storage_vtable(static_cast<__vtable_t*>(nullptr))};
+ private:
+ const __vtable_t* __vtable_{__default_storage_vtable(static_cast<__vtable_t*>(nullptr))};
void* __object_pointer_{nullptr};
alignas(__alignment) std::byte __buffer_[__buffer_size]{};
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Allocator __allocator_{};
+ STDEXEC_ATTRIBUTE(no_unique_address) _Allocator __allocator_ { };
+ };
};
-};
-template <class _Vtable, class _Allocator, bool _Copyable,
- std::size_t _InlineSize, std::size_t _Alignment>
-class __storage<_Vtable, _Allocator, _Copyable, _InlineSize, _Alignment>::__t :
- __if_c<_Copyable, __, __move_only>
-{
- static_assert(STDEXEC_IS_CONVERTIBLE_TO(
- typename std::allocator_traits<_Allocator>::void_pointer, void*));
+ template <
+ class _Vtable,
+ class _Allocator,
+ bool _Copyable,
+ std::size_t _InlineSize,
+ std::size_t _Alignment
+ >
+ class __storage<_Vtable, _Allocator, _Copyable, _InlineSize, _Alignment>::__t
+ : __if_c<_Copyable, __, __move_only> {
+ static_assert(
+ STDEXEC_IS_CONVERTIBLE_TO(typename std::allocator_traits<_Allocator>::void_pointer, void*));
- static constexpr std::size_t __buffer_size =
- std::max(_InlineSize, sizeof(void*));
- static constexpr std::size_t __alignment =
- std::max(_Alignment, alignof(void*));
- using __with_copy = __copy_construct_t(void(const __t&));
- using __with_move = __move_construct_t(void(__t&&) noexcept);
- using __with_delete = __delete_t(void() noexcept);
+ static constexpr std::size_t __buffer_size = std::max(_InlineSize, sizeof(void*));
+ static constexpr std::size_t __alignment = std::max(_Alignment, alignof(void*));
+ using __with_copy = __copy_construct_t(void(const __t&));
+ using __with_move = __move_construct_t(void(__t&&) noexcept);
+ using __with_delete = __delete_t(void() noexcept);
- template <class _Tp>
- static constexpr bool __is_small =
- sizeof(_Tp) <= __buffer_size && alignof(_Tp) <= __alignment &&
- std::is_nothrow_move_constructible_v<_Tp>;
+ template <class _Tp>
+ static constexpr bool __is_small = sizeof(_Tp) <= __buffer_size && alignof(_Tp) <= __alignment
+ && std::is_nothrow_move_constructible_v<_Tp>;
- using __vtable_t = __if_c<
+ using __vtable_t = __if_c<
_Copyable,
__storage_vtable<_Vtable, __with_delete, __with_move, __with_copy>,
- __storage_vtable<_Vtable, __with_delete, __with_move>>;
+ __storage_vtable<_Vtable, __with_delete, __with_move>
+ >;
- template <class _Tp>
- static constexpr auto __get_vtable_of_type() noexcept -> const __vtable_t*
- {
- if constexpr (_Copyable)
- {
- return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete,
- __with_move, __with_copy>;
+ template <class _Tp>
+ static constexpr auto __get_vtable_of_type() noexcept -> const __vtable_t* {
+ if constexpr (_Copyable) {
+ return &__storage_vtbl<
+ __t,
+ __decay_t<_Tp>,
+ _Vtable,
+ __with_delete,
+ __with_move,
+ __with_copy
+ >;
+ } else {
+ return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete, __with_move>;
}
- else
- {
- return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete,
- __with_move>;
- }
- }
+ }
- public:
- using __id = __storage;
+ public:
+ using __id = __storage;
- __t() = default;
+ __t() = default;
- template <__not_decays_to<__t> _Tp>
- requires __callable<__create_vtable_t, __mtype<_Vtable>,
- __mtype<__decay_t<_Tp>>>
- __t(_Tp&& __object) : __vtable_{__get_vtable_of_type<_Tp>()}
- {
+ template <__not_decays_to<__t> _Tp>
+ requires __callable<__create_vtable_t, __mtype<_Vtable>, __mtype<__decay_t<_Tp>>>
+ __t(_Tp&& __object)
+ : __vtable_{__get_vtable_of_type<_Tp>()} {
using _Dp = __decay_t<_Tp>;
- if constexpr (__is_small<_Dp>)
- {
- __construct_small<_Dp>(static_cast<_Tp&&>(__object));
+ if constexpr (__is_small<_Dp>) {
+ __construct_small<_Dp>(static_cast<_Tp&&>(__object));
+ } else {
+ __construct_large<_Dp>(static_cast<_Tp&&>(__object));
}
- else
- {
- __construct_large<_Dp>(static_cast<_Tp&&>(__object));
- }
- }
+ }
- template <class _Tp, class... _Args>
+ template <class _Tp, class... _Args>
requires __callable<__create_vtable_t, __mtype<_Vtable>, __mtype<_Tp>>
- __t(std::in_place_type_t<_Tp>, _Args&&... __args) :
- __vtable_{__get_vtable_of_type<_Tp>()}
- {
- if constexpr (__is_small<_Tp>)
- {
- __construct_small<_Tp>(static_cast<_Args&&>(__args)...);
+ __t(std::in_place_type_t<_Tp>, _Args&&... __args)
+ : __vtable_{__get_vtable_of_type<_Tp>()} {
+ if constexpr (__is_small<_Tp>) {
+ __construct_small<_Tp>(static_cast<_Args&&>(__args)...);
+ } else {
+ __construct_large<_Tp>(static_cast<_Args&&>(__args)...);
}
- else
- {
- __construct_large<_Tp>(static_cast<_Args&&>(__args)...);
- }
- }
+ }
- __t(const __t& __other)
+ __t(const __t& __other)
requires(_Copyable)
- {
+ : __vtable_(__other.__vtable_) {
(*__other.__vtable_)(__copy_construct, this, __other);
- }
+ }
- auto operator=(const __t& __other) -> __t&
+ auto operator=(const __t& __other) -> __t&
requires(_Copyable)
- {
- if (&__other != this)
- {
- __t tmp(__other);
- *this = std::move(tmp);
+ {
+ if (&__other != this) {
+ __t tmp(__other);
+ *this = std::move(tmp);
}
return *this;
- }
+ }
- __t(__t&& __other) noexcept
- {
- (*__other.__vtable_)(__move_construct, this,
- static_cast<__t&&>(__other));
- }
+ __t(__t&& __other) noexcept
+ : __vtable_(__other.__vtable_) {
+ (*__other.__vtable_)(__move_construct, this, static_cast<__t&&>(__other));
+ }
- auto operator=(__t&& __other) noexcept -> __t&
- {
+ auto operator=(__t&& __other) noexcept -> __t& {
__reset();
- (*__other.__vtable_)(__move_construct, this,
- static_cast<__t&&>(__other));
+ (*__other.__vtable_)(__move_construct, this, static_cast<__t&&>(__other));
return *this;
- }
+ }
- ~__t()
- {
+ ~__t() {
__reset();
- }
+ }
- void __reset() noexcept
- {
+ void __reset() noexcept {
(*__vtable_)(__delete, this);
__object_pointer_ = nullptr;
__vtable_ = __default_storage_vtable(static_cast<__vtable_t*>(nullptr));
- }
+ }
- auto __get_vtable() const noexcept -> const _Vtable*
- {
+ auto __get_vtable() const noexcept -> const _Vtable* {
return __vtable_;
- }
+ }
- [[nodiscard]] auto __get_object_pointer() const noexcept -> void*
- {
+ [[nodiscard]]
+ auto __get_object_pointer() const noexcept -> void* {
return __object_pointer_;
- }
+ }
- private:
- template <class _Tp, class... _As>
- void __construct_small(_As&&... __args)
- {
- static_assert(sizeof(_Tp) <= __buffer_size &&
- alignof(_Tp) <= __alignment);
- _Tp* __pointer = static_cast<_Tp*>(static_cast<void*>(&__buffer_[0]));
- using _Alloc = typename std::allocator_traits<
- _Allocator>::template rebind_alloc<_Tp>;
+ private:
+ template <class _Tp, class... _As>
+ void __construct_small(_As&&... __args) {
+ static_assert(sizeof(_Tp) <= __buffer_size && alignof(_Tp) <= __alignment);
+ _Tp* __pointer = reinterpret_cast<_Tp*>(&__buffer_[0]);
+ using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
_Alloc __alloc{__allocator_};
- std::allocator_traits<_Alloc>::construct(__alloc, __pointer,
- static_cast<_As&&>(__args)...);
+ std::allocator_traits<_Alloc>::construct(__alloc, __pointer, static_cast<_As&&>(__args)...);
__object_pointer_ = __pointer;
- }
+ }
- template <class _Tp, class... _As>
- void __construct_large(_As&&... __args)
- {
- using _Alloc = typename std::allocator_traits<
- _Allocator>::template rebind_alloc<_Tp>;
+ template <class _Tp, class... _As>
+ void __construct_large(_As&&... __args) {
+ using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
_Alloc __alloc{__allocator_};
_Tp* __pointer = std::allocator_traits<_Alloc>::allocate(__alloc, 1);
- try
- {
- std::allocator_traits<_Alloc>::construct(
- __alloc, __pointer, static_cast<_As&&>(__args)...);
+ STDEXEC_TRY {
+ std::allocator_traits<_Alloc>::construct(
+ __alloc, __pointer, static_cast<_As&&>(__args)...);
}
- catch (...)
- {
- std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, 1);
- throw;
+ STDEXEC_CATCH_ALL {
+ std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, 1);
+ STDEXEC_THROW();
}
__object_pointer_ = __pointer;
- }
+ }
- template <class _Tp>
- STDEXEC_MEMFN_DECL(void __delete)(this __mtype<_Tp>, __t& __self) noexcept
- {
- if (!__self.__object_pointer_)
- {
- return;
+ template <class _Tp>
+ STDEXEC_MEMFN_DECL(void __delete)(this __mtype<_Tp>, __t& __self) noexcept {
+ if (!__self.__object_pointer_) {
+ return;
}
- using _Alloc = typename std::allocator_traits<
- _Allocator>::template rebind_alloc<_Tp>;
+ using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
_Alloc __alloc{__self.__allocator_};
- _Tp* __pointer =
- static_cast<_Tp*>(std::exchange(__self.__object_pointer_, nullptr));
+ _Tp* __pointer = static_cast<_Tp*>(std::exchange(__self.__object_pointer_, nullptr));
std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
- if constexpr (!__is_small<_Tp>)
- {
- std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, 1);
+ if constexpr (!__is_small<_Tp>) {
+ std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, 1);
}
- }
+ }
- template <class _Tp>
- STDEXEC_MEMFN_DECL(void __move_construct)(this __mtype<_Tp>, __t& __self,
- __t&& __other) noexcept
- {
- if (!__other.__object_pointer_)
- {
- return;
+ template <class _Tp>
+ STDEXEC_MEMFN_DECL(
+ void __move_construct)(this __mtype<_Tp>, __t& __self, __t&& __other) noexcept {
+ if (!__other.__object_pointer_) {
+ return;
}
- _Tp* __pointer = static_cast<_Tp*>(
- std::exchange(__other.__object_pointer_, nullptr));
- if constexpr (__is_small<_Tp>)
- {
- _Tp& __other_object = *__pointer;
- __self.template __construct_small<_Tp>(
- static_cast<_Tp&&>(__other_object));
- using _Alloc = typename std::allocator_traits<
- _Allocator>::template rebind_alloc<_Tp>;
- _Alloc __alloc{__self.__allocator_};
- std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
- }
- else
- {
- __self.__object_pointer_ = __pointer;
+ _Tp* __pointer = static_cast<_Tp*>(std::exchange(__other.__object_pointer_, nullptr));
+ if constexpr (__is_small<_Tp>) {
+ _Tp& __other_object = *__pointer;
+ __self.template __construct_small<_Tp>(static_cast<_Tp&&>(__other_object));
+ using _Alloc = std::allocator_traits<_Allocator>::template rebind_alloc<_Tp>;
+ _Alloc __alloc{__self.__allocator_};
+ std::allocator_traits<_Alloc>::destroy(__alloc, __pointer);
+ } else {
+ __self.__object_pointer_ = __pointer;
}
__self.__vtable_ = std::exchange(
- __other.__vtable_,
- __default_storage_vtable(static_cast<__vtable_t*>(nullptr)));
- }
+ __other.__vtable_, __default_storage_vtable(static_cast<__vtable_t*>(nullptr)));
+ }
- template <class _Tp>
+ template <class _Tp>
requires _Copyable
- STDEXEC_MEMFN_DECL(void __copy_construct)(this __mtype<_Tp>, __t& __self,
- const __t& __other)
- {
- if (!__other.__object_pointer_)
- {
- return;
+ STDEXEC_MEMFN_DECL(
+ void __copy_construct)(this __mtype<_Tp>, __t& __self, const __t& __other) {
+ if (!__other.__object_pointer_) {
+ return;
}
- const _Tp& __other_object =
- *static_cast<const _Tp*>(__other.__object_pointer_);
- if constexpr (__is_small<_Tp>)
- {
- __self.template __construct_small<_Tp>(__other_object);
- }
- else
- {
- __self.template __construct_large<_Tp>(__other_object);
+ const _Tp& __other_object = *static_cast<const _Tp*>(__other.__object_pointer_);
+ if constexpr (__is_small<_Tp>) {
+ __self.template __construct_small<_Tp>(__other_object);
+ } else {
+ __self.template __construct_large<_Tp>(__other_object);
}
__self.__vtable_ = __other.__vtable_;
- }
+ }
- const __vtable_t* __vtable_{
- __default_storage_vtable(static_cast<__vtable_t*>(nullptr))};
- void* __object_pointer_{nullptr};
- alignas(__alignment) std::byte __buffer_[__buffer_size]{};
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Allocator __allocator_{};
-};
+ const __vtable_t* __vtable_{__default_storage_vtable(static_cast<__vtable_t*>(nullptr))};
+ void* __object_pointer_{nullptr};
+ alignas(__alignment) std::byte __buffer_[__buffer_size]{};
+ STDEXEC_ATTRIBUTE(no_unique_address) _Allocator __allocator_ { };
+ };
-struct __empty_vtable
-{
- template <class _Sender>
- STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__empty_vtable>,
- __mtype<_Sender>) noexcept
- -> const __empty_vtable*
- {
+ struct __empty_vtable {
+ template <class _Sender>
+ STDEXEC_MEMFN_DECL(
+ auto __create_vtable)(this __mtype<__empty_vtable>, __mtype<_Sender>) noexcept
+ -> const __empty_vtable* {
static const __empty_vtable __vtable_{};
return &__vtable_;
- }
-};
-
-template <class _VTable = __empty_vtable,
- class _Allocator = std::allocator<std::byte>>
-using __immovable_storage_t = __t<__immovable_storage<_VTable, _Allocator>>;
-
-template <class _VTable, class _Allocator = std::allocator<std::byte>>
-using __unique_storage_t = __t<__storage<_VTable, _Allocator>>;
-
-template <class _VTable, std::size_t _InlineSize = 3 * sizeof(void*),
- class _Allocator = std::allocator<std::byte>>
-using __copyable_storage_t =
- __t<__storage<_VTable, _Allocator, true, _InlineSize>>;
-
-template <class _Tag, class... _As>
-auto __tag_type(_Tag (*)(_As...)) -> _Tag;
-
-template <class _Tag, class... _As>
-auto __tag_type(_Tag (*)(_As...) noexcept) -> _Tag;
-
-template <class _Query>
-concept __is_stop_token_query = requires {
- {
- __tag_type(static_cast<_Query>(nullptr))
- } -> same_as<get_stop_token_t>;
- };
-
-template <class _Query>
-concept __is_not_stop_token_query = !__is_stop_token_query<_Query>;
-
-template <class _Query>
-using __is_not_stop_token_query_v = __mbool<__is_not_stop_token_query<_Query>>;
-
-namespace __rec
-{
-template <class _Sigs, class... _Queries>
-struct __vtable
-{
- class __t;
-};
-
-template <class _Sigs, class... _Queries>
-struct __ref;
-
-template <class... _Sigs, class... _Queries>
-struct __vtable<completion_signatures<_Sigs...>, _Queries...>
-{
- class __t :
- public __any_::__rcvr_vfun<_Sigs>...,
- public __query_vfun<_Queries>...
- {
- public:
- using __query_vfun<_Queries>::operator()...;
-
- private:
- template <class _Rcvr>
- requires receiver_of<_Rcvr, completion_signatures<_Sigs...>> &&
- (__callable<__query_vfun_fn<_Rcvr>, _Queries> && ...)
- STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__t>,
- __mtype<_Rcvr>) noexcept
- -> const __t*
- {
- static const __t __vtable_{
- {__any_::__rcvr_vfun_fn(static_cast<_Rcvr*>(nullptr),
- static_cast<_Sigs*>(nullptr))}...,
- {__query_vfun_fn<_Rcvr>{}(static_cast<_Queries>(nullptr))}...};
- return &__vtable_;
- }
+ }
};
-};
-template <class... _Sigs, class... _Queries>
- requires(__is_not_stop_token_query<_Queries> && ...)
-struct __ref<completion_signatures<_Sigs...>, _Queries...>
-{
+ template <
+ class _VTable = __empty_vtable,
+ class _Allocator = std::allocator<std::byte>,
+ std::size_t _InlineSize = 3 * sizeof(void*),
+ std::size_t _Alignment = alignof(std::max_align_t)
+ >
+ using __immovable_storage_t =
+ __t<__immovable_storage<_VTable, _Allocator, _InlineSize, _Alignment>>;
+
+ template <class _VTable, class _Allocator = std::allocator<std::byte>>
+ using __unique_storage_t = __t<__storage<_VTable, _Allocator>>;
+
+ template <
+ class _VTable,
+ std::size_t _InlineSize = 3 * sizeof(void*),
+ class _Allocator = std::allocator<std::byte>
+ >
+ using __copyable_storage_t = __t<__storage<_VTable, _Allocator, true, _InlineSize>>;
+
+ template <class _Tag, class... _As>
+ auto __tag_type(_Tag (*)(_As...)) -> _Tag;
+
+ template <class _Tag, class... _As>
+ auto __tag_type(_Tag (*)(_As...) noexcept) -> _Tag;
+
+ template <class _Query>
+ using __tag_type_t = decltype(__tag_type(static_cast<_Query>(nullptr)));
+
+ template <class _Query>
+ concept __is_stop_token_query = __same_as<__tag_type_t<_Query>, get_stop_token_t>;
+
+ template <class _Query>
+ concept __is_not_stop_token_query = !__is_stop_token_query<_Query>;
+
+ template <class _Query>
+ using __is_not_stop_token_query_t = __mbool<__is_not_stop_token_query<_Query>>;
+
+ auto __test_never_stop_token(get_stop_token_t (*)(never_stop_token (*)() noexcept))
+ -> __mbool<true>;
+
+ template <class _Tag, class _Ret, class... _As>
+ auto __test_never_stop_token(_Tag (*)(_Ret (*)(_As...) noexcept)) -> __mbool<false>;
+
+ template <class _Tag, class _Ret, class... _As>
+ auto __test_never_stop_token(_Tag (*)(_Ret (*)(_As...))) -> __mbool<false>;
+
+ template <class _Query>
+ using __is_never_stop_token_query_t = decltype(__test_never_stop_token(
+ static_cast<_Query>(nullptr)));
+
+ template <class _Query>
+ concept __is_never_stop_token_query = __is_never_stop_token_query_t<_Query>::value;
+
+ template <class _Query, class _Env>
+ concept __satisfies_receiver_stop_token_query =
+ __same_as<__decay_t<__query_result_t<_Env, __tag_type_t<_Query>>>, stop_token_of_t<_Env>>;
+
+ template <class _Query, class... _Env>
+ concept __satisfies_receiver_query = !__is_stop_token_query<_Query>
+ || __is_never_stop_token_query<_Query>
+ || (__satisfies_receiver_stop_token_query<_Query, _Env> || ...);
+
+ namespace __rec {
+ template <class _Sigs, class... _Queries>
+ struct __vtable {
+ class __t;
+ };
+
+ template <class _Sigs, class... _Queries>
+ struct __ref;
+
+ template <class... _Sigs, class... _Queries>
+ struct __vtable<completion_signatures<_Sigs...>, _Queries...> {
+ struct __t
+ : __overload<__any_::__rcvr_vfun<_Sigs>...>
+ , __query_vfun<_Queries>... {
+ using __query_vfun<_Queries>::operator()...;
+
+ template <class _Tag, class... _As>
+ requires __one_of<_Tag(_As...), _Sigs...>
+ || __callable<__overload<__any_::__rcvr_vfun<_Sigs>...>, void*, _Tag, _As...>
+ void operator()(void* __rcvr, _Tag, _As&&... __as) const noexcept {
+ if constexpr (__one_of<_Tag(_As...), _Sigs...>) {
+ const __any_::__rcvr_vfun<_Tag(_As...)>& __vfun = *this;
+ __vfun(__rcvr, _Tag(), static_cast<_As&&>(__as)...);
+ } else {
+ const __overload<__any_::__rcvr_vfun<_Sigs>...>& __vfun = *this;
+ __vfun(__rcvr, _Tag(), static_cast<_As&&>(__as)...);
+ }
+ }
+
+ private:
+ template <class _Rcvr>
+ requires receiver_of<_Rcvr, completion_signatures<_Sigs...>>
+ && (__callable<__query_vfun_fn<_Rcvr>, _Queries> && ...)
+ STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__t>, __mtype<_Rcvr>) noexcept
+ -> const __t* {
+ static const __t __vtable_{
+ {{__any_::__rcvr_vfun_fn(
+ static_cast<_Rcvr*>(nullptr), static_cast<_Sigs*>(nullptr))}...},
+ {__query_vfun_fn<_Rcvr>{}(static_cast<_Queries>(nullptr))}...};
+ return &__vtable_;
+ }
+ };
+ };
+
+ template <class... _Sigs, class... _Queries>
+ requires(__is_not_stop_token_query<_Queries> && ...)
+ struct __ref<completion_signatures<_Sigs...>, _Queries...> {
#if !STDEXEC_MSVC()
- // MSVCBUG
- // https://developercommunity.visualstudio.com/t/Private-member-inaccessible-when-used-in/10448363
-
- private:
+ // MSVCBUG https://developercommunity.visualstudio.com/t/Private-member-inaccessible-when-used-in/10448363
+ private:
#endif
- using __vtable_t =
- stdexec::__t<__vtable<completion_signatures<_Sigs...>, _Queries...>>;
+ using __vtable_t = stdexec::__t<__vtable<completion_signatures<_Sigs...>, _Queries...>>;
- struct __env_t
- {
- const __vtable_t* __vtable_;
- void* __rcvr_;
- inplace_stop_token __token_;
+ struct __env_t {
+ const __vtable_t* __vtable_;
+ void* __rcvr_;
+ inplace_stop_token __token_;
- template <class _Tag, class... _As>
+ template <class _Tag, class... _As>
requires __callable<const __vtable_t&, _Tag, void*, _As...>
- auto query(_Tag, _As&&... __as) const //
+ auto query(_Tag, _As&&... __as) const
noexcept(__nothrow_callable<const __vtable_t&, _Tag, void*, _As...>)
- -> __call_result_t<const __vtable_t&, _Tag, void*, _As...>
- {
+ -> __call_result_t<const __vtable_t&, _Tag, void*, _As...> {
return (*__vtable_)(_Tag{}, __rcvr_, static_cast<_As&&>(__as)...);
- }
+ }
- auto query(get_stop_token_t) const noexcept -> inplace_stop_token
- {
+ [[nodiscard]]
+ auto query(get_stop_token_t) const noexcept -> inplace_stop_token {
return __token_;
- }
- } __env_;
-
- public:
- using receiver_concept = stdexec::receiver_t;
- using __id = __ref;
- using __t = __ref;
-
- template <__none_of<__ref, const __ref, __env_t, const __env_t> _Rcvr>
- requires receiver_of<_Rcvr, completion_signatures<_Sigs...>> &&
- (__callable<__query_vfun_fn<_Rcvr>, _Queries> && ...)
- __ref(_Rcvr& __rcvr) noexcept :
- __env_{__create_vtable(__mtype<__vtable_t>{}, __mtype<_Rcvr>{}),
- &__rcvr, stdexec::get_stop_token(stdexec::get_env(__rcvr))}
- {}
-
- template <class... _As>
- requires __one_of<set_value_t(_As...), _Sigs...>
- void set_value(_As&&... __as) noexcept
- {
- const __any_::__rcvr_vfun<set_value_t(_As...)>* __vfun =
- __env_.__vtable_;
- (*__vfun->__complete_)(__env_.__rcvr_, static_cast<_As&&>(__as)...);
- }
-
- template <class _Error>
- requires __one_of<set_error_t(_Error), _Sigs...>
- void set_error(_Error&& __err) noexcept
- {
- const __any_::__rcvr_vfun<set_error_t(_Error)>* __vfun =
- __env_.__vtable_;
- (*__vfun->__complete_)(__env_.__rcvr_, static_cast<_Error&&>(__err));
- }
-
- void set_stopped() noexcept
- requires __one_of<set_stopped_t(), _Sigs...>
- {
- const __any_::__rcvr_vfun<set_stopped_t()>* __vfun = __env_.__vtable_;
- (*__vfun->__complete_)(__env_.__rcvr_);
- }
-
- auto get_env() const noexcept -> const __env_t&
- {
- return __env_;
- }
-};
-
-auto __test_never_stop_token(
- get_stop_token_t (*)(never_stop_token (*)() noexcept)) -> __mbool<true>;
-
-template <class _Tag, class _Ret, class... _As>
-auto __test_never_stop_token(_Tag (*)(_Ret (*)(_As...) noexcept))
- -> __mbool<false>;
-
-template <class _Tag, class _Ret, class... _As>
-auto __test_never_stop_token(_Tag (*)(_Ret (*)(_As...))) -> __mbool<false>;
-
-template <class _Query>
-using __is_never_stop_token_query =
- decltype(__test_never_stop_token(static_cast<_Query>(nullptr)));
-
-template <class... _Sigs, class... _Queries>
- requires(__is_stop_token_query<_Queries> || ...)
-struct __ref<completion_signatures<_Sigs...>, _Queries...>
-{
-#if !STDEXEC_MSVC()
- // MSVCBUG
- // https://developercommunity.visualstudio.com/t/Private-member-inaccessible-when-used-in/10448363
-
- private:
-#endif
- using _FilteredQueries =
- __minvoke<__mremove_if<__q<__is_never_stop_token_query>>, _Queries...>;
- using __vtable_t = stdexec::__t<
- __mapply<__mbind_front_q<__vtable, completion_signatures<_Sigs...>>,
- _FilteredQueries>>;
-
- struct __env_t
- {
- const __vtable_t* __vtable_;
- void* __rcvr_;
-
- template <class _Tag, class... _As>
- requires __callable<const __vtable_t&, _Tag, void*, _As...>
- auto query(_Tag, _As&&... __as) const //
- noexcept(__nothrow_callable<const __vtable_t&, _Tag, void*, _As...>)
- -> __call_result_t<const __vtable_t&, _Tag, void*, _As...>
- {
- return (*__vtable_)(_Tag{}, __rcvr_, static_cast<_As&&>(__as)...);
- }
- } __env_;
-
- public:
- using receiver_concept = stdexec::receiver_t;
- using __id = __ref;
- using __t = __ref;
-
- template <__none_of<__ref, const __ref, __env_t, const __env_t> _Rcvr>
- requires receiver_of<_Rcvr, completion_signatures<_Sigs...>> &&
- (__callable<__query_vfun_fn<_Rcvr>, _Queries> && ...)
- __ref(_Rcvr& __rcvr) noexcept :
- __env_{__create_vtable(__mtype<__vtable_t>{}, __mtype<_Rcvr>{}),
- &__rcvr}
- {}
-
- template <class... _As>
- requires __one_of<set_value_t(_As...), _Sigs...>
- void set_value(_As&&... __as) noexcept
- {
- const __any_::__rcvr_vfun<set_value_t(_As...)>* __vfun =
- __env_.__vtable_;
- (*__vfun->__complete_)(__env_.__rcvr_, static_cast<_As&&>(__as)...);
- }
-
- template <class _Error>
- requires __one_of<set_error_t(_Error), _Sigs...>
- void set_error(_Error&& __err) noexcept
- {
- const __any_::__rcvr_vfun<set_error_t(_Error)>* __vfun =
- __env_.__vtable_;
- (*__vfun->__complete_)(__env_.__rcvr_, static_cast<_Error&&>(__err));
- }
-
- void set_stopped() noexcept
- requires __one_of<set_stopped_t(), _Sigs...>
- {
- const __any_::__rcvr_vfun<set_stopped_t()>* __vfun = __env_.__vtable_;
- (*__vfun->__complete_)(__env_.__rcvr_);
- }
-
- auto get_env() const noexcept -> const __env_t&
- {
- return __env_;
- }
-};
-} // namespace __rec
-
-class __operation_vtable
-{
- public:
- void (*__start_)(void*) noexcept;
-
- private:
- template <class _Op>
- STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__operation_vtable>,
- __mtype<_Op>) noexcept
- -> const __operation_vtable*
- {
- static __operation_vtable __vtable{
- [](void* __object_pointer) noexcept -> void {
- STDEXEC_ASSERT(__object_pointer);
- _Op& __op = *static_cast<_Op*>(__object_pointer);
- static_assert(operation_state<_Op>);
- stdexec::start(__op);
- }};
- return &__vtable;
- }
-};
-
-using __immovable_operation_storage = __immovable_storage_t<__operation_vtable>;
-
-template <class _Sigs, class _Queries>
-using __receiver_ref =
- __mapply<__mbind_front<__q<__rec::__ref>, _Sigs>, _Queries>;
-
-struct __on_stop_t
-{
- stdexec::inplace_stop_source& __source_;
-
- void operator()() const noexcept
- {
- __source_.request_stop();
- }
-};
-
-template <class _Receiver>
-struct __operation_base
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Receiver __rcvr_;
- stdexec::inplace_stop_source __stop_source_{};
- using __stop_callback = typename stdexec::stop_token_of_t<
- stdexec::env_of_t<_Receiver>>::template callback_type<__on_stop_t>;
- std::optional<__stop_callback> __on_stop_{};
-};
-
-template <class _Env>
-using __env_t =
- __env::__join_t<prop<get_stop_token_t, inplace_stop_token>, _Env>;
-
-template <class _ReceiverId>
-struct __stoppable_receiver
-{
- using _Receiver = stdexec::__t<_ReceiverId>;
-
- struct __t
- {
+ }
+ } __env_;
+ public:
using receiver_concept = stdexec::receiver_t;
- __operation_base<_Receiver>* __op_;
+ using __id = __ref;
+ using __t = __ref;
- template <same_as<__t> _Self, class _Item>
- requires __callable<set_next_t, _Receiver&, _Item>
- STDEXEC_MEMFN_DECL(auto set_next)(this _Self& __self,
- _Item&& __item) noexcept
- -> __call_result_t<set_next_t, _Receiver&, _Item>
- {
- return exec::set_next(__self.__op_->__rcvr_,
- static_cast<_Item&&>(__item));
+ template <__none_of<__ref, const __ref, __env_t, const __env_t> _Rcvr>
+ requires receiver_of<_Rcvr, completion_signatures<_Sigs...>>
+ && (__callable<__query_vfun_fn<_Rcvr>, _Queries> && ...)
+ __ref(_Rcvr& __rcvr) noexcept
+ : __env_{
+ __create_vtable(__mtype<__vtable_t>{}, __mtype<_Rcvr>{}),
+ &__rcvr,
+ stdexec::get_stop_token(stdexec::get_env(__rcvr))} {
}
- template <class... _Args>
- requires __callable<set_value_t, _Receiver, _Args...>
- void set_value(_Args&&... __args) noexcept
- {
- __op_->__on_stop_.reset();
- stdexec::set_value(static_cast<_Receiver&&>(__op_->__rcvr_),
- static_cast<_Args&&>(__args)...);
+ template <class... _As>
+ requires __callable<__vtable_t, void*, set_value_t, _As...>
+ void set_value(_As&&... __as) noexcept {
+ (*__env_.__vtable_)(__env_.__rcvr_, set_value_t(), static_cast<_As&&>(__as)...);
}
template <class _Error>
- requires __callable<set_error_t, _Receiver, _Error>
- void set_error(_Error&& __err) noexcept
- {
- __op_->__on_stop_.reset();
- stdexec::set_error(static_cast<_Receiver&&>(__op_->__rcvr_),
- static_cast<_Error&&>(__err));
+ requires __callable<__vtable_t, void*, set_error_t, _Error>
+ void set_error(_Error&& __err) noexcept {
+ (*__env_.__vtable_)(__env_.__rcvr_, set_error_t(), static_cast<_Error&&>(__err));
}
void set_stopped() noexcept
- requires __callable<set_stopped_t, _Receiver>
+ requires __callable<__vtable_t, void*, set_stopped_t>
{
- __op_->__on_stop_.reset();
- stdexec::set_stopped(static_cast<_Receiver&&>(__op_->__rcvr_));
+ (*__env_.__vtable_)(__env_.__rcvr_, set_stopped_t());
}
- auto get_env() const noexcept -> __env_t<env_of_t<_Receiver>>
- {
- return __env::__join(
- prop{get_stop_token, __op_->__stop_source_.get_token()},
- stdexec::get_env(__op_->__rcvr_));
+ auto get_env() const noexcept -> const __env_t& {
+ return __env_;
}
+ };
+
+ template <class... _Sigs, class... _Queries>
+ requires(__is_stop_token_query<_Queries> || ...)
+ struct __ref<completion_signatures<_Sigs...>, _Queries...> {
+#if !STDEXEC_MSVC()
+ // MSVCBUG https://developercommunity.visualstudio.com/t/Private-member-inaccessible-when-used-in/10448363
+
+ private:
+#endif
+ using _FilteredQueries =
+ __minvoke<__mremove_if<__q<__is_never_stop_token_query_t>>, _Queries...>;
+ using __vtable_t = stdexec::__t<
+ __mapply<__mbind_front_q<__vtable, completion_signatures<_Sigs...>>, _FilteredQueries>
+ >;
+
+ struct __env_t {
+ const __vtable_t* __vtable_;
+ void* __rcvr_;
+
+ template <class _Tag, class... _As>
+ requires __callable<const __vtable_t&, _Tag, void*, _As...>
+ auto query(_Tag, _As&&... __as) const
+ noexcept(__nothrow_callable<const __vtable_t&, _Tag, void*, _As...>)
+ -> __call_result_t<const __vtable_t&, _Tag, void*, _As...> {
+ return (*__vtable_)(_Tag{}, __rcvr_, static_cast<_As&&>(__as)...);
+ }
+ } __env_;
+ public:
+ using receiver_concept = stdexec::receiver_t;
+ using __id = __ref;
+ using __t = __ref;
+
+ template <__none_of<__ref, const __ref, __env_t, const __env_t> _Rcvr>
+ requires receiver_of<_Rcvr, completion_signatures<_Sigs...>>
+ && (__callable<__query_vfun_fn<_Rcvr>, _Queries> && ...)
+ __ref(_Rcvr& __rcvr) noexcept
+ : __env_{__create_vtable(__mtype<__vtable_t>{}, __mtype<_Rcvr>{}), &__rcvr} {
+ }
+
+ template <class... _As>
+ requires __one_of<set_value_t(_As...), _Sigs...>
+ || __callable<__overload<__any_::__rcvr_vfun<_Sigs>...>, void*, set_value_t, _As...>
+ void set_value(_As&&... __as) noexcept {
+ if constexpr (__one_of<set_value_t(_As...), _Sigs...>) {
+ const __any_::__rcvr_vfun<set_value_t(_As...)>& __vfun = *__env_.__vtable_;
+ __vfun(__env_.__rcvr_, set_value_t(), static_cast<_As&&>(__as)...);
+ } else {
+ const __overload<__any_::__rcvr_vfun<_Sigs>...>& __vfun = *__env_.__vtable_;
+ __vfun(__env_.__rcvr_, set_value_t(), static_cast<_As&&>(__as)...);
+ }
+ }
+
+ template <class _Error>
+ requires __one_of<set_error_t(_Error), _Sigs...>
+ || __callable<__overload<__any_::__rcvr_vfun<_Sigs>...>, void*, set_error_t, _Error>
+ void set_error(_Error&& __err) noexcept {
+ if constexpr (__one_of<set_error_t(_Error), _Sigs...>) {
+ const __any_::__rcvr_vfun<set_error_t(_Error)>& __vfun = *__env_.__vtable_;
+ __vfun(__env_.__rcvr_, set_error_t(), static_cast<_Error&&>(__err));
+ } else {
+ const __overload<__any_::__rcvr_vfun<_Sigs>...>& __vfun = *__env_.__vtable_;
+ __vfun(__env_.__rcvr_, set_error_t(), static_cast<_Error&&>(__err));
+ }
+ }
+
+ void set_stopped() noexcept
+ requires __one_of<set_stopped_t(), _Sigs...>
+ {
+ const __any_::__rcvr_vfun<set_stopped_t()>& __vfun = *__env_.__vtable_;
+ __vfun(__env_.__rcvr_, set_stopped_t());
+ }
+
+ auto get_env() const noexcept -> const __env_t& {
+ return __env_;
+ }
+ };
+ } // namespace __rec
+
+ class __operation_vtable {
+ public:
+ void (*__start_)(void*) noexcept;
+
+ private:
+ template <class _Op>
+ STDEXEC_MEMFN_DECL(
+ auto __create_vtable)(this __mtype<__operation_vtable>, __mtype<_Op>) noexcept
+ -> const __operation_vtable* {
+ static __operation_vtable __vtable{[](void* __object_pointer) noexcept -> void {
+ STDEXEC_ASSERT(__object_pointer);
+ _Op& __op = *static_cast<_Op*>(__object_pointer);
+ static_assert(operation_state<_Op>);
+ stdexec::start(__op);
+ }};
+ return &__vtable;
+ }
};
-};
-template <class _ReceiverId>
-using __stoppable_receiver_t = stdexec::__t<__stoppable_receiver<_ReceiverId>>;
+ using __immovable_operation_storage =
+ __immovable_storage_t<__operation_vtable, std::allocator<std::byte>, 6 * sizeof(void*)>;
-template <class _ReceiverId, bool>
-struct __operation
-{
- using _Receiver = stdexec::__t<_ReceiverId>;
+ template <class _Sigs, class _Queries>
+ using __receiver_ref = __mapply<__mbind_front_q<__rec::__ref, _Sigs>, _Queries>;
- class __t : public __operation_base<_Receiver>
- {
- public:
+ struct __on_stop_t {
+ stdexec::inplace_stop_source& __source_;
+
+ void operator()() const noexcept {
+ __source_.request_stop();
+ }
+ };
+
+ template <class _Receiver>
+ struct __operation_base {
+ STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rcvr_;
+ stdexec::inplace_stop_source __stop_source_{};
+ using __stop_callback =
+ stdexec::stop_token_of_t<stdexec::env_of_t<_Receiver>>::template callback_type<__on_stop_t>;
+ std::optional<__stop_callback> __on_stop_{};
+ };
+
+ template <class _Env>
+ using __env_t = __join_env_t<prop<get_stop_token_t, inplace_stop_token>, _Env>;
+
+ template <class _ReceiverId>
+ struct __stoppable_receiver {
+ using _Receiver = stdexec::__t<_ReceiverId>;
+
+ struct __t {
+ using receiver_concept = stdexec::receiver_t;
+ __operation_base<_Receiver>* __op_;
+
+ template <class _Item>
+ requires __callable<set_next_t, _Receiver&, _Item>
+ [[nodiscard]]
+ auto set_next(_Item&& __item) & noexcept(__nothrow_callable<set_next_t, _Receiver&, _Item>)
+ -> __call_result_t<set_next_t, _Receiver&, _Item> {
+ return exec::set_next(__op_->__rcvr_, static_cast<_Item&&>(__item));
+ }
+
+ template <class... _Args>
+ requires __callable<set_value_t, _Receiver, _Args...>
+ void set_value(_Args&&... __args) noexcept {
+ __op_->__on_stop_.reset();
+ stdexec::set_value(
+ static_cast<_Receiver&&>(__op_->__rcvr_), static_cast<_Args&&>(__args)...);
+ }
+
+ template <class _Error>
+ requires __callable<set_error_t, _Receiver, _Error>
+ void set_error(_Error&& __err) noexcept {
+ __op_->__on_stop_.reset();
+ stdexec::set_error(
+ static_cast<_Receiver&&>(__op_->__rcvr_), static_cast<_Error&&>(__err));
+ }
+
+ void set_stopped() noexcept
+ requires __callable<set_stopped_t, _Receiver>
+ {
+ __op_->__on_stop_.reset();
+ stdexec::set_stopped(static_cast<_Receiver&&>(__op_->__rcvr_));
+ }
+
+ auto get_env() const noexcept -> __env_t<env_of_t<_Receiver>> {
+ return __env::__join(
+ prop{get_stop_token, __op_->__stop_source_.get_token()},
+ stdexec::get_env(__op_->__rcvr_));
+ }
+ };
+ };
+
+ template <class _ReceiverId>
+ using __stoppable_receiver_t = stdexec::__t<__stoppable_receiver<_ReceiverId>>;
+
+ template <class _ReceiverId, bool>
+ struct __operation {
+ using _Receiver = stdexec::__t<_ReceiverId>;
+
+ class __t : public __operation_base<_Receiver> {
+ public:
using __id = __operation;
template <class _Sender>
- __t(_Sender&& __sender, _Receiver&& __receiver) :
- __operation_base<_Receiver>{static_cast<_Receiver&&>(__receiver)},
- __rec_{this}, __storage_{__sender.__connect(__rec_)}
- {}
-
- void start() & noexcept
- {
- this->__on_stop_.emplace(
- stdexec::get_stop_token(stdexec::get_env(this->__rcvr_)),
- __on_stop_t{this->__stop_source_});
- STDEXEC_ASSERT(__storage_.__get_vtable()->__start_);
- __storage_.__get_vtable()->__start_(
- __storage_.__get_object_pointer());
+ __t(_Sender&& __sender, _Receiver&& __receiver)
+ : __operation_base<_Receiver>{static_cast<_Receiver&&>(__receiver)}
+ , __rec_{this}
+ , __storage_{__sender.__connect(__rec_)} {
}
- private:
+ void start() & noexcept {
+ this->__on_stop_.emplace(
+ stdexec::get_stop_token(stdexec::get_env(this->__rcvr_)),
+ __on_stop_t{this->__stop_source_});
+ STDEXEC_ASSERT(__storage_.__get_vtable()->__start_);
+ __storage_.__get_vtable()->__start_(__storage_.__get_object_pointer());
+ }
+
+ private:
__stoppable_receiver_t<_ReceiverId> __rec_;
__immovable_operation_storage __storage_{};
+ };
};
-};
-template <class _ReceiverId>
-struct __operation<_ReceiverId, false>
-{
- using _Receiver = stdexec::__t<_ReceiverId>;
+ template <class _ReceiverId>
+ struct __operation<_ReceiverId, false> {
+ using _Receiver = stdexec::__t<_ReceiverId>;
- class __t
- {
- public:
+ class __t {
+ public:
using __id = __operation;
template <class _Sender>
- __t(_Sender&& __sender, _Receiver&& __receiver) :
- __rec_{static_cast<_Receiver&&>(__receiver)},
- __storage_{__sender.__connect(__rec_)}
- {}
-
- void start() & noexcept
- {
- STDEXEC_ASSERT(__storage_.__get_vtable()->__start_);
- __storage_.__get_vtable()->__start_(
- __storage_.__get_object_pointer());
+ __t(_Sender&& __sender, _Receiver&& __receiver)
+ : __rec_{static_cast<_Receiver&&>(__receiver)}
+ , __storage_{__sender.__connect(__rec_)} {
}
- private:
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Receiver __rec_;
+ void start() & noexcept {
+ STDEXEC_ASSERT(__storage_.__get_vtable()->__start_);
+ __storage_.__get_vtable()->__start_(__storage_.__get_object_pointer());
+ }
+
+ private:
+ STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rec_;
__immovable_operation_storage __storage_{};
+ };
};
-};
-template <class _Queries, bool _IsEnvProvider = true>
-class __query_vtable;
+ template <class _Queries, bool _IsEnvProvider = true>
+ class __query_vtable;
-template <template <class...> class _List, class... _Queries,
- bool _IsEnvProvider>
-class __query_vtable<_List<_Queries...>, _IsEnvProvider> :
- public __query_vfun<_Queries>...
-{
- public:
- using __query_vfun<_Queries>::operator()...;
-
- private:
- template <class _Queryable>
- requires(
- __callable<__query_vfun_fn<_Queryable, _IsEnvProvider>, _Queries> &&
- ...)
- STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__query_vtable>,
- __mtype<_Queryable>) noexcept
- -> const __query_vtable*
- {
+ template <template <class...> class _List, class... _Queries, bool _IsEnvProvider>
+ class __query_vtable<_List<_Queries...>, _IsEnvProvider> : public __query_vfun<_Queries>... {
+ public:
+ using __query_vfun<_Queries>::operator()...;
+ private:
+ template <class _Queryable>
+ requires(__callable<__query_vfun_fn<_Queryable, _IsEnvProvider>, _Queries> && ...)
+ STDEXEC_MEMFN_DECL(
+ auto __create_vtable)(this __mtype<__query_vtable>, __mtype<_Queryable>) noexcept
+ -> const __query_vtable* {
static const __query_vtable __vtable{
- {__query_vfun_fn<_Queryable, _IsEnvProvider>{}(
- static_cast<_Queries>(nullptr))}...};
+ {__query_vfun_fn<_Queryable, _IsEnvProvider>{}(static_cast<_Queries>(nullptr))}...};
return &__vtable;
- }
-};
+ }
+ };
-template <class _Sigs, class _SenderQueries = __types<>,
- class _ReceiverQueries = __types<>>
-struct __sender
-{
- using __receiver_ref_t = __receiver_ref<_Sigs, _ReceiverQueries>;
- static constexpr bool __with_inplace_stop_token =
- __v<__mapply<__mall_of<__q<__is_not_stop_token_query_v>>,
- _ReceiverQueries>>;
+ template <class _Sigs, class _SenderQueries = __types<>, class _ReceiverQueries = __types<>>
+ struct __sender {
+ using __receiver_ref_t = __receiver_ref<_Sigs, _ReceiverQueries>;
+ static constexpr bool __with_inplace_stop_token =
+ __v<__mapply<__mall_of<__q<__is_not_stop_token_query_t>>, _ReceiverQueries>>;
- class __vtable : public __query_vtable<_SenderQueries>
- {
- public:
+ class __vtable : public __query_vtable<_SenderQueries> {
+ public:
using __id = __vtable;
- auto __queries() const noexcept -> const __query_vtable<_SenderQueries>&
- {
- return *this;
+ auto __queries() const noexcept -> const __query_vtable<_SenderQueries>& {
+ return *this;
}
__immovable_operation_storage (*__connect_)(void*, __receiver_ref_t);
-
- private:
+ private:
template <sender_to<__receiver_ref_t> _Sender>
- STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__vtable>,
- __mtype<_Sender>) noexcept
- -> const __vtable*
- {
- static const __vtable __vtable_{
- {*__create_vtable(__mtype<__query_vtable<_SenderQueries>>{},
- __mtype<_Sender>{})},
- [](void* __object_pointer, __receiver_ref_t __receiver)
- -> __immovable_operation_storage {
- _Sender& __sender =
- *static_cast<_Sender*>(__object_pointer);
- using __op_state_t =
- connect_result_t<_Sender, __receiver_ref_t>;
- return __immovable_operation_storage{
- std::in_place_type<__op_state_t>, __emplace_from{[&] {
- return stdexec::connect(
- static_cast<_Sender&&>(__sender),
- static_cast<__receiver_ref_t&&>(__receiver));
- }}};
- }};
- return &__vtable_;
+ STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__vtable>, __mtype<_Sender>) noexcept
+ -> const __vtable* {
+ static const __vtable __vtable_{
+ {*__create_vtable(__mtype<__query_vtable<_SenderQueries>>{}, __mtype<_Sender>{})},
+ [](void* __object_pointer, __receiver_ref_t __receiver)
+ -> __immovable_operation_storage {
+ _Sender& __sender = *static_cast<_Sender*>(__object_pointer);
+ using __op_state_t = connect_result_t<_Sender, __receiver_ref_t>;
+ return __immovable_operation_storage{
+ std::in_place_type<__op_state_t>, __emplace_from{[&] {
+ return stdexec::connect(
+ static_cast<_Sender&&>(__sender), static_cast<__receiver_ref_t&&>(__receiver));
+ }}};
+ }};
+ return &__vtable_;
}
- };
+ };
- struct __env_t
- {
+ struct __env_t {
const __vtable* __vtable_;
void* __sender_;
template <class _Tag, class... _As>
- requires __callable<const __query_vtable<_SenderQueries>&, _Tag,
- void*, _As...>
- auto query(_Tag, _As&&... __as) const //
- noexcept(__nothrow_callable<const __query_vtable<_SenderQueries>&,
- _Tag, void*, _As...>)
- -> __call_result_t<const __query_vtable<_SenderQueries>&, _Tag,
- void*, _As...>
- {
- return __vtable_->__queries()(_Tag{}, __sender_,
- static_cast<_As&&>(__as)...);
+ requires __callable<const __query_vtable<_SenderQueries>&, _Tag, void*, _As...>
+ auto query(_Tag, _As&&... __as) const
+ noexcept(__nothrow_callable<const __query_vtable<_SenderQueries>&, _Tag, void*, _As...>)
+ -> __call_result_t<const __query_vtable<_SenderQueries>&, _Tag, void*, _As...> {
+ return __vtable_->__queries()(_Tag{}, __sender_, static_cast<_As&&>(__as)...);
}
- };
+ };
- struct __t
- {
+ struct __t {
using __id = __sender;
using completion_signatures = _Sigs;
using sender_concept = stdexec::sender_t;
@@ -1225,346 +1064,279 @@
auto operator=(__t&&) -> __t& = default;
template <__not_decays_to<__t> _Sender>
- requires sender_to<_Sender, __receiver_ref<_Sigs, _ReceiverQueries>>
- __t(_Sender&& __sndr) : __storage_{static_cast<_Sender&&>(__sndr)}
- {}
-
- auto __connect(__receiver_ref_t __receiver)
- -> __immovable_operation_storage
- {
- return __storage_.__get_vtable()->__connect_(
- __storage_.__get_object_pointer(),
- static_cast<__receiver_ref_t&&>(__receiver));
+ requires sender_to<_Sender, __receiver_ref<_Sigs, _ReceiverQueries>>
+ __t(_Sender&& __sndr)
+ : __storage_{static_cast<_Sender&&>(__sndr)} {
}
- explicit operator bool() const noexcept
- {
- return __get_object_pointer(__storage_) != nullptr;
+ auto __connect(__receiver_ref_t __receiver) -> __immovable_operation_storage {
+ return __storage_.__get_vtable()->__connect_(
+ __storage_.__get_object_pointer(), static_cast<__receiver_ref_t&&>(__receiver));
}
- auto get_env() const noexcept -> __env_t
- {
- return {__storage_.__get_vtable(),
- __storage_.__get_object_pointer()};
+ auto get_env() const noexcept -> __env_t {
+ return {__storage_.__get_vtable(), __storage_.__get_object_pointer()};
}
template <receiver_of<_Sigs> _Rcvr>
- auto connect(_Rcvr __rcvr) && //
- -> stdexec::__t<
- __operation<stdexec::__id<_Rcvr>, __with_inplace_stop_token>>
- {
- return {static_cast<__t&&>(*this), static_cast<_Rcvr&&>(__rcvr)};
+ auto connect(_Rcvr __rcvr) && -> stdexec::__t<
+ __operation<stdexec::__id<_Rcvr>, __with_inplace_stop_token>
+ > {
+ return {static_cast<__t&&>(*this), static_cast<_Rcvr&&>(__rcvr)};
}
- private:
+ private:
__unique_storage_t<__vtable> __storage_;
+ };
};
-};
-template <class _ScheduleSender, class _SchedulerQueries = __types<>>
-class __scheduler
-{
- static constexpr std::size_t __buffer_size = 4 * sizeof(void*);
- template <class _Ty>
- static constexpr bool __is_small =
- sizeof(_Ty) <= __buffer_size &&
- alignof(_Ty) <= alignof(std::max_align_t);
+ template <class _ScheduleSender, class _SchedulerQueries = __types<>>
+ class __scheduler {
+ static constexpr std::size_t __buffer_size = 4 * sizeof(void*);
+ template <class _Ty>
+ static constexpr bool __is_small = sizeof(_Ty) <= __buffer_size
+ && alignof(_Ty) <= alignof(std::max_align_t);
- public:
- template <class _Scheduler>
+ public:
+ template <class _Scheduler>
requires(!__decays_to<_Scheduler, __scheduler>) && scheduler<_Scheduler>
- __scheduler(_Scheduler&& __scheduler) :
- __storage_{static_cast<_Scheduler&&>(__scheduler)}
- {
+ __scheduler(_Scheduler&& __scheduler)
+ : __storage_{static_cast<_Scheduler&&>(__scheduler)} {
static_assert(
- __is_small<_Scheduler>,
- "any_scheduler<> must have a nothrow copy constructor, so the scheduler object must be "
- "small enough to be stored in the internal buffer to avoid dynamic allocation.");
- }
+ __is_small<_Scheduler>,
+ "any_scheduler<> must have a nothrow copy constructor, so the scheduler object must be "
+ "small enough to be stored in the internal buffer to avoid dynamic allocation.");
+ }
- __scheduler(__scheduler&&) noexcept = default;
- __scheduler(const __scheduler&) noexcept = default;
- __scheduler& operator=(__scheduler&&) noexcept = default;
- __scheduler& operator=(const __scheduler&) noexcept = default;
+ __scheduler(__scheduler&&) noexcept = default;
+ __scheduler(const __scheduler&) noexcept = default;
+ auto operator=(__scheduler&&) noexcept -> __scheduler& = default;
+ auto operator=(const __scheduler&) noexcept -> __scheduler& = default;
- using __sender_t = _ScheduleSender;
+ using __sender_t = _ScheduleSender;
- auto schedule() const noexcept -> __sender_t
- {
+ auto schedule() const noexcept -> __sender_t {
STDEXEC_ASSERT(__storage_.__get_vtable()->__schedule_);
- return __storage_.__get_vtable()->__schedule_(
- __storage_.__get_object_pointer());
- }
+ return __storage_.__get_vtable()->__schedule_(__storage_.__get_object_pointer());
+ }
- template <class _Tag, class... _As>
- requires __callable<const __query_vtable<_SchedulerQueries, false>&,
- _Tag, void*, _As...>
- auto query(_Tag, _As&&... __as) const //
- noexcept(
- __nothrow_callable<const __query_vtable<_SchedulerQueries, false>&,
- _Tag, void*, _As...>)
- -> __call_result_t<const __query_vtable<_SchedulerQueries, false>&,
- _Tag, void*, _As...>
- {
- return __storage_.__get_vtable()->__queries()(
- _Tag{}, __storage_.__get_object_pointer(),
- static_cast<_As&&>(__as)...);
- }
+ template <class _Tag, class... _As>
+ requires __callable<const __query_vtable<_SchedulerQueries, false>&, _Tag, void*, _As...>
+ auto query(_Tag, _As&&... __as) const noexcept(
+ __nothrow_callable<const __query_vtable<_SchedulerQueries, false>&, _Tag, void*, _As...>)
+ -> __call_result_t<const __query_vtable<_SchedulerQueries, false>&, _Tag, void*, _As...> {
+ return __storage_.__get_vtable()
+ ->__queries()(_Tag{}, __storage_.__get_object_pointer(), static_cast<_As&&>(__as)...);
+ }
- private:
- class __vtable : public __query_vtable<_SchedulerQueries, false>
- {
- public:
+ private:
+ class __vtable : public __query_vtable<_SchedulerQueries, false> {
+ public:
__sender_t (*__schedule_)(void*) noexcept;
bool (*__equal_to_)(const void*, const void* other) noexcept;
- auto __queries() const noexcept
- -> const __query_vtable<_SchedulerQueries, false>&
- {
- return *this;
+ auto __queries() const noexcept -> const __query_vtable<_SchedulerQueries, false>& {
+ return *this;
}
-
- private:
+ private:
template <scheduler _Scheduler>
- STDEXEC_MEMFN_DECL(auto __create_vtable)(this __mtype<__vtable>,
- __mtype<_Scheduler>) noexcept
- -> const __vtable*
- {
- static const __vtable __vtable_{
- {*__create_vtable(
- __mtype<__query_vtable<_SchedulerQueries, false>>{},
- __mtype<_Scheduler>{})},
- [](void* __object_pointer) noexcept -> __sender_t {
- const _Scheduler& __scheduler =
- *static_cast<const _Scheduler*>(__object_pointer);
- return __sender_t{stdexec::schedule(__scheduler)};
- },
- [](const void* __self, const void* __other) noexcept -> bool {
- static_assert(noexcept(__declval<const _Scheduler&>() ==
- __declval<const _Scheduler&>()));
- STDEXEC_ASSERT(__self && __other);
- const _Scheduler& __self_scheduler =
- *static_cast<const _Scheduler*>(__self);
- const _Scheduler& __other_scheduler =
- *static_cast<const _Scheduler*>(__other);
- return __self_scheduler == __other_scheduler;
- }};
- return &__vtable_;
+ STDEXEC_MEMFN_DECL(
+ auto __create_vtable)(this __mtype<__vtable>, __mtype<_Scheduler>) noexcept
+ -> const __vtable* {
+ static const __vtable __vtable_{
+ {*__create_vtable(
+ __mtype<__query_vtable<_SchedulerQueries, false>>{}, __mtype<_Scheduler>{})},
+ [](void* __object_pointer) noexcept -> __sender_t {
+ const _Scheduler& __scheduler = *static_cast<const _Scheduler*>(__object_pointer);
+ return __sender_t{stdexec::schedule(__scheduler)};
+ },
+ [](const void* __self, const void* __other) noexcept -> bool {
+ static_assert(
+ noexcept(__declval<const _Scheduler&>() == __declval<const _Scheduler&>()));
+ STDEXEC_ASSERT(__self && __other);
+ const _Scheduler& __self_scheduler = *static_cast<const _Scheduler*>(__self);
+ const _Scheduler& __other_scheduler = *static_cast<const _Scheduler*>(__other);
+ return __self_scheduler == __other_scheduler;
+ }};
+ return &__vtable_;
}
- };
+ };
- friend auto operator==(const __scheduler& __self,
- const __scheduler& __other) noexcept -> bool
- {
- if (__self.__storage_.__get_vtable() !=
- __other.__storage_.__get_vtable())
- {
- return false;
+ friend auto
+ operator==(const __scheduler& __self, const __scheduler& __other) noexcept -> bool {
+ if (__self.__storage_.__get_vtable() != __other.__storage_.__get_vtable()) {
+ return false;
}
void* __p = __self.__storage_.__get_object_pointer();
void* __o = __other.__storage_.__get_object_pointer();
- // if both object pointers are not null, use the virtual equal_to
- // function
- return (__p && __o &&
- __self.__storage_.__get_vtable()->__equal_to_(__p, __o))
- // if both object pointers are nullptrs, they are equal
- || (!__p && !__o);
- }
+ // if both object pointers are not null, use the virtual equal_to function
+ return (__p && __o && __self.__storage_.__get_vtable()->__equal_to_(__p, __o))
+ // if both object pointers are nullptrs, they are equal
+ || (!__p && !__o);
+ }
- friend auto operator!=(const __scheduler& __self,
- const __scheduler& __other) noexcept -> bool
- {
+ friend auto
+ operator!=(const __scheduler& __self, const __scheduler& __other) noexcept -> bool {
return !(__self == __other);
- }
+ }
- __copyable_storage_t<__vtable, __buffer_size> __storage_{};
-};
-} // namespace __any
+ __copyable_storage_t<__vtable, __buffer_size> __storage_{};
+ };
+ } // namespace __any
-template <auto... _Sigs>
-using queries = stdexec::__types<decltype(_Sigs)...>;
+ template <auto... _Sigs>
+ using queries = stdexec::__types<decltype(_Sigs)...>;
-template <class _Completions, auto... _ReceiverQueries>
-class any_receiver_ref
-{
- using __receiver_base =
- __any::__rec::__ref<_Completions, decltype(_ReceiverQueries)...>;
+ template <class _Completions, auto... _ReceiverQueries>
+ class any_receiver_ref {
+ using __receiver_base = __any::__rec::__ref<_Completions, decltype(_ReceiverQueries)...>;
using __env_t = stdexec::env_of_t<__receiver_base>;
__receiver_base __receiver_;
- public:
+ public:
using receiver_concept = stdexec::receiver_t;
using __t = any_receiver_ref;
using __id = any_receiver_ref;
- template <stdexec::__none_of<any_receiver_ref, const any_receiver_ref,
- __env_t, const __env_t>
- _Receiver>
- requires stdexec::receiver_of<_Receiver, _Completions>
- any_receiver_ref(_Receiver& __receiver) //
- noexcept(
- stdexec::__nothrow_constructible_from<__receiver_base, _Receiver>) :
- __receiver_(__receiver)
- {}
+ template <stdexec::__none_of<any_receiver_ref, const any_receiver_ref, __env_t, const __env_t>
+ _Receiver>
+ requires stdexec::receiver_of<_Receiver, _Completions>
+ any_receiver_ref(_Receiver& __receiver)
+ noexcept(stdexec::__nothrow_constructible_from<__receiver_base, _Receiver>)
+ : __receiver_(__receiver) {
+ }
template <class... _As>
- requires stdexec::tag_invocable<stdexec::set_value_t, __receiver_base,
- _As...>
- void set_value(_As&&... __as) noexcept
- {
- stdexec::tag_invoke(stdexec::set_value,
- static_cast<__receiver_base&&>(__receiver_),
- static_cast<_As&&>(__as)...);
+ requires stdexec::__callable<stdexec::set_value_t, __receiver_base, _As...>
+ void set_value(_As&&... __as) noexcept {
+ stdexec::set_value(static_cast<__receiver_base&&>(__receiver_), static_cast<_As&&>(__as)...);
}
template <class _Error>
- requires stdexec::tag_invocable<stdexec::set_error_t, __receiver_base,
- _Error>
- void set_error(_Error&& __err) noexcept
- {
- stdexec::tag_invoke(stdexec::set_error,
- static_cast<__receiver_base&&>(__receiver_),
- static_cast<_Error&&>(__err));
+ requires stdexec::__callable<stdexec::set_error_t, __receiver_base, _Error>
+ void set_error(_Error&& __err) noexcept {
+ stdexec::set_error(static_cast<__receiver_base&&>(__receiver_), static_cast<_Error&&>(__err));
}
void set_stopped() noexcept
- requires stdexec::tag_invocable<stdexec::set_stopped_t, __receiver_base>
+ requires stdexec::__callable<stdexec::set_stopped_t, __receiver_base>
{
- stdexec::tag_invoke(stdexec::set_stopped,
- static_cast<__receiver_base&&>(__receiver_));
+ stdexec::set_stopped(static_cast<__receiver_base&&>(__receiver_));
}
- auto get_env() const noexcept -> stdexec::env_of_t<__receiver_base>
- {
- return stdexec::get_env(__receiver_);
+ auto get_env() const noexcept -> stdexec::env_of_t<__receiver_base> {
+ return stdexec::get_env(__receiver_);
}
template <auto... _SenderQueries>
- class any_sender
- {
- using __sender_base = stdexec::__t<
- __any::__sender<_Completions, queries<_SenderQueries...>,
- queries<_ReceiverQueries...>>>;
- __sender_base __sender_;
+ class any_sender {
+ using __sender_base = stdexec::__t<
+ __any::__sender<_Completions, queries<_SenderQueries...>, queries<_ReceiverQueries...>>
+ >;
+ __sender_base __sender_;
- template <class _Tag, stdexec::__decays_to<any_sender> Self,
- class... _As>
- requires stdexec::tag_invocable<
- _Tag, stdexec::__copy_cvref_t<Self, __sender_base>, _As...>
- friend auto tag_invoke(_Tag, Self&& __self, _As&&... __as) //
- noexcept(
- stdexec::nothrow_tag_invocable<
- _Tag, stdexec::__copy_cvref_t<Self, __sender_base>, _As...>)
- {
- return stdexec::tag_invoke(_Tag{},
- static_cast<Self&&>(__self).__sender_,
- static_cast<_As&&>(__as)...);
- }
+ public:
+ using sender_concept = stdexec::sender_t;
+ using __t = any_sender;
+ using __id = any_sender;
- public:
- using sender_concept = stdexec::sender_t;
- using completion_signatures =
- typename __sender_base::completion_signatures;
+ template <stdexec::__not_decays_to<any_sender> _Sender>
+ requires stdexec::sender_to<_Sender, __receiver_base>
+ any_sender(_Sender&& __sender)
+ noexcept(stdexec::__nothrow_constructible_from<__sender_base, _Sender>)
+ : __sender_(static_cast<_Sender&&>(__sender)) {
+ }
- template <stdexec::__not_decays_to<any_sender> _Sender>
- requires stdexec::sender_to<_Sender, __receiver_base>
- any_sender(_Sender&& __sender) //
- noexcept(
- stdexec::__nothrow_constructible_from<__sender_base, _Sender>) :
- __sender_(static_cast<_Sender&&>(__sender))
- {}
+ template <stdexec::__decays_to<any_sender> _Self, class... _Env>
+ requires(__any::__satisfies_receiver_query<decltype(_ReceiverQueries), _Env...> && ...)
+ static auto get_completion_signatures(_Self&&, _Env&&...) noexcept
+ -> __sender_base::completion_signatures {
+ return {};
+ }
- template <stdexec::receiver_of<_Completions> _Receiver>
- auto connect(_Receiver __rcvr) && -> stdexec::connect_result_t<
- __sender_base, _Receiver>
- {
- return static_cast<__sender_base&&>(__sender_).connect(
- static_cast<_Receiver&&>(__rcvr));
- }
+ template <stdexec::receiver_of<_Completions> _Receiver>
+ auto connect(_Receiver __rcvr) && -> stdexec::connect_result_t<__sender_base, _Receiver> {
+ return static_cast<__sender_base&&>(__sender_).connect(static_cast<_Receiver&&>(__rcvr));
+ }
- template <auto... _SchedulerQueries>
- class any_scheduler
- {
- using __schedule_completions =
- stdexec::__concat_completion_signatures<
- _Completions,
- stdexec::completion_signatures<stdexec::set_value_t()>>;
- using __schedule_receiver =
- any_receiver_ref<__schedule_completions, _ReceiverQueries...>;
+ auto get_env() const noexcept -> stdexec::env_of_t<__sender_base> {
+ return static_cast<const __sender_base&>(__sender_).get_env();
+ }
- template <typename _Tag, typename _Sig>
- static auto __ret_fn(_Tag (*const)(_Sig)) -> _Tag;
+ template <auto... _SchedulerQueries>
+ class any_scheduler {
+ // Add the required set_value_t() completions to the schedule-sender.
+ using __schedule_completions = stdexec::__concat_completion_signatures<
+ _Completions,
+ stdexec::completion_signatures<stdexec::set_value_t()>
+ >;
+ using __schedule_receiver = any_receiver_ref<__schedule_completions, _ReceiverQueries...>;
- template <class _Tag>
- struct __ret_equals_to
- {
- template <class _Sig>
- using __f = std::is_same<
- _Tag, decltype(__ret_fn(static_cast<_Sig>(nullptr)))>;
- };
+ template <typename _Tag, typename _Sig>
+ static auto __ret_fn(_Tag (*const)(_Sig)) -> _Tag;
- using schedule_sender_queries = stdexec::__minvoke<
- stdexec::__mremove_if<__ret_equals_to<
- stdexec::get_completion_scheduler_t<stdexec::set_value_t>>>,
- decltype(_SenderQueries)...>;
+ template <class _Tag>
+ struct __ret_equals_to {
+ template <class _Sig>
+ using __f =
+ stdexec::__mbool<STDEXEC_IS_SAME(_Tag, decltype(__ret_fn(static_cast<_Sig>(nullptr))))>;
+ };
+
+ using __schedule_sender_queries = stdexec::__minvoke<
+ stdexec::__mremove_if<
+ __ret_equals_to<stdexec::get_completion_scheduler_t<stdexec::set_value_t>>
+ >,
+ decltype(_SenderQueries)...
+ >;
#if STDEXEC_MSVC()
- // MSVCBUG
- // https://developercommunity.visualstudio.com/t/ICE-and-non-ICE-bug-in-NTTP-argument-w/10361081
+ // MSVCBUG https://developercommunity.visualstudio.com/t/ICE-and-non-ICE-bug-in-NTTP-argument-w/10361081
- static constexpr auto __any_scheduler_noexcept_signature =
- stdexec::get_completion_scheduler<stdexec::set_value_t>.signature<any_scheduler() noexcept>;
- template <class... _Queries>
- using __schedule_sender_fn =
- typename __schedule_receiver::template any_sender<
- __any_scheduler_noexcept_signature>;
+ static constexpr auto __any_scheduler_noexcept_signature =
+ stdexec::get_completion_scheduler<stdexec::set_value_t>.signature<any_scheduler() noexcept>;
+ template <class... _Queries>
+ using __schedule_sender_fn =
+ __schedule_receiver::template any_sender<__any_scheduler_noexcept_signature>;
#else
- template <class... _Queries>
- using __schedule_sender_fn = typename __schedule_receiver::template any_sender<
- stdexec::get_completion_scheduler<stdexec::set_value_t>.template signature<any_scheduler() noexcept>>;
+ template <class... _Queries>
+ using __schedule_sender_fn = __schedule_receiver::template any_sender<
+ stdexec::get_completion_scheduler<stdexec::set_value_t>.template signature<any_scheduler() noexcept>
+ >;
#endif
- using __schedule_sender =
- stdexec::__mapply<stdexec::__q<__schedule_sender_fn>,
- schedule_sender_queries>;
+ using __schedule_sender =
+ stdexec::__mapply<stdexec::__q<__schedule_sender_fn>, __schedule_sender_queries>;
- using __scheduler_base =
- __any::__scheduler<__schedule_sender,
- queries<_SchedulerQueries...>>;
+ using __scheduler_base =
+ __any::__scheduler<__schedule_sender, queries<_SchedulerQueries...>>;
- __scheduler_base __scheduler_;
+ __scheduler_base __scheduler_;
- public:
- using __t = any_scheduler;
- using __id = any_scheduler;
+ public:
+ using scheduler_concept = stdexec::scheduler_t;
+ using __t = any_scheduler;
+ using __id = any_scheduler;
- template <stdexec::__none_of<any_scheduler> _Scheduler>
- requires stdexec::scheduler<_Scheduler>
- any_scheduler(_Scheduler __scheduler) :
- __scheduler_{static_cast<_Scheduler&&>(__scheduler)}
- {}
+ template <stdexec::__none_of<any_scheduler> _Scheduler>
+ requires stdexec::scheduler<_Scheduler>
+ any_scheduler(_Scheduler __scheduler)
+ : __scheduler_{static_cast<_Scheduler&&>(__scheduler)} {
+ }
- auto schedule() const noexcept -> __schedule_sender
- {
- return __scheduler_.schedule();
- }
+ auto schedule() const noexcept -> __schedule_sender {
+ return __scheduler_.schedule();
+ }
- template <class _Tag, class... _As>
- requires stdexec::tag_invocable<_Tag, const __scheduler_base&,
- _As...>
- auto query(_Tag, _As&&... __as) const noexcept(
- stdexec::nothrow_tag_invocable<_Tag, const __scheduler_base&,
- _As...>)
- -> stdexec::tag_invoke_result_t<_Tag, const __scheduler_base&,
- _As...>
- {
- return stdexec::tag_invoke(_Tag(), __scheduler_,
- static_cast<_As&&>(__as)...);
- }
+ template <class _Tag, class... _As>
+ requires stdexec::__queryable_with<const __scheduler_base&, _Tag, _As...>
+ auto query(_Tag, _As&&... __as) const
+ noexcept(stdexec::__nothrow_queryable_with<const __scheduler_base&, _Tag, _As...>)
+ -> stdexec::__query_result_t<const __scheduler_base&, _Tag, _As...> {
+ return __scheduler_.query(_Tag{}, static_cast<_As&&>(__as)...);
+ }
- auto operator==(const any_scheduler&) const noexcept
- -> bool = default;
- };
+ auto operator==(const any_scheduler&) const noexcept -> bool = default;
+ };
};
-};
+ };
} // namespace exec
diff --git a/include/sdbusplus/async/stdexec/async_scope.hpp b/include/sdbusplus/async/stdexec/async_scope.hpp
index 0f61e80..f6f48aa 100644
--- a/include/sdbusplus/async/stdexec/async_scope.hpp
+++ b/include/sdbusplus/async/stdexec/async_scope.hpp
@@ -15,957 +15,830 @@
*/
#pragma once
-#include "../stdexec/__detail/__intrusive_queue.hpp"
-#include "../stdexec/__detail/__optional.hpp"
#include "../stdexec/execution.hpp"
#include "../stdexec/stop_token.hpp"
+#include "../stdexec/__detail/__intrusive_queue.hpp"
+#include "../stdexec/__detail/__optional.hpp"
#include "env.hpp"
+#include <atomic>
#include <mutex>
-namespace exec
-{
-/////////////////////////////////////////////////////////////////////////////
-// async_scope
-namespace __scope
-{
-using namespace stdexec;
+namespace exec {
+ /////////////////////////////////////////////////////////////////////////////
+ // async_scope
+ namespace __scope {
+ using namespace stdexec;
-struct __impl;
-struct async_scope;
+ struct __impl;
+ struct async_scope;
-template <class _A>
-concept __async_scope = requires(_A& __a) {
- {
- __a.nest(stdexec::just())
- } -> sender_of<stdexec::set_value_t()>;
- };
+ template <class _A>
+ concept __async_scope = requires(_A& __a) {
+ { __a.nest(stdexec::just()) } -> sender_of<stdexec::set_value_t()>;
+ };
-struct __task : __immovable
-{
- const __impl* __scope_;
- void (*__notify_waiter)(__task*) noexcept;
- __task* __next_ = nullptr;
-};
+ struct __task : __immovable {
+ const __impl* __scope_;
+ void (*__notify_waiter)(__task*) noexcept;
+ __task* __next_ = nullptr;
+ };
-template <class _BaseEnv>
-using __env_t =
- make_env_t<_BaseEnv, prop<get_stop_token_t, inplace_stop_token>>;
+ template <class _BaseEnv>
+ using __env_t = make_env_t<_BaseEnv, prop<get_stop_token_t, inplace_stop_token>>;
-struct __impl
-{
- inplace_stop_source __stop_source_{};
- mutable std::mutex __lock_{};
- mutable std::ptrdiff_t __active_ = 0;
- mutable __intrusive_queue<&__task::__next_> __waiters_{};
+ struct __impl {
+ inplace_stop_source __stop_source_{};
+ mutable std::mutex __lock_{};
+ mutable std::atomic_ptrdiff_t __active_ = 0;
+ mutable __intrusive_queue<&__task::__next_> __waiters_{};
- ~__impl()
- {
+ ~__impl() {
std::unique_lock __guard{__lock_};
STDEXEC_ASSERT(__active_ == 0);
STDEXEC_ASSERT(__waiters_.empty());
- }
-};
+ }
+ };
-////////////////////////////////////////////////////////////////////////////
-// async_scope::when_empty implementation
-template <class _ConstrainedId, class _ReceiverId>
-struct __when_empty_op
-{
- using _Constrained = __cvref_t<_ConstrainedId>;
- using _Receiver = stdexec::__t<_ReceiverId>;
+ ////////////////////////////////////////////////////////////////////////////
+ // async_scope::when_empty implementation
+ template <class _ConstrainedId, class _ReceiverId>
+ struct __when_empty_op {
+ using _Constrained = __cvref_t<_ConstrainedId>;
+ using _Receiver = stdexec::__t<_ReceiverId>;
- struct __t : __task
- {
+ struct __t : __task {
using __id = __when_empty_op;
- explicit __t(const __impl* __scope, _Constrained&& __sndr,
- _Receiver __rcvr) :
- __task{{}, __scope, __notify_waiter},
- __op_(stdexec::connect(static_cast<_Constrained&&>(__sndr),
- static_cast<_Receiver&&>(__rcvr)))
- {}
-
- void start() & noexcept
- {
- std::unique_lock __guard{this->__scope_->__lock_};
- auto& __active = this->__scope_->__active_;
- auto& __waiters = this->__scope_->__waiters_;
- if (__active != 0)
- {
- __waiters.push_back(this);
- return;
- }
- __guard.unlock();
- stdexec::start(this->__op_);
+ explicit __t(const __impl* __scope, _Constrained&& __sndr, _Receiver __rcvr)
+ : __task{{}, __scope, __notify_waiter}
+ , __op_(
+ stdexec::connect(
+ static_cast<_Constrained&&>(__sndr),
+ static_cast<_Receiver&&>(__rcvr))) {
}
- private:
- static void __notify_waiter(__task* __self) noexcept
- {
- stdexec::start(static_cast<__t*>(__self)->__op_);
+ void start() & noexcept {
+ // must get lock before checking __active, or if the __active is drained before
+ // the waiter is queued but after __active is checked, the waiter will never be notified
+ std::unique_lock __guard{this->__scope_->__lock_};
+ auto& __active = this->__scope_->__active_;
+ auto& __waiters = this->__scope_->__waiters_;
+ if (__active.load(std::memory_order_acquire) != 0) {
+ __waiters.push_back(this);
+ return;
+ }
+ __guard.unlock();
+ stdexec::start(this->__op_);
+ }
+
+ private:
+ static void __notify_waiter(__task* __self) noexcept {
+ stdexec::start(static_cast<__t*>(__self)->__op_);
}
STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
connect_result_t<_Constrained, _Receiver> __op_;
+ };
};
-};
-template <class _ConstrainedId>
-struct __when_empty_sender
-{
- using _Constrained = stdexec::__t<_ConstrainedId>;
+ template <class _ConstrainedId>
+ struct __when_empty_sender {
+ using _Constrained = stdexec::__t<_ConstrainedId>;
- struct __t
- {
+ struct __t {
using __id = __when_empty_sender;
using sender_concept = stdexec::sender_t;
template <class _Self, class _Receiver>
using __when_empty_op_t =
- stdexec::__t<__when_empty_op<__cvref_id<_Self, _Constrained>,
- stdexec::__id<_Receiver>>>;
+ stdexec::__t<__when_empty_op<__cvref_id<_Self, _Constrained>, stdexec::__id<_Receiver>>>;
template <__decays_to<__t> _Self, receiver _Receiver>
- requires sender_to<__copy_cvref_t<_Self, _Constrained>, _Receiver>
- [[nodiscard]] static auto connect(_Self&& __self, _Receiver __rcvr) //
- -> __when_empty_op_t<_Self, _Receiver>
- {
- return __when_empty_op_t<_Self, _Receiver>{
- __self.__scope_, static_cast<_Self&&>(__self).__c_,
- static_cast<_Receiver&&>(__rcvr)};
+ requires sender_to<__copy_cvref_t<_Self, _Constrained>, _Receiver>
+ [[nodiscard]]
+ static auto
+ connect(_Self&& __self, _Receiver __rcvr) -> __when_empty_op_t<_Self, _Receiver> {
+ return __when_empty_op_t<_Self, _Receiver>{
+ __self.__scope_, static_cast<_Self&&>(__self).__c_, static_cast<_Receiver&&>(__rcvr)};
}
template <__decays_to<__t> _Self, class... _Env>
static auto get_completion_signatures(_Self&&, _Env&&...)
- -> __completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>,
- __env_t<_Env>...>
- {
- return {};
+ -> __completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>, __env_t<_Env>...> {
+ return {};
}
const __impl* __scope_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Constrained __c_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Constrained __c_;
+ };
};
-};
-template <class _Constrained>
-using __when_empty_sender_t =
- stdexec::__t<__when_empty_sender<__id<__decay_t<_Constrained>>>>;
+ template <class _Constrained>
+ using __when_empty_sender_t = stdexec::__t<__when_empty_sender<__id<__decay_t<_Constrained>>>>;
-////////////////////////////////////////////////////////////////////////////
-// async_scope::nest implementation
-template <class _ReceiverId>
-struct __nest_op_base : __immovable
-{
- using _Receiver = stdexec::__t<_ReceiverId>;
- const __impl* __scope_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Receiver __rcvr_;
-};
+ ////////////////////////////////////////////////////////////////////////////
+ // async_scope::nest implementation
+ template <class _ReceiverId>
+ struct __nest_op_base : __immovable {
+ using _Receiver = stdexec::__t<_ReceiverId>;
+ const __impl* __scope_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rcvr_;
+ };
-template <class _ReceiverId>
-struct __nest_rcvr
-{
- using _Receiver = stdexec::__t<_ReceiverId>;
+ template <class _ReceiverId>
+ struct __nest_rcvr {
+ using _Receiver = stdexec::__t<_ReceiverId>;
- struct __t
- {
+ struct __t {
using __id = __nest_rcvr;
using receiver_concept = stdexec::receiver_t;
__nest_op_base<_ReceiverId>* __op_;
- static void __complete(const __impl* __scope) noexcept
- {
+ static void __complete(const __impl* __scope) noexcept {
+ auto& __active = __scope->__active_;
+ if (__active.fetch_sub(1, std::memory_order_acq_rel) == 1) {
std::unique_lock __guard{__scope->__lock_};
- auto& __active = __scope->__active_;
- if (--__active == 0)
- {
- auto __local_waiters = std::move(__scope->__waiters_);
- __guard.unlock();
- __scope = nullptr;
- // do not access __scope
- while (!__local_waiters.empty())
- {
- auto* __next = __local_waiters.pop_front();
- __next->__notify_waiter(__next);
- // __scope must be considered deleted
- }
+ auto __local_waiters = std::move(__scope->__waiters_);
+ __guard.unlock();
+ __scope = nullptr;
+ // do not access __scope
+ while (!__local_waiters.empty()) {
+ auto* __next = __local_waiters.pop_front();
+ __next->__notify_waiter(__next);
+ // __scope must be considered deleted
}
+ }
}
template <class... _As>
- requires __callable<set_value_t, _Receiver, _As...>
- void set_value(_As&&... __as) noexcept
- {
- auto __scope = __op_->__scope_;
- stdexec::set_value(std::move(__op_->__rcvr_),
- static_cast<_As&&>(__as)...);
- // do not access __op_
- // do not access this
- __complete(__scope);
+ requires __callable<set_value_t, _Receiver, _As...>
+ void set_value(_As&&... __as) noexcept {
+ auto __scope = __op_->__scope_;
+ stdexec::set_value(std::move(__op_->__rcvr_), static_cast<_As&&>(__as)...);
+ // do not access __op_
+ // do not access this
+ __complete(__scope);
}
template <class _Error>
- requires __callable<set_error_t, _Receiver, _Error>
- void set_error(_Error&& __err) noexcept
- {
- auto __scope = __op_->__scope_;
- stdexec::set_error(std::move(__op_->__rcvr_),
- static_cast<_Error&&>(__err));
- // do not access __op_
- // do not access this
- __complete(__scope);
+ requires __callable<set_error_t, _Receiver, _Error>
+ void set_error(_Error&& __err) noexcept {
+ auto __scope = __op_->__scope_;
+ stdexec::set_error(std::move(__op_->__rcvr_), static_cast<_Error&&>(__err));
+ // do not access __op_
+ // do not access this
+ __complete(__scope);
}
void set_stopped() noexcept
- requires __callable<set_stopped_t, _Receiver>
+ requires __callable<set_stopped_t, _Receiver>
{
- auto __scope = __op_->__scope_;
- stdexec::set_stopped(std::move(__op_->__rcvr_));
- // do not access __op_
- // do not access this
- __complete(__scope);
+ auto __scope = __op_->__scope_;
+ stdexec::set_stopped(std::move(__op_->__rcvr_));
+ // do not access __op_
+ // do not access this
+ __complete(__scope);
}
- auto get_env() const noexcept -> __env_t<env_of_t<_Receiver>>
- {
- return make_env(
- stdexec::get_env(__op_->__rcvr_),
- stdexec::prop{get_stop_token,
- __op_->__scope_->__stop_source_.get_token()});
+ auto get_env() const noexcept -> __env_t<env_of_t<_Receiver>> {
+ return make_env(
+ stdexec::get_env(__op_->__rcvr_),
+ stdexec::prop{get_stop_token, __op_->__scope_->__stop_source_.get_token()});
}
+ };
};
-};
-template <class _ConstrainedId, class _ReceiverId>
-struct __nest_op
-{
- using _Constrained = stdexec::__t<_ConstrainedId>;
- using _Receiver = stdexec::__t<_ReceiverId>;
+ template <class _ConstrainedId, class _ReceiverId>
+ struct __nest_op {
+ using _Constrained = stdexec::__t<_ConstrainedId>;
+ using _Receiver = stdexec::__t<_ReceiverId>;
- struct __t : __nest_op_base<_ReceiverId>
- {
+ struct __t : __nest_op_base<_ReceiverId> {
using __id = __nest_op;
using __nest_rcvr_t = stdexec::__t<__nest_rcvr<_ReceiverId>>;
STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS
connect_result_t<_Constrained, __nest_rcvr_t> __op_;
- template <__decays_to<_Constrained> _Sender,
- __decays_to<_Receiver> _Rcvr>
- explicit __t(const __impl* __scope, _Sender&& __c, _Rcvr&& __rcvr) :
- __nest_op_base<_ReceiverId>{
- {}, __scope, static_cast<_Rcvr&&>(__rcvr)},
- __op_(stdexec::connect(static_cast<_Sender&&>(__c),
- __nest_rcvr_t{this}))
- {}
-
- void start() & noexcept
- {
- STDEXEC_ASSERT(this->__scope_);
- std::unique_lock __guard{this->__scope_->__lock_};
- auto& __active = this->__scope_->__active_;
- ++__active;
- __guard.unlock();
- stdexec::start(__op_);
+ template <__decays_to<_Constrained> _Sender, __decays_to<_Receiver> _Rcvr>
+ explicit __t(const __impl* __scope, _Sender&& __c, _Rcvr&& __rcvr)
+ : __nest_op_base<_ReceiverId>{{}, __scope, static_cast<_Rcvr&&>(__rcvr)}
+ , __op_(stdexec::connect(static_cast<_Sender&&>(__c), __nest_rcvr_t{this})) {
}
+
+ void start() & noexcept {
+ STDEXEC_ASSERT(this->__scope_);
+ auto& __active = this->__scope_->__active_;
+ __active.fetch_add(1, std::memory_order_relaxed);
+ stdexec::start(__op_);
+ }
+ };
};
-};
-template <class _ConstrainedId>
-struct __nest_sender
-{
- using _Constrained = stdexec::__t<_ConstrainedId>;
+ template <class _ConstrainedId>
+ struct __nest_sender {
+ using _Constrained = stdexec::__t<_ConstrainedId>;
- struct __t
- {
+ struct __t {
using __id = __nest_sender;
using sender_concept = stdexec::sender_t;
const __impl* __scope_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Constrained __c_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Constrained __c_;
template <class _Receiver>
using __nest_operation_t =
- stdexec::__t<__nest_op<_ConstrainedId, stdexec::__id<_Receiver>>>;
+ stdexec::__t<__nest_op<_ConstrainedId, stdexec::__id<_Receiver>>>;
template <class _Receiver>
- using __nest_receiver_t =
- stdexec::__t<__nest_rcvr<stdexec::__id<_Receiver>>>;
+ using __nest_receiver_t = stdexec::__t<__nest_rcvr<stdexec::__id<_Receiver>>>;
template <__decays_to<__t> _Self, receiver _Receiver>
- requires sender_to<__copy_cvref_t<_Self, _Constrained>,
- __nest_receiver_t<_Receiver>>
- [[nodiscard]] static auto connect(_Self&& __self, _Receiver __rcvr)
- -> __nest_operation_t<_Receiver>
- {
- return __nest_operation_t<_Receiver>{
- __self.__scope_, static_cast<_Self&&>(__self).__c_,
- static_cast<_Receiver&&>(__rcvr)};
+ requires sender_to<__copy_cvref_t<_Self, _Constrained>, __nest_receiver_t<_Receiver>>
+ [[nodiscard]]
+ static auto connect(_Self&& __self, _Receiver __rcvr) -> __nest_operation_t<_Receiver> {
+ return __nest_operation_t<_Receiver>{
+ __self.__scope_, static_cast<_Self&&>(__self).__c_, static_cast<_Receiver&&>(__rcvr)};
}
template <__decays_to<__t> _Self, class... _Env>
static auto get_completion_signatures(_Self&&, _Env&&...)
- -> __completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>,
- __env_t<_Env>...>
- {
- return {};
+ -> __completion_signatures_of_t<__copy_cvref_t<_Self, _Constrained>, __env_t<_Env>...> {
+ return {};
}
+ };
};
-};
-template <class _Constrained>
-using __nest_sender_t =
- stdexec::__t<__nest_sender<__id<__decay_t<_Constrained>>>>;
+ template <class _Constrained>
+ using __nest_sender_t = stdexec::__t<__nest_sender<__id<__decay_t<_Constrained>>>>;
-////////////////////////////////////////////////////////////////////////////
-// async_scope::spawn_future implementation
-enum class __future_step
-{
- __invalid = 0,
- __created,
- __future,
- __no_future,
- __deleted
-};
+ ////////////////////////////////////////////////////////////////////////////
+ // async_scope::spawn_future implementation
+ enum class __future_step {
+ __invalid = 0,
+ __created,
+ __future,
+ __no_future,
+ __deleted
+ };
-template <class _Sender, class _Env>
-struct __future_state;
+ template <class _Sender, class _Env>
+ struct __future_state;
-struct __forward_stopped
-{
- inplace_stop_source* __stop_source_;
+ struct __forward_stopped {
+ inplace_stop_source* __stop_source_;
- void operator()() noexcept
- {
+ void operator()() noexcept {
__stop_source_->request_stop();
- }
-};
+ }
+ };
-struct __subscription : __immovable
-{
- void (*__complete_)(__subscription*) noexcept = nullptr;
+ struct __subscription : __immovable {
+ void (*__complete_)(__subscription*) noexcept = nullptr;
- void __complete() noexcept
- {
+ void __complete() noexcept {
__complete_(this);
- }
+ }
- __subscription* __next_ = nullptr;
-};
+ __subscription* __next_ = nullptr;
+ };
-template <class _SenderId, class _EnvId, class _ReceiverId>
-struct __future_op
-{
- using _Sender = stdexec::__t<_SenderId>;
- using _Env = stdexec::__t<_EnvId>;
- using _Receiver = stdexec::__t<_ReceiverId>;
+ template <class _SenderId, class _EnvId, class _ReceiverId>
+ struct __future_op {
+ using _Sender = stdexec::__t<_SenderId>;
+ using _Env = stdexec::__t<_EnvId>;
+ using _Receiver = stdexec::__t<_ReceiverId>;
- class __t : __subscription
- {
- using __forward_consumer = typename stop_token_of_t<
- env_of_t<_Receiver>>::template callback_type<__forward_stopped>;
+ class __t : __subscription {
+ using __forward_consumer =
+ stop_token_of_t<env_of_t<_Receiver>>::template callback_type<__forward_stopped>;
- void __complete_() noexcept
- {
- try
- {
- __forward_consumer_.reset();
- auto __state = std::move(__state_);
- STDEXEC_ASSERT(__state != nullptr);
- std::unique_lock __guard{__state->__mutex_};
- // either the future is still in use or it has passed ownership
- // to __state->__no_future_
- if (__state->__no_future_.get() != nullptr ||
- __state->__step_ != __future_step::__future)
- {
- // invalid state - there is a code bug in the state machine
+ void __complete_() noexcept {
+ STDEXEC_TRY {
+ __forward_consumer_.reset();
+ auto __state = std::move(__state_);
+ STDEXEC_ASSERT(__state != nullptr);
+ std::unique_lock __guard{__state->__mutex_};
+ // either the future is still in use or it has passed ownership to __state->__no_future_
+ if (
+ __state->__no_future_.get() != nullptr
+ || __state->__step_ != __future_step::__future) {
+ // invalid state - there is a code bug in the state machine
+ std::terminate();
+ } else if (get_stop_token(get_env(__rcvr_)).stop_requested()) {
+
+ __guard.unlock();
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
+ __guard.lock();
+ } else {
+ std::visit(
+ [this, &__guard]<class _Tup>(_Tup& __tup) {
+ if constexpr (same_as<_Tup, std::monostate>) {
std::terminate();
- }
- else if (get_stop_token(get_env(__rcvr_)).stop_requested())
- {
- __guard.unlock();
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
- __guard.lock();
- }
- else
- {
- std::visit(
- [this, &__guard]<class _Tup>(_Tup& __tup) {
- if constexpr (same_as<_Tup, std::monostate>)
- {
- std::terminate();
- }
- else
- {
- std::apply(
- [this, &__guard]<class... _As>(
- auto tag, _As&... __as) {
- __guard.unlock();
- tag(static_cast<_Receiver&&>(__rcvr_),
- static_cast<_As&&>(__as)...);
- __guard.lock();
- },
- __tup);
- }
- },
- __state->__data_);
- }
+ } else {
+ std::apply(
+ [this, &__guard]<class... _As>(auto tag, _As&... __as) {
+ __guard.unlock();
+ tag(static_cast<_Receiver&&>(__rcvr_), static_cast<_As&&>(__as)...);
+ __guard.lock();
+ },
+ __tup);
+ }
+ },
+ __state->__data_);
}
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr_),
- std::current_exception());
- }
+ }
+ STDEXEC_CATCH_ALL {
+
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr_), std::current_exception());
+ }
}
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Receiver __rcvr_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rcvr_;
std::unique_ptr<__future_state<_Sender, _Env>> __state_;
- STDEXEC_ATTRIBUTE((no_unique_address))
+ STDEXEC_ATTRIBUTE(no_unique_address)
stdexec::__optional<__forward_consumer> __forward_consumer_;
- public:
+ public:
using __id = __future_op;
- ~__t() noexcept
- {
- if (__state_ != nullptr)
- {
- auto __raw_state = __state_.get();
- std::unique_lock __guard{__raw_state->__mutex_};
- if (__raw_state->__data_.index() > 0)
- {
- // completed given sender
- // state is no longer needed
- return;
- }
- __raw_state->__no_future_ = std::move(__state_);
- __raw_state->__step_from_to_(__guard, __future_step::__future,
- __future_step::__no_future);
+ ~__t() noexcept {
+ if (__state_ != nullptr) {
+ auto __raw_state = __state_.get();
+ std::unique_lock __guard{__raw_state->__mutex_};
+ if (__raw_state->__data_.index() > 0) {
+ // completed given sender
+ // state is no longer needed
+ return;
}
+ __raw_state->__no_future_ = std::move(__state_);
+ __raw_state
+ ->__step_from_to_(__guard, __future_step::__future, __future_step::__no_future);
+ }
}
template <class _Receiver2>
- explicit __t(_Receiver2&& __rcvr,
- std::unique_ptr<__future_state<_Sender, _Env>> __state) :
- __subscription{{},
- [](__subscription* __self) noexcept -> void {
- static_cast<__t*>(__self)->__complete_();
- }},
- __rcvr_(static_cast<_Receiver2&&>(__rcvr)),
- __state_(std::move(__state)),
- __forward_consumer_(std::in_place, get_stop_token(get_env(__rcvr_)),
- __forward_stopped{&__state_->__stop_source_})
- {}
-
- void start() & noexcept
- {
- try
- {
- if (!!__state_)
- {
- std::unique_lock __guard{__state_->__mutex_};
- if (__state_->__data_.index() != 0)
- {
- __guard.unlock();
- __complete_();
- }
- else
- {
- __state_->__subscribers_.push_back(this);
- }
- }
- }
- catch (...)
- {
- stdexec::set_error(static_cast<_Receiver&&>(__rcvr_),
- std::current_exception());
- }
+ explicit __t(
+ _Receiver2&& __rcvr, std::unique_ptr<__future_state<_Sender, _Env>> __state)
+ : __subscription{{},
+ [](__subscription* __self) noexcept -> void {
+ static_cast<__t*>(__self)->__complete_();
+ }}
+ , __rcvr_(static_cast<_Receiver2&&>(__rcvr))
+ , __state_(std::move(__state))
+ , __forward_consumer_(std::in_place, get_stop_token(get_env(__rcvr_)),
+ __forward_stopped{&__state_->__stop_source_}) {
}
+
+ void start() & noexcept {
+ STDEXEC_TRY {
+ if (!!__state_) {
+ std::unique_lock __guard{__state_->__mutex_};
+ if (__state_->__data_.index() != 0) {
+ __guard.unlock();
+ __complete_();
+ } else {
+ __state_->__subscribers_.push_back(this);
+ }
+ }
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(static_cast<_Receiver&&>(__rcvr_), std::current_exception());
+ }
+ }
+ };
};
-};
#if STDEXEC_EDG()
-template <class _Fn>
-struct __completion_as_tuple2_;
+ template <class _Fn>
+ struct __completion_as_tuple2_;
-template <class _Tag, class... _Ts>
-struct __completion_as_tuple2_<_Tag(_Ts...)>
-{
- using __t = std::tuple<_Tag, _Ts...>;
-};
-template <class _Fn>
-using __completion_as_tuple_t = stdexec::__t<__completion_as_tuple2_<_Fn>>;
+ template <class _Tag, class... _Ts>
+ struct __completion_as_tuple2_<_Tag(_Ts...)> {
+ using __t = std::tuple<_Tag, _Ts...>;
+ };
+ template <class _Fn>
+ using __completion_as_tuple_t = stdexec::__t<__completion_as_tuple2_<_Fn>>;
#else
-template <class _Tag, class... _Ts>
-auto __completion_as_tuple_(_Tag (*)(_Ts...)) -> std::tuple<_Tag, _Ts...>;
+ template <class _Tag, class... _Ts>
+ auto __completion_as_tuple_(_Tag (*)(_Ts...)) -> std::tuple<_Tag, _Ts...>;
-template <class _Fn>
-using __completion_as_tuple_t =
- decltype(__scope::__completion_as_tuple_(static_cast<_Fn*>(nullptr)));
+ template <class _Fn>
+ using __completion_as_tuple_t = decltype(__scope::__completion_as_tuple_(
+ static_cast<_Fn*>(nullptr)));
#endif
-template <class... _Ts>
-using __decay_values_t = completion_signatures<set_value_t(__decay_t<_Ts>...)>;
+ template <class... _Ts>
+ using __decay_values_t = completion_signatures<set_value_t(__decay_t<_Ts>...)>;
-template <class _Ty>
-using __decay_error_t = completion_signatures<set_error_t(__decay_t<_Ty>)>;
+ template <class _Ty>
+ using __decay_error_t = completion_signatures<set_error_t(__decay_t<_Ty>)>;
-template <class _Sender, class _Env>
-using __future_completions_t = //
- transform_completion_signatures_of<
- _Sender, __env_t<_Env>,
- completion_signatures<set_stopped_t(), set_error_t(std::exception_ptr)>,
- __decay_values_t, __decay_error_t>;
+ template <class _Sender, class _Env>
+ using __future_completions_t = transform_completion_signatures_of<
+ _Sender,
+ __env_t<_Env>,
+ completion_signatures<set_stopped_t(), set_error_t(std::exception_ptr)>,
+ __decay_values_t,
+ __decay_error_t
+ >;
-template <class _Completions>
-using __completions_as_variant = //
- __mapply<__mtransform<__q<__completion_as_tuple_t>,
- __mbind_front_q<std::variant, std::monostate>>,
- _Completions>;
+ template <class _Completions>
+ using __completions_as_variant = __mapply<
+ __mtransform<__q<__completion_as_tuple_t>, __mbind_front_q<std::variant, std::monostate>>,
+ _Completions
+ >;
-template <class _Ty>
-struct __dynamic_delete
-{
- __dynamic_delete() : __delete_([](_Ty* __p) { delete __p; }) {}
+ template <class _Ty>
+ struct __dynamic_delete {
+ __dynamic_delete()
+ : __delete_([](_Ty* __p) { delete __p; }) {
+ }
- template <class _Uy>
+ template <class _Uy>
requires convertible_to<_Uy*, _Ty*>
- __dynamic_delete(std::default_delete<_Uy>) :
- __delete_([](_Ty* __p) { delete static_cast<_Uy*>(__p); })
- {}
+ __dynamic_delete(std::default_delete<_Uy>)
+ : __delete_([](_Ty* __p) { delete static_cast<_Uy*>(__p); }) {
+ }
- template <class _Uy>
+ template <class _Uy>
requires convertible_to<_Uy*, _Ty*>
- auto operator=(std::default_delete<_Uy> __d) -> __dynamic_delete&
- {
+ auto operator=(std::default_delete<_Uy> __d) -> __dynamic_delete& {
__delete_ = __dynamic_delete{__d}.__delete_;
return *this;
- }
+ }
- void operator()(_Ty* __p)
- {
+ void operator()(_Ty* __p) {
__delete_(__p);
- }
+ }
- void (*__delete_)(_Ty*);
-};
+ void (*__delete_)(_Ty*);
+ };
-template <class _Completions, class _Env>
-struct __future_state_base
-{
- __future_state_base(_Env __env, const __impl* __scope) :
- __forward_scope_{std::in_place, __scope->__stop_source_.get_token(),
- __forward_stopped{&__stop_source_}},
- __env_(make_env(
+ template <class _Completions, class _Env>
+ struct __future_state_base {
+ __future_state_base(_Env __env, const __impl* __scope)
+ : __forward_scope_{std::in_place, __scope->__stop_source_.get_token(), __forward_stopped{&__stop_source_}}
+ , __env_(make_env(
static_cast<_Env&&>(__env),
- stdexec::prop{get_stop_token, __scope->__stop_source_.get_token()}))
- {}
+ stdexec::prop{get_stop_token, __scope->__stop_source_.get_token()})) {
+ }
- ~__future_state_base()
- {
+ ~__future_state_base() {
std::unique_lock __guard{__mutex_};
- if (__step_ == __future_step::__created)
- {
- // exception during connect() will end up here
- __step_from_to_(__guard, __future_step::__created,
- __future_step::__deleted);
+ if (__step_ == __future_step::__created) {
+ // exception during connect() will end up here
+ __step_from_to_(__guard, __future_step::__created, __future_step::__deleted);
+ } else if (__step_ != __future_step::__deleted) {
+ // completing the given sender before the future is dropped will end here
+ __step_from_to_(__guard, __future_step::__future, __future_step::__deleted);
}
- else if (__step_ != __future_step::__deleted)
- {
- // completing the given sender before the future is dropped will end
- // here
- __step_from_to_(__guard, __future_step::__future,
- __future_step::__deleted);
- }
- }
+ }
- void __step_from_to_(std::unique_lock<std::mutex>& __guard,
- __future_step __from, __future_step __to)
- {
+ void __step_from_to_(
+ std::unique_lock<std::mutex>& __guard,
+ __future_step __from,
+ __future_step __to) {
STDEXEC_ASSERT(__guard.owns_lock());
auto actual = std::exchange(__step_, __to);
STDEXEC_ASSERT(actual == __from);
- }
+ }
- inplace_stop_source __stop_source_;
- stdexec::__optional<inplace_stop_callback<__forward_stopped>>
- __forward_scope_;
- std::mutex __mutex_;
- __future_step __step_ = __future_step::__created;
- std::unique_ptr<__future_state_base, __dynamic_delete<__future_state_base>>
- __no_future_;
- __completions_as_variant<_Completions> __data_;
- __intrusive_queue<&__subscription::__next_> __subscribers_;
- __env_t<_Env> __env_;
-};
+ inplace_stop_source __stop_source_;
+ stdexec::__optional<inplace_stop_callback<__forward_stopped>> __forward_scope_;
+ std::mutex __mutex_;
+ __future_step __step_ = __future_step::__created;
+ std::unique_ptr<__future_state_base, __dynamic_delete<__future_state_base>> __no_future_;
+ __completions_as_variant<_Completions> __data_;
+ __intrusive_queue<&__subscription::__next_> __subscribers_;
+ __env_t<_Env> __env_;
+ };
-template <class _Completions, class _EnvId>
-struct __future_rcvr
-{
- using _Env = stdexec::__t<_EnvId>;
+ template <class _Completions, class _EnvId>
+ struct __future_rcvr {
+ using _Env = stdexec::__t<_EnvId>;
- struct __t
- {
+ struct __t {
using __id = __future_rcvr;
using receiver_concept = stdexec::receiver_t;
__future_state_base<_Completions, _Env>* __state_;
const __impl* __scope_;
- void __dispatch_result_(std::unique_lock<std::mutex>& __guard) noexcept
- {
- auto& __state = *__state_;
- auto __local_subscribers = std::move(__state.__subscribers_);
- __state.__forward_scope_.reset();
- if (__state.__no_future_.get() != nullptr)
- {
- // nobody is waiting for the results
- // delete this and return
- __state.__step_from_to_(__guard, __future_step::__no_future,
- __future_step::__deleted);
- __guard.unlock();
- __state.__no_future_.reset();
- return;
- }
+ void __dispatch_result_(std::unique_lock<std::mutex>& __guard) noexcept {
+ auto& __state = *__state_;
+ auto __local_subscribers = std::move(__state.__subscribers_);
+ __state.__forward_scope_.reset();
+ if (__state.__no_future_.get() != nullptr) {
+ // nobody is waiting for the results
+ // delete this and return
+ __state.__step_from_to_(__guard, __future_step::__no_future, __future_step::__deleted);
__guard.unlock();
- while (!__local_subscribers.empty())
- {
- auto* __sub = __local_subscribers.pop_front();
- __sub->__complete();
- }
+ __state.__no_future_.reset();
+ return;
+ }
+ __guard.unlock();
+ while (!__local_subscribers.empty()) {
+ auto* __sub = __local_subscribers.pop_front();
+ __sub->__complete();
+ }
}
template <class _Tag, class... _As>
- void __save_completion(_Tag, _As&&... __as) noexcept
- {
- auto& __state = *__state_;
- try
- {
- using _Tuple = __decayed_std_tuple<_Tag, _As...>;
- __state.__data_.template emplace<_Tuple>(
- _Tag(), static_cast<_As&&>(__as)...);
- }
- catch (...)
- {
- using _Tuple = std::tuple<set_error_t, std::exception_ptr>;
- __state.__data_.template emplace<_Tuple>(
- set_error_t(), std::current_exception());
- }
+ void __save_completion(_Tag, _As&&... __as) noexcept {
+ auto& __state = *__state_;
+ STDEXEC_TRY {
+ using _Tuple = __decayed_std_tuple<_Tag, _As...>;
+ __state.__data_.template emplace<_Tuple>(_Tag(), static_cast<_As&&>(__as)...);
+ }
+ STDEXEC_CATCH_ALL {
+ using _Tuple = std::tuple<set_error_t, std::exception_ptr>;
+ __state.__data_.template emplace<_Tuple>(set_error_t(), std::current_exception());
+ }
}
template <__movable_value... _As>
- void set_value(_As&&... __as) noexcept
- {
- auto& __state = *__state_;
- std::unique_lock __guard{__state.__mutex_};
- __save_completion(set_value_t(), static_cast<_As&&>(__as)...);
- __dispatch_result_(__guard);
+ void set_value(_As&&... __as) noexcept {
+ auto& __state = *__state_;
+ std::unique_lock __guard{__state.__mutex_};
+ __save_completion(set_value_t(), static_cast<_As&&>(__as)...);
+ __dispatch_result_(__guard);
}
template <__movable_value _Error>
- void set_error(_Error&& __err) noexcept
- {
- auto& __state = *__state_;
- std::unique_lock __guard{__state.__mutex_};
- __save_completion(set_error_t(), static_cast<_Error&&>(__err));
- __dispatch_result_(__guard);
+ void set_error(_Error&& __err) noexcept {
+ auto& __state = *__state_;
+ std::unique_lock __guard{__state.__mutex_};
+ __save_completion(set_error_t(), static_cast<_Error&&>(__err));
+ __dispatch_result_(__guard);
}
- void set_stopped() noexcept
- {
- auto& __state = *__state_;
- std::unique_lock __guard{__state.__mutex_};
- __save_completion(set_stopped_t());
- __dispatch_result_(__guard);
+ void set_stopped() noexcept {
+ auto& __state = *__state_;
+ std::unique_lock __guard{__state.__mutex_};
+ __save_completion(set_stopped_t());
+ __dispatch_result_(__guard);
}
- auto get_env() const noexcept -> const __env_t<_Env>&
- {
- return __state_->__env_;
+ auto get_env() const noexcept -> const __env_t<_Env>& {
+ return __state_->__env_;
}
+ };
};
-};
-template <class _Sender, class _Env>
-using __future_receiver_t =
- __t<__future_rcvr<__future_completions_t<_Sender, _Env>, __id<_Env>>>;
+ template <class _Sender, class _Env>
+ using __future_receiver_t =
+ __t<__future_rcvr<__future_completions_t<_Sender, _Env>, __id<_Env>>>;
-template <class _Sender, class _Env>
-struct __future_state :
- __future_state_base<__future_completions_t<_Sender, _Env>, _Env>
-{
- using _Completions = __future_completions_t<_Sender, _Env>;
+ template <class _Sender, class _Env>
+ struct __future_state : __future_state_base<__future_completions_t<_Sender, _Env>, _Env> {
+ using _Completions = __future_completions_t<_Sender, _Env>;
- __future_state(_Sender __sndr, _Env __env, const __impl* __scope) :
- __future_state_base<_Completions, _Env>(static_cast<_Env&&>(__env),
- __scope),
- __op_(
- stdexec::connect(static_cast<_Sender&&>(__sndr),
- __future_receiver_t<_Sender, _Env>{this, __scope}))
- {}
+ __future_state(connect_t, _Sender&& __sndr, _Env __env, const __impl* __scope)
+ : __future_state_base<_Completions, _Env>(static_cast<_Env&&>(__env), __scope)
+ , __op_(static_cast<_Sender&&>(__sndr), __future_receiver_t<_Sender, _Env>{this, __scope}) {
+ }
- connect_result_t<_Sender, __future_receiver_t<_Sender, _Env>> __op_;
-};
+ __future_state(_Sender __sndr, _Env __env, const __impl* __scope)
+ : __future_state(
+ stdexec::connect,
+ static_cast<_Sender&&>(__sndr),
+ static_cast<_Env&&>(__env),
+ __scope) {
+ // If the operation completes synchronously, then the following line will cause
+ // the destruction of *this, which is not a problem because we used a delegating
+ // constructor, so *this is considered fully constructed.
+ __op_.submit(
+ static_cast<_Sender&&>(__sndr), __future_receiver_t<_Sender, _Env>{this, __scope});
+ }
-template <class _SenderId, class _EnvId>
-struct __future
-{
- using _Sender = stdexec::__t<_SenderId>;
- using _Env = stdexec::__t<_EnvId>;
+ STDEXEC_ATTRIBUTE(no_unique_address)
+ submit_result<_Sender, __future_receiver_t<_Sender, _Env>> __op_{};
+ };
- class __t
- {
+ template <class _SenderId, class _EnvId>
+ struct __future {
+ using _Sender = stdexec::__t<_SenderId>;
+ using _Env = stdexec::__t<_EnvId>;
+
+ class __t {
template <class _Self>
- using __completions_t =
- __future_completions_t<__mfront<_Sender, _Self>, _Env>;
+ using __completions_t = __future_completions_t<__mfront<_Sender, _Self>, _Env>;
template <class _Receiver>
- using __future_op_t = stdexec::__t<
- __future_op<_SenderId, _EnvId, stdexec::__id<_Receiver>>>;
+ using __future_op_t =
+ stdexec::__t<__future_op<_SenderId, _EnvId, stdexec::__id<_Receiver>>>;
- public:
+ public:
using __id = __future;
using sender_concept = stdexec::sender_t;
__t(__t&&) = default;
auto operator=(__t&&) -> __t& = default;
- ~__t() noexcept
- {
- if (__state_ != nullptr)
- {
- auto __raw_state = __state_.get();
- std::unique_lock __guard{__raw_state->__mutex_};
- if (__raw_state->__data_.index() != 0)
- {
- // completed given sender
- // state is no longer needed
- return;
- }
- __raw_state->__no_future_ = std::move(__state_);
- __raw_state->__step_from_to_(__guard, __future_step::__future,
- __future_step::__no_future);
+ ~__t() noexcept {
+ if (__state_ != nullptr) {
+ auto __raw_state = __state_.get();
+ std::unique_lock __guard{__raw_state->__mutex_};
+ if (__raw_state->__data_.index() != 0) {
+ // completed given sender
+ // state is no longer needed
+ return;
}
+ __raw_state->__no_future_ = std::move(__state_);
+ __raw_state
+ ->__step_from_to_(__guard, __future_step::__future, __future_step::__no_future);
+ }
}
template <__decays_to<__t> _Self, receiver _Receiver>
- requires receiver_of<_Receiver, __completions_t<_Self>>
- static auto connect(_Self&& __self, _Receiver __rcvr)
- -> __future_op_t<_Receiver>
- {
- return __future_op_t<_Receiver>{
- static_cast<_Receiver&&>(__rcvr),
- static_cast<_Self&&>(__self).__state_};
+ requires receiver_of<_Receiver, __completions_t<_Self>>
+ static auto connect(_Self&& __self, _Receiver __rcvr) -> __future_op_t<_Receiver> {
+ return __future_op_t<_Receiver>{
+ static_cast<_Receiver&&>(__rcvr), static_cast<_Self&&>(__self).__state_};
}
template <__decays_to<__t> _Self, class... _OtherEnv>
- static auto get_completion_signatures(_Self&&, _OtherEnv&&...)
- -> __completions_t<_Self>
- {
- return {};
+ static auto get_completion_signatures(_Self&&, _OtherEnv&&...) -> __completions_t<_Self> {
+ return {};
}
- private:
+ private:
friend struct async_scope;
- explicit __t(
- std::unique_ptr<__future_state<_Sender, _Env>> __state) noexcept :
- __state_(std::move(__state))
- {
- std::unique_lock __guard{__state_->__mutex_};
- __state_->__step_from_to_(__guard, __future_step::__created,
- __future_step::__future);
+ explicit __t(std::unique_ptr<__future_state<_Sender, _Env>> __state) noexcept
+ : __state_(std::move(__state)) {
+ std::unique_lock __guard{__state_->__mutex_};
+ __state_->__step_from_to_(__guard, __future_step::__created, __future_step::__future);
}
std::unique_ptr<__future_state<_Sender, _Env>> __state_;
+ };
};
-};
-template <class _Sender, class _Env>
-using __future_t = stdexec::__t<
- __future<__id<__nest_sender_t<_Sender>>, __id<__decay_t<_Env>>>>;
+ template <class _Sender, class _Env>
+ using __future_t =
+ stdexec::__t<__future<__id<__nest_sender_t<_Sender>>, __id<__decay_t<_Env>>>>;
-////////////////////////////////////////////////////////////////////////////
-// async_scope::spawn implementation
-struct __spawn_env_
-{
- inplace_stop_token __token_;
+ ////////////////////////////////////////////////////////////////////////////
+ // async_scope::spawn implementation
+ struct __spawn_env_ {
+ inplace_stop_token __token_;
- auto query(get_stop_token_t) const noexcept -> inplace_stop_token
- {
+ [[nodiscard]]
+ auto query(get_stop_token_t) const noexcept -> inplace_stop_token {
return __token_;
- }
+ }
- auto query(get_scheduler_t) const noexcept -> __inln::__scheduler
- {
+ [[nodiscard]]
+ auto query(get_scheduler_t) const noexcept -> stdexec::inline_scheduler {
return {};
- }
-};
+ }
+ };
-template <class _Env>
-using __spawn_env_t = __env::__join_t<_Env, __spawn_env_>;
+ template <class _Env>
+ using __spawn_env_t = __join_env_t<_Env, __spawn_env_>;
-template <class _EnvId>
-struct __spawn_op_base
-{
- using _Env = stdexec::__t<_EnvId>;
- __spawn_env_t<_Env> __env_;
- void (*__delete_)(__spawn_op_base*);
-};
+ template <class _EnvId>
+ struct __spawn_op_base {
+ using _Env = stdexec::__t<_EnvId>;
+ __spawn_env_t<_Env> __env_;
+ void (*__delete_)(__spawn_op_base*);
+ };
-template <class _EnvId>
-struct __spawn_rcvr
-{
- using _Env = stdexec::__t<_EnvId>;
+ template <class _EnvId>
+ struct __spawn_rcvr {
+ using _Env = stdexec::__t<_EnvId>;
- struct __t
- {
+ struct __t {
using __id = __spawn_rcvr;
using receiver_concept = stdexec::receiver_t;
__spawn_op_base<_EnvId>* __op_;
- void set_value() noexcept
- {
- __op_->__delete_(__op_);
+ void set_value() noexcept {
+ __op_->__delete_(__op_);
}
// BUGBUG NOT TO SPEC spawn shouldn't accept senders that can fail.
- [[noreturn]] void set_error(std::exception_ptr __eptr) noexcept
- {
- std::rethrow_exception(std::move(__eptr));
+ [[noreturn]]
+ void set_error(std::exception_ptr __eptr) noexcept {
+ std::rethrow_exception(std::move(__eptr));
}
- void set_stopped() noexcept
- {
- __op_->__delete_(__op_);
+ void set_stopped() noexcept {
+ __op_->__delete_(__op_);
}
- auto get_env() const noexcept -> const __spawn_env_t<_Env>&
- {
- return __op_->__env_;
+ auto get_env() const noexcept -> const __spawn_env_t<_Env>& {
+ return __op_->__env_;
}
+ };
};
-};
-template <class _Env>
-using __spawn_receiver_t = stdexec::__t<__spawn_rcvr<__id<_Env>>>;
+ template <class _Env>
+ using __spawn_receiver_t = stdexec::__t<__spawn_rcvr<__id<_Env>>>;
-template <class _SenderId, class _EnvId>
-struct __spawn_op
-{
- using _Env = stdexec::__t<_EnvId>;
- using _Sender = stdexec::__t<_SenderId>;
+ template <class _SenderId, class _EnvId>
+ struct __spawn_op {
+ using _Env = stdexec::__t<_EnvId>;
+ using _Sender = stdexec::__t<_SenderId>;
- struct __t : __spawn_op_base<_EnvId>
- {
- template <__decays_to<_Sender> _Sndr>
- __t(_Sndr&& __sndr, _Env __env, const __impl* __scope) :
- __spawn_op_base<_EnvId>{
- __env::__join(
- static_cast<_Env&&>(__env),
- __spawn_env_{__scope->__stop_source_.get_token()}),
- [](__spawn_op_base<_EnvId>* __op) {
- delete static_cast<__t*>(__op);
- }},
- __op_(stdexec::connect(static_cast<_Sndr&&>(__sndr),
- __spawn_receiver_t<_Env>{this}))
- {}
-
- void start() & noexcept
- {
- stdexec::start(__op_);
+ struct __t : __spawn_op_base<_EnvId> {
+ __t(connect_t, _Sender&& __sndr, _Env __env, const __impl* __scope)
+ : __spawn_op_base<
+ _EnvId
+ >{__env::__join(
+ static_cast<_Env&&>(__env),
+ __spawn_env_{__scope->__stop_source_.get_token()}),
+ [](__spawn_op_base<_EnvId>* __op) { delete static_cast<__t*>(__op); }}
+ , __data_(static_cast<_Sender&&>(__sndr), __spawn_receiver_t<_Env>{this}) {
}
- connect_result_t<_Sender, __spawn_receiver_t<_Env>> __op_;
+ __t(_Sender __sndr, _Env __env, const __impl* __scope)
+ : __t(
+ stdexec::connect,
+ static_cast<_Sender&&>(__sndr),
+ static_cast<_Env&&>(__env),
+ __scope) {
+ // If the operation completes synchronously, then the following line will cause
+ // the destruction of *this, which is not a problem because we used a delegating
+ // constructor, so *this is considered fully constructed.
+ __data_.submit(static_cast<_Sender&&>(__sndr), __spawn_receiver_t<_Env>{this});
+ }
+
+ STDEXEC_ATTRIBUTE(no_unique_address)
+ submit_result<_Sender, __spawn_receiver_t<_Env>> __data_;
+ };
};
-};
-template <class _Sender, class _Env>
-using __spawn_operation_t = stdexec::__t<__spawn_op<__id<_Sender>, __id<_Env>>>;
+ template <class _Sender, class _Env>
+ using __spawn_operation_t = stdexec::__t<__spawn_op<__id<_Sender>, __id<_Env>>>;
-////////////////////////////////////////////////////////////////////////////
-// async_scope
-struct async_scope : __immovable
-{
- async_scope() = default;
+ ////////////////////////////////////////////////////////////////////////////
+ // async_scope
+ struct async_scope : __immovable {
+ async_scope() = default;
- template <sender _Constrained>
- [[nodiscard]] auto when_empty(_Constrained&& __c) const
- -> __when_empty_sender_t<_Constrained>
- {
- return __when_empty_sender_t<_Constrained>{
- &__impl_, static_cast<_Constrained&&>(__c)};
- }
+ template <sender _Constrained>
+ [[nodiscard]]
+ auto when_empty(_Constrained&& __c) const -> __when_empty_sender_t<_Constrained> {
+ return __when_empty_sender_t<_Constrained>{&__impl_, static_cast<_Constrained&&>(__c)};
+ }
- [[nodiscard]] auto on_empty() const
- {
+ [[nodiscard]]
+ auto on_empty() const {
return when_empty(just());
- }
+ }
- template <sender _Constrained>
- using nest_result_t = __nest_sender_t<_Constrained>;
+ template <sender _Constrained>
+ using nest_result_t = __nest_sender_t<_Constrained>;
- template <sender _Constrained>
- [[nodiscard]] auto nest(_Constrained&& __c) -> nest_result_t<_Constrained>
- {
- return nest_result_t<_Constrained>{&__impl_,
- static_cast<_Constrained&&>(__c)};
- }
+ template <sender _Constrained>
+ [[nodiscard]]
+ auto nest(_Constrained&& __c) -> nest_result_t<_Constrained> {
+ return nest_result_t<_Constrained>{&__impl_, static_cast<_Constrained&&>(__c)};
+ }
- template <__movable_value _Env = empty_env,
- sender_in<__spawn_env_t<_Env>> _Sender>
+ template <__movable_value _Env = env<>, sender_in<__spawn_env_t<_Env>> _Sender>
requires sender_to<nest_result_t<_Sender>, __spawn_receiver_t<_Env>>
- void spawn(_Sender&& __sndr, _Env __env = {})
- {
+ void spawn(_Sender&& __sndr, _Env __env = {}) {
using __op_t = __spawn_operation_t<nest_result_t<_Sender>, _Env>;
- // start is noexcept so we can assume that the operation will complete
- // after this, which means we can rely on its self-ownership to ensure
- // that it is eventually deleted
- stdexec::start(*(new __op_t{nest(static_cast<_Sender&&>(__sndr)),
- static_cast<_Env&&>(__env), &__impl_}));
- }
+ // this will connect and start the operation, after which the operation state is
+ // responsible for deleting itself after it completes.
+ [[maybe_unused]]
+ auto* __op =
+ new __op_t{nest(static_cast<_Sender&&>(__sndr)), static_cast<_Env&&>(__env), &__impl_};
+ }
- template <__movable_value _Env = empty_env,
- sender_in<__env_t<_Env>> _Sender>
- auto spawn_future(_Sender&& __sndr, _Env __env = {})
- -> __future_t<_Sender, _Env>
- {
+ template <__movable_value _Env = env<>, sender_in<__env_t<_Env>> _Sender>
+ auto spawn_future(_Sender&& __sndr, _Env __env = {}) -> __future_t<_Sender, _Env> {
using __state_t = __future_state<nest_result_t<_Sender>, _Env>;
- auto __state =
- std::make_unique<__state_t>(nest(static_cast<_Sender&&>(__sndr)),
- static_cast<_Env&&>(__env), &__impl_);
- stdexec::start(__state->__op_);
+ auto __state = std::make_unique<__state_t>(
+ nest(static_cast<_Sender&&>(__sndr)), static_cast<_Env&&>(__env), &__impl_);
return __future_t<_Sender, _Env>{std::move(__state)};
- }
+ }
- auto get_stop_source() noexcept -> inplace_stop_source&
- {
+ auto get_stop_source() noexcept -> inplace_stop_source& {
return __impl_.__stop_source_;
- }
+ }
- auto get_stop_token() const noexcept -> inplace_stop_token
- {
+ auto get_stop_token() const noexcept -> inplace_stop_token {
return __impl_.__stop_source_.get_token();
- }
+ }
- auto request_stop() noexcept -> bool
- {
+ auto request_stop() noexcept -> bool {
return __impl_.__stop_source_.request_stop();
- }
+ }
- private:
- __impl __impl_;
-};
-} // namespace __scope
+ private:
+ __impl __impl_;
+ };
+ } // namespace __scope
-using __scope::async_scope;
+ using __scope::async_scope;
-template <class _AsyncScope, class _Sender>
-using nest_result_t = decltype(stdexec::__declval<_AsyncScope&>().nest(
- stdexec::__declval<_Sender&&>()));
+ template <class _AsyncScope, class _Sender>
+ using nest_result_t = decltype(stdexec::__declval<_AsyncScope&>()
+ .nest(stdexec::__declval<_Sender&&>()));
} // namespace exec
diff --git a/include/sdbusplus/async/stdexec/at_coroutine_exit.hpp b/include/sdbusplus/async/stdexec/at_coroutine_exit.hpp
index 6da8bd5..7817658 100644
--- a/include/sdbusplus/async/stdexec/at_coroutine_exit.hpp
+++ b/include/sdbusplus/async/stdexec/at_coroutine_exit.hpp
@@ -18,287 +18,246 @@
// The original idea is taken from libunifex and adapted to stdexec.
-#include "../stdexec/execution.hpp"
-#include "any_sender_of.hpp"
-#include "inline_scheduler.hpp"
-
#include <exception>
-#include <type_traits>
-namespace exec
-{
-namespace __at_coro_exit
-{
-using namespace stdexec;
+#include "../stdexec/execution.hpp"
-using __any_scheduler = //
- any_receiver_ref< //
- completion_signatures<set_error_t(std::exception_ptr),
- set_stopped_t()>> //
- ::any_sender<>::any_scheduler<>;
+#include "inline_scheduler.hpp"
+#include "any_sender_of.hpp"
-struct __die_on_stop_t
-{
- template <class _Receiver>
- struct __receiver_id
- {
- struct __t
- {
- using receiver_concept = stdexec::receiver_t;
- using __id = __receiver_id;
- _Receiver __receiver_;
+namespace exec {
+ namespace __at_coro_exit {
+ using namespace stdexec;
- template <class... _Args>
- requires __callable<set_value_t, _Receiver, _Args...>
- void set_value(_Args&&... __args) noexcept
- {
- stdexec::set_value(static_cast<_Receiver&&>(__receiver_),
- static_cast<_Args&&>(__args)...);
- }
+ using __any_scheduler = any_receiver_ref<
+ completion_signatures<set_error_t(std::exception_ptr), set_stopped_t()>
+ >::any_sender<>::any_scheduler<>;
- template <class _Error>
- requires __callable<set_error_t, _Receiver, _Error>
- void set_error(_Error&& __err) noexcept
- {
- stdexec::set_error(static_cast<_Receiver&&>(__receiver_),
- static_cast<_Error&&>(__err));
- }
+ struct __die_on_stop_t {
+ template <class _Receiver>
+ struct __receiver_id {
+ struct __t {
+ using receiver_concept = stdexec::receiver_t;
+ using __id = __receiver_id;
+ _Receiver __receiver_;
- [[noreturn]] void set_stopped() noexcept
- {
- std::terminate();
- }
+ template <class... _Args>
+ requires __callable<set_value_t, _Receiver, _Args...>
+ void set_value(_Args&&... __args) noexcept {
+ stdexec::set_value(
+ static_cast<_Receiver&&>(__receiver_), static_cast<_Args&&>(__args)...);
+ }
- auto get_env() const noexcept -> env_of_t<_Receiver>
- {
- return stdexec::get_env(__receiver_);
- }
+ template <class _Error>
+ requires __callable<set_error_t, _Receiver, _Error>
+ void set_error(_Error&& __err) noexcept {
+ stdexec::set_error(static_cast<_Receiver&&>(__receiver_), static_cast<_Error&&>(__err));
+ }
+
+ [[noreturn]]
+ void set_stopped() noexcept {
+ std::terminate();
+ }
+
+ auto get_env() const noexcept -> env_of_t<_Receiver> {
+ return stdexec::get_env(__receiver_);
+ }
};
- };
+ };
- template <class _Rec>
- using __receiver = __t<__receiver_id<_Rec>>;
+ template <class _Rec>
+ using __receiver = __t<__receiver_id<_Rec>>;
- template <class _Sender>
- struct __sender_id
- {
+ template <class _Sender>
+ struct __sender_id {
template <class... _Env>
- using __completion_signatures = //
- __mapply<__mremove<set_stopped_t(), __q<completion_signatures>>,
- __completion_signatures_of_t<_Sender, _Env...>>;
+ using __completion_signatures = __mapply<
+ __mremove<set_stopped_t(), __q<completion_signatures>>,
+ __completion_signatures_of_t<_Sender, _Env...>
+ >;
- struct __t
- {
- using __id = __sender_id;
- using sender_concept = stdexec::sender_t;
+ struct __t {
+ using __id = __sender_id;
+ using sender_concept = stdexec::sender_t;
- _Sender __sender_;
+ _Sender __sender_;
- template <receiver _Receiver>
- requires sender_to<_Sender, __receiver<_Receiver>>
- auto connect(_Receiver __rcvr) && noexcept
- -> connect_result_t<_Sender, __receiver<_Receiver>>
- {
- return stdexec::connect(
- static_cast<_Sender&&>(__sender_),
- __receiver<_Receiver>{static_cast<_Receiver&&>(__rcvr)});
- }
+ template <receiver _Receiver>
+ requires sender_to<_Sender, __receiver<_Receiver>>
+ auto connect(_Receiver __rcvr) && noexcept
+ -> connect_result_t<_Sender, __receiver<_Receiver>> {
+ return stdexec::connect(
+ static_cast<_Sender&&>(__sender_),
+ __receiver<_Receiver>{static_cast<_Receiver&&>(__rcvr)});
+ }
- template <class... _Env>
- auto get_completion_signatures(_Env&&...)
- -> __completion_signatures<_Env...>
- {
- return {};
- }
+ template <class... _Env>
+ auto get_completion_signatures(_Env&&...) -> __completion_signatures<_Env...> {
+ return {};
+ }
- auto get_env() const noexcept -> env_of_t<_Sender>
- {
- return stdexec::get_env(__sender_);
- }
+ auto get_env() const noexcept -> env_of_t<_Sender> {
+ return stdexec::get_env(__sender_);
+ }
};
- };
- template <class _Sender>
- using __sender = __t<__sender_id<__decay_t<_Sender>>>;
+ };
+ template <class _Sender>
+ using __sender = __t<__sender_id<__decay_t<_Sender>>>;
- template <sender _Sender>
- auto operator()(_Sender&& __sndr) const
- noexcept(__nothrow_decay_copyable<_Sender>) -> __sender<_Sender>
- {
+ template <sender _Sender>
+ auto operator()(_Sender&& __sndr) const noexcept(__nothrow_decay_copyable<_Sender>)
+ -> __sender<_Sender> {
return __sender<_Sender>{static_cast<_Sender&&>(__sndr)};
- }
+ }
- template <class _Value>
- auto operator()(_Value&& __value) const noexcept -> _Value&&
- {
+ template <class _Value>
+ auto operator()(_Value&& __value) const noexcept -> _Value&& {
return static_cast<_Value&&>(__value);
- }
-};
-
-inline constexpr __die_on_stop_t __die_on_stop;
-
-template <class _Promise>
-concept __has_continuation = //
- requires(_Promise& __promise, __continuation_handle<> __c) {
- { __promise.continuation() } -> convertible_to<__continuation_handle<>>;
- { __promise.set_continuation(__c) };
+ }
};
-template <class... _Ts>
-class [[nodiscard]] __task
-{
- struct __promise;
+ inline constexpr __die_on_stop_t __die_on_stop;
- public:
- using promise_type = __promise;
+ template <class _Promise>
+ concept __has_continuation = requires(_Promise& __promise, __coroutine_handle<> __c) {
+ { __promise.continuation() } -> convertible_to<__coroutine_handle<>>;
+ { __promise.set_continuation(__c) };
+ };
+
+ template <class... _Ts>
+ class [[nodiscard]] __task {
+ struct __promise;
+ public:
+ using promise_type = __promise;
#if STDEXEC_EDG()
- __task(__coro::coroutine_handle<__promise> __coro) noexcept :
- __coro_(__coro)
- {}
+ __task(__coro::coroutine_handle<__promise> __coro) noexcept
+ : __coro_(__coro) {
+ }
#else
- explicit __task(__coro::coroutine_handle<__promise> __coro) noexcept :
- __coro_(__coro)
- {}
+ explicit __task(__coro::coroutine_handle<__promise> __coro) noexcept
+ : __coro_(__coro) {
+ }
#endif
- __task(__task&& __that) noexcept :
- __coro_(std::exchange(__that.__coro_, {}))
- {}
+ __task(__task&& __that) noexcept
+ : __coro_(std::exchange(__that.__coro_, {})) {
+ }
- [[nodiscard]] auto await_ready() const noexcept -> bool
- {
+ [[nodiscard]]
+ auto await_ready() const noexcept -> bool {
return false;
- }
+ }
- template <__has_continuation _Promise>
- auto await_suspend(__coro::coroutine_handle<_Promise> __parent) noexcept
- -> bool
- {
- __coro_.promise().__scheduler_ =
- get_scheduler(get_env(__parent.promise()));
+ template <__has_continuation _Promise>
+ auto await_suspend(__coro::coroutine_handle<_Promise> __parent) noexcept -> bool {
+ __coro_.promise().__scheduler_ = get_scheduler(get_env(__parent.promise()));
__coro_.promise().set_continuation(__parent.promise().continuation());
__parent.promise().set_continuation(__coro_);
return false;
- }
+ }
- auto await_resume() noexcept -> std::tuple<_Ts&...>
- {
+ auto await_resume() noexcept -> std::tuple<_Ts&...> {
return std::exchange(__coro_, {}).promise().__args_;
- }
+ }
- private:
- struct __final_awaitable
- {
- static constexpr auto await_ready() noexcept -> bool
- {
- return false;
+ private:
+ struct __final_awaitable {
+ static constexpr auto await_ready() noexcept -> bool {
+ return false;
}
- static auto await_suspend(
- __coro::coroutine_handle<__promise> __h) noexcept
- -> __coro::coroutine_handle<>
- {
- __promise& __p = __h.promise();
- auto __coro = __p.__is_unhandled_stopped_
- ? __p.continuation().unhandled_stopped()
- : __p.continuation().handle();
- return STDEXEC_DESTROY_AND_CONTINUE(__h, __coro);
+ static auto await_suspend(__coro::coroutine_handle<__promise> __h) noexcept
+ -> __coro::coroutine_handle<> {
+ __promise& __p = __h.promise();
+ auto __coro = __p.__is_unhandled_stopped_ ? __p.continuation().unhandled_stopped()
+ : __p.continuation().handle();
+ return STDEXEC_DESTROY_AND_CONTINUE(__h, __coro);
}
- void await_resume() const noexcept {}
- };
+ void await_resume() const noexcept {
+ }
+ };
- struct __env
- {
+ struct __env {
const __promise& __promise_;
- auto query(get_scheduler_t) const noexcept -> __any_scheduler
- {
- return __promise_.__scheduler_;
+ [[nodiscard]]
+ auto query(get_scheduler_t) const noexcept -> __any_scheduler {
+ return __promise_.__scheduler_;
}
- };
+ };
- struct __promise : with_awaitable_senders<__promise>
- {
+ struct __promise : with_awaitable_senders<__promise> {
#if STDEXEC_EDG()
template <class _Action>
- __promise(_Action&&, _Ts&&... __ts) noexcept : __args_{__ts...}
- {}
+ __promise(_Action&&, _Ts&&... __ts) noexcept
+ : __args_{__ts...} {
+ }
#else
template <class _Action>
- explicit __promise(_Action&&, _Ts&... __ts) noexcept : __args_{__ts...}
- {}
+ explicit __promise(_Action&&, _Ts&... __ts) noexcept
+ : __args_{__ts...} {
+ }
#endif
- auto initial_suspend() noexcept -> __coro::suspend_always
- {
- return {};
+ auto initial_suspend() noexcept -> __coro::suspend_always {
+ return {};
}
- auto final_suspend() noexcept -> __final_awaitable
- {
- return {};
+ auto final_suspend() noexcept -> __final_awaitable {
+ return {};
}
- void return_void() noexcept {}
-
- [[noreturn]] void unhandled_exception() noexcept
- {
- std::terminate();
+ void return_void() noexcept {
}
- auto unhandled_stopped() noexcept -> __coro::coroutine_handle<__promise>
- {
- __is_unhandled_stopped_ = true;
- return __coro::coroutine_handle<__promise>::from_promise(*this);
+ [[noreturn]]
+ void unhandled_exception() noexcept {
+ std::terminate();
}
- auto get_return_object() noexcept -> __task
- {
- return __task(
- __coro::coroutine_handle<__promise>::from_promise(*this));
+ auto unhandled_stopped() noexcept -> __coro::coroutine_handle<__promise> {
+ __is_unhandled_stopped_ = true;
+ return __coro::coroutine_handle<__promise>::from_promise(*this);
+ }
+
+ auto get_return_object() noexcept -> __task {
+ return __task(__coro::coroutine_handle<__promise>::from_promise(*this));
}
template <class _Awaitable>
- auto await_transform(_Awaitable&& __awaitable) noexcept
- -> decltype(auto)
- {
- return as_awaitable(
- __die_on_stop(static_cast<_Awaitable&&>(__awaitable)), *this);
+ auto await_transform(_Awaitable&& __awaitable) noexcept -> decltype(auto) {
+ return as_awaitable(__die_on_stop(static_cast<_Awaitable&&>(__awaitable)), *this);
}
- auto get_env() const noexcept -> __env
- {
- return {*this};
+ auto get_env() const noexcept -> __env {
+ return {*this};
}
bool __is_unhandled_stopped_{false};
std::tuple<_Ts&...> __args_{};
- __any_scheduler __scheduler_{inline_scheduler{}};
+ __any_scheduler __scheduler_{stdexec::inline_scheduler{}};
+ };
+
+ __coro::coroutine_handle<__promise> __coro_;
};
- __coro::coroutine_handle<__promise> __coro_;
-};
-
-struct __at_coro_exit_t
-{
- private:
- template <class _Action, class... _Ts>
- static auto __impl(_Action __action, _Ts... __ts) -> __task<_Ts...>
- {
+ struct __at_coro_exit_t {
+ private:
+ template <class _Action, class... _Ts>
+ static auto __impl(_Action __action, _Ts... __ts) -> __task<_Ts...> {
co_await static_cast<_Action&&>(__action)(static_cast<_Ts&&>(__ts)...);
- }
+ }
- public:
- template <class _Action, class... _Ts>
+ public:
+ template <class _Action, class... _Ts>
requires __callable<__decay_t<_Action>, __decay_t<_Ts>...>
- auto operator()(_Action&& __action, _Ts&&... __ts) const -> __task<_Ts...>
- {
- return __impl(static_cast<_Action&&>(__action),
- static_cast<_Ts&&>(__ts)...);
- }
-};
-} // namespace __at_coro_exit
+ auto operator()(_Action&& __action, _Ts&&... __ts) const -> __task<_Ts...> {
+ return __impl(static_cast<_Action&&>(__action), static_cast<_Ts&&>(__ts)...);
+ }
+ };
+ } // namespace __at_coro_exit
-inline constexpr __at_coro_exit::__at_coro_exit_t at_coroutine_exit{};
+ inline constexpr __at_coro_exit::__at_coro_exit_t at_coroutine_exit{};
} // namespace exec
diff --git a/include/sdbusplus/async/stdexec/commit.info b/include/sdbusplus/async/stdexec/commit.info
index 349afcb..ccc0d8e 100644
--- a/include/sdbusplus/async/stdexec/commit.info
+++ b/include/sdbusplus/async/stdexec/commit.info
@@ -1 +1 @@
-c3f90d40a3d4a596e44cc115e2249a2eeb6fcde0
+7fed34ce2139454eef1cbd9cb05f10b5a8ec1a2e
diff --git a/include/sdbusplus/async/stdexec/concepts.hpp b/include/sdbusplus/async/stdexec/concepts.hpp
index 3ece504..cd6c9c2 100644
--- a/include/sdbusplus/async/stdexec/concepts.hpp
+++ b/include/sdbusplus/async/stdexec/concepts.hpp
@@ -15,4 +15,4 @@
*/
#pragma once
-#include "__detail/__concepts.hpp"
+#include "__detail/__concepts.hpp" // IWYU pragma: export
diff --git a/include/sdbusplus/async/stdexec/coroutine.hpp b/include/sdbusplus/async/stdexec/coroutine.hpp
index 2835332..8279b69 100644
--- a/include/sdbusplus/async/stdexec/coroutine.hpp
+++ b/include/sdbusplus/async/stdexec/coroutine.hpp
@@ -15,130 +15,106 @@
*/
#pragma once
-#include "__detail/__awaitable.hpp"
+#include "__detail/__awaitable.hpp" // IWYU pragma: export
#include "__detail/__config.hpp"
-#if STDEXEC_MSVC() && _MSC_VER <= 1939
-namespace stdexec
-{
-// MSVCBUG
-// https://developercommunity.visualstudio.com/t/destroy-coroutine-from-final_suspend-r/10096047
+#if STDEXEC_MSVC() && STDEXEC_MSVC_VERSION <= 19'39
+namespace stdexec {
+ // MSVCBUG https://developercommunity.visualstudio.com/t/destroy-coroutine-from-final_suspend-r/10096047
-// Prior to Visual Studio 17.9 (Feb, 2024), aka MSVC 19.39, MSVC incorrectly
-// allocates the return buffer for await_suspend calls within the suspended
-// coroutine frame. When the suspended coroutine is destroyed within
-// await_suspend, the continuation coroutine handle is not only used after free,
-// but also overwritten by the debug malloc implementation when NRVO is in play.
+ // Prior to Visual Studio 17.9 (Feb, 2024), aka MSVC 19.39, MSVC incorrectly allocates the return
+ // buffer for await_suspend calls within the suspended coroutine frame. When the suspended
+ // coroutine is destroyed within await_suspend, the continuation coroutine handle is not only used
+ // after free, but also overwritten by the debug malloc implementation when NRVO is in play.
-// This workaround delays the destruction of the suspended coroutine by wrapping
-// the continuation in another coroutine which destroys the former and transfers
-// execution to the original continuation.
+ // This workaround delays the destruction of the suspended coroutine by wrapping the continuation
+ // in another coroutine which destroys the former and transfers execution to the original
+ // continuation.
-// The wrapping coroutine is thread-local and is reused within the thread for
-// each destroy-and-continue sequence. The wrapping coroutine itself is
-// destroyed at thread exit.
+ // The wrapping coroutine is thread-local and is reused within the thread for each
+ // destroy-and-continue sequence. The wrapping coroutine itself is destroyed at thread exit.
-namespace __destroy_and_continue_msvc
-{
-struct __task
-{
- struct promise_type
- {
- __task get_return_object() noexcept
- {
- return {
- __coro::coroutine_handle<promise_type>::from_promise(*this)};
+ namespace __destroy_and_continue_msvc {
+ struct __task {
+ struct promise_type {
+ __task get_return_object() noexcept {
+ return {__coro::coroutine_handle<promise_type>::from_promise(*this)};
}
- static std::suspend_never initial_suspend() noexcept
- {
- return {};
+ static std::suspend_never initial_suspend() noexcept {
+ return {};
}
- static std::suspend_never final_suspend() noexcept
- {
- STDEXEC_ASSERT(!"Should never get here");
- return {};
+ static std::suspend_never final_suspend() noexcept {
+ STDEXEC_ASSERT(!"Should never get here");
+ return {};
}
- static void return_void() noexcept
- {
- STDEXEC_ASSERT(!"Should never get here");
+ static void return_void() noexcept {
+ STDEXEC_ASSERT(!"Should never get here");
}
- static void unhandled_exception() noexcept
- {
- STDEXEC_ASSERT(!"Should never get here");
+ static void unhandled_exception() noexcept {
+ STDEXEC_ASSERT(!"Should never get here");
}
+ };
+
+ __coro::coroutine_handle<> __coro_;
};
- __coro::coroutine_handle<> __coro_;
-};
-
-struct __continue_t
-{
- static constexpr bool await_ready() noexcept
- {
+ struct __continue_t {
+ static constexpr bool await_ready() noexcept {
return false;
- }
+ }
- __coro::coroutine_handle<> await_suspend(
- __coro::coroutine_handle<>) noexcept
- {
+ __coro::coroutine_handle<> await_suspend(__coro::coroutine_handle<>) noexcept {
return __continue_;
- }
+ }
- static void await_resume() noexcept {}
+ static void await_resume() noexcept {
+ }
- __coro::coroutine_handle<> __continue_;
-};
+ __coro::coroutine_handle<> __continue_;
+ };
-struct __context
-{
- __coro::coroutine_handle<> __destroy_;
- __coro::coroutine_handle<> __continue_;
-};
+ struct __context {
+ __coro::coroutine_handle<> __destroy_;
+ __coro::coroutine_handle<> __continue_;
+ };
-inline __task __co_impl(__context& __c)
-{
- while (true)
- {
+ inline __task __co_impl(__context& __c) {
+ while (true) {
co_await __continue_t{__c.__continue_};
__c.__destroy_.destroy();
+ }
}
-}
-struct __context_and_coro
-{
- __context_and_coro()
- {
+ struct __context_and_coro {
+ __context_and_coro() {
__context_.__continue_ = __coro::noop_coroutine();
__coro_ = __co_impl(__context_).__coro_;
- }
+ }
- ~__context_and_coro()
- {
+ ~__context_and_coro() {
__coro_.destroy();
+ }
+
+ __context __context_;
+ __coro::coroutine_handle<> __coro_;
+ };
+
+ inline __coro::coroutine_handle<>
+ __impl(__coro::coroutine_handle<> __destroy, __coro::coroutine_handle<> __continue) {
+ static thread_local __context_and_coro __c;
+ __c.__context_.__destroy_ = __destroy;
+ __c.__context_.__continue_ = __continue;
+ return __c.__coro_;
}
-
- __context __context_;
- __coro::coroutine_handle<> __coro_;
-};
-
-inline __coro::coroutine_handle<> __impl(__coro::coroutine_handle<> __destroy,
- __coro::coroutine_handle<> __continue)
-{
- static thread_local __context_and_coro __c;
- __c.__context_.__destroy_ = __destroy;
- __c.__context_.__continue_ = __continue;
- return __c.__coro_;
-}
-} // namespace __destroy_and_continue_msvc
+ } // namespace __destroy_and_continue_msvc
} // namespace stdexec
-#define STDEXEC_DESTROY_AND_CONTINUE(__destroy, __continue) \
+# define STDEXEC_DESTROY_AND_CONTINUE(__destroy, __continue) \
(::stdexec::__destroy_and_continue_msvc::__impl(__destroy, __continue))
#else
-#define STDEXEC_DESTROY_AND_CONTINUE(__destroy, __continue) \
- (__destroy.destroy(), __continue)
+# define STDEXEC_DESTROY_AND_CONTINUE(__destroy, __continue) (__destroy.destroy(), __continue)
#endif
diff --git a/include/sdbusplus/async/stdexec/env.hpp b/include/sdbusplus/async/stdexec/env.hpp
index 27590f2..32d8037 100644
--- a/include/sdbusplus/async/stdexec/env.hpp
+++ b/include/sdbusplus/async/stdexec/env.hpp
@@ -20,159 +20,196 @@
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_EDG(1302)
-namespace exec
-{
-template <class _Tag, class _Value>
-using with_t = stdexec::prop<_Tag, _Value>;
+namespace exec {
+ template <class _Tag, class _Value>
+ using with_t = stdexec::prop<_Tag, _Value>;
-namespace __envs
-{
-struct __with_t
-{
- template <class _Tag, class _Value>
- auto operator()(_Tag, _Value&& __val) const
- {
+ namespace __envs {
+ struct __with_t {
+ template <class _Tag, class _Value>
+ constexpr auto operator()(_Tag, _Value&& __val) const {
return stdexec::prop{_Tag(), static_cast<_Value&&>(__val)};
- }
-};
+ }
+ };
-struct __without_t
-{
- template <class _Env, class _Tag>
- auto operator()(_Env&& __env, _Tag) const -> decltype(auto)
- {
+ struct __without_t {
+ template <class _Env, class _Tag>
+ constexpr auto operator()(_Env&& __env, _Tag) const -> decltype(auto) {
return stdexec::__env::__without(static_cast<_Env&&>(__env), _Tag());
- }
-};
+ }
+ };
-// For making an environment from key/value pairs and optionally
-// another environment.
-struct __make_env_t
-{
- template <stdexec::__nothrow_move_constructible _Base,
- stdexec::__nothrow_move_constructible _Env>
- auto operator()(_Base&& __base, _Env&& __env) const noexcept
- -> stdexec::__env::__join_t<_Env, _Base>
- {
- return stdexec::__env::__join(static_cast<_Env&&>(__env),
- static_cast<_Base&&>(__base));
- }
+ // For making an environment from key/value pairs and optionally
+ // another environment.
+ struct __make_env_t {
+ template <
+ stdexec::__nothrow_move_constructible _Base,
+ stdexec::__nothrow_move_constructible _Env
+ >
+ constexpr auto operator()(_Base&& __base, _Env&& __env) const noexcept
+ -> stdexec::__join_env_t<_Env, _Base> {
+ return stdexec::__env::__join(static_cast<_Env&&>(__env), static_cast<_Base&&>(__base));
+ }
- template <stdexec::__nothrow_move_constructible _Env>
- auto operator()(_Env&& __env) const noexcept -> _Env
- {
+ template <stdexec::__nothrow_move_constructible _Env>
+ constexpr auto operator()(_Env&& __env) const noexcept -> _Env {
return static_cast<_Env&&>(__env);
- }
-};
-} // namespace __envs
+ }
+ };
+ } // namespace __envs
-inline constexpr __envs::__with_t with{};
-inline constexpr __envs::__without_t without{};
-inline constexpr __envs::__make_env_t make_env{};
+ inline constexpr __envs::__with_t with{};
+ inline constexpr __envs::__without_t without{};
+ inline constexpr __envs::__make_env_t make_env{};
-template <class... _Ts>
-using make_env_t = stdexec::__result_of<make_env, _Ts...>;
+ template <class... _Ts>
+ using make_env_t = stdexec::__result_of<make_env, _Ts...>;
-namespace __read_with_default
-{
-using namespace stdexec;
+ namespace __read_with_default {
+ using namespace stdexec;
-struct read_with_default_t;
+ struct read_with_default_t;
-template <class _Tag, class _DefaultId, class _ReceiverId>
-struct __operation
-{
- using _Default = stdexec::__t<_DefaultId>;
- using _Receiver = stdexec::__t<_ReceiverId>;
+ template <class _Tag, class _DefaultId, class _ReceiverId>
+ struct __operation {
+ using _Default = stdexec::__t<_DefaultId>;
+ using _Receiver = stdexec::__t<_ReceiverId>;
- struct __t : __immovable
- {
+ struct __t : __immovable {
using __id = __operation;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Default __default_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Default __default_;
_Receiver __rcvr_;
- void start() & noexcept
- {
- try
- {
- if constexpr (__callable<_Tag, env_of_t<_Receiver>>)
- {
- const auto& __env = get_env(__rcvr_);
- stdexec::set_value(std::move(__rcvr_), _Tag{}(__env));
- }
- else
- {
- stdexec::set_value(std::move(__rcvr_),
- std::move(__default_));
- }
+ constexpr void start() & noexcept {
+ STDEXEC_TRY {
+ if constexpr (__callable<_Tag, env_of_t<_Receiver>>) {
+ const auto& __env = get_env(__rcvr_);
+ stdexec::set_value(std::move(__rcvr_), _Tag{}(__env));
+ } else {
+ stdexec::set_value(std::move(__rcvr_), std::move(__default_));
}
- catch (...)
- {
- stdexec::set_error(std::move(__rcvr_),
- std::current_exception());
- }
+ }
+ STDEXEC_CATCH_ALL {
+ stdexec::set_error(std::move(__rcvr_), std::current_exception());
+ }
}
+ };
};
-};
-template <class _Tag, class _Default, class _Receiver>
-using __operation_t = __t<__operation<_Tag, __id<_Default>, __id<_Receiver>>>;
+ template <class _Tag, class _Default, class _Receiver>
+ using __operation_t = __t<__operation<_Tag, __id<_Default>, __id<_Receiver>>>;
-template <class _Tag, class _Default>
-struct __sender
-{
- using __id = __sender;
- using __t = __sender;
- using sender_concept = stdexec::sender_t;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Default __default_;
-
- template <class _Env>
- using __value_t = __minvoke<
- __with_default<__mbind_back_q<__call_result_t, _Env>, _Default>, _Tag>;
- template <class _Env>
- using __default_t = __if_c<__callable<_Tag, _Env>, __ignore, _Default>;
-
- template <class _Env>
- using __completions_t =
- completion_signatures<set_value_t(__value_t<_Env>),
- set_error_t(std::exception_ptr)>;
-
- template <__decays_to<__sender> _Self, class _Receiver>
- requires receiver_of<_Receiver, __completions_t<env_of_t<_Receiver>>>
- static auto connect(_Self&& __self, _Receiver __rcvr) //
- noexcept(std::is_nothrow_move_constructible_v<_Receiver>)
- -> __operation_t<_Tag, __default_t<env_of_t<_Receiver>>, _Receiver>
- {
- return {{},
- static_cast<_Self&&>(__self).__default_,
- static_cast<_Receiver&&>(__rcvr)};
- }
-
- template <class _Env>
- auto get_completion_signatures(_Env&&) -> __completions_t<_Env>
- {
- return {};
- }
-};
-
-struct __read_with_default_t
-{
template <class _Tag, class _Default>
- constexpr auto operator()(_Tag, _Default&& __default) const
- -> __sender<_Tag, __decay_t<_Default>>
- {
+ struct __sender {
+ using __id = __sender;
+ using __t = __sender;
+ using sender_concept = stdexec::sender_t;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Default __default_;
+
+ template <class _Env>
+ using __value_t =
+ __minvoke<__with_default<__mbind_back_q<__call_result_t, _Env>, _Default>, _Tag>;
+ template <class _Env>
+ using __default_t = __if_c<__callable<_Tag, _Env>, __ignore, _Default>;
+
+ template <class _Env>
+ using __completions_t =
+ completion_signatures<set_value_t(__value_t<_Env>), set_error_t(std::exception_ptr)>;
+
+ template <__decays_to<__sender> _Self, class _Receiver>
+ requires receiver_of<_Receiver, __completions_t<env_of_t<_Receiver>>>
+ static constexpr auto connect(_Self&& __self, _Receiver __rcvr)
+ noexcept(std::is_nothrow_move_constructible_v<_Receiver>)
+ -> __operation_t<_Tag, __default_t<env_of_t<_Receiver>>, _Receiver> {
+ return {{}, static_cast<_Self&&>(__self).__default_, static_cast<_Receiver&&>(__rcvr)};
+ }
+
+ template <class _Env>
+ constexpr auto get_completion_signatures(_Env&&) -> __completions_t<_Env> {
+ return {};
+ }
+ };
+
+ struct __read_with_default_t {
+ template <class _Tag, class _Default>
+ constexpr auto
+ operator()(_Tag, _Default&& __default) const -> __sender<_Tag, __decay_t<_Default>> {
return {static_cast<_Default&&>(__default)};
- }
-};
-} // namespace __read_with_default
+ }
+ };
+ } // namespace __read_with_default
-inline constexpr __read_with_default::__read_with_default_t read_with_default{};
+ inline constexpr __read_with_default::__read_with_default_t read_with_default{};
-inline constexpr stdexec::__write_::__write_env_t write{};
-inline constexpr stdexec::__write_::__write_env_t write_env{};
+ [[deprecated("exec::write has been renamed to stdexec::write_env")]]
+ inline constexpr stdexec::__write::write_env_t write{};
+ [[deprecated("write_env has been moved to the stdexec:: namespace")]]
+ inline constexpr stdexec::__write::write_env_t write_env{};
+
+ namespace __write_attrs {
+ using namespace stdexec;
+
+ template <class _SenderId, class _Attrs>
+ struct __sender {
+ using _Sender = stdexec::__t<_SenderId>;
+
+ struct __t {
+ using sender_concept = sender_t;
+ using __id = __sender;
+ _Sender __sndr_;
+ _Attrs __attrs_;
+
+ constexpr auto get_env() const noexcept -> __join_env_t<const _Attrs&, env_of_t<_Sender>> {
+ return stdexec::__env::__join(__attrs_, stdexec::get_env(__sndr_));
+ }
+
+ template <__decays_to<__t> _Self, class... _Env>
+ static constexpr auto get_completion_signatures(_Self&&, _Env&&...)
+ -> completion_signatures_of_t<__copy_cvref_t<_Self, _Sender>, _Env...> {
+ return {};
+ }
+
+ template <__decays_to<__t> _Self, class _Receiver>
+ requires sender_in<__copy_cvref_t<_Self, _Sender>, env_of_t<_Receiver>>
+ static constexpr auto connect(_Self&& __self, _Receiver __rcvr)
+ -> connect_result_t<__copy_cvref_t<_Self, _Sender>, _Receiver> {
+ return stdexec::connect(std::forward<_Self>(__self).__sndr_, std::move(__rcvr));
+ }
+ };
+ };
+
+ struct __write_attrs_t {
+ template <class _Sender, class _Attrs>
+ STDEXEC_ATTRIBUTE(host, device)
+ constexpr auto
+ operator()(_Sender snd, _Attrs __attrs_) const -> __write_attrs::__sender<_Sender, _Attrs> {
+ return __t<__write_attrs::__sender<__id<_Sender>, _Attrs>>{
+ static_cast<_Sender&&>(snd), static_cast<_Attrs&&>(__attrs_)};
+ }
+
+ template <class _Attrs>
+ struct __closure {
+ _Attrs __attrs_;
+
+ template <class _Sender>
+ STDEXEC_ATTRIBUTE(host, device)
+ friend constexpr auto operator|(_Sender __sndr_, __closure _clsr) {
+ return __t<__write_attrs::__sender<__id<_Sender>, _Attrs>>{
+ static_cast<_Sender&&>(__sndr_), static_cast<_Attrs&&>(_clsr.__attrs_)};
+ }
+ };
+
+ template <class _Attrs>
+ STDEXEC_ATTRIBUTE(host, device)
+ constexpr auto operator()(_Attrs __attrs_) const {
+ return __closure<_Attrs>{static_cast<_Attrs&&>(__attrs_)};
+ }
+ };
+ } // namespace __write_attrs
+
+ inline constexpr __write_attrs::__write_attrs_t write_attrs{};
+
} // namespace exec
STDEXEC_PRAGMA_POP()
diff --git a/include/sdbusplus/async/stdexec/execution.hpp b/include/sdbusplus/async/stdexec/execution.hpp
index 65956d4..6f282bb 100644
--- a/include/sdbusplus/async/stdexec/execution.hpp
+++ b/include/sdbusplus/async/stdexec/execution.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021-2024 NVIDIA Corporation
+ * Copyright (c) 2025 NVIDIA Corporation
*
* Licensed under the Apache License Version 2.0 with LLVM Exceptions
* (the "License"); you may not use this file except in compliance with
@@ -18,59 +18,63 @@
#include "__detail/__execution_fwd.hpp"
// include these after __execution_fwd.hpp
-#include "__detail/__as_awaitable.hpp"
-#include "__detail/__basic_sender.hpp"
-#include "__detail/__bulk.hpp"
-#include "__detail/__completion_signatures.hpp"
-#include "__detail/__connect_awaitable.hpp"
-#include "__detail/__continues_on.hpp"
-#include "__detail/__cpo.hpp"
-#include "__detail/__debug.hpp"
-#include "__detail/__domain.hpp"
-#include "__detail/__ensure_started.hpp"
-#include "__detail/__env.hpp"
-#include "__detail/__execute.hpp"
-#include "__detail/__inline_scheduler.hpp"
-#include "__detail/__into_variant.hpp"
-#include "__detail/__intrusive_ptr.hpp"
-#include "__detail/__intrusive_slist.hpp"
-#include "__detail/__just.hpp"
-#include "__detail/__let.hpp"
-#include "__detail/__meta.hpp"
-#include "__detail/__on.hpp"
-#include "__detail/__operation_states.hpp"
-#include "__detail/__read_env.hpp"
-#include "__detail/__receiver_adaptor.hpp"
-#include "__detail/__receivers.hpp"
-#include "__detail/__run_loop.hpp"
-#include "__detail/__schedule_from.hpp"
-#include "__detail/__schedulers.hpp"
-#include "__detail/__sender_adaptor_closure.hpp"
-#include "__detail/__senders.hpp"
-#include "__detail/__split.hpp"
-#include "__detail/__start_detached.hpp"
-#include "__detail/__starts_on.hpp"
-#include "__detail/__stopped_as_error.hpp"
-#include "__detail/__stopped_as_optional.hpp"
-#include "__detail/__submit.hpp"
-#include "__detail/__sync_wait.hpp"
-#include "__detail/__then.hpp"
-#include "__detail/__transfer_just.hpp"
-#include "__detail/__transform_completion_signatures.hpp"
-#include "__detail/__transform_sender.hpp"
-#include "__detail/__type_traits.hpp"
-#include "__detail/__upon_error.hpp"
-#include "__detail/__upon_stopped.hpp"
-#include "__detail/__utility.hpp"
-#include "__detail/__when_all.hpp"
-#include "__detail/__with_awaitable_senders.hpp"
-#include "__detail/__write_env.hpp"
-#include "concepts.hpp"
-#include "coroutine.hpp"
-#include "functional.hpp"
-#include "stop_token.hpp"
+#include "__detail/__as_awaitable.hpp" // IWYU pragma: export
+#include "__detail/__basic_sender.hpp" // IWYU pragma: export
+#include "__detail/__bulk.hpp" // IWYU pragma: export
+#include "__detail/__completion_signatures.hpp" // IWYU pragma: export
+#include "__detail/__connect_awaitable.hpp" // IWYU pragma: export
+#include "__detail/__continues_on.hpp" // IWYU pragma: export
+#include "__detail/__cpo.hpp" // IWYU pragma: export
+#include "__detail/__debug.hpp" // IWYU pragma: export
+#include "__detail/__domain.hpp" // IWYU pragma: export
+#include "__detail/__ensure_started.hpp" // IWYU pragma: export
+#include "__detail/__env.hpp" // IWYU pragma: export
+#include "__detail/__execute.hpp" // IWYU pragma: export
+#include "__detail/__execution_legacy.hpp" // IWYU pragma: export
+#include "__detail/__inline_scheduler.hpp" // IWYU pragma: export
+#include "__detail/__into_variant.hpp" // IWYU pragma: export
+#include "__detail/__intrusive_ptr.hpp" // IWYU pragma: export
+#include "__detail/__intrusive_slist.hpp" // IWYU pragma: export
+#include "__detail/__just.hpp" // IWYU pragma: export
+#include "__detail/__let.hpp" // IWYU pragma: export
+#include "__detail/__meta.hpp" // IWYU pragma: export
+#include "__detail/__on.hpp" // IWYU pragma: export
+#include "__detail/__operation_states.hpp" // IWYU pragma: export
+#include "__detail/__read_env.hpp" // IWYU pragma: export
+#include "__detail/__receivers.hpp" // IWYU pragma: export
+#include "__detail/__receiver_adaptor.hpp" // IWYU pragma: export
+#include "__detail/__receiver_ref.hpp" // IWYU pragma: export
+#include "__detail/__run_loop.hpp" // IWYU pragma: export
+#include "__detail/__schedule_from.hpp" // IWYU pragma: export
+#include "__detail/__schedulers.hpp" // IWYU pragma: export
+#include "__detail/__senders.hpp" // IWYU pragma: export
+#include "__detail/__sender_adaptor_closure.hpp" // IWYU pragma: export
+#include "__detail/__split.hpp" // IWYU pragma: export
+#include "__detail/__start_detached.hpp" // IWYU pragma: export
+#include "__detail/__starts_on.hpp" // IWYU pragma: export
+#include "__detail/__stopped_as_error.hpp" // IWYU pragma: export
+#include "__detail/__stopped_as_optional.hpp" // IWYU pragma: export
+#include "__detail/__submit.hpp" // IWYU pragma: export
+#include "__detail/__sync_wait.hpp" // IWYU pragma: export
+#include "__detail/__then.hpp" // IWYU pragma: export
+#include "__detail/__transfer_just.hpp" // IWYU pragma: export
+#include "__detail/__transform_sender.hpp" // IWYU pragma: export
+#include "__detail/__transform_completion_signatures.hpp" // IWYU pragma: export
+#include "__detail/__type_traits.hpp" // IWYU pragma: export
+#include "__detail/__upon_error.hpp" // IWYU pragma: export
+#include "__detail/__upon_stopped.hpp" // IWYU pragma: export
+#include "__detail/__unstoppable.hpp" // IWYU pragma: export
+#include "__detail/__utility.hpp" // IWYU pragma: export
+#include "__detail/__when_all.hpp" // IWYU pragma: export
+#include "__detail/__with_awaitable_senders.hpp" // IWYU pragma: export
+#include "__detail/__write_env.hpp" // IWYU pragma: export
+
+#include "functional.hpp" // IWYU pragma: export
+#include "concepts.hpp" // IWYU pragma: export
+#include "coroutine.hpp" // IWYU pragma: export
+#include "stop_token.hpp" // IWYU pragma: export
// For issuing a meaningful diagnostic for the erroneous `snd1 | snd2`.
template <stdexec::sender _Ignore, stdexec::sender _Sender>
- requires stdexec::__ok<stdexec::__bad_pipe_sink_t<_Sender>>
+ requires stdexec::__ok<stdexec::__bad_pipe_sink_t<_Sender>>
auto operator|(_Ignore&&, _Sender&&) noexcept;
diff --git a/include/sdbusplus/async/stdexec/functional.hpp b/include/sdbusplus/async/stdexec/functional.hpp
index b39bbaa..f8af702 100644
--- a/include/sdbusplus/async/stdexec/functional.hpp
+++ b/include/sdbusplus/async/stdexec/functional.hpp
@@ -17,325 +17,227 @@
#include "__detail/__config.hpp"
#include "__detail/__meta.hpp"
-#include "__detail/__tag_invoke.hpp"
-#include "concepts.hpp"
-#include <cstddef>
+#include "concepts.hpp" // IWYU pragma: keep
+
#include <functional>
#include <tuple>
#include <type_traits>
+#include <cstddef>
-namespace stdexec
-{
-template <class _Fun0, class _Fun1>
-struct __composed
-{
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fun0 __t0_;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fun1 __t1_;
+namespace stdexec {
+ template <class _Fun0, class _Fun1>
+ struct __composed {
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fun0 __t0_;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fun1 __t1_;
template <class... _Ts>
- requires __callable<_Fun1, _Ts...> &&
- __callable<_Fun0, __call_result_t<_Fun1, _Ts...>>
- STDEXEC_ATTRIBUTE((always_inline))
- __call_result_t<_Fun0, __call_result_t<_Fun1, _Ts...>> operator()(
- _Ts&&... __ts) &&
- {
- return static_cast<_Fun0&&>(__t0_)(
- static_cast<_Fun1&&>(__t1_)(static_cast<_Ts&&>(__ts)...));
+ requires __callable<_Fun1, _Ts...> && __callable<_Fun0, __call_result_t<_Fun1, _Ts...>>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_Ts&&... __ts) && -> __call_result_t<_Fun0, __call_result_t<_Fun1, _Ts...>> {
+ return static_cast<_Fun0&&>(__t0_)(static_cast<_Fun1&&>(__t1_)(static_cast<_Ts&&>(__ts)...));
}
template <class... _Ts>
- requires __callable<const _Fun1&, _Ts...> &&
- __callable<const _Fun0&, __call_result_t<const _Fun1&, _Ts...>>
- STDEXEC_ATTRIBUTE((always_inline))
- __call_result_t<_Fun0, __call_result_t<_Fun1, _Ts...>> operator()(
- _Ts&&... __ts) const&
- {
- return __t0_(__t1_(static_cast<_Ts&&>(__ts)...));
+ requires __callable<const _Fun1&, _Ts...>
+ && __callable<const _Fun0&, __call_result_t<const _Fun1&, _Ts...>>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto
+ operator()(_Ts&&... __ts) const & -> __call_result_t<_Fun0, __call_result_t<_Fun1, _Ts...>> {
+ return __t0_(__t1_(static_cast<_Ts&&>(__ts)...));
}
-};
+ };
-inline constexpr struct __compose_t
-{
+ inline constexpr struct __compose_t {
template <class _Fun0, class _Fun1>
- STDEXEC_ATTRIBUTE((always_inline))
- __composed<_Fun0, _Fun1> operator()(_Fun0 __fun0, _Fun1 __fun1) const
- {
- return {static_cast<_Fun0&&>(__fun0), static_cast<_Fun1&&>(__fun1)};
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ auto operator()(_Fun0 __fun0, _Fun1 __fun1) const -> __composed<_Fun0, _Fun1> {
+ return {static_cast<_Fun0&&>(__fun0), static_cast<_Fun1&&>(__fun1)};
}
-} __compose{};
+ } __compose{};
-namespace __invoke_
-{
-template <class>
-inline constexpr bool __is_refwrap = false;
-template <class _Up>
-inline constexpr bool __is_refwrap<std::reference_wrapper<_Up>> = true;
+ namespace __invoke_ {
+ template <class>
+ inline constexpr bool __is_refwrap = false;
+ template <class _Up>
+ inline constexpr bool __is_refwrap<std::reference_wrapper<_Up>> = true;
-struct __funobj
-{
- template <class _Fun, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Fun&& __fun, _Args&&... __args) const noexcept(
- noexcept((static_cast<_Fun&&>(__fun))(static_cast<_Args&&>(__args)...)))
- -> decltype((static_cast<_Fun&&>(__fun))(
- static_cast<_Args&&>(__args)...))
- {
+ struct __funobj {
+ template <class _Fun, class... _Args>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Fun&& __fun, _Args&&... __args) const
+ noexcept(noexcept((static_cast<_Fun&&>(__fun))(static_cast<_Args&&>(__args)...)))
+ -> decltype((static_cast<_Fun&&>(__fun))(static_cast<_Args&&>(__args)...)) {
return static_cast<_Fun&&>(__fun)(static_cast<_Args&&>(__args)...);
- }
-};
+ }
+ };
-struct __memfn
-{
- template <class _Memptr, class _Ty, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Memptr __mem_ptr, _Ty&& __ty,
- _Args&&... __args) const
- noexcept(noexcept(((static_cast<_Ty&&>(__ty)).*
- __mem_ptr)(static_cast<_Args&&>(__args)...)))
- -> decltype(((static_cast<_Ty&&>(__ty)).*
- __mem_ptr)(static_cast<_Args&&>(__args)...))
- {
- return ((static_cast<_Ty&&>(__ty)).*__mem_ptr)(
- static_cast<_Args&&>(__args)...);
- }
-};
+ struct __memfn {
+ template <class _Memptr, class _Ty, class... _Args>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Memptr __mem_ptr, _Ty&& __ty, _Args&&... __args) const
+ noexcept(noexcept(((static_cast<_Ty&&>(__ty)).*__mem_ptr)(static_cast<_Args&&>(__args)...)))
+ -> decltype(((static_cast<_Ty&&>(__ty)).*__mem_ptr)(static_cast<_Args&&>(__args)...)) {
+ return ((static_cast<_Ty&&>(__ty)).*__mem_ptr)(static_cast<_Args&&>(__args)...);
+ }
+ };
-struct __memfn_refwrap
-{
- template <class _Memptr, class _Ty, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Memptr __mem_ptr, _Ty __ty,
- _Args&&... __args) const
- noexcept(noexcept((__ty.get().*
- __mem_ptr)(static_cast<_Args&&>(__args)...)))
- -> decltype((__ty.get().*
- __mem_ptr)(static_cast<_Args&&>(__args)...))
- {
+ struct __memfn_refwrap {
+ template <class _Memptr, class _Ty, class... _Args>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Memptr __mem_ptr, _Ty __ty, _Args&&... __args) const
+ noexcept(noexcept((__ty.get().*__mem_ptr)(static_cast<_Args&&>(__args)...)))
+ -> decltype((__ty.get().*__mem_ptr)(static_cast<_Args&&>(__args)...)) {
return (__ty.get().*__mem_ptr)(static_cast<_Args&&>(__args)...);
- }
-};
+ }
+ };
-struct __memfn_smartptr
-{
- template <class _Memptr, class _Ty, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Memptr __mem_ptr, _Ty&& __ty,
- _Args&&... __args) const
- noexcept(noexcept(((*static_cast<_Ty&&>(__ty)).*
- __mem_ptr)(static_cast<_Args&&>(__args)...)))
- -> decltype(((*static_cast<_Ty&&>(__ty)).*
- __mem_ptr)(static_cast<_Args&&>(__args)...))
- {
- return ((*static_cast<_Ty&&>(__ty)).*__mem_ptr)(
- static_cast<_Args&&>(__args)...);
- }
-};
+ struct __memfn_smartptr {
+ template <class _Memptr, class _Ty, class... _Args>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Memptr __mem_ptr, _Ty&& __ty, _Args&&... __args) const noexcept(
+ noexcept(((*static_cast<_Ty&&>(__ty)).*__mem_ptr)(static_cast<_Args&&>(__args)...)))
+ -> decltype(((*static_cast<_Ty&&>(__ty)).*__mem_ptr)(static_cast<_Args&&>(__args)...)) {
+ return ((*static_cast<_Ty&&>(__ty)).*__mem_ptr)(static_cast<_Args&&>(__args)...);
+ }
+ };
-struct __memobj
-{
- template <class _Mbr, class _Class, class _Ty>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Mbr _Class::* __mem_ptr,
- _Ty&& __ty) const noexcept
- -> decltype(((static_cast<_Ty&&>(__ty)).*__mem_ptr))
- {
+ struct __memobj {
+ template <class _Mbr, class _Class, class _Ty>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Mbr _Class::* __mem_ptr, _Ty&& __ty) const noexcept
+ -> decltype(((static_cast<_Ty&&>(__ty)).*__mem_ptr)) {
return ((static_cast<_Ty&&>(__ty)).*__mem_ptr);
- }
-};
+ }
+ };
-struct __memobj_refwrap
-{
- template <class _Mbr, class _Class, class _Ty>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Mbr _Class::* __mem_ptr, _Ty __ty) const noexcept
- -> decltype((__ty.get().*__mem_ptr))
- {
+ struct __memobj_refwrap {
+ template <class _Mbr, class _Class, class _Ty>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Mbr _Class::* __mem_ptr, _Ty __ty) const noexcept
+ -> decltype((__ty.get().*__mem_ptr)) {
return (__ty.get().*__mem_ptr);
- }
-};
+ }
+ };
-struct __memobj_smartptr
-{
- template <class _Mbr, class _Class, class _Ty>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Mbr _Class::* __mem_ptr,
- _Ty&& __ty) const noexcept
- -> decltype(((*static_cast<_Ty&&>(__ty)).*__mem_ptr))
- {
+ struct __memobj_smartptr {
+ template <class _Mbr, class _Class, class _Ty>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Mbr _Class::* __mem_ptr, _Ty&& __ty) const noexcept
+ -> decltype(((*static_cast<_Ty&&>(__ty)).*__mem_ptr)) {
return ((*static_cast<_Ty&&>(__ty)).*__mem_ptr);
- }
-};
+ }
+ };
-auto __invoke_selector(__ignore, __ignore) noexcept -> __funobj;
+ STDEXEC_ATTRIBUTE(host, device)
+ auto __invoke_selector(__ignore, __ignore) noexcept -> __funobj;
-template <class _Mbr, class _Class, class _Ty>
-auto __invoke_selector(_Mbr _Class::*, const _Ty&) noexcept
-{
- if constexpr (STDEXEC_IS_CONST(_Mbr) || STDEXEC_IS_CONST(const _Mbr))
- {
+ template <class _Mbr, class _Class, class _Ty>
+ STDEXEC_ATTRIBUTE(host, device)
+ auto __invoke_selector(_Mbr _Class::*, const _Ty&) noexcept {
+ if constexpr (STDEXEC_IS_FUNCTION(_Mbr)) {
// member function ptr case
- if constexpr (STDEXEC_IS_BASE_OF(_Class, _Ty))
- {
- return __memobj{};
+ if constexpr (STDEXEC_IS_BASE_OF(_Class, _Ty)) {
+ return __memfn{};
+ } else if constexpr (__is_refwrap<_Ty>) {
+ return __memfn_refwrap{};
+ } else {
+ return __memfn_smartptr{};
}
- else if constexpr (__is_refwrap<_Ty>)
- {
- return __memobj_refwrap{};
- }
- else
- {
- return __memobj_smartptr{};
- }
- }
- else
- {
+ } else {
// member object ptr case
- if constexpr (STDEXEC_IS_BASE_OF(_Class, _Ty))
- {
- return __memfn{};
+ if constexpr (STDEXEC_IS_BASE_OF(_Class, _Ty)) {
+ return __memobj{};
+ } else if constexpr (__is_refwrap<_Ty>) {
+ return __memobj_refwrap{};
+ } else {
+ return __memobj_smartptr{};
}
- else if constexpr (__is_refwrap<_Ty>)
- {
- return __memfn_refwrap{};
- }
- else
- {
- return __memfn_smartptr{};
- }
+ }
}
-}
-struct __invoke_t
-{
- template <class _Fun>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Fun&& __fun) const
- noexcept(noexcept((static_cast<_Fun&&>(__fun))()))
- -> decltype((static_cast<_Fun&&>(__fun))())
- {
+ struct __invoke_t {
+ template <class _Fun>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Fun&& __fun) const noexcept(noexcept(static_cast<_Fun&&>(__fun)()))
+ -> decltype(static_cast<_Fun&&>(__fun)()) {
return static_cast<_Fun&&>(__fun)();
+ }
+
+ template <class _Fun, class _Ty, class... _Args>
+ STDEXEC_ATTRIBUTE(host, device, always_inline)
+ constexpr auto operator()(_Fun&& __fun, _Ty&& __ty, _Args&&... __args) const
+ noexcept(noexcept(__invoke_::__invoke_selector(__fun, __ty)(
+ static_cast<_Fun&&>(__fun),
+ static_cast<_Ty&&>(__ty),
+ static_cast<_Args&&>(__args)...)))
+ -> decltype(__invoke_::__invoke_selector(__fun, __ty)(
+ static_cast<_Fun&&>(__fun),
+ static_cast<_Ty&&>(__ty),
+ static_cast<_Args&&>(__args)...)) {
+ return decltype(__invoke_::__invoke_selector(__fun, __ty))()(
+ static_cast<_Fun&&>(__fun), static_cast<_Ty&&>(__ty), static_cast<_Args&&>(__args)...);
+ }
+ };
+ } // namespace __invoke_
+
+ inline constexpr __invoke_::__invoke_t __invoke{};
+
+ template <class _Fun, class... _As>
+ concept __invocable = requires(_Fun&& __f, _As&&... __as) {
+ __invoke(static_cast<_Fun &&>(__f), static_cast<_As &&>(__as)...);
+ };
+
+ template <class _Fun, class... _As>
+ concept __nothrow_invocable = __invocable<_Fun, _As...> && requires(_Fun&& __f, _As&&... __as) {
+ { __invoke(static_cast<_Fun &&>(__f), static_cast<_As &&>(__as)...) } noexcept;
+ };
+
+ template <class _Fun, class... _As>
+ using __invoke_result_t = decltype(__invoke(__declval<_Fun>(), __declval<_As>()...));
+
+ namespace __apply_ {
+ using std::get;
+
+ template <std::size_t... _Is, class _Fn, class _Tup>
+ STDEXEC_ATTRIBUTE(always_inline)
+ constexpr auto __impl(__indices<_Is...>, _Fn&& __fn, _Tup&& __tup) noexcept(
+ noexcept(__invoke(static_cast<_Fn&&>(__fn), get<_Is>(static_cast<_Tup&&>(__tup))...)))
+ -> decltype(__invoke(static_cast<_Fn&&>(__fn), get<_Is>(static_cast<_Tup&&>(__tup))...)) {
+ return __invoke(static_cast<_Fn&&>(__fn), get<_Is>(static_cast<_Tup&&>(__tup))...);
}
- template <class _Fun, class _Ty, class... _Args>
- STDEXEC_ATTRIBUTE((always_inline))
- constexpr auto operator()(_Fun&& __fun, _Ty&& __ty, _Args&&... __args) const
- noexcept(noexcept(__invoke_selector(__fun, __ty)(
- static_cast<_Fun&&>(__fun), static_cast<_Ty&&>(__ty),
- static_cast<_Args&&>(__args)...)))
- -> decltype(__invoke_selector(__fun, __ty)(
- static_cast<_Fun&&>(__fun), static_cast<_Ty&&>(__ty),
- static_cast<_Args&&>(__args)...))
- {
- return decltype(__invoke_selector(__fun, __ty))()(
- static_cast<_Fun&&>(__fun), static_cast<_Ty&&>(__ty),
- static_cast<_Args&&>(__args)...);
- }
-};
-} // namespace __invoke_
+ template <class _Tup>
+ using __tuple_indices = __make_indices<std::tuple_size<std::remove_cvref_t<_Tup>>::value>;
-inline constexpr __invoke_::__invoke_t __invoke{};
-
-template <class _Fun, class... _As>
-concept __invocable = //
- requires(_Fun&& __f, _As&&... __as) {
- __invoke(static_cast<_Fun&&>(__f), static_cast<_As&&>(__as)...);
- };
-
-template <class _Fun, class... _As>
-concept __nothrow_invocable = //
- __invocable<_Fun, _As...> && //
- requires(_Fun&& __f, _As&&... __as) {
- {
- __invoke(static_cast<_Fun&&>(__f), static_cast<_As&&>(__as)...)
- } noexcept;
- };
-
-template <class _Fun, class... _As>
-using __invoke_result_t = //
- decltype(__invoke(__declval<_Fun>(), __declval<_As>()...));
-
-namespace __apply_
-{
-using std::get;
-
-template <std::size_t... _Is, class _Fn, class _Tup>
-STDEXEC_ATTRIBUTE((always_inline))
-constexpr auto __impl(__indices<_Is...>, _Fn&& __fn, _Tup&& __tup) //
- noexcept(noexcept(__invoke(static_cast<_Fn&&>(__fn),
- get<_Is>(static_cast<_Tup&&>(__tup))...)))
- -> decltype(__invoke(static_cast<_Fn&&>(__fn),
- get<_Is>(static_cast<_Tup&&>(__tup))...))
-{
- return __invoke(static_cast<_Fn&&>(__fn),
- get<_Is>(static_cast<_Tup&&>(__tup))...);
-}
-
-template <class _Tup>
-using __tuple_indices =
- __make_indices<std::tuple_size<std::remove_cvref_t<_Tup>>::value>;
-
-template <class _Fn, class _Tup>
-using __result_t = decltype(__apply_::__impl(
- __tuple_indices<_Tup>(), __declval<_Fn>(), __declval<_Tup>()));
-} // namespace __apply_
-
-template <class _Fn, class _Tup>
-concept __applicable = __mvalid<__apply_::__result_t, _Fn, _Tup>;
-
-template <class _Fn, class _Tup>
-concept __nothrow_applicable =
- __applicable<_Fn, _Tup> //
- && //
- noexcept(__apply_::__impl(__apply_::__tuple_indices<_Tup>(),
- __declval<_Fn>(), __declval<_Tup>()));
-
-template <class _Fn, class _Tup>
- requires __applicable<_Fn, _Tup>
-using __apply_result_t = __apply_::__result_t<_Fn, _Tup>;
-
-struct __apply_t
-{
template <class _Fn, class _Tup>
- requires __applicable<_Fn, _Tup>
- STDEXEC_ATTRIBUTE((always_inline))
+ using __result_t =
+ decltype(__apply_::__impl(__tuple_indices<_Tup>(), __declval<_Fn>(), __declval<_Tup>()));
+ } // namespace __apply_
+
+ template <class _Fn, class _Tup>
+ concept __applicable = __mvalid<__apply_::__result_t, _Fn, _Tup>;
+
+ template <class _Fn, class _Tup>
+ concept __nothrow_applicable =
+ __applicable<_Fn, _Tup>
+ && noexcept(
+ __apply_::__impl(__apply_::__tuple_indices<_Tup>(), __declval<_Fn>(), __declval<_Tup>()));
+
+ template <class _Fn, class _Tup>
+ requires __applicable<_Fn, _Tup>
+ using __apply_result_t = __apply_::__result_t<_Fn, _Tup>;
+
+ struct __apply_t {
+ template <class _Fn, class _Tup>
+ requires __applicable<_Fn, _Tup>
+ STDEXEC_ATTRIBUTE(always_inline)
constexpr auto operator()(_Fn&& __fn, _Tup&& __tup) const
- noexcept(__nothrow_applicable<_Fn, _Tup>) -> __apply_result_t<_Fn, _Tup>
- {
- return __apply_::__impl(__apply_::__tuple_indices<_Tup>(),
- static_cast<_Fn&&>(__fn),
- static_cast<_Tup&&>(__tup));
+ noexcept(__nothrow_applicable<_Fn, _Tup>) -> __apply_result_t<_Fn, _Tup> {
+ return __apply_::__impl(
+ __apply_::__tuple_indices<_Tup>(), static_cast<_Fn&&>(__fn), static_cast<_Tup&&>(__tup));
}
-};
+ };
-inline constexpr __apply_t __apply{};
-
-template <class _Tag, class _Ty>
-struct __field
-{
- STDEXEC_ATTRIBUTE((always_inline))
- _Ty operator()(_Tag) const noexcept(__nothrow_decay_copyable<const _Ty&>)
- {
- return __t_;
- }
-
- _Ty __t_;
-};
-
-template <class _Tag>
-struct __mkfield_
-{
- template <class _Ty>
- STDEXEC_ATTRIBUTE((always_inline))
- __field<_Tag, __decay_t<_Ty>> operator()(_Ty&& __ty) const
- noexcept(__nothrow_decay_copyable<_Ty>)
- {
- return {static_cast<_Ty&&>(__ty)};
- }
-};
-
-template <class _Tag>
-inline constexpr __mkfield_<_Tag> __mkfield{};
+ inline constexpr __apply_t __apply{};
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/import b/include/sdbusplus/async/stdexec/import
index df69427..9c2f6d1 100755
--- a/include/sdbusplus/async/stdexec/import
+++ b/include/sdbusplus/async/stdexec/import
@@ -11,5 +11,4 @@
sed -i "s#include <stdexec/#include <sdbusplus/async/stdexec/#" -- "${f}"
sed -i "s#include <exec/#include <sdbusplus/async/stdexec/#" -- "${f}"
sed -i 's#include "\./\([^"]*\)"#include <sdbusplus/async/stdexec/\1>#' -- "${f}"
- clang-format -i "${f}"
done
diff --git a/include/sdbusplus/async/stdexec/inline_scheduler.hpp b/include/sdbusplus/async/stdexec/inline_scheduler.hpp
index 4634e9e..1a4c4f7 100644
--- a/include/sdbusplus/async/stdexec/inline_scheduler.hpp
+++ b/include/sdbusplus/async/stdexec/inline_scheduler.hpp
@@ -17,12 +17,9 @@
#include "../stdexec/execution.hpp"
-#include <exception>
-#include <type_traits>
-
-namespace exec
-{
-// A simple scheduler that executes its continuation inline, on the
-// thread of the caller of start().
-using inline_scheduler = stdexec::__inln::__scheduler;
+namespace exec {
+ // A simple scheduler that executes its continuation inline, on the
+ // thread of the caller of start().
+ using inline_scheduler
+ [[deprecated("Use stdexec::inline_scheduler instead")]] = stdexec::inline_scheduler;
} // namespace exec
diff --git a/include/sdbusplus/async/stdexec/scope.hpp b/include/sdbusplus/async/stdexec/scope.hpp
index 5b86305..a8d1e33 100644
--- a/include/sdbusplus/async/stdexec/scope.hpp
+++ b/include/sdbusplus/async/stdexec/scope.hpp
@@ -17,21 +17,18 @@
#include "../stdexec/__detail/__scope.hpp"
-namespace exec
-{
+namespace exec {
-template <class _Fn, class... _Ts>
+ template <class _Fn, class... _Ts>
requires stdexec::__nothrow_callable<_Fn, _Ts...>
-struct scope_guard
-{
+ struct scope_guard {
stdexec::__scope_guard<_Fn, _Ts...> __guard_;
- void dismiss() noexcept
- {
- __guard_.__dismiss();
+ void dismiss() noexcept {
+ __guard_.__dismiss();
}
-};
-template <class _Fn, class... _Ts>
-scope_guard(_Fn, _Ts...) -> scope_guard<_Fn, _Ts...>;
+ };
+ template <class _Fn, class... _Ts>
+ scope_guard(_Fn, _Ts...) -> scope_guard<_Fn, _Ts...>;
} // namespace exec
diff --git a/include/sdbusplus/async/stdexec/sequence_senders.hpp b/include/sdbusplus/async/stdexec/sequence_senders.hpp
index 012779f..85c85e3 100644
--- a/include/sdbusplus/async/stdexec/sequence_senders.hpp
+++ b/include/sdbusplus/async/stdexec/sequence_senders.hpp
@@ -17,519 +17,788 @@
#pragma once
#include "../stdexec/execution.hpp"
+#include "../stdexec/__detail/__concepts.hpp"
+#include "../stdexec/__detail/__meta.hpp"
-namespace exec
-{
-struct sequence_sender_t : stdexec::sender_t
-{};
+namespace exec {
+ struct sequence_sender_t : stdexec::sender_t { };
-using sequence_tag [[deprecated("Renamed to exec::sequence_sender_t")]] =
- exec::sequence_sender_t;
+ using sequence_tag [[deprecated("Renamed to exec::sequence_sender_t")]] = exec::sequence_sender_t;
-namespace __sequence_sndr
-{
-using namespace stdexec;
+ namespace __sequence_sndr {
+ using namespace stdexec;
-template <class _Haystack>
-struct __mall_contained_in_impl
-{
- template <class... _Needles>
- using __f = __mand<__mapply<__mcontains<_Needles>, _Haystack>...>;
-};
+ template <class _Haystack>
+ struct __mall_contained_in_impl {
+ template <class... _Needles>
+ using __f = __mand<__mapply<__mcontains<_Needles>, _Haystack>...>;
+ };
+ template <class _Needles, class _Haystack>
+ using __mall_contained_in_t = __mapply<__mall_contained_in_impl<_Haystack>, _Needles>;
-template <class _Needles, class _Haystack>
-using __mall_contained_in =
- __mapply<__mall_contained_in_impl<_Haystack>, _Needles>;
+ template <class _Needles, class _Haystack>
+ concept __all_contained_in = __v<__mall_contained_in_t<_Needles, _Haystack>>;
+ } // namespace __sequence_sndr
-template <class _Needles, class _Haystack>
-concept __all_contained_in = __v<__mall_contained_in<_Needles, _Haystack>>;
+ // This concept checks if a given sender satisfies the requirements to be returned from `set_next`.
+ template <class _Sender, class _Env = stdexec::env<>>
+ concept next_sender =
+ stdexec::sender_in<_Sender, _Env>
+ && __sequence_sndr::__all_contained_in<
+ stdexec::completion_signatures_of_t<_Sender, _Env>,
+ stdexec::completion_signatures<stdexec::set_value_t(), stdexec::set_stopped_t()>
+ >;
-// This concept checks if a given sender satisfies the requirements to be
-// returned from `set_next`.
-template <class _Sender, class _Env = empty_env>
-concept next_sender = //
- sender_in<_Sender, _Env> //
- &&
- __all_contained_in<completion_signatures_of_t<_Sender, _Env>,
- completion_signatures<set_value_t(), set_stopped_t()>>;
+ namespace __sequence_sndr {
-// This is a sequence-receiver CPO that is used to apply algorithms on an input
-// sender and it returns a next-sender. `set_next` is usually called in a
-// context where a sender will be connected to a receiver. Since calling
-// `set_next` usually involves constructing senders it is allowed to throw an
-// excpetion, which needs to be handled by a calling sequence-operation. The
-// returned object is a sender that can complete with `set_value_t()` or
-// `set_stopped_t()`.
-struct set_next_t
-{
- template <receiver _Receiver, sender _Item>
- requires tag_invocable<set_next_t, _Receiver&, _Item>
- auto operator()(_Receiver& __rcvr, _Item&& __item) const
+ template <class _Receiver, class _Item>
+ concept __has_set_next_member = requires(_Receiver& __rcvr, _Item&& __item) {
+ __rcvr.set_next(static_cast<_Item&&>(__item));
+ };
+
+ // This is a sequence-receiver CPO that is used to apply algorithms on an input sender and it
+ // returns a next-sender. `set_next` is usually called in a context where a sender will be
+ // connected to a receiver. Since calling `set_next` usually involves constructing senders it
+ // is allowed to throw an excpetion, which needs to be handled by a calling sequence-operation.
+ // The returned object is a sender that can complete with `set_value_t()` or `set_stopped_t()`.
+ struct set_next_t {
+ template <receiver _Receiver, sender _Item>
+ requires __has_set_next_member<_Receiver, _Item>
+ auto operator()(_Receiver& __rcvr, _Item&& __item) const
+ noexcept(noexcept(__rcvr.set_next(static_cast<_Item&&>(__item))))
+ -> decltype(__rcvr.set_next(static_cast<_Item&&>(__item))) {
+ return __rcvr.set_next(static_cast<_Item&&>(__item));
+ }
+
+ template <receiver _Receiver, sender _Item>
+ requires(!__has_set_next_member<_Receiver, _Item>)
+ && tag_invocable<set_next_t, _Receiver&, _Item>
+ auto operator()(_Receiver& __rcvr, _Item&& __item) const
noexcept(nothrow_tag_invocable<set_next_t, _Receiver&, _Item>)
- -> tag_invoke_result_t<set_next_t, _Receiver&, _Item>
- {
+ -> tag_invoke_result_t<set_next_t, _Receiver&, _Item> {
static_assert(
- next_sender<tag_invoke_result_t<set_next_t, _Receiver&, _Item>>,
- "The sender returned from set_next is required to complete with set_value_t() or "
- "set_stopped_t()");
+ next_sender<tag_invoke_result_t<set_next_t, _Receiver&, _Item>>,
+ "The sender returned from set_next is required to complete with set_value_t() or "
+ "set_stopped_t()");
return tag_invoke(*this, __rcvr, static_cast<_Item&&>(__item));
- }
-};
-} // namespace __sequence_sndr
+ }
+ };
+ } // namespace __sequence_sndr
-using __sequence_sndr::set_next_t;
-inline constexpr set_next_t set_next;
+ using __sequence_sndr::set_next_t;
+ inline constexpr set_next_t set_next;
-template <class _Receiver, class _Sender>
-using next_sender_of_t = decltype(exec::set_next(
+ template <class _Receiver, class _Sequence>
+ using next_sender_of_t = decltype(exec::set_next(
stdexec::__declval<stdexec::__decay_t<_Receiver>&>(),
- stdexec::__declval<_Sender>()));
+ stdexec::__declval<_Sequence>()));
-namespace __sequence_sndr
-{
+ namespace __sequence_sndr {
-template <class _ReceiverId>
-struct __stopped_means_break
-{
- struct __t
- {
+ template <class _ReceiverId>
+ struct __stopped_means_break {
+ struct __t {
using receiver_concept = stdexec::receiver_t;
using __id = __stopped_means_break;
using _Receiver = stdexec::__t<_ReceiverId>;
- using _Token = stop_token_of_t<env_of_t<_Receiver>>;
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Receiver __rcvr_;
+ using __token_t = stop_token_of_t<env_of_t<_Receiver>>;
+ STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rcvr_;
- auto get_env() const noexcept -> env_of_t<_Receiver>
- {
- return stdexec::get_env(__rcvr_);
+ auto get_env() const noexcept -> env_of_t<_Receiver> {
+ return stdexec::get_env(__rcvr_);
}
void set_value() noexcept
- requires __callable<set_value_t, _Receiver>
+ requires __callable<set_value_t, _Receiver>
{
- return stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
+ return stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
}
void set_stopped() noexcept
- requires __callable<set_value_t, _Receiver> &&
- (unstoppable_token<_Token> ||
- __callable<set_stopped_t, _Receiver>)
+ requires __callable<set_value_t, _Receiver>
+ && (unstoppable_token<__token_t> || __callable<set_stopped_t, _Receiver>)
{
- if constexpr (unstoppable_token<_Token>)
- {
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
+ if constexpr (unstoppable_token<__token_t>) {
+ stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
+ } else {
+ auto __token = stdexec::get_stop_token(stdexec::get_env(__rcvr_));
+ if (__token.stop_requested()) {
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
+ } else {
+ stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
}
- else
- {
- auto __token =
- stdexec::get_stop_token(stdexec::get_env(__rcvr_));
- if (__token.stop_requested())
- {
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr_));
- }
- else
- {
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
- }
- }
+ }
}
+ };
};
-};
-template <class _Rcvr>
-using __stopped_means_break_t =
- __t<__stopped_means_break<__id<__decay_t<_Rcvr>>>>;
-} // namespace __sequence_sndr
+ template <class _Rcvr>
+ using __stopped_means_break_t = __t<__stopped_means_break<__id<__decay_t<_Rcvr>>>>;
+ } // namespace __sequence_sndr
-template <class _Sender>
-concept __enable_sequence_sender = //
- requires { typename _Sender::sender_concept; } && //
- stdexec::same_as<typename _Sender::sender_concept, sequence_sender_t>;
+ template <class _Sequence>
+ concept __enable_sequence_sender = requires {
+ typename _Sequence::sender_concept;
+ } && stdexec::derived_from<typename _Sequence::sender_concept, sequence_sender_t>;
-template <class _Sender>
-inline constexpr bool enable_sequence_sender =
- __enable_sequence_sender<_Sender>;
+ template <class _Sequence>
+ inline constexpr bool enable_sequence_sender = __enable_sequence_sender<_Sequence>;
-template <class... _Senders>
-struct item_types
-{};
+ template <class... _Senders>
+ struct item_types { };
-template <class _Tp>
-concept __has_item_typedef = requires { typename _Tp::item_types; };
+ template <class _Tp>
+ concept __has_item_typedef = requires { typename _Tp::item_types; };
-/////////////////////////////////////////////////////////////////////////////
-// [execution.sndtraits]
-namespace __sequence_sndr
-{
-struct get_item_types_t;
-template <class _Sender, class _Env>
-using __tfx_sender =
- transform_sender_result_t<__late_domain_of_t<_Sender, _Env>, _Sender, _Env>;
+ namespace __debug {
+ using namespace stdexec::__debug;
-template <class _Sender, class _Env>
-concept __with_tag_invoke = //
- tag_invocable<get_item_types_t, __tfx_sender<_Sender, _Env>, _Env>;
-template <class _Sender, class _Env>
-using __member_alias_t = //
- typename __decay_t<__tfx_sender<_Sender, _Env>>::item_types;
+ struct __item_types { };
+ } // namespace __debug
-template <class _Sender, class _Env>
-concept __with_member_alias = __mvalid<__member_alias_t, _Sender, _Env>;
+ namespace __errs {
+ using namespace stdexec;
+ inline constexpr __mstring __unrecognized_sequence_type_diagnostic =
+ "The given type cannot be used as a sequence with the given environment "
+ "because the attempt to compute the item types failed."_mstr;
+ } // namespace __errs
-struct get_item_types_t
-{
- template <class _Sender, class _Env>
- static auto __impl()
- {
- static_assert(sizeof(_Sender),
- "Incomplete type used with get_item_types");
+ template <class _Sequence>
+ struct _WITH_SEQUENCE_;
+
+ template <class... _Sequences>
+ struct _WITH_SEQUENCES_;
+
+ template <stdexec::__mstring _Diagnostic = __errs::__unrecognized_sequence_type_diagnostic>
+ struct _UNRECOGNIZED_SEQUENCE_TYPE_;
+
+ /////////////////////////////////////////////////////////////////////////////
+ // [execution.seqtraits]
+ namespace __sequence_sndr {
+ struct get_item_types_t;
+
+ template <class _Sequence, class... _Env>
+ using __item_types_of_t = __call_result_t<get_item_types_t, _Sequence, _Env...>;
+
+ template <class _Sequence, class... _Env>
+ using __unrecognized_sequence_error_t = __mexception<
+ _UNRECOGNIZED_SEQUENCE_TYPE_<>,
+ _WITH_SEQUENCE_<_Sequence>,
+ _WITH_ENVIRONMENT_<_Env>...
+ >;
+
+ template <class _Sequence, class _Env>
+ using __member_result_t = decltype(__declval<_Sequence>().get_item_types(__declval<_Env>()));
+
+ template <class _Sequence, class _Env>
+ using __static_member_result_t = decltype(STDEXEC_REMOVE_REFERENCE(
+ _Sequence)::get_item_types(__declval<_Sequence>(), __declval<_Env>()));
+
+ template <class _Sequence, class _Env>
+ using __tfx_sequence_t =
+ transform_sender_result_t<__late_domain_of_t<_Sequence, _Env>, _Sequence, _Env>;
+
+ template <class _Sequence, class _Env>
+ concept __with_tag_invoke =
+ tag_invocable<get_item_types_t, __tfx_sequence_t<_Sequence, _Env>, _Env>;
+
+ template <class _Sequence, class _Env>
+ using __member_alias_t = __decay_t<__tfx_sequence_t<_Sequence, _Env>>::item_types;
+
+ template <class _Sequence, class _Env>
+ concept __with_member_alias = __mvalid<__member_alias_t, _Sequence, _Env>;
+
+ template <class _Sequence, class _Env>
+ concept __with_static_member = __mvalid<__static_member_result_t, _Sequence, _Env>;
+
+ template <class _Sequence, class... _Env>
+ concept __with_member = __mvalid<__member_result_t, _Sequence, _Env...>;
+
+ struct get_item_types_t {
+ template <class _Sequence, class _Env>
+ static auto __impl() {
+ static_assert(sizeof(_Sequence), "Incomplete type used with get_item_types");
static_assert(sizeof(_Env), "Incomplete type used with get_item_types");
- using _TfxSender = __tfx_sender<_Sender, _Env>;
- if constexpr (__with_tag_invoke<_Sender, _Env>)
- {
- using _Result =
- tag_invoke_result_t<get_item_types_t, _TfxSender, _Env>;
- return static_cast<_Result (*)()>(nullptr);
+ using __tfx_sequence_t = __tfx_sequence_t<_Sequence, _Env>;
+ if constexpr (__merror<__tfx_sequence_t>) {
+ // Computing the type of the transformed sender returned an error type. Propagate it.
+ return static_cast<__tfx_sequence_t (*)()>(nullptr);
+ } else if constexpr (__with_member_alias<__tfx_sequence_t, _Env>) {
+ using __result_t = __member_alias_t<__tfx_sequence_t, _Env>;
+ return static_cast<__result_t (*)()>(nullptr);
+ } else if constexpr (__with_static_member<__tfx_sequence_t, _Env>) {
+ using __result_t = __static_member_result_t<__tfx_sequence_t, _Env>;
+ return static_cast<__result_t (*)()>(nullptr);
+ } else if constexpr (__with_member<__tfx_sequence_t, _Env>) {
+ using __result_t = decltype(__declval<__tfx_sequence_t>()
+ .get_item_types(__declval<_Env>()));
+ return static_cast<__result_t (*)()>(nullptr);
+ } else if constexpr (__with_tag_invoke<__tfx_sequence_t, _Env>) {
+ using __result_t = tag_invoke_result_t<get_item_types_t, __tfx_sequence_t, _Env>;
+ return static_cast<__result_t (*)()>(nullptr);
+ } else if constexpr (
+ sender_in<__tfx_sequence_t, _Env>
+ && !enable_sequence_sender<stdexec::__decay_t<__tfx_sequence_t>>) {
+ using __result_t = item_types<stdexec::__decay_t<__tfx_sequence_t>>;
+ return static_cast<__result_t (*)()>(nullptr);
+ } else if constexpr (__is_debug_env<_Env>) {
+ using __tag_invoke::tag_invoke;
+ // This ought to cause a hard error that indicates where the problem is.
+ using __item_types_t
+ [[maybe_unused]] = tag_invoke_result_t<get_item_types_t, __tfx_sequence_t, _Env>;
+ return static_cast<__debug::__item_types (*)()>(nullptr);
+ } else {
+ using __result_t = __unrecognized_sequence_error_t<_Sequence, _Env>;
+ return static_cast<__result_t (*)()>(nullptr);
}
- else if constexpr (__with_member_alias<_TfxSender, _Env>)
- {
- using _Result = __member_alias_t<_TfxSender, _Env>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else if constexpr (sender_in<_TfxSender, _Env> &&
- !enable_sequence_sender<
- stdexec::__decay_t<_TfxSender>>)
- {
- using _Result = item_types<stdexec::__decay_t<_TfxSender>>;
- return static_cast<_Result (*)()>(nullptr);
- }
- else if constexpr (__is_debug_env<_Env>)
- {
- using __tag_invoke::tag_invoke;
- // This ought to cause a hard error that indicates where the problem
- // is.
- using _Completions [[maybe_unused]] =
- tag_invoke_result_t<get_item_types_t,
- __tfx_sender<_Sender, _Env>, _Env>;
- return static_cast<__debug::__completion_signatures (*)()>(nullptr);
- }
- else
- {
- using _Result =
- __mexception<_UNRECOGNIZED_SENDER_TYPE_<>,
- _WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>;
- return static_cast<_Result (*)()>(nullptr);
- }
- }
+ }
- template <class _Sender, class _Env = empty_env>
- constexpr auto operator()(_Sender&&, _Env&& = {}) const noexcept
- -> decltype(__impl<_Sender, _Env>()())
- {
+ template <class _Sequence, class _Env = env<>>
+ constexpr auto operator()(_Sequence&&, _Env&& = {}) const noexcept
+ -> decltype(__impl<_Sequence, _Env>()()) {
return {};
- }
-};
-} // namespace __sequence_sndr
-
-using __sequence_sndr::get_item_types_t;
-inline constexpr get_item_types_t get_item_types{};
-
-template <class _Sender, class... _Env>
-using item_types_of_t = decltype(get_item_types(stdexec::__declval<_Sender>(),
- stdexec::__declval<_Env>()...));
-
-template <class _Sender, class... _Env>
-concept sequence_sender = //
- stdexec::sender_in<_Sender, _Env...> && //
- enable_sequence_sender<stdexec::__decay_t<_Sender>>;
-
-template <class _Sender, class... _Env>
-concept has_sequence_item_types =
- requires(_Sender&& __sndr, _Env&&... __env) {
- get_item_types(static_cast<_Sender&&>(__sndr),
- static_cast<_Env&&>(__env)...);
+ }
};
+ } // namespace __sequence_sndr
-template <class _Sender, class... _Env>
-concept sequence_sender_in = //
- stdexec::sender_in<_Sender, _Env...> && //
- has_sequence_item_types<_Sender, _Env...> && //
- sequence_sender<_Sender, _Env...>;
+ using __sequence_sndr::get_item_types_t;
+ inline constexpr get_item_types_t get_item_types{};
-template <class _Receiver>
-struct _WITH_RECEIVER_
-{};
+ template <class _Sequence, class... _Env>
+ concept sequence_sender = stdexec::sender_in<_Sequence, _Env...>
+ && enable_sequence_sender<stdexec::__decay_t<_Sequence>>;
-template <class _Item>
-struct _MISSING_SET_NEXT_OVERLOAD_FOR_ITEM_
-{};
+ template <class _Sequence, class... _Env>
+ concept has_sequence_item_types = requires(_Sequence&& __sequence, _Env&&... __env) {
+ { get_item_types(static_cast<_Sequence&&>(__sequence), static_cast<_Env&&>(__env)...) };
+ };
-template <class _Receiver, class _Item>
-auto __try_item(_Item*) //
- -> stdexec::__mexception<_MISSING_SET_NEXT_OVERLOAD_FOR_ITEM_<_Item>,
- _WITH_RECEIVER_<_Receiver>>;
+ template <class _Sequence, class... _Env>
+ concept sequence_sender_in = sequence_sender<_Sequence, _Env...>
+ && has_sequence_item_types<_Sequence, _Env...>;
-template <class _Receiver, class _Item>
+ template <class _Sequence, class... _Env>
+ using __item_types_of_t =
+ decltype(get_item_types(stdexec::__declval<_Sequence>(), stdexec::__declval<_Env>()...));
+
+
+ template <class _Item>
+ struct _SEQUENCE_ITEM_IS_NOT_A_WELL_FORMED_SENDER_ { };
+
+ template <class _Sequence, class _Item>
+ auto __check_item(_Item*) -> stdexec::__mexception<
+ _SEQUENCE_ITEM_IS_NOT_A_WELL_FORMED_SENDER_<_Item>,
+ _WITH_SEQUENCE_<_Sequence>
+ >;
+
+ template <class _Sequence, class _Item>
+ requires stdexec::__well_formed_sender<_Item>
+ auto __check_item(_Item*) -> stdexec::__msuccess;
+
+ template <class _Sequence, class _Items>
+ requires stdexec::__merror<_Items>
+ auto __check_items(_Items*) -> _Items;
+
+ template <class _Item>
+ struct _SEQUENCE_GET_ITEM_TYPES_RESULT_IS_NOT_WELL_FORMED_ { };
+
+ template <class _Sequence, class _Items>
+ requires(!stdexec::__merror<_Items>)
+ auto __check_items(_Items*) -> stdexec::__mexception<
+ _SEQUENCE_GET_ITEM_TYPES_RESULT_IS_NOT_WELL_FORMED_<_Items>,
+ _WITH_SEQUENCE_<_Sequence>
+ >;
+
+ template <class _Sequence, class... _Items>
+ auto __check_items(exec::item_types<_Items...>*) -> decltype((
+ stdexec::__msuccess(),
+ ...,
+ exec::__check_item<_Sequence>(static_cast<_Items*>(nullptr))));
+
+ template <class _Sequence>
+ requires stdexec::__merror<_Sequence>
+ auto __check_sequence(_Sequence*) -> _Sequence;
+
+ struct _SEQUENCE_GET_ITEM_TYPES_IS_NOT_WELL_FORMED_ { };
+
+ template <class _Sequence>
+ requires(!stdexec::__merror<_Sequence>) && (!stdexec::__mvalid<__item_types_of_t, _Sequence>)
+ auto __check_sequence(_Sequence*) -> stdexec::__mexception<
+ _SEQUENCE_GET_ITEM_TYPES_IS_NOT_WELL_FORMED_,
+ _WITH_SEQUENCE_<_Sequence>
+ >;
+
+ template <class _Sequence>
+ requires(!stdexec::__merror<_Sequence>) && stdexec::__mvalid<__item_types_of_t, _Sequence>
+ auto __check_sequence(_Sequence*) -> decltype(exec::__check_items<_Sequence>(
+ static_cast<__item_types_of_t<_Sequence>*>(nullptr)));
+
+ template <class _Sequence>
+ concept __well_formed_item_senders = has_sequence_item_types<stdexec::__decay_t<_Sequence>>
+ && requires(stdexec::__decay_t<_Sequence>* __sequence) {
+ { exec::__check_sequence(__sequence) } -> stdexec::__ok;
+ };
+
+ template <class _Sequence>
+ concept __well_formed_sequence_sender = stdexec::__well_formed_sender<_Sequence>
+ && enable_sequence_sender<stdexec::__decay_t<_Sequence>>
+ && __well_formed_item_senders<_Sequence>;
+
+ template <class _Receiver>
+ struct _WITH_RECEIVER_ { };
+
+ template <class _Item>
+ struct _MISSING_SET_NEXT_OVERLOAD_FOR_ITEM_ { };
+
+ template <class _Receiver, class _Item>
+ auto __try_item(_Item*) -> stdexec::__mexception<
+ _MISSING_SET_NEXT_OVERLOAD_FOR_ITEM_<_Item>,
+ _WITH_RECEIVER_<_Receiver>
+ >;
+
+ template <class _Receiver, class _Item>
requires stdexec::__callable<set_next_t, _Receiver&, _Item>
-auto __try_item(_Item*) -> stdexec::__msuccess;
+ auto __try_item(_Item*) -> stdexec::__msuccess;
-template <class _Receiver, class... _Items>
-auto __try_items(exec::item_types<_Items...>*) //
- -> decltype((stdexec::__msuccess(), ...,
- exec::__try_item<_Receiver>(static_cast<_Items*>(nullptr))));
+ template <class _Receiver, class... _Items>
+ auto __try_items(exec::item_types<_Items...>*) -> decltype((
+ stdexec::__msuccess(),
+ ...,
+ exec::__try_item<_Receiver>(static_cast<_Items*>(nullptr))));
-template <class _Receiver, class _Items>
-concept __sequence_receiver_of =
- requires(_Items* __items) {
- {
- exec::__try_items<stdexec::__decay_t<_Receiver>>(__items)
- } -> stdexec::__ok;
+ template <class _Receiver, class _Items>
+ concept __sequence_receiver_of = requires(_Items* __items) {
+ { exec::__try_items<stdexec::__decay_t<_Receiver>>(__items) } -> stdexec::__ok;
+ };
+
+ template <class _Receiver, class _SequenceItems>
+ concept sequence_receiver_of = stdexec::receiver<_Receiver>
+ && __sequence_receiver_of<_Receiver, _SequenceItems>;
+
+ template <class _Completions>
+ using __to_sequence_completions_t = stdexec::__transform_completion_signatures<
+ _Completions,
+ stdexec::__mconst<stdexec::completion_signatures<stdexec::set_value_t()>>::__f,
+ stdexec::__sigs::__default_set_error,
+ stdexec::completion_signatures<stdexec::set_stopped_t()>,
+ stdexec::__concat_completion_signatures
+ >;
+
+ template <class _Sender, class... _Env>
+ using __item_completion_signatures_t = stdexec::transform_completion_signatures<
+ stdexec::__completion_signatures_of_t<_Sender, _Env...>,
+ stdexec::completion_signatures<stdexec::set_value_t()>,
+ stdexec::__mconst<stdexec::completion_signatures<>>::__f
+ >;
+
+ template <class _Sequence, class... _Env>
+ using __sequence_completion_signatures_t = stdexec::transform_completion_signatures<
+ stdexec::__completion_signatures_of_t<_Sequence, _Env...>,
+ stdexec::completion_signatures<stdexec::set_value_t()>,
+ stdexec::__mconst<stdexec::completion_signatures<>>::__f
+ >;
+
+ template <class _Sequence, class... _Env>
+ using __sequence_completion_signatures_of_t = stdexec::__mapply<
+ stdexec::__mtransform<
+ stdexec::__mbind_back_q<__item_completion_signatures_t, _Env...>,
+ stdexec::__mbind_back<
+ stdexec::__mtry_q<stdexec::__concat_completion_signatures>,
+ __sequence_completion_signatures_t<_Sequence, _Env...>
+ >
+ >,
+ __item_types_of_t<_Sequence, _Env...>
+ >;
+
+ template <class _Receiver, class _Sequence>
+ concept sequence_receiver_from = stdexec::receiver<_Receiver>
+ && stdexec::sender_in<_Sequence, stdexec::env_of_t<_Receiver>>
+ && sequence_receiver_of<
+ _Receiver,
+ __item_types_of_t<_Sequence, stdexec::env_of_t<_Receiver>>
+ >
+ && ((sequence_sender_in<_Sequence, stdexec::env_of_t<_Receiver>>
+ && stdexec::receiver_of<
+ _Receiver,
+ stdexec::completion_signatures_of_t<
+ _Sequence,
+ stdexec::env_of_t<_Receiver>
+ >
+ >)
+ || (!sequence_sender_in<_Sequence, stdexec::env_of_t<_Receiver>> && stdexec::__receiver_from<__sequence_sndr::__stopped_means_break_t<_Receiver>, next_sender_of_t<_Receiver, _Sequence>>) );
+
+ namespace __sequence_sndr {
+ struct subscribe_t;
+
+ struct _NO_USABLE_SUBSCRIBE_CUSTOMIZATION_FOUND_ {
+ void operator()() const noexcept = delete;
};
-template <class _Receiver, class _SequenceItems>
-concept sequence_receiver_of = //
- stdexec::receiver<_Receiver> && //
- __sequence_receiver_of<_Receiver, _SequenceItems>;
-
-template <class _Completions>
-using __to_sequence_completions_t = //
- stdexec::__transform_completion_signatures<
- _Completions,
- stdexec::__mconst<
- stdexec::completion_signatures<stdexec::set_value_t()>>::__f,
- stdexec::__sigs::__default_set_error,
- stdexec::completion_signatures<stdexec::set_stopped_t()>,
- stdexec::__concat_completion_signatures>;
-
-template <class _Sender, class... _Env>
-using __item_completion_signatures = //
- stdexec::transform_completion_signatures<
- stdexec::__completion_signatures_of_t<_Sender, _Env...>,
- stdexec::completion_signatures<stdexec::set_value_t()>,
- stdexec::__mconst<stdexec::completion_signatures<>>::__f>;
-
-template <class _Sequence, class... _Env>
-using __sequence_completion_signatures = //
- stdexec::transform_completion_signatures<
- stdexec::__completion_signatures_of_t<_Sequence, _Env...>,
- stdexec::completion_signatures<stdexec::set_value_t()>,
- stdexec::__mconst<stdexec::completion_signatures<>>::__f>;
-
-template <class _Sequence, class... _Env>
-using __sequence_completion_signatures_of_t = //
- stdexec::__mapply<
- stdexec::__mtransform<
- stdexec::__mbind_back_q<__item_completion_signatures, _Env...>,
- stdexec::__mbind_back<
- stdexec::__mtry_q<stdexec::__concat_completion_signatures>,
- __sequence_completion_signatures<_Sequence, _Env...>>>,
- item_types_of_t<_Sequence, _Env...>>;
-
-template <class _Receiver, class _Sender>
-concept sequence_receiver_from = //
- stdexec::receiver<_Receiver> && //
- stdexec::sender_in<_Sender, stdexec::env_of_t<_Receiver>> && //
- sequence_receiver_of<
- _Receiver, item_types_of_t<_Sender, stdexec::env_of_t<_Receiver>>> && //
- ((sequence_sender_in<_Sender, stdexec::env_of_t<_Receiver>> &&
- stdexec::receiver_of<_Receiver,
- stdexec::completion_signatures_of_t<
- _Sender, stdexec::env_of_t<_Receiver>>>) || //
- (!sequence_sender_in<_Sender, stdexec::env_of_t<_Receiver>> &&
- stdexec::__receiver_from<
- __sequence_sndr::__stopped_means_break_t<_Receiver>,
- next_sender_of_t<_Receiver, _Sender>>));
-
-namespace __sequence_sndr
-{
-struct subscribe_t;
-
-template <class _Env>
-using __single_sender_completion_sigs =
- __if_c<unstoppable_token<stop_token_of_t<_Env>>,
- completion_signatures<set_value_t()>,
- completion_signatures<set_value_t(), set_stopped_t()>>;
-
-template <class _Sender, class _Receiver>
-concept __next_connectable =
- receiver<_Receiver> && //
- sender_in<_Sender, env_of_t<_Receiver>> && //
- !sequence_sender_in<_Sender, env_of_t<_Receiver>> && //
- sequence_receiver_of<_Receiver,
- item_types<stdexec::__decay_t<_Sender>>> && //
- sender_to<next_sender_of_t<_Receiver, _Sender>,
- __stopped_means_break_t<_Receiver>>;
-
-template <class _Sender, class _Receiver>
-concept __subscribeable_with_tag_invoke =
- receiver<_Receiver> && //
- sequence_sender_in<_Sender, env_of_t<_Receiver>> && //
- sequence_receiver_from<_Receiver, _Sender> && //
- tag_invocable<subscribe_t, _Sender, _Receiver>;
-
-struct subscribe_t
-{
- template <class _Sender, class _Receiver>
- using __tfx_sndr = __tfx_sender<_Sender, env_of_t<_Receiver>>;
+ template <class _Env>
+ using __next_sender_completion_sigs_t = __if_c<
+ unstoppable_token<stop_token_of_t<_Env>>,
+ completion_signatures<set_value_t()>,
+ completion_signatures<set_value_t(), set_stopped_t()>
+ >;
template <class _Sender, class _Receiver>
- static constexpr auto __select_impl() noexcept
- {
- using _Domain = __late_domain_of_t<_Sender, env_of_t<_Receiver&>>;
- constexpr bool _NothrowTfxSender =
- __nothrow_callable<transform_sender_t, _Domain, _Sender,
- env_of_t<_Receiver&>>;
- using _TfxSender = __tfx_sndr<_Sender, _Receiver>;
- if constexpr (__next_connectable<_TfxSender, _Receiver>)
- {
- using _Result =
- connect_result_t<next_sender_of_t<_Receiver, _TfxSender>,
- __stopped_means_break_t<_Receiver>>;
- constexpr bool _Nothrow =
- __nothrow_connectable<next_sender_of_t<_Receiver, _TfxSender>,
- __stopped_means_break_t<_Receiver>>;
- return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
- }
- else if constexpr (__subscribeable_with_tag_invoke<_TfxSender,
- _Receiver>)
- {
- using _Result =
- tag_invoke_result_t<subscribe_t, _TfxSender, _Receiver>;
- constexpr bool _Nothrow = //
- _NothrowTfxSender &&
- nothrow_tag_invocable<subscribe_t, _TfxSender, _Receiver>;
- return static_cast<_Result (*)() noexcept(_Nothrow)>(nullptr);
- }
- else
- {
- return static_cast<__debug::__debug_operation (*)() noexcept>(
- nullptr);
- }
- }
+ concept __next_connectable =
+ receiver<_Receiver> && sender_in<_Sender, env_of_t<_Receiver>>
+ && !sequence_sender_in<_Sender, env_of_t<_Receiver>>
+ && sequence_receiver_of<_Receiver, item_types<stdexec::__decay_t<_Sender>>>
+ && sender_to<next_sender_of_t<_Receiver, _Sender>, __stopped_means_break_t<_Receiver>>;
- template <class _Sender, class _Receiver>
- using __select_impl_t = decltype(__select_impl<_Sender, _Receiver>());
+ template <class _Sequence, class _Receiver>
+ concept __subscribable_with_static_member =
+ receiver<_Receiver> && sequence_sender_in<_Sequence, env_of_t<_Receiver>>
+ && sequence_receiver_from<_Receiver, _Sequence>
+ && requires(_Sequence&& __sequence, _Receiver&& __rcvr) {
+ {
+ STDEXEC_REMOVE_REFERENCE(_Sequence)
+ ::subscribe(static_cast<_Sequence&&>(__sequence), static_cast<_Receiver&&>(__rcvr))
+ };
+ };
- template <sender _Sender, receiver _Receiver>
- requires __next_connectable<__tfx_sndr<_Sender, _Receiver>,
- _Receiver> ||
- __subscribeable_with_tag_invoke<__tfx_sndr<_Sender, _Receiver>,
- _Receiver> ||
- __is_debug_env<env_of_t<_Receiver>>
- auto operator()(_Sender&& __sndr, _Receiver&& __rcvr) const
- noexcept(__nothrow_callable<__select_impl_t<_Sender, _Receiver>>)
- -> __call_result_t<__select_impl_t<_Sender, _Receiver>>
- {
- using _TfxSender = __tfx_sndr<_Sender, _Receiver>;
- auto&& __env = get_env(__rcvr);
- auto __domain = __get_late_domain(__sndr, __env);
- if constexpr (__next_connectable<_TfxSender, _Receiver>)
- {
- static_assert(
- operation_state<
- connect_result_t<next_sender_of_t<_Receiver, _TfxSender>,
- __stopped_means_break_t<_Receiver>>>,
- "stdexec::connect(sender, receiver) must return a type that "
- "satisfies the operation_state concept");
- next_sender_of_t<_Receiver, _TfxSender> __next = set_next(
- __rcvr, transform_sender(
- __domain, static_cast<_Sender&&>(__sndr), __env));
- return stdexec::connect(
- static_cast<next_sender_of_t<_Receiver, _TfxSender>&&>(__next),
- __stopped_means_break_t<_Receiver>{
- static_cast<_Receiver&&>(__rcvr)});
- }
- else if constexpr (__subscribeable_with_tag_invoke<_TfxSender,
- _Receiver>)
- {
- static_assert(
- operation_state<
- tag_invoke_result_t<subscribe_t, _TfxSender, _Receiver>>,
- "exec::subscribe(sender, receiver) must return a type that "
- "satisfies the operation_state concept");
- return tag_invoke(
- subscribe_t{},
- transform_sender(__domain, static_cast<_Sender&&>(__sndr),
- __env),
- static_cast<_Receiver&&>(__rcvr));
- }
- else if constexpr (enable_sequence_sender<
- stdexec::__decay_t<_TfxSender>>)
- {
- // This should generate an instantiate backtrace that contains
- // useful debugging information.
- using __tag_invoke::tag_invoke;
- tag_invoke(*this,
- transform_sender(__domain,
- static_cast<_Sender&&>(__sndr), __env),
- static_cast<_Receiver&&>(__rcvr));
- }
- else
- {
- next_sender_of_t<_Receiver, _TfxSender> __next = set_next(
- __rcvr, transform_sender(
- __domain, static_cast<_Sender&&>(__sndr), __env));
- return tag_invoke(
- connect_t{},
- static_cast<next_sender_of_t<_Receiver, _TfxSender>&&>(__next),
- __stopped_means_break_t<_Receiver>{
- static_cast<_Receiver&&>(__rcvr)});
- }
- }
+ template <class _Sequence, class _Receiver>
+ concept __subscribable_with_member = receiver<_Receiver>
+ && sequence_sender_in<_Sequence, env_of_t<_Receiver>>
+ && sequence_receiver_from<_Receiver, _Sequence>
+ && requires(_Sequence&& __sequence, _Receiver&& __rcvr) {
+ {
+ static_cast<_Sequence&&>(__sequence)
+ .subscribe(static_cast<_Receiver&&>(__rcvr))
+ };
+ };
- static constexpr auto query(stdexec::forwarding_query_t) noexcept -> bool
- {
+ template <class _Sequence, class _Receiver>
+ concept __subscribable_with_tag_invoke = receiver<_Receiver>
+ && sequence_sender_in<_Sequence, env_of_t<_Receiver>>
+ && sequence_receiver_from<_Receiver, _Sequence>
+ && tag_invocable<subscribe_t, _Sequence, _Receiver>;
+
+ struct subscribe_t {
+ template <class _Sequence, class _Receiver>
+ using __tfx_sequence_t = __tfx_sequence_t<_Sequence, env_of_t<_Receiver>>;
+
+ template <class _Sequence, class _Receiver>
+ static constexpr auto __select_impl() noexcept {
+ using __domain_t = __late_domain_of_t<_Sequence, env_of_t<_Receiver&>>;
+ constexpr bool _NothrowTfxSequence =
+ __nothrow_callable<transform_sender_t, __domain_t, _Sequence, env_of_t<_Receiver&>>;
+ using __tfx_sequence_t = __tfx_sequence_t<_Sequence, _Receiver>;
+ if constexpr (__next_connectable<__tfx_sequence_t, _Receiver>) {
+ using __result_t = connect_result_t<
+ next_sender_of_t<_Receiver, __tfx_sequence_t>,
+ __stopped_means_break_t<_Receiver>
+ >;
+ static_assert(
+ operation_state<__result_t>,
+ "stdexec::connect(sender, receiver) must return a type that "
+ "satisfies the operation_state concept");
+ constexpr bool _Nothrow = __nothrow_connectable<
+ next_sender_of_t<_Receiver, __tfx_sequence_t>,
+ __stopped_means_break_t<_Receiver>
+ >;
+ return static_cast<__result_t (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (__subscribable_with_static_member<__tfx_sequence_t, _Receiver>) {
+ using __result_t = decltype(STDEXEC_REMOVE_REFERENCE(
+ __tfx_sequence_t)::subscribe(__declval<__tfx_sequence_t>(), __declval<_Receiver>()));
+ static_assert(
+ operation_state<__result_t>,
+ "Sequence::subscribe(sender, receiver) must return a type that "
+ "satisfies the operation_state concept");
+ constexpr bool _Nothrow = _NothrowTfxSequence
+ && noexcept(STDEXEC_REMOVE_REFERENCE(__tfx_sequence_t)::subscribe(
+ __declval<__tfx_sequence_t>(), __declval<_Receiver>()));
+ return static_cast<__result_t (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (__subscribable_with_member<__tfx_sequence_t, _Receiver>) {
+ using __result_t = decltype(__declval<__tfx_sequence_t>()
+ .subscribe(__declval<_Receiver>()));
+ static_assert(
+ operation_state<__result_t>,
+ "Sequence::subscribe(sender, receiver) must return a type that "
+ "satisfies the operation_state concept");
+ constexpr bool _Nothrow = _NothrowTfxSequence
+ && noexcept(__declval<__tfx_sequence_t>()
+ .subscribe(__declval<_Receiver>()));
+ return static_cast<__result_t (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (__subscribable_with_tag_invoke<__tfx_sequence_t, _Receiver>) {
+ using __result_t = tag_invoke_result_t<subscribe_t, __tfx_sequence_t, _Receiver>;
+ static_assert(
+ operation_state<__result_t>,
+ "exec::subscribe(sender, receiver) must return a type that "
+ "satisfies the operation_state concept");
+ constexpr bool _Nothrow = _NothrowTfxSequence
+ && nothrow_tag_invocable<subscribe_t, __tfx_sequence_t, _Receiver>;
+ return static_cast<__result_t (*)() noexcept(_Nothrow)>(nullptr);
+ } else if constexpr (__is_debug_env<env_of_t<_Receiver>>) {
+ using __result_t = __debug::__debug_operation;
+ return static_cast<__result_t (*)() noexcept(_NothrowTfxSequence)>(nullptr);
+ } else {
+ return _NO_USABLE_SUBSCRIBE_CUSTOMIZATION_FOUND_();
+ }
+ }
+
+ template <class _Sequence, class _Receiver>
+ using __select_impl_t = decltype(__select_impl<_Sequence, _Receiver>());
+
+ template <sender _Sequence, receiver _Receiver>
+ auto operator()(_Sequence&& __sequence, _Receiver&& __rcvr) const
+ noexcept(__nothrow_callable<__select_impl_t<_Sequence, _Receiver>>)
+ -> __call_result_t<__select_impl_t<_Sequence, _Receiver>> {
+ using __tfx_sequence_t = __tfx_sequence_t<_Sequence, _Receiver>;
+ auto&& __env = stdexec::get_env(__rcvr);
+ auto __domain = __get_late_domain(__sequence, __env);
+ if constexpr (__next_connectable<__tfx_sequence_t, _Receiver>) {
+ next_sender_of_t<_Receiver, __tfx_sequence_t> __next = set_next(
+ __rcvr,
+ stdexec::transform_sender(__domain, static_cast<_Sequence&&>(__sequence), __env));
+ return stdexec::connect(
+ static_cast<next_sender_of_t<_Receiver, __tfx_sequence_t>&&>(__next),
+ __stopped_means_break_t<_Receiver>{static_cast<_Receiver&&>(__rcvr)});
+ // NOLINTNEXTLINE(bugprone-branch-clone)
+ } else if constexpr (__subscribable_with_static_member<__tfx_sequence_t, _Receiver>) {
+ auto&& __tfx_sequence =
+ transform_sender(__domain, static_cast<_Sequence&&>(__sequence), __env);
+ return __tfx_sequence.subscribe(
+ static_cast<__tfx_sequence_t&&>(__tfx_sequence), static_cast<_Receiver&&>(__rcvr));
+ } else if constexpr (__subscribable_with_member<__tfx_sequence_t, _Receiver>) {
+ return stdexec::transform_sender(__domain, static_cast<_Sequence&&>(__sequence), __env)
+ .subscribe(static_cast<_Receiver&&>(__rcvr));
+ } else if constexpr (__subscribable_with_tag_invoke<__tfx_sequence_t, _Receiver>) {
+ return stdexec::tag_invoke(
+ subscribe_t{},
+ stdexec::transform_sender(__domain, static_cast<_Sequence&&>(__sequence), __env),
+ static_cast<_Receiver&&>(__rcvr));
+ } else if constexpr (enable_sequence_sender<stdexec::__decay_t<__tfx_sequence_t>>) {
+ // This should generate an instantiate backtrace that contains useful
+ // debugging information.
+ auto&& __tfx_sequence =
+ transform_sender(__domain, static_cast<_Sequence&&>(__sequence), __env);
+ return __tfx_sequence.subscribe(
+ static_cast<__tfx_sequence_t&&>(__tfx_sequence), static_cast<_Receiver&&>(__rcvr));
+ } else {
+ // This should generate an instantiate backtrace that contains useful
+ // debugging information.
+ next_sender_of_t<_Receiver, __tfx_sequence_t> __next = set_next(
+ __rcvr,
+ stdexec::transform_sender(__domain, static_cast<_Sequence&&>(__sequence), __env));
+ return stdexec::connect(
+ static_cast<next_sender_of_t<_Receiver, __tfx_sequence_t>&&>(__next),
+ __stopped_means_break_t<_Receiver>{static_cast<_Receiver&&>(__rcvr)});
+ }
+ }
+
+ static constexpr auto query(stdexec::forwarding_query_t) noexcept -> bool {
return false;
- }
-};
-
-template <class _Sender, class _Receiver>
-using subscribe_result_t = __call_result_t<subscribe_t, _Sender, _Receiver>;
-} // namespace __sequence_sndr
-
-using __sequence_sndr::__single_sender_completion_sigs;
-
-using __sequence_sndr::subscribe_t;
-inline constexpr subscribe_t subscribe;
-
-using __sequence_sndr::subscribe_result_t;
-
-template <class _Sender, class _Receiver>
-concept sequence_sender_to =
- sequence_receiver_from<_Receiver, _Sender> && //
- requires(_Sender&& __sndr, _Receiver&& __rcvr) {
- subscribe(static_cast<_Sender&&>(__sndr),
- static_cast<_Receiver&&>(__rcvr));
+ }
};
-template <class _Receiver>
-concept __stoppable_receiver = //
- stdexec::__callable<stdexec::set_value_t, _Receiver> && //
- (stdexec::unstoppable_token<
- stdexec::stop_token_of_t<stdexec::env_of_t<_Receiver>>> ||
- stdexec::__callable<stdexec::set_stopped_t, _Receiver>);
+ template <class _Sequence, class _Receiver>
+ using subscribe_result_t = __call_result_t<subscribe_t, _Sequence, _Receiver>;
+ } // namespace __sequence_sndr
-template <class _Receiver>
+ using __sequence_sndr::__next_sender_completion_sigs_t;
+
+ using __sequence_sndr::subscribe_t;
+ inline constexpr subscribe_t subscribe{};
+
+ using __sequence_sndr::subscribe_result_t;
+
+ template <class _Sequence, class _Receiver>
+ concept sequence_sender_to =
+ sequence_receiver_from<_Receiver, _Sequence>
+ && requires(_Sequence&& __sequence, _Receiver&& __rcvr) {
+ subscribe(static_cast<_Sequence&&>(__sequence), static_cast<_Receiver&&>(__rcvr));
+ };
+
+ template <class _Receiver>
+ concept __stoppable_receiver = stdexec::__callable<stdexec::set_value_t, _Receiver>
+ && (stdexec::unstoppable_token<
+ stdexec::stop_token_of_t<stdexec::env_of_t<_Receiver>>
+ >
+ || stdexec::__callable<stdexec::set_stopped_t, _Receiver>);
+
+ template <class _Receiver>
requires __stoppable_receiver<_Receiver>
-void __set_value_unless_stopped(_Receiver&& __rcvr)
-{
+ void __set_value_unless_stopped(_Receiver&& __rcvr) {
using token_type = stdexec::stop_token_of_t<stdexec::env_of_t<_Receiver>>;
- if constexpr (stdexec::unstoppable_token<token_type>)
- {
+ if constexpr (stdexec::unstoppable_token<token_type>) {
+ stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
+ } else {
+ auto token = stdexec::get_stop_token(stdexec::get_env(__rcvr));
+ if (!token.stop_requested()) {
stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
+ } else {
+ stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
+ }
}
- else
- {
- auto token = stdexec::get_stop_token(stdexec::get_env(__rcvr));
- if (!token.stop_requested())
- {
- stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
- }
- else
- {
- stdexec::set_stopped(static_cast<_Receiver&&>(__rcvr));
- }
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+#define STDEXEC_ERROR_GET_ITEM_TYPES_RETURNED_AN_ERROR \
+ "\n" \
+ "\n" \
+ "Trying to compute the sequences's item types resulted in an error. See\n" \
+ "the rest of the compiler diagnostic for clues. Look for the string \"_ERROR_\".\n"
+
+#define STDEXEC_ERROR_GET_ITEM_TYPES_HAS_INVALID_RETURN_TYPE \
+ "\n" \
+ "\n" \
+ "The member function `get_item_types` of the sequence returned an\n" \
+ "invalid type.\n" \
+ "\n" \
+ "A sender's `get_item_types` function must return a specialization of\n" \
+ "`exec::item_types<...>`, as follows:\n" \
+ "\n" \
+ " class MySequence\n" \
+ " {\n" \
+ " public:\n" \
+ " using sender_concept = exec::sequence_sender_t;\n" \
+ "\n" \
+ " template <class... _Env>\n" \
+ " auto get_item_types(_Env&&...) -> exec::item_types<\n" \
+ " // This sequence produces void items...\n" \
+ " stdexec::__call_result_t<stdexec::just_t>>\n" \
+ " {\n" \
+ " return {};\n" \
+ " }\n" \
+ " ...\n" \
+ " };\n"
+
+ // Used to report a meaningful error message when the sender_in<Sndr, Env>
+ // concept check fails.
+ template <class _Sequence, class... _Env>
+ auto __diagnose_sequence_concept_failure() {
+ if constexpr (!enable_sequence_sender<stdexec::__decay_t<_Sequence>>) {
+ static_assert(enable_sequence_sender<_Sequence>, STDEXEC_ERROR_ENABLE_SENDER_IS_FALSE);
+ } else if constexpr (!stdexec::__detail::__consistent_completion_domains<_Sequence>) {
+ static_assert(
+ stdexec::__detail::__consistent_completion_domains<_Sequence>,
+ "The completion schedulers of the sequence do not have "
+ "consistent domains. This is likely a "
+ "bug in the sequence implementation.");
+ } else if constexpr (!std::move_constructible<stdexec::__decay_t<_Sequence>>) {
+ static_assert(
+ std::move_constructible<stdexec::__decay_t<_Sequence>>,
+ "The sequence type is not move-constructible.");
+ } else if constexpr (!std::constructible_from<stdexec::__decay_t<_Sequence>, _Sequence>) {
+ static_assert(
+ std::constructible_from<stdexec::__decay_t<_Sequence>, _Sequence>,
+ "The sequence cannot be decay-copied. Did you forget a std::move?");
+ } else {
+ using __items_t = __item_types_of_t<_Sequence, _Env...>;
+ if constexpr (stdexec::__same_as<
+ __items_t,
+ __sequence_sndr::__unrecognized_sequence_error_t<_Sequence, _Env...>
+ >) {
+ static_assert(
+ stdexec::__mnever<__items_t>, STDEXEC_ERROR_CANNOT_COMPUTE_COMPLETION_SIGNATURES);
+ } else if constexpr (stdexec::__merror<__items_t>) {
+ static_assert(
+ !stdexec::__merror<__items_t>, STDEXEC_ERROR_GET_ITEM_TYPES_RETURNED_AN_ERROR);
+ } else if constexpr (!__well_formed_item_senders<_Sequence>) {
+ static_assert(
+ __well_formed_item_senders<_Sequence>,
+ STDEXEC_ERROR_GET_ITEM_TYPES_HAS_INVALID_RETURN_TYPE);
+ } else {
+ stdexec::__diagnose_sender_concept_failure<_Sequence, _Env...>();
+ }
}
-}
+ }
+
+ namespace __debug {
+
+ template <class... _Items>
+ struct __valid_next {
+ template <class _Item>
+ requires stdexec::__one_of<_Item, _Items...>
+ STDEXEC_ATTRIBUTE(host, device)
+ stdexec::__call_result_t<stdexec::just_t> set_next(_Item&&) noexcept {
+ STDEXEC_TERMINATE();
+ return stdexec::just();
+ }
+ };
+
+ template <class _CvrefSequenceId, class _Env, class _Completions, class _ItemTypes>
+ struct __debug_sequence_sender_receiver {
+ using __t = __debug_sequence_sender_receiver;
+ using __id = __debug_sequence_sender_receiver;
+ using receiver_concept = stdexec::receiver_t;
+ };
+
+ template <class _CvrefSequenceId, class _Env, class... _Sigs, class... _Items>
+ struct __debug_sequence_sender_receiver<
+ _CvrefSequenceId,
+ _Env,
+ stdexec::completion_signatures<_Sigs...>,
+ item_types<_Items...>
+ >
+ : __valid_completions<__normalize_sig_t<_Sigs>...>
+ , __valid_next<_Items...> {
+ using __t = __debug_sequence_sender_receiver;
+ using __id = __debug_sequence_sender_receiver;
+ using receiver_concept = stdexec::receiver_t;
+
+ STDEXEC_ATTRIBUTE(host, device) auto get_env() const noexcept -> __debug_env_t<_Env> {
+ STDEXEC_TERMINATE();
+ }
+ };
+
+ template <class _Env = stdexec::env<>, class _Sequence>
+ void __debug_sequence_sender(_Sequence&& __sequence, const _Env& = {}) {
+ if constexpr (!__is_debug_env<_Env>) {
+ if constexpr (sequence_sender_in<_Sequence, _Env>) {
+ using __sigs_t = stdexec::__completion_signatures_of_t<_Sequence, __debug_env_t<_Env>>;
+ using __item_types_t = __sequence_sndr::__item_types_of_t<_Sequence, __debug_env_t<_Env>>;
+ using __receiver_t = __debug_sequence_sender_receiver<
+ stdexec::__cvref_id<_Sequence>,
+ _Env,
+ __sigs_t,
+ __item_types_t
+ >;
+ if constexpr (
+ !std::same_as<__sigs_t, __debug::__completion_signatures>
+ || !std::same_as<__item_types_t, __debug::__item_types>) {
+ using __operation_t = exec::subscribe_result_t<_Sequence, __receiver_t>;
+ //static_assert(receiver_of<_Receiver, _Sigs>);
+ if constexpr (!std::same_as<__operation_t, __debug_operation>) {
+ if (sizeof(_Sequence) == ~0ul) { // never true
+ auto __op = subscribe(static_cast<_Sequence&&>(__sequence), __receiver_t{});
+ stdexec::start(__op);
+ }
+ }
+ }
+ } else {
+ __diagnose_sequence_concept_failure<_Sequence, _Env>();
+ }
+ }
+ }
+ } // namespace __debug
+ using __debug::__debug_sequence_sender;
+
+#if STDEXEC_ENABLE_EXTRA_TYPE_CHECKING()
+ // __checked_completion_signatures is for catching logic bugs in a sender's metadata. If sender<S>
+ // and sender_in<S, Ctx> are both true, then they had better report the same metadata. This
+ // completion signatures wrapper enforces that at compile time.
+ template <class _Sequence, class... _Env>
+ auto __checked_item_types(_Sequence&& __sequence, _Env&&... __env) noexcept {
+ using __completions_t =
+ decltype(get_item_types(stdexec::__declval<_Sequence>(), stdexec::__declval<_Env>()...));
+ // (void)__sequence;
+ // [](auto&&...){}(__env...);
+ exec::__debug_sequence_sender(static_cast<_Sequence&&>(__sequence), __env...);
+ return __completions_t{};
+ }
+
+ template <class _Sequence, class... _Env>
+ requires sequence_sender_in<_Sequence, _Env...>
+ using item_types_of_t = decltype(exec::__checked_item_types(
+ stdexec::__declval<_Sequence>(),
+ stdexec::__declval<_Env>()...));
+#else
+ template <class _Sequence, class... _Env>
+ requires sequence_sender_in<_Sequence, _Env...>
+ using item_types_of_t = __item_types_of_t<_Sequence, _Env...>;
+#endif
} // namespace exec
diff --git a/include/sdbusplus/async/stdexec/stop_token.hpp b/include/sdbusplus/async/stdexec/stop_token.hpp
index 5f22a94..7b3b4cb 100644
--- a/include/sdbusplus/async/stdexec/stop_token.hpp
+++ b/include/sdbusplus/async/stdexec/stop_token.hpp
@@ -16,109 +16,72 @@
*/
#pragma once
-#include "__detail/__stop_token.hpp"
+#include "__detail/__stop_token.hpp" // IWYU pragma: export
-#include <atomic>
-#include <concepts>
-#include <cstdint>
-#include <thread>
-#include <type_traits>
-#include <utility>
#include <version>
+#include <cstdint>
+#include <utility>
+#include <atomic>
+#include <thread>
-#if __has_include(<stop_token>) && __cpp_lib_jthread >= 201911
-#include <stop_token>
+#if __has_include(<stop_token>) && __cpp_lib_jthread >= 2019'11L
+# include <stop_token> // IWYU pragma: export
#endif
-namespace stdexec
-{
-namespace __stok
-{
-struct __inplace_stop_callback_base
-{
- void __execute() noexcept
- {
+namespace stdexec {
+ namespace __stok {
+ struct __inplace_stop_callback_base {
+ void __execute() noexcept {
this->__execute_(this);
- }
+ }
- protected:
- using __execute_fn_t = void(__inplace_stop_callback_base*) noexcept;
+ protected:
+ using __execute_fn_t = void(__inplace_stop_callback_base*) noexcept;
- explicit __inplace_stop_callback_base( //
- const inplace_stop_source* __source, //
- __execute_fn_t* __execute) noexcept :
- __source_(__source), __execute_(__execute)
- {}
+ explicit __inplace_stop_callback_base(
+ const inplace_stop_source* __source,
+ __execute_fn_t* __execute) noexcept
+ : __source_(__source)
+ , __execute_(__execute) {
+ }
- void __register_callback_() noexcept;
+ void __register_callback_() noexcept;
- friend inplace_stop_source;
+ friend inplace_stop_source;
- const inplace_stop_source* __source_;
- __execute_fn_t* __execute_;
- __inplace_stop_callback_base* __next_ = nullptr;
- __inplace_stop_callback_base** __prev_ptr_ = nullptr;
- bool* __removed_during_callback_ = nullptr;
- std::atomic<bool> __callback_completed_{false};
-};
-
-struct __spin_wait
-{
- __spin_wait() noexcept = default;
-
- void __wait() noexcept
- {
- if (__count_++ < __yield_threshold_)
- {
- // TODO: _mm_pause();
- }
- else
- {
- if (__count_ == 0)
- __count_ = __yield_threshold_;
- std::this_thread::yield();
- }
- }
-
- private:
- static constexpr uint32_t __yield_threshold_ = 20;
- uint32_t __count_ = 0;
-};
-} // namespace __stok
-
-// [stoptoken.never], class never_stop_token
-struct never_stop_token
-{
- private:
- struct __callback_type
- {
- explicit __callback_type(never_stop_token, auto&&) noexcept {}
+ const inplace_stop_source* __source_;
+ __execute_fn_t* __execute_;
+ __inplace_stop_callback_base* __next_ = nullptr;
+ __inplace_stop_callback_base** __prev_ptr_ = nullptr;
+ bool* __removed_during_callback_ = nullptr;
+ std::atomic<bool> __callback_completed_{false};
};
- public:
- template <class>
- using callback_type = __callback_type;
+ struct __spin_wait {
+ __spin_wait() noexcept = default;
- static constexpr auto stop_requested() noexcept -> bool
- {
- return false;
- }
+ void __wait() noexcept {
+ if (__count_++ < __yield_threshold_) {
+ // TODO: _mm_pause();
+ } else {
+ if (__count_ == 0)
+ __count_ = __yield_threshold_;
+ std::this_thread::yield();
+ }
+ }
- static constexpr auto stop_possible() noexcept -> bool
- {
- return false;
- }
+ private:
+ static constexpr uint32_t __yield_threshold_ = 20;
+ uint32_t __count_ = 0;
+ };
+ } // namespace __stok
- auto operator==(const never_stop_token&) const noexcept -> bool = default;
-};
+ template <class _Callback>
+ class inplace_stop_callback;
-template <class _Callback>
-class inplace_stop_callback;
-
-// [stopsource.inplace], class inplace_stop_source
-class inplace_stop_source
-{
- public:
+ // [stopsource.inplace], class inplace_stop_source
+ class inplace_stop_source {
+ public:
inplace_stop_source() noexcept = default;
~inplace_stop_source();
inplace_stop_source(inplace_stop_source&&) = delete;
@@ -127,13 +90,11 @@
auto request_stop() noexcept -> bool;
- auto stop_requested() const noexcept -> bool
- {
- return (__state_.load(std::memory_order_acquire) &
- __stop_requested_flag_) != 0;
+ auto stop_requested() const noexcept -> bool {
+ return (__state_.load(std::memory_order_acquire) & __stop_requested_flag_) != 0;
}
- private:
+ private:
friend inplace_stop_token;
friend __stok::__inplace_stop_callback_base;
template <class>
@@ -144,11 +105,9 @@
auto __try_lock_unless_stop_requested_(bool) const noexcept -> bool;
- auto __try_add_callback_(
- __stok::__inplace_stop_callback_base*) const noexcept -> bool;
+ auto __try_add_callback_(__stok::__inplace_stop_callback_base*) const noexcept -> bool;
- void __remove_callback_(
- __stok::__inplace_stop_callback_base*) const noexcept;
+ void __remove_callback_(__stok::__inplace_stop_callback_base*) const noexcept;
static constexpr uint8_t __stop_requested_flag_ = 1;
static constexpr uint8_t __locked_flag_ = 2;
@@ -156,294 +115,249 @@
mutable std::atomic<uint8_t> __state_{0};
mutable __stok::__inplace_stop_callback_base* __callbacks_ = nullptr;
std::thread::id __notifying_thread_;
-};
+ };
-// [stoptoken.inplace], class inplace_stop_token
-class inplace_stop_token
-{
- public:
+ // [stoptoken.inplace], class inplace_stop_token
+ class inplace_stop_token {
+ public:
template <class _Fun>
using callback_type = inplace_stop_callback<_Fun>;
- inplace_stop_token() noexcept : __source_(nullptr) {}
+ inplace_stop_token() noexcept
+ : __source_(nullptr) {
+ }
inplace_stop_token(const inplace_stop_token& __other) noexcept = default;
- inplace_stop_token(inplace_stop_token&& __other) noexcept :
- __source_(std::exchange(__other.__source_, {}))
- {}
-
- auto operator=(const inplace_stop_token& __other) noexcept
- -> inplace_stop_token& = default;
-
- auto operator=(inplace_stop_token&& __other) noexcept -> inplace_stop_token&
- {
- __source_ = std::exchange(__other.__source_, nullptr);
- return *this;
+ inplace_stop_token(inplace_stop_token&& __other) noexcept
+ : __source_(std::exchange(__other.__source_, {})) {
}
- [[nodiscard]] auto stop_requested() const noexcept -> bool
- {
- return __source_ != nullptr && __source_->stop_requested();
+ auto operator=(const inplace_stop_token& __other) noexcept -> inplace_stop_token& = default;
+
+ auto operator=(inplace_stop_token&& __other) noexcept -> inplace_stop_token& {
+ __source_ = std::exchange(__other.__source_, nullptr);
+ return *this;
}
- [[nodiscard]] auto stop_possible() const noexcept -> bool
- {
- return __source_ != nullptr;
+ [[nodiscard]]
+ auto stop_requested() const noexcept -> bool {
+ return __source_ != nullptr && __source_->stop_requested();
}
- void swap(inplace_stop_token& __other) noexcept
- {
- std::swap(__source_, __other.__source_);
+ [[nodiscard]]
+ auto stop_possible() const noexcept -> bool {
+ return __source_ != nullptr;
+ }
+
+ void swap(inplace_stop_token& __other) noexcept {
+ std::swap(__source_, __other.__source_);
}
auto operator==(const inplace_stop_token&) const noexcept -> bool = default;
- private:
+ private:
friend inplace_stop_source;
template <class>
friend class inplace_stop_callback;
- explicit inplace_stop_token(const inplace_stop_source* __source) noexcept :
- __source_(__source)
- {}
+ explicit inplace_stop_token(const inplace_stop_source* __source) noexcept
+ : __source_(__source) {
+ }
const inplace_stop_source* __source_;
-};
+ };
-inline auto inplace_stop_source::get_token() const noexcept
- -> inplace_stop_token
-{
+ inline auto inplace_stop_source::get_token() const noexcept -> inplace_stop_token {
return inplace_stop_token{this};
-}
+ }
-// [stopcallback.inplace], class template inplace_stop_callback
-template <class _Fun>
-class inplace_stop_callback : __stok::__inplace_stop_callback_base
-{
- public:
+ // [stopcallback.inplace], class template inplace_stop_callback
+ template <class _Fun>
+ class inplace_stop_callback : __stok::__inplace_stop_callback_base {
+ public:
template <class _Fun2>
- requires constructible_from<_Fun, _Fun2>
- explicit inplace_stop_callback(inplace_stop_token __token,
- _Fun2&& __fun) //
- noexcept(__nothrow_constructible_from<_Fun, _Fun2>) :
- __stok::__inplace_stop_callback_base(
- __token.__source_, &inplace_stop_callback::__execute_impl_),
- __fun_(static_cast<_Fun2&&>(__fun))
- {
- __register_callback_();
+ requires constructible_from<_Fun, _Fun2>
+ explicit inplace_stop_callback(inplace_stop_token __token, _Fun2&& __fun)
+ noexcept(__nothrow_constructible_from<_Fun, _Fun2>)
+ : __stok::__inplace_stop_callback_base(
+ __token.__source_,
+ &inplace_stop_callback::__execute_impl_)
+ , __fun_(static_cast<_Fun2&&>(__fun)) {
+ __register_callback_();
}
- ~inplace_stop_callback()
- {
- if (__source_ != nullptr)
- __source_->__remove_callback_(this);
+ ~inplace_stop_callback() {
+ if (__source_ != nullptr)
+ __source_->__remove_callback_(this);
}
- private:
- static void __execute_impl_(
- __stok::__inplace_stop_callback_base* cb) noexcept
- {
- std::move(static_cast<inplace_stop_callback*>(cb)->__fun_)();
+ private:
+ static void __execute_impl_(__stok::__inplace_stop_callback_base* cb) noexcept {
+ std::move(static_cast<inplace_stop_callback*>(cb)->__fun_)();
}
- STDEXEC_ATTRIBUTE((no_unique_address))
- _Fun __fun_;
-};
+ STDEXEC_ATTRIBUTE(no_unique_address) _Fun __fun_;
+ };
-namespace __stok
-{
-inline void __inplace_stop_callback_base::__register_callback_() noexcept
-{
- if (__source_ != nullptr)
- {
- if (!__source_->__try_add_callback_(this))
- {
- __source_ = nullptr;
- // Callback not registered because stop_requested() was true.
- // Execute inline here.
- __execute();
+ namespace __stok {
+ inline void __inplace_stop_callback_base::__register_callback_() noexcept {
+ if (__source_ != nullptr) {
+ if (!__source_->__try_add_callback_(this)) {
+ __source_ = nullptr;
+ // Callback not registered because stop_requested() was true.
+ // Execute inline here.
+ __execute();
}
+ }
}
-}
-} // namespace __stok
+ } // namespace __stok
-inline inplace_stop_source::~inplace_stop_source()
-{
- STDEXEC_ASSERT(
- (__state_.load(std::memory_order_relaxed) & __locked_flag_) == 0);
+ inline inplace_stop_source::~inplace_stop_source() {
+ STDEXEC_ASSERT((__state_.load(std::memory_order_relaxed) & __locked_flag_) == 0);
STDEXEC_ASSERT(__callbacks_ == nullptr);
-}
+ }
-inline auto inplace_stop_source::request_stop() noexcept -> bool
-{
+ inline auto inplace_stop_source::request_stop() noexcept -> bool {
if (!__try_lock_unless_stop_requested_(true))
- return true;
+ return true;
__notifying_thread_ = std::this_thread::get_id();
// We are responsible for executing callbacks.
- while (__callbacks_ != nullptr)
- {
- auto* __callbk = __callbacks_;
- __callbk->__prev_ptr_ = nullptr;
- __callbacks_ = __callbk->__next_;
- if (__callbacks_ != nullptr)
- __callbacks_->__prev_ptr_ = &__callbacks_;
+ while (__callbacks_ != nullptr) {
+ auto* __callbk = __callbacks_;
+ __callbk->__prev_ptr_ = nullptr;
+ __callbacks_ = __callbk->__next_;
+ if (__callbacks_ != nullptr)
+ __callbacks_->__prev_ptr_ = &__callbacks_;
- __state_.store(__stop_requested_flag_, std::memory_order_release);
+ __state_.store(__stop_requested_flag_, std::memory_order_release);
- bool __removed_during_callback = false;
- __callbk->__removed_during_callback_ = &__removed_during_callback;
+ bool __removed_during_callback = false;
+ __callbk->__removed_during_callback_ = &__removed_during_callback;
- __callbk->__execute();
+ __callbk->__execute();
- if (!__removed_during_callback)
- {
- __callbk->__removed_during_callback_ = nullptr;
- __callbk->__callback_completed_.store(true,
- std::memory_order_release);
- }
+ if (!__removed_during_callback) {
+ __callbk->__removed_during_callback_ = nullptr;
+ __callbk->__callback_completed_.store(true, std::memory_order_release);
+ }
- __lock_();
+ __lock_();
}
__state_.store(__stop_requested_flag_, std::memory_order_release);
return false;
-}
+ }
-inline auto inplace_stop_source::__lock_() const noexcept -> uint8_t
-{
+ inline auto inplace_stop_source::__lock_() const noexcept -> uint8_t {
__stok::__spin_wait __spin;
auto __old_state = __state_.load(std::memory_order_relaxed);
- do
- {
- while ((__old_state & __locked_flag_) != 0)
- {
- __spin.__wait();
- __old_state = __state_.load(std::memory_order_relaxed);
- }
+ do {
+ while ((__old_state & __locked_flag_) != 0) {
+ __spin.__wait();
+ __old_state = __state_.load(std::memory_order_relaxed);
+ }
} while (!__state_.compare_exchange_weak(
- __old_state, __old_state | __locked_flag_, std::memory_order_acquire,
- std::memory_order_relaxed));
+ __old_state,
+ __old_state | __locked_flag_,
+ std::memory_order_acquire,
+ std::memory_order_relaxed));
return __old_state;
-}
+ }
-inline void inplace_stop_source::__unlock_(uint8_t __old_state) const noexcept
-{
- (void)__state_.store(__old_state, std::memory_order_release);
-}
+ inline void inplace_stop_source::__unlock_(uint8_t __old_state) const noexcept {
+ (void) __state_.store(__old_state, std::memory_order_release);
+ }
-inline auto inplace_stop_source::__try_lock_unless_stop_requested_(
- bool __set_stop_requested) const noexcept -> bool
-{
+ inline auto
+ inplace_stop_source::__try_lock_unless_stop_requested_(bool __set_stop_requested) const noexcept
+ -> bool {
__stok::__spin_wait __spin;
auto __old_state = __state_.load(std::memory_order_relaxed);
- do
- {
- while (true)
- {
- if ((__old_state & __stop_requested_flag_) != 0)
- {
- // Stop already requested.
- return false;
- }
- else if (__old_state == 0)
- {
- break;
- }
- else
- {
- __spin.__wait();
- __old_state = __state_.load(std::memory_order_relaxed);
- }
+ do {
+ while (true) {
+ if ((__old_state & __stop_requested_flag_) != 0) {
+ // Stop already requested.
+ return false;
+ } else if (__old_state == 0) {
+ break;
+ } else {
+ __spin.__wait();
+ __old_state = __state_.load(std::memory_order_relaxed);
}
+ }
} while (!__state_.compare_exchange_weak(
- __old_state,
- __set_stop_requested ? (__locked_flag_ | __stop_requested_flag_)
- : __locked_flag_,
- std::memory_order_acq_rel, std::memory_order_relaxed));
+ __old_state,
+ __set_stop_requested ? (__locked_flag_ | __stop_requested_flag_) : __locked_flag_,
+ std::memory_order_acq_rel,
+ std::memory_order_relaxed));
// Lock acquired successfully
return true;
-}
+ }
-inline auto inplace_stop_source::__try_add_callback_(
- __stok::__inplace_stop_callback_base* __callbk) const noexcept -> bool
-{
- if (!__try_lock_unless_stop_requested_(false))
- {
- return false;
+ inline auto inplace_stop_source::__try_add_callback_(
+ __stok::__inplace_stop_callback_base* __callbk) const noexcept -> bool {
+ if (!__try_lock_unless_stop_requested_(false)) {
+ return false;
}
__callbk->__next_ = __callbacks_;
__callbk->__prev_ptr_ = &__callbacks_;
- if (__callbacks_ != nullptr)
- {
- __callbacks_->__prev_ptr_ = &__callbk->__next_;
+ if (__callbacks_ != nullptr) {
+ __callbacks_->__prev_ptr_ = &__callbk->__next_;
}
__callbacks_ = __callbk;
__unlock_(0);
return true;
-}
+ }
-inline void inplace_stop_source::__remove_callback_(
- __stok::__inplace_stop_callback_base* __callbk) const noexcept
-{
+ inline void inplace_stop_source::__remove_callback_(
+ __stok::__inplace_stop_callback_base* __callbk) const noexcept {
auto __old_state = __lock_();
- if (__callbk->__prev_ptr_ != nullptr)
- {
- // Callback has not been executed yet.
- // Remove from the list.
- *__callbk->__prev_ptr_ = __callbk->__next_;
- if (__callbk->__next_ != nullptr)
- {
- __callbk->__next_->__prev_ptr_ = __callbk->__prev_ptr_;
+ if (__callbk->__prev_ptr_ != nullptr) {
+ // Callback has not been executed yet.
+ // Remove from the list.
+ *__callbk->__prev_ptr_ = __callbk->__next_;
+ if (__callbk->__next_ != nullptr) {
+ __callbk->__next_->__prev_ptr_ = __callbk->__prev_ptr_;
+ }
+ __unlock_(__old_state);
+ } else {
+ auto __notifying_thread = __notifying_thread_;
+ __unlock_(__old_state);
+
+ // Callback has either already been executed or is
+ // currently executing on another thread.
+ if (std::this_thread::get_id() == __notifying_thread) {
+ if (__callbk->__removed_during_callback_ != nullptr) {
+ *__callbk->__removed_during_callback_ = true;
}
- __unlock_(__old_state);
+ } else {
+ // Concurrently executing on another thread.
+ // Wait until the other thread finishes executing the callback.
+ __stok::__spin_wait __spin;
+ while (!__callbk->__callback_completed_.load(std::memory_order_acquire)) {
+ __spin.__wait();
+ }
+ }
}
- else
- {
- auto __notifying_thread = __notifying_thread_;
- __unlock_(__old_state);
+ }
- // Callback has either already been executed or is
- // currently executing on another thread.
- if (std::this_thread::get_id() == __notifying_thread)
- {
- if (__callbk->__removed_during_callback_ != nullptr)
- {
- *__callbk->__removed_during_callback_ = true;
- }
- }
- else
- {
- // Concurrently executing on another thread.
- // Wait until the other thread finishes executing the callback.
- __stok::__spin_wait __spin;
- while (!__callbk->__callback_completed_.load(
- std::memory_order_acquire))
- {
- __spin.__wait();
- }
- }
- }
-}
+ using in_place_stop_token
+ [[deprecated("in_place_stop_token has been renamed inplace_stop_token")]] = inplace_stop_token;
-using in_place_stop_token
- [[deprecated("in_place_stop_token has been renamed inplace_stop_token")]] =
- inplace_stop_token;
+ using in_place_stop_source [[deprecated(
+ "in_place_stop_token has been renamed inplace_stop_source")]] = inplace_stop_source;
-using in_place_stop_source
- [[deprecated("in_place_stop_token has been renamed inplace_stop_source")]] =
- inplace_stop_source;
-
-template <class _Fun>
-using in_place_stop_callback [[deprecated(
- "in_place_stop_callback has been renamed inplace_stop_callback")]] =
- inplace_stop_callback<_Fun>;
+ template <class _Fun>
+ using in_place_stop_callback
+ [[deprecated("in_place_stop_callback has been renamed inplace_stop_callback")]] =
+ inplace_stop_callback<_Fun>;
} // namespace stdexec
diff --git a/include/sdbusplus/async/stdexec/task.hpp b/include/sdbusplus/async/stdexec/task.hpp
index 5e3f94f..9eb73c7 100644
--- a/include/sdbusplus/async/stdexec/task.hpp
+++ b/include/sdbusplus/async/stdexec/task.hpp
@@ -15,589 +15,512 @@
*/
#pragma once
-#include "../stdexec/__detail/__meta.hpp"
-#include "../stdexec/__detail/__optional.hpp"
-#include "../stdexec/__detail/__variant.hpp"
-#include "../stdexec/coroutine.hpp"
-#include "../stdexec/execution.hpp"
-#include "any_sender_of.hpp"
-#include "at_coroutine_exit.hpp"
-#include "inline_scheduler.hpp"
-#include "scope.hpp"
-
#include <any>
#include <cassert>
#include <exception>
#include <utility>
+#include "../stdexec/execution.hpp"
+#include "../stdexec/__detail/__meta.hpp"
+#include "../stdexec/__detail/__optional.hpp"
+#include "../stdexec/__detail/__variant.hpp"
+
+#include "any_sender_of.hpp"
+#include "at_coroutine_exit.hpp"
+#include "scope.hpp"
+
STDEXEC_PRAGMA_PUSH()
STDEXEC_PRAGMA_IGNORE_GNU("-Wundefined-inline")
-namespace exec
-{
-namespace __task
-{
-using namespace stdexec;
+namespace exec {
+ namespace __task {
+ using namespace stdexec;
-using __any_scheduler = //
- any_receiver_ref< //
- completion_signatures<set_error_t(std::exception_ptr),
- set_stopped_t()> //
- >::any_sender<>::any_scheduler<>;
-static_assert(scheduler<__any_scheduler>);
+ // The required set_value_t() scheduler-sender completion signature is added in
+ // any_receiver_ref::any_sender::any_scheduler.
+ using __any_scheduler_completions =
+ completion_signatures<set_error_t(std::exception_ptr), set_stopped_t()>;
-template <class _Ty>
-concept __stop_token_provider = //
- requires(const _Ty& t) { //
- get_stop_token(t);
+ using __any_scheduler =
+ any_receiver_ref<__any_scheduler_completions>::any_sender<>::any_scheduler<>;
+
+ static_assert(scheduler<__any_scheduler>);
+
+ template <class _Ty>
+ concept __stop_token_provider = requires(const _Ty& t) { get_stop_token(t); };
+
+ template <class _Ty>
+ concept __indirect_stop_token_provider = requires(const _Ty& t) {
+ { get_env(t) } -> __stop_token_provider;
};
-template <class _Ty>
-concept __indirect_stop_token_provider = //
- requires(const _Ty& t) {
- { get_env(t) } -> __stop_token_provider;
+ template <class _Ty>
+ concept __indirect_scheduler_provider = requires(const _Ty& t) {
+ { get_env(t) } -> __scheduler_provider;
};
-template <class _Ty>
-concept __indirect_scheduler_provider = //
- requires(const _Ty& t) {
- { get_env(t) } -> __scheduler_provider;
- };
+ template <class _ParentPromise>
+ constexpr auto __check_parent_promise_has_scheduler() noexcept -> bool {
+ static_assert(
+ __indirect_scheduler_provider<_ParentPromise>,
+ "exec::task<T> cannot be co_await-ed in a coroutine that "
+ "does not have an associated scheduler.");
+ return __indirect_scheduler_provider<_ParentPromise>;
+ }
-template <class _ParentPromise>
-constexpr bool __check_parent_promise_has_scheduler() noexcept
-{
- static_assert(__indirect_scheduler_provider<_ParentPromise>,
- "exec::task<T> cannot be co_await-ed in a coroutine that "
- "does not have an associated scheduler.");
- return __indirect_scheduler_provider<_ParentPromise>;
-}
+ struct __forward_stop_request {
+ inplace_stop_source& __stop_source_;
-struct __forward_stop_request
-{
- inplace_stop_source& __stop_source_;
-
- void operator()() noexcept
- {
+ void operator()() noexcept {
__stop_source_.request_stop();
- }
-};
+ }
+ };
-template <class _ParentPromise>
-struct __default_awaiter_context;
-
-////////////////////////////////////////////////////////////////////////////////
-// This is the context that is associated with basic_task's promise type
-// by default. It handles forwarding of stop requests from parent to child.
-enum class __scheduler_affinity
-{
- __none,
- __sticky
-};
-
-struct __parent_promise_t
-{};
-
-template <__scheduler_affinity _SchedulerAffinity =
- __scheduler_affinity::__sticky>
-class __default_task_context_impl
-{
template <class _ParentPromise>
- friend struct __default_awaiter_context;
+ struct __default_awaiter_context;
- static constexpr bool __with_scheduler =
- _SchedulerAffinity == __scheduler_affinity::__sticky;
+ ////////////////////////////////////////////////////////////////////////////////
+ // This is the context that is associated with basic_task's promise type
+ // by default. It handles forwarding of stop requests from parent to child.
+ enum class __scheduler_affinity {
+ __none,
+ __sticky
+ };
- STDEXEC_ATTRIBUTE((no_unique_address))
- __if_c<__with_scheduler, __any_scheduler, __ignore> //
- __scheduler_{exec::inline_scheduler{}};
- inplace_stop_token __stop_token_;
+ template <__scheduler_affinity _SchedulerAffinity = __scheduler_affinity::__sticky>
+ class __default_task_context_impl {
+ template <class _ParentPromise>
+ friend struct __default_awaiter_context;
- public:
- template <class _ParentPromise>
- explicit __default_task_context_impl(__parent_promise_t,
- _ParentPromise& __parent) noexcept
- {
- if constexpr (_SchedulerAffinity == __scheduler_affinity::__sticky)
- {
- if constexpr (__check_parent_promise_has_scheduler<
- _ParentPromise>())
- {
- __scheduler_ = get_scheduler(get_env(__parent));
- }
+ static constexpr bool __with_scheduler = _SchedulerAffinity == __scheduler_affinity::__sticky;
+
+ STDEXEC_ATTRIBUTE(no_unique_address)
+ __if_c<__with_scheduler, __any_scheduler, __ignore> __scheduler_{stdexec::inline_scheduler{}};
+ inplace_stop_token __stop_token_;
+
+ public:
+ template <class _ParentPromise>
+ explicit __default_task_context_impl(_ParentPromise& __parent) noexcept {
+ if constexpr (_SchedulerAffinity == __scheduler_affinity::__sticky) {
+ if constexpr (__check_parent_promise_has_scheduler<_ParentPromise>()) {
+ __scheduler_ = get_scheduler(get_env(__parent));
+ }
}
- }
+ }
- template <scheduler _Scheduler>
- explicit __default_task_context_impl(_Scheduler&& __scheduler) :
- __scheduler_{static_cast<_Scheduler&&>(__scheduler)}
- {}
+ template <scheduler _Scheduler>
+ explicit __default_task_context_impl(_Scheduler&& __scheduler)
+ : __scheduler_{static_cast<_Scheduler&&>(__scheduler)} {
+ }
- auto query(get_scheduler_t) const noexcept -> const __any_scheduler&
+ [[nodiscard]]
+ auto query(get_scheduler_t) const noexcept -> const __any_scheduler&
requires(__with_scheduler)
- {
+ {
return __scheduler_;
- }
+ }
- auto query(get_stop_token_t) const noexcept -> inplace_stop_token
- {
+ [[nodiscard]]
+ auto query(get_stop_token_t) const noexcept -> inplace_stop_token {
return __stop_token_;
- }
+ }
- [[nodiscard]] auto stop_requested() const noexcept -> bool
- {
+ [[nodiscard]]
+ auto stop_requested() const noexcept -> bool {
return __stop_token_.stop_requested();
- }
+ }
- template <scheduler _Scheduler>
- void set_scheduler(_Scheduler&& __sched)
+ template <scheduler _Scheduler>
+ void set_scheduler(_Scheduler&& __sched)
requires(__with_scheduler)
- {
+ {
__scheduler_ = static_cast<_Scheduler&&>(__sched);
- }
+ }
- template <class _ThisPromise>
- using promise_context_t = __default_task_context_impl;
+ template <class _ThisPromise>
+ using promise_context_t = __default_task_context_impl;
- template <class _ThisPromise, class _ParentPromise = void>
- requires(!__with_scheduler) ||
- __indirect_scheduler_provider<_ParentPromise>
- using awaiter_context_t = __default_awaiter_context<_ParentPromise>;
-};
+ template <class _ThisPromise, class _ParentPromise = void>
+ requires(!__with_scheduler) || __indirect_scheduler_provider<_ParentPromise>
+ using awaiter_context_t = __default_awaiter_context<_ParentPromise>;
+ };
-template <class _Ty>
-using default_task_context =
- __default_task_context_impl<__scheduler_affinity::__sticky>;
+ template <class _Ty>
+ using default_task_context = __default_task_context_impl<__scheduler_affinity::__sticky>;
-template <class _Ty>
-using __raw_task_context =
- __default_task_context_impl<__scheduler_affinity::__none>;
+ template <class _Ty>
+ using __raw_task_context = __default_task_context_impl<__scheduler_affinity::__none>;
-// This is the context associated with basic_task's awaiter. By default
-// it does nothing.
-template <class _ParentPromise>
-struct __default_awaiter_context
-{
- template <__scheduler_affinity _Affinity>
- explicit __default_awaiter_context(
- __default_task_context_impl<_Affinity>& __self,
- _ParentPromise& __parent) noexcept
- {}
-};
+ // This is the context associated with basic_task's awaiter. By default
+ // it does nothing.
+ template <class _ParentPromise>
+ struct __default_awaiter_context {
+ template <__scheduler_affinity _Affinity>
+ explicit __default_awaiter_context(
+ __default_task_context_impl<_Affinity>&,
+ _ParentPromise&) noexcept {
+ }
+ };
-////////////////////////////////////////////////////////////////////////////////
-// This is the context to be associated with basic_task's awaiter when
-// the parent coroutine's promise type is known, is a __stop_token_provider,
-// and its stop token type is neither inplace_stop_token nor unstoppable.
-template <__indirect_stop_token_provider _ParentPromise>
-struct __default_awaiter_context<_ParentPromise>
-{
- using __stop_token_t = stop_token_of_t<env_of_t<_ParentPromise>>;
- using __stop_callback_t =
- typename __stop_token_t::template callback_type<__forward_stop_request>;
+ ////////////////////////////////////////////////////////////////////////////////
+ // This is the context to be associated with basic_task's awaiter when
+ // the parent coroutine's promise type is known, is a __stop_token_provider,
+ // and its stop token type is neither inplace_stop_token nor unstoppable.
+ template <__indirect_stop_token_provider _ParentPromise>
+ struct __default_awaiter_context<_ParentPromise> {
+ using __stop_token_t = stop_token_of_t<env_of_t<_ParentPromise>>;
+ using __stop_callback_t = __stop_token_t::template callback_type<__forward_stop_request>;
- template <__scheduler_affinity _Affinity>
- explicit __default_awaiter_context(
+ template <__scheduler_affinity _Affinity>
+ explicit __default_awaiter_context(
__default_task_context_impl<_Affinity>& __self,
_ParentPromise& __parent) noexcept
// Register a callback that will request stop on this basic_task's
// stop_source when stop is requested on the parent coroutine's stop
// token.
- :
- __stop_callback_{get_stop_token(get_env(__parent)),
- __forward_stop_request{__stop_source_}}
- {
- static_assert(
- std::is_nothrow_constructible_v<__stop_callback_t, __stop_token_t,
- __forward_stop_request>);
+ : __stop_callback_{
+ get_stop_token(get_env(__parent)),
+ __forward_stop_request{__stop_source_}} {
+ static_assert(std::is_nothrow_constructible_v<
+ __stop_callback_t,
+ __stop_token_t,
+ __forward_stop_request
+ >);
__self.__stop_token_ = __stop_source_.get_token();
- }
+ }
- inplace_stop_source __stop_source_{};
- __stop_callback_t __stop_callback_;
-};
+ inplace_stop_source __stop_source_{};
+ __stop_callback_t __stop_callback_;
+ };
-// If the parent coroutine's type has a stop token of type inplace_stop_token,
-// we don't need to register a stop callback.
-template <__indirect_stop_token_provider _ParentPromise>
- requires std::same_as<inplace_stop_token,
- stop_token_of_t<env_of_t<_ParentPromise>>>
-struct __default_awaiter_context<_ParentPromise>
-{
- template <__scheduler_affinity _Affinity>
- explicit __default_awaiter_context(
+ // If the parent coroutine's type has a stop token of type inplace_stop_token,
+ // we don't need to register a stop callback.
+ template <__indirect_stop_token_provider _ParentPromise>
+ requires std::same_as<inplace_stop_token, stop_token_of_t<env_of_t<_ParentPromise>>>
+ struct __default_awaiter_context<_ParentPromise> {
+ template <__scheduler_affinity _Affinity>
+ explicit __default_awaiter_context(
__default_task_context_impl<_Affinity>& __self,
- _ParentPromise& __parent) noexcept
- {
+ _ParentPromise& __parent) noexcept {
__self.__stop_token_ = get_stop_token(get_env(__parent));
- }
-};
+ }
+ };
-// If the parent coroutine's stop token is unstoppable, there's no point
-// forwarding stop tokens or stop requests at all.
-template <__indirect_stop_token_provider _ParentPromise>
- requires unstoppable_token<stop_token_of_t<env_of_t<_ParentPromise>>>
-struct __default_awaiter_context<_ParentPromise>
-{
- template <__scheduler_affinity _Affinity>
- explicit __default_awaiter_context(__default_task_context_impl<_Affinity>&,
- _ParentPromise&) noexcept
- {}
-};
+ // If the parent coroutine's stop token is unstoppable, there's no point
+ // forwarding stop tokens or stop requests at all.
+ template <__indirect_stop_token_provider _ParentPromise>
+ requires unstoppable_token<stop_token_of_t<env_of_t<_ParentPromise>>>
+ struct __default_awaiter_context<_ParentPromise> {
+ template <__scheduler_affinity _Affinity>
+ explicit __default_awaiter_context(
+ __default_task_context_impl<_Affinity>&,
+ _ParentPromise&) noexcept {
+ }
+ };
-// Finally, if we don't know the parent coroutine's promise type, assume the
-// worst and save a type-erased stop callback.
-template <>
-struct __default_awaiter_context<void>
-{
- template <__scheduler_affinity _Affinity, class _ParentPromise>
- explicit __default_awaiter_context(
+ // Finally, if we don't know the parent coroutine's promise type, assume the
+ // worst and save a type-erased stop callback.
+ template <>
+ struct __default_awaiter_context<void> {
+ template <__scheduler_affinity _Affinity, class _ParentPromise>
+ explicit __default_awaiter_context(
+ __default_task_context_impl<_Affinity>&,
+ _ParentPromise&) noexcept {
+ }
+
+ template <__scheduler_affinity _Affinity, __indirect_stop_token_provider _ParentPromise>
+ explicit __default_awaiter_context(
__default_task_context_impl<_Affinity>& __self,
- _ParentPromise& __parent) noexcept
- {}
-
- template <__scheduler_affinity _Affinity,
- __indirect_stop_token_provider _ParentPromise>
- explicit __default_awaiter_context(
- __default_task_context_impl<_Affinity>& __self,
- _ParentPromise& __parent)
- {
+ _ParentPromise& __parent) {
// Register a callback that will request stop on this basic_task's
// stop_source when stop is requested on the parent coroutine's stop
// token.
using __stop_token_t = stop_token_of_t<env_of_t<_ParentPromise>>;
- using __stop_callback_t =
- stop_callback_for_t<__stop_token_t, __forward_stop_request>;
+ using __stop_callback_t = stop_callback_for_t<__stop_token_t, __forward_stop_request>;
- if constexpr (std::same_as<__stop_token_t, inplace_stop_token>)
- {
- __self.__stop_token_ = get_stop_token(get_env(__parent));
+ if constexpr (std::same_as<__stop_token_t, inplace_stop_token>) {
+ __self.__stop_token_ = get_stop_token(get_env(__parent));
+ } else if (auto __token = get_stop_token(get_env(__parent)); __token.stop_possible()) {
+ __stop_callback_
+ .emplace<__stop_callback_t>(std::move(__token), __forward_stop_request{__stop_source_});
+ __self.__stop_token_ = __stop_source_.get_token();
}
- else if (auto __token = get_stop_token(get_env(__parent));
- __token.stop_possible())
- {
- __stop_callback_.emplace<__stop_callback_t>(
- std::move(__token), __forward_stop_request{__stop_source_});
- __self.__stop_token_ = __stop_source_.get_token();
- }
- }
+ }
- inplace_stop_source __stop_source_{};
- std::any __stop_callback_{};
-};
+ inplace_stop_source __stop_source_{};
+ std::any __stop_callback_{};
+ };
-template <class _Promise, class _ParentPromise = void>
-using awaiter_context_t = //
- typename __decay_t<env_of_t<_Promise>> //
- ::template awaiter_context_t<_Promise, _ParentPromise>;
+ template <class _Promise, class _ParentPromise = void>
+ using awaiter_context_t =
+ __decay_t<env_of_t<_Promise>>::template awaiter_context_t<_Promise, _ParentPromise>;
-////////////////////////////////////////////////////////////////////////////////
-// In a base class so it can be specialized when _Ty is void:
-template <class _Ty>
-struct __promise_base
-{
- void return_value(_Ty value)
- {
+ ////////////////////////////////////////////////////////////////////////////////
+ // In a base class so it can be specialized when _Ty is void:
+ template <class _Ty>
+ struct __promise_base {
+ void return_value(_Ty value) {
__data_.template emplace<0>(std::move(value));
- }
+ }
- __variant_for<_Ty, std::exception_ptr> __data_{};
-};
+ __variant_for<_Ty, std::exception_ptr> __data_{};
+ };
-template <>
-struct __promise_base<void>
-{
- struct __void
- {};
+ template <>
+ struct __promise_base<void> {
+ struct __void { };
- void return_void()
- {
+ void return_void() {
__data_.template emplace<0>(__void{});
- }
+ }
- __variant_for<__void, std::exception_ptr> __data_{};
-};
+ __variant_for<__void, std::exception_ptr> __data_{};
+ };
-enum class disposition : unsigned
-{
- stopped,
- succeeded,
- failed,
-};
+ template <class _Sch>
+ struct __just_void {
+ using sender_concept = sender_t;
+ using completion_signatures = stdexec::completion_signatures<set_value_t()>;
-struct __reschedule_coroutine_on
-{
- template <class _Scheduler>
- struct __wrap
- {
+ template <class _Rcvr>
+ [[nodiscard]]
+ static constexpr auto connect(_Rcvr __rcvr) noexcept {
+ return stdexec::connect(just(), static_cast<_Rcvr&&>(__rcvr));
+ }
+
+ [[nodiscard]]
+ constexpr auto get_env() const noexcept {
+ return prop{get_completion_scheduler<set_value_t>, __sch_};
+ }
+
+ _Sch __sch_;
+ };
+
+ enum class disposition : unsigned {
+ stopped,
+ succeeded,
+ failed,
+ };
+
+ struct __reschedule_coroutine_on {
+ template <class _Scheduler>
+ struct __wrap {
_Scheduler __sched_;
- };
+ };
- template <scheduler _Scheduler>
- auto operator()(_Scheduler __sched) const noexcept -> __wrap<_Scheduler>
- {
+ template <scheduler _Scheduler>
+ auto operator()(_Scheduler __sched) const noexcept -> __wrap<_Scheduler> {
return {static_cast<_Scheduler&&>(__sched)};
- }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// basic_task
-template <class _Ty, class _Context = default_task_context<_Ty>>
-class [[nodiscard]] basic_task
-{
- struct __promise;
-
- public:
- using __t = basic_task;
- using __id = basic_task;
- using promise_type = __promise;
-
- basic_task(basic_task&& __that) noexcept :
- __coro_(std::exchange(__that.__coro_, {}))
- {}
-
- ~basic_task()
- {
- if (__coro_)
- __coro_.destroy();
- }
-
- private:
- struct __final_awaitable
- {
- static constexpr auto await_ready() noexcept -> bool
- {
- return false;
- }
-
- static auto await_suspend(
- __coro::coroutine_handle<__promise> __h) noexcept
- -> __coro::coroutine_handle<>
- {
- return __h.promise().continuation().handle();
- }
-
- static void await_resume() noexcept {}
+ }
};
- using __promise_context_t =
- typename _Context::template promise_context_t<__promise>;
+ ////////////////////////////////////////////////////////////////////////////////
+ // basic_task
+ template <class _Ty, class _Context = default_task_context<_Ty>>
+ class [[nodiscard]] basic_task {
+ struct __promise;
+ public:
+ using __t = basic_task;
+ using __id = basic_task;
+ using promise_type = __promise;
- struct __promise : __promise_base<_Ty>, with_awaitable_senders<__promise>
- {
+ basic_task(basic_task&& __that) noexcept
+ : __coro_(std::exchange(__that.__coro_, {})) {
+ }
+
+ ~basic_task() {
+ if (__coro_)
+ __coro_.destroy();
+ }
+
+ private:
+ using __scheduler_t =
+ __query_result_or_t<get_scheduler_t, _Context, stdexec::inline_scheduler>;
+
+ struct __final_awaitable {
+ static constexpr auto await_ready() noexcept -> bool {
+ return false;
+ }
+
+ static auto await_suspend(__coro::coroutine_handle<__promise> __h) noexcept
+ -> __coro::coroutine_handle<> {
+ return __h.promise().continuation().handle();
+ }
+
+ static void await_resume() noexcept {
+ }
+ };
+
+ using __promise_context_t = _Context::template promise_context_t<__promise>;
+
+ struct __promise
+ : __promise_base<_Ty>
+ , with_awaitable_senders<__promise> {
using __t = __promise;
using __id = __promise;
- auto get_return_object() noexcept -> basic_task
- {
- return basic_task(
- __coro::coroutine_handle<__promise>::from_promise(*this));
+ auto get_return_object() noexcept -> basic_task {
+ return basic_task(__coro::coroutine_handle<__promise>::from_promise(*this));
}
- auto initial_suspend() noexcept -> __coro::suspend_always
- {
- return {};
+ auto initial_suspend() noexcept -> __coro::suspend_always {
+ return {};
}
- auto final_suspend() noexcept -> __final_awaitable
- {
- return {};
+ auto final_suspend() noexcept -> __final_awaitable {
+ return {};
}
- [[nodiscard]] auto disposition() const noexcept -> __task::disposition
- {
- switch (this->__data_.index())
- {
- case 0:
- return __task::disposition::succeeded;
- case 1:
- return __task::disposition::failed;
- default:
- return __task::disposition::stopped;
- }
+ [[nodiscard]]
+ auto disposition() const noexcept -> __task::disposition {
+ switch (this->__data_.index()) {
+ case 0:
+ return __task::disposition::succeeded;
+ case 1:
+ return __task::disposition::failed;
+ default:
+ return __task::disposition::stopped;
+ }
}
- void unhandled_exception() noexcept
- {
- this->__data_.template emplace<1>(std::current_exception());
+ void unhandled_exception() noexcept {
+ this->__data_.template emplace<1>(std::current_exception());
}
+#ifndef __clang_analyzer__
template <sender _Awaitable>
- requires __scheduler_provider<_Context>
- auto await_transform(_Awaitable&& __awaitable) noexcept
- -> decltype(auto)
- {
- // TODO: If we have a complete-where-it-starts query then we can
- // optimize this to avoid the reschedule
- return as_awaitable(
- continues_on(static_cast<_Awaitable&&>(__awaitable),
- get_scheduler(*__context_)),
- *this);
+ requires __scheduler_provider<_Context>
+ auto await_transform(_Awaitable&& __awaitable) noexcept -> decltype(auto) {
+ // TODO: If we have a complete-where-it-starts query then we can optimize
+ // this to avoid the reschedule
+ return stdexec::as_awaitable(
+ continues_on(static_cast<_Awaitable&&>(__awaitable), get_scheduler(*__context_)),
+ *this);
}
template <class _Scheduler>
- requires __scheduler_provider<_Context>
- auto await_transform(
- __reschedule_coroutine_on::__wrap<_Scheduler> __box) noexcept
- -> decltype(auto)
- {
- if (!std::exchange(__rescheduled_, true))
- {
- // Create a cleanup action that transitions back onto the
- // current scheduler:
- auto __sched = get_scheduler(*__context_);
- auto __cleanup_task =
- at_coroutine_exit(schedule, std::move(__sched));
- // Insert the cleanup action into the head of the continuation
- // chain by making direct calls to the cleanup task's awaiter
- // member functions. See type _cleanup_task in
- // at_coroutine_exit.hpp:
- __cleanup_task.await_suspend(
- __coro::coroutine_handle<__promise>::from_promise(*this));
- (void)__cleanup_task.await_resume();
- }
- __context_->set_scheduler(__box.__sched_);
- return as_awaitable(schedule(__box.__sched_), *this);
+ requires __scheduler_provider<_Context>
+ auto await_transform(__reschedule_coroutine_on::__wrap<_Scheduler> __box) noexcept
+ -> decltype(auto) {
+ if (!std::exchange(__rescheduled_, true)) {
+ // Create a cleanup action that transitions back onto the current scheduler:
+ auto __sched = get_scheduler(*__context_);
+ auto __cleanup_task = at_coroutine_exit(schedule, std::move(__sched));
+ // Insert the cleanup action into the head of the continuation chain by making
+ // direct calls to the cleanup task's awaiter member functions. See type
+ // _cleanup_task in at_coroutine_exit.hpp:
+ __cleanup_task.await_suspend(__coro::coroutine_handle<__promise>::from_promise(*this));
+ (void) __cleanup_task.await_resume();
+ }
+ __context_->set_scheduler(__box.__sched_);
+ return stdexec::as_awaitable(schedule(__box.__sched_), *this);
+ }
+#endif
+
+ template <__sender_adaptor_closure_for<__just_void<__scheduler_t>> _Closure>
+ auto await_transform(_Closure&& __closure) noexcept -> decltype(auto) {
+ return await_transform(static_cast<_Closure&&>(__closure)(__just_void<__scheduler_t>()));
}
template <class _Awaitable>
- auto await_transform(_Awaitable&& __awaitable) noexcept
- -> decltype(auto)
- {
- return with_awaitable_senders<__promise>::await_transform(
- static_cast<_Awaitable&&>(__awaitable));
+ auto await_transform(_Awaitable&& __awaitable) noexcept -> decltype(auto) {
+ return with_awaitable_senders<__promise>::await_transform(
+ static_cast<_Awaitable&&>(__awaitable));
}
- auto get_env() const noexcept -> const __promise_context_t&
- {
- return *__context_;
+ auto get_env() const noexcept -> const __promise_context_t& {
+ return *__context_;
}
__optional<__promise_context_t> __context_{};
bool __rescheduled_{false};
- };
+ };
- template <class _ParentPromise = void>
- struct __task_awaitable
- {
+ template <class _ParentPromise = void>
+ struct __task_awaitable {
__coro::coroutine_handle<__promise> __coro_;
__optional<awaiter_context_t<__promise, _ParentPromise>> __context_{};
- ~__task_awaitable()
- {
- if (__coro_)
- __coro_.destroy();
+ ~__task_awaitable() {
+ if (__coro_)
+ __coro_.destroy();
}
- static constexpr auto await_ready() noexcept -> bool
- {
- return false;
+ static constexpr auto await_ready() noexcept -> bool {
+ return false;
}
template <class _ParentPromise2>
- auto await_suspend(
- __coro::coroutine_handle<_ParentPromise2> __parent) noexcept
- -> __coro::coroutine_handle<>
- {
- static_assert(__one_of<_ParentPromise, _ParentPromise2, void>);
- __coro_.promise().__context_.emplace(__parent_promise_t(),
- __parent.promise());
- __context_.emplace(*__coro_.promise().__context_,
- __parent.promise());
- __coro_.promise().set_continuation(__parent);
- if constexpr (requires {
- __coro_.promise().stop_requested() ? 0 : 1;
- })
- {
- if (__coro_.promise().stop_requested())
- return __parent.promise().unhandled_stopped();
- }
- return __coro_;
+ auto await_suspend(__coro::coroutine_handle<_ParentPromise2> __parent) noexcept
+ -> __coro::coroutine_handle<> {
+ static_assert(__one_of<_ParentPromise, _ParentPromise2, void>);
+ __coro_.promise().__context_.emplace(__parent.promise());
+ __context_.emplace(*__coro_.promise().__context_, __parent.promise());
+ __coro_.promise().set_continuation(__parent);
+ if constexpr (requires { __coro_.promise().stop_requested() ? 0 : 1; }) {
+ if (__coro_.promise().stop_requested())
+ return __parent.promise().unhandled_stopped();
+ }
+ return __coro_;
}
- auto await_resume() -> _Ty
- {
- __context_.reset();
- scope_guard __on_exit{[this]() noexcept {
- std::exchange(__coro_, {}).destroy();
- }};
- if (__coro_.promise().__data_.index() == 1)
- std::rethrow_exception(
- std::move(__coro_.promise().__data_.template get<1>()));
- if constexpr (!std::is_void_v<_Ty>)
- return std::move(__coro_.promise().__data_.template get<0>());
+ auto await_resume() -> _Ty {
+ __context_.reset();
+ scope_guard __on_exit{[this]() noexcept { std::exchange(__coro_, {}).destroy(); }};
+ if (__coro_.promise().__data_.index() == 1)
+ std::rethrow_exception(std::move(__coro_.promise().__data_.template get<1>()));
+ if constexpr (!std::is_void_v<_Ty>)
+ return std::move(__coro_.promise().__data_.template get<0>());
}
- };
+ };
- public:
- // Make this task awaitable within a particular context:
- template <class _ParentPromise>
+ public:
+ // Make this task awaitable within a particular context:
+ template <class _ParentPromise>
requires constructible_from<
- awaiter_context_t<__promise, _ParentPromise>, __promise_context_t&,
- _ParentPromise&>
- STDEXEC_MEMFN_DECL(auto as_awaitable)(this basic_task&& __self,
- _ParentPromise&) noexcept
- -> __task_awaitable<_ParentPromise>
- {
- return __task_awaitable<_ParentPromise>{
- std::exchange(__self.__coro_, {})};
- }
+ awaiter_context_t<__promise, _ParentPromise>,
+ __promise_context_t&,
+ _ParentPromise&
+ >
+ auto as_awaitable(_ParentPromise&) && noexcept -> __task_awaitable<_ParentPromise> {
+ return __task_awaitable<_ParentPromise>{std::exchange(__coro_, {})};
+ }
- // Make this task generally awaitable:
- auto operator co_await() && noexcept -> __task_awaitable<>
+ // Make this task generally awaitable:
+ auto operator co_await() && noexcept -> __task_awaitable<>
requires __mvalid<awaiter_context_t, __promise>
- {
+ {
return __task_awaitable<>{std::exchange(__coro_, {})};
- }
+ }
- // From the list of types [_Ty], remove any types that are void, and send
- // the resulting list to __qf<set_value_t>, which uses the list of types
- // as arguments of a function type. In other words, set_value_t() if _Ty
- // is void, and set_value_t(_Ty) otherwise.
- using __set_value_sig_t =
- __minvoke<__mremove<void, __qf<set_value_t>>, _Ty>;
+ explicit basic_task(__coro::coroutine_handle<promise_type> __coro) noexcept
+ : __coro_(__coro) {
+ }
- // Specify basic_task's completion signatures
- // This is only necessary when basic_task is not generally awaitable
- // owing to constraints imposed by its _Context parameter.
- using __task_traits_t = //
- completion_signatures<__set_value_sig_t,
- set_error_t(std::exception_ptr), set_stopped_t()>;
+ __coro::coroutine_handle<promise_type> __coro_;
+ };
+ } // namespace __task
- auto get_completion_signatures(__ignore = {}) const -> __task_traits_t
- {
- return {};
- }
+ using task_disposition = __task::disposition;
- explicit basic_task(__coro::coroutine_handle<promise_type> __coro) noexcept
- : __coro_(__coro)
- {}
+ template <class _Ty>
+ using default_task_context = __task::default_task_context<_Ty>;
- __coro::coroutine_handle<promise_type> __coro_;
-};
-} // namespace __task
+ template <class _Promise, class _ParentPromise = void>
+ using awaiter_context_t = __task::awaiter_context_t<_Promise, _ParentPromise>;
-using task_disposition = __task::disposition;
+ template <class _Ty, class _Context = default_task_context<_Ty>>
+ using basic_task = __task::basic_task<_Ty, _Context>;
-template <class _Ty>
-using default_task_context = __task::default_task_context<_Ty>;
+ template <class _Ty>
+ using task = basic_task<_Ty, default_task_context<_Ty>>;
-template <class _Promise, class _ParentPromise = void>
-using awaiter_context_t = __task::awaiter_context_t<_Promise, _ParentPromise>;
-
-template <class _Ty, class _Context = default_task_context<_Ty>>
-using basic_task = __task::basic_task<_Ty, _Context>;
-
-template <class _Ty>
-using task = basic_task<_Ty, default_task_context<_Ty>>;
-
-inline constexpr __task::__reschedule_coroutine_on reschedule_coroutine_on{};
+ inline constexpr __task::__reschedule_coroutine_on reschedule_coroutine_on{};
} // namespace exec
-namespace stdexec
-{
-template <class _Ty, class _Context>
-inline constexpr bool enable_sender<exec::basic_task<_Ty, _Context>> = true;
+namespace stdexec {
+ template <class _Ty, class _Context>
+ inline constexpr bool enable_sender<exec::basic_task<_Ty, _Context>> = true;
} // namespace stdexec
STDEXEC_PRAGMA_POP()