stdexec: update to latest commit
Signed-off-by: Patrick Williams <patrick@stwcx.xyz>
Change-Id: I6b64c4f7181d4aa298e3b863c39c04b551caa442
diff --git a/include/sdbusplus/async/stdexec/__detail/__env.hpp b/include/sdbusplus/async/stdexec/__detail/__env.hpp
index 229de70..3c0ff09 100644
--- a/include/sdbusplus/async/stdexec/__detail/__env.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__env.hpp
@@ -325,230 +325,23 @@
__call_result_t<query_or_t, _Tag, _Queryable, _Default>;
/////////////////////////////////////////////////////////////////////////////
-// env_of
namespace __env
{
-template <class _Descriptor>
-struct __prop;
-
-template <class _Value, class... _Tags>
-struct __prop<_Value(_Tags...)>
-{
- using __t = __prop;
- using __id = __prop;
- _Value __value_;
-
- template <__one_of<_Tags...> _Key>
- friend auto tag_invoke(_Key, const __prop& __self) //
- noexcept(__nothrow_decay_copyable<_Value>) -> _Value
- {
- return __self.__value_;
- }
-};
-
-template <class... _Tags>
-struct __prop<void(_Tags...)>
-{
- using __t = __prop;
- using __id = __prop;
-
- template <__one_of<_Tags...> _Key, class _Self>
- requires(std::is_base_of_v<__prop, __decay_t<_Self>>)
- friend auto tag_invoke(_Key, _Self&&) noexcept = delete;
-};
-
-struct __mkprop_t
-{
- template <class _Value, class _Tag, class... _Tags>
- auto operator()(_Value&& __value, _Tag, _Tags...) const
- noexcept(__nothrow_decay_copyable<_Value>)
- -> __prop<__decay_t<_Value>(_Tag, _Tags...)>
- {
- return {(_Value&&)__value};
- }
-
- template <class _Tag>
- auto operator()(_Tag) const -> __prop<void(_Tag)>
- {
- return {};
- }
-};
-
-template <__nothrow_move_constructible _Fun>
-struct __env_fn
-{
- using __t = __env_fn;
- using __id = __env_fn;
- STDEXEC_ATTRIBUTE((no_unique_address)) _Fun __fun_;
-
- template <class _Tag>
- requires __callable<const _Fun&, _Tag>
- friend auto tag_invoke(_Tag, const __env_fn& __self) //
- noexcept(__nothrow_callable<const _Fun&, _Tag>)
- -> __call_result_t<const _Fun&, _Tag>
- {
- return __self.__fun_(_Tag());
- }
-};
-
-template <class _Fun>
-__env_fn(_Fun) -> __env_fn<_Fun>;
-
-template <class _Env>
-struct __env_fwd
-{
- static_assert(__nothrow_move_constructible<_Env>);
- using __t = __env_fwd;
- using __id = __env_fwd;
- STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_;
-
- template <__forwarding_query _Tag>
- requires tag_invocable<_Tag, const _Env&>
- friend auto tag_invoke(_Tag, const __env_fwd& __self) //
- noexcept(nothrow_tag_invocable<_Tag, const _Env&>)
- -> tag_invoke_result_t<_Tag, const _Env&>
- {
- return _Tag()(__self.__env_);
- }
-};
-
-template <class _Env>
-__env_fwd(_Env&&) -> __env_fwd<_Env>;
-
-template <class _Env, class _Base = empty_env>
-struct __joined_env : __env_fwd<_Base>
-{
- static_assert(__nothrow_move_constructible<_Env>);
- using __t = __joined_env;
- using __id = __joined_env;
- STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_;
-
- const _Base& base() const noexcept
- {
- return this->__env_fwd<_Base>::__env_;
- }
-
- template <class _Tag>
- requires tag_invocable<_Tag, const _Env&>
- friend auto tag_invoke(_Tag, const __joined_env& __self) //
- noexcept(nothrow_tag_invocable<_Tag, const _Env&>)
- -> tag_invoke_result_t<_Tag, const _Env&>
- {
- return _Tag()(__self.__env_);
- }
-};
-
-template <class _Tag, class _Base>
-struct __joined_env<__prop<void(_Tag)>, _Base> : __env_fwd<_Base>
-{
- using __t = __joined_env;
- using __id = __joined_env;
- STDEXEC_ATTRIBUTE((no_unique_address)) __prop<void(_Tag)> __env_;
-
- friend void tag_invoke(_Tag, const __joined_env&) noexcept = delete;
-};
-
-struct __join_env_t
-{
- template <class _Env>
- _Env operator()(_Env&& __env) const noexcept
- {
- return (_Env&&)__env;
- }
-
- template <class _Env, class _Base>
- decltype(auto) operator()(_Env&& __env, _Base&& __base) const noexcept
- {
- using __env_t = __decay_t<_Env>;
- using __base_t = __decay_t<_Base>;
- if constexpr (__same_as<__env_t, empty_env>)
- {
- return _Base((_Base&&)__base);
- }
- else if constexpr (__same_as<__base_t, empty_env>)
- {
- return _Env((_Env&&)__env);
- }
- else
- {
- return __joined_env<_Env, _Base>{{(_Base&&)__base}, (_Env&&)__env};
- }
- }
-
- template <class _Env0, class _Env1, class _Env2, class... _Envs>
- decltype(auto) operator()(_Env0&& __env0, _Env1&& __env1, _Env2&& __env2,
- _Envs&&... __envs) const noexcept
- {
- const auto& __join_env = *this;
- return __join_env(
- (_Env0&&)__env0,
- __join_env((_Env1&&)__env1,
- __join_env((_Env2&&)__env2, (_Envs&&)__envs...)));
- }
-};
-
-template <class... _Envs>
-using __env_join_t = __call_result_t<__join_env_t, _Envs...>;
-
-// To be kept in sync with the promise type used in __connect_awaitable
-template <class _Env>
-struct __env_promise
-{
- template <class _Ty>
- _Ty&& await_transform(_Ty&& __value) noexcept
- {
- return (_Ty&&)__value;
- }
-
- template <class _Ty>
- requires tag_invocable<as_awaitable_t, _Ty, __env_promise&>
- auto await_transform(_Ty&& __value) //
- noexcept(nothrow_tag_invocable<as_awaitable_t, _Ty, __env_promise&>)
- -> tag_invoke_result_t<as_awaitable_t, _Ty, __env_promise&>
- {
- return tag_invoke(as_awaitable, (_Ty&&)__value, *this);
- }
-
- template <same_as<get_env_t> _Tag>
- friend auto tag_invoke(_Tag, const __env_promise&) noexcept -> const _Env&
- {
- std::terminate();
- }
-};
-
-// For making an environment from key/value pairs and optionally
-// another environment.
-struct __make_env_t
-{
- template <__nothrow_move_constructible _Base,
- __nothrow_move_constructible _Env>
- auto operator()(_Base&& __base, _Env&& __env) const noexcept
- -> __env_join_t<_Env, _Base>
- {
- return __join_env_t()((_Env&&)__env, (_Base&&)__base);
- }
-
- template <__nothrow_move_constructible _Env>
- _Env operator()(_Env&& __env) const noexcept
- {
- return (_Env&&)__env;
- }
-};
-
-// For getting an evaluation environment from a receiver
+// For getting an execution environment from a receiver,
+// or the attributes from a sender.
struct get_env_t
{
template <class _EnvProvider>
requires tag_invocable<get_env_t, const _EnvProvider&>
STDEXEC_ATTRIBUTE((always_inline)) //
constexpr auto
- operator()(const _EnvProvider& __with_env) const noexcept
+ 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, __with_env);
+ return tag_invoke(*this, __env_provider);
}
template <class _EnvProvider>
@@ -557,28 +350,259 @@
return {};
}
};
+
+// To be kept in sync with the promise type used in __connect_awaitable
+template <class _Env>
+struct __promise
+{
+ template <class _Ty>
+ _Ty&& await_transform(_Ty&& __value) noexcept
+ {
+ return (_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, (_Ty&&)__value, *this);
+ }
+
+ template <same_as<get_env_t> _Tag>
+ friend auto tag_invoke(_Tag, const __promise&) noexcept -> const _Env&
+ {
+ std::terminate();
+ }
+};
+
+template <class _Value, class _Tag, class... _Tags>
+struct __with
+{
+ using __t = __with;
+ using __id = __with;
+ _Value __value_;
+
+ constexpr __with(_Value __value) noexcept(
+ __nothrow_decay_copyable<_Value>) :
+ __value_((_Value&&)__value)
+ {}
+
+ constexpr explicit __with(_Value __value, _Tag, _Tags...) noexcept(
+ __nothrow_decay_copyable<_Value>) :
+ __value_((_Value&&)__value)
+ {}
+
+ template <__one_of<_Tag, _Tags...> _Key>
+ friend auto tag_invoke(_Key, const __with& __self) //
+ noexcept(__nothrow_decay_copyable<_Value>) -> _Value
+ {
+ return __self.__value_;
+ }
+};
+
+template <class _Value, class _Tag, class... _Tags>
+__with(_Value, _Tag, _Tags...) -> __with<_Value, _Tag, _Tags...>;
+
+template <class _Tag, class... _Tags>
+struct __without
+{
+ using __t = __without;
+ using __id = __without;
+
+ __without() = default;
+
+ constexpr explicit __without(_Tag, _Tags...) noexcept {}
+};
+
+template <class _Env>
+struct __fwd
+{
+ static_assert(__nothrow_move_constructible<_Env>);
+ using __t = __fwd;
+ using __id = __fwd;
+ STDEXEC_ATTRIBUTE((no_unique_address)) _Env __env_;
+
+ template <__forwarding_query _Tag>
+ requires tag_invocable<_Tag, const _Env&>
+ friend auto tag_invoke(_Tag, const __fwd& __self) //
+ noexcept(nothrow_tag_invocable<_Tag, const _Env&>)
+ -> tag_invoke_result_t<_Tag, const _Env&>
+ {
+ return _Tag()(__self.__env_);
+ }
+};
+
+template <class _Env>
+__fwd(_Env&&) -> __fwd<_Env>;
+
+template <class _Second, class _First>
+struct __joined : _Second
+{
+ static_assert(__nothrow_move_constructible<_First>);
+ static_assert(__nothrow_move_constructible<_Second>);
+ using __t = __joined;
+ using __id = __joined;
+
+ STDEXEC_ATTRIBUTE((no_unique_address)) _First __env_;
+
+ template <class _Tag>
+ requires tag_invocable<_Tag, const _First&>
+ friend auto tag_invoke(_Tag, const __joined& __self) //
+ noexcept(nothrow_tag_invocable<_Tag, const _First&>)
+ -> tag_invoke_result_t<_Tag, const _First&>
+ {
+ return _Tag()(__self.__env_);
+ }
+};
+
+template <class _Second, class _Tag, class... _Tags>
+struct __joined<_Second, __without<_Tag, _Tags...>> :
+ _Second,
+ __without<_Tag, _Tags...>
+{
+ using __t = __joined;
+ using __id = __joined;
+
+ template <__one_of<_Tag, _Tags...> _Key, class _Self>
+ requires(std::is_base_of_v<__joined, __decay_t<_Self>>)
+ friend auto tag_invoke(_Key, _Self&&) noexcept = delete;
+};
+
+template <class _Second, class _First>
+__joined(_Second&&, _First&&) -> __joined<_Second, _First>;
+
+template <__nothrow_move_constructible _Fun>
+struct __from
+{
+ using __t = __from;
+ using __id = __from;
+ STDEXEC_ATTRIBUTE((no_unique_address)) _Fun __fun_;
+
+ template <class _Tag>
+ requires __callable<const _Fun&, _Tag>
+ friend auto tag_invoke(_Tag, const __from& __self) //
+ noexcept(__nothrow_callable<const _Fun&, _Tag>)
+ -> __call_result_t<const _Fun&, _Tag>
+ {
+ return __self.__fun_(_Tag());
+ }
+};
+
+template <class _Fun>
+__from(_Fun) -> __from<_Fun>;
+
+struct __fwd_fn
+{
+ template <class Env>
+ auto operator()(Env&& env) const
+ {
+ return __fwd{(Env&&)env};
+ }
+
+ empty_env operator()(empty_env) const
+ {
+ return {};
+ }
+
+ template <class _Tag, class... _Tags>
+ __without<_Tag, _Tags...> operator()(__without<_Tag, _Tags...>) const
+ {
+ return {};
+ }
+};
+
+struct __join_fn
+{
+ empty_env operator()() const
+ {
+ return {};
+ }
+
+ template <class _Env>
+ _Env operator()(_Env&& __env) const
+ {
+ return (_Env&&)__env;
+ }
+
+ empty_env operator()(empty_env) const
+ {
+ return {};
+ }
+
+ template <class _Tag, class... _Tags>
+ empty_env operator()(__without<_Tag, _Tags...>) const
+ {
+ return {};
+ }
+
+ template <class _Env>
+ _Env operator()(_Env&& __env, empty_env) const
+ {
+ return (_Env&&)__env;
+ }
+
+ template <class _Env, class _Tag, class... _Tags>
+ _Env operator()(_Env&& __env, __without<_Tag, _Tags...>) const
+ {
+ return (_Env&&)__env;
+ }
+
+ empty_env operator()(empty_env, empty_env) const
+ {
+ return {};
+ }
+
+ template <class _Tag, class... _Tags>
+ empty_env operator()(empty_env, __without<_Tag, _Tags...>) const
+ {
+ return {};
+ }
+
+ template <class _Tag, class... _Tags>
+ empty_env operator()(__without<_Tag, _Tags...>, empty_env) const
+ {
+ return {};
+ }
+
+ template <class _Tag, class... _Tags, class _Tag2, class... _Tags2>
+ empty_env operator()(__without<_Tag, _Tags...>,
+ __without<_Tag2, _Tags2...>) const
+ {
+ return {};
+ }
+
+ template <class... Rest>
+ decltype(auto) operator()(empty_env, Rest&&... rest) const
+ {
+ return __fwd_fn()(__join_fn()((Rest&&)rest...));
+ }
+
+ template <class _Tag, class... _Tags, class... Rest>
+ decltype(auto) operator()(__without<_Tag, _Tags...>, Rest&&... rest) const
+ {
+ return __joined{__fwd_fn()(__join_fn()((Rest&&)rest...)),
+ __without<_Tag, _Tags...>()};
+ }
+
+ template <class First, class... Rest>
+ decltype(auto) operator()(First&& first, Rest&&... rest) const
+ {
+ return __joined{__fwd_fn()(__join_fn()((Rest&&)rest...)),
+ (First&&)first};
+ }
+};
+
+inline constexpr __join_fn __join{};
+
+template <class... _Envs>
+using __join_t = __result_of<__join, _Envs...>;
} // namespace __env
using __env::empty_env;
-using __empty_env
- [[deprecated("Please use stdexec::empty_env now.")]] = empty_env;
-
-using __env::__env_promise;
-
-inline constexpr __env::__make_env_t __make_env{};
-inline constexpr __env::__join_env_t __join_env{};
-inline constexpr __env::get_env_t get_env{};
-
-// for making an environment from a single key/value pair
-inline constexpr __env::__mkprop_t __mkprop{};
-
-template <class _Tag, class _Value = void>
-using __with = __env::__prop<_Value(_Tag)>;
-
-template <class... _Ts>
-using __make_env_t = __call_result_t<__env::__make_env_t, _Ts...>;
-
-using __default_env = empty_env;
+using __env::get_env_t;
+inline constexpr get_env_t get_env{};
template <class _EnvProvider>
concept environment_provider = //
diff --git a/include/sdbusplus/async/stdexec/__detail/__meta.hpp b/include/sdbusplus/async/stdexec/__detail/__meta.hpp
index 8ddc0de..2a4c33b 100644
--- a/include/sdbusplus/async/stdexec/__detail/__meta.hpp
+++ b/include/sdbusplus/async/stdexec/__detail/__meta.hpp
@@ -170,29 +170,58 @@
const char __what_[_Len];
};
+STDEXEC_PRAGMA_PUSH()
+STDEXEC_PRAGMA_IGNORE_GNU("-Wuser-defined-literals")
+
#if STDEXEC_NVHPC() && (__EDG_VERSION__ < 604)
// Use a non-standard extension for older nvc++ releases
template <__mchar _Char, _Char... _Str>
-constexpr __mstring<sizeof...(_Str)> operator""__csz() noexcept
+[[deprecated("Use _mstr instead")]] constexpr __mstring<sizeof...(_Str)>
+ operator""__csz() noexcept
+{
+ return {_Str...};
+}
+
+// Use a non-standard extension for older nvc++ releases
+template <__mchar _Char, _Char... _Str>
+constexpr __mstring<sizeof...(_Str)> operator""_mstr() noexcept
{
return {_Str...};
}
#elif STDEXEC_NVHPC() && (__EDG_VERSION__ < 605)
// This is to work around an unfiled (by me) EDG bug that fixed in build 605
template <__mstring _Str>
-constexpr const __mtypeof<_Str> operator""__csz() noexcept
+[[deprecated("Use _mstr instead")]] constexpr const __mtypeof<_Str>
+ operator""__csz() noexcept
+{
+ return _Str;
+}
+
+// This is to work around an unfiled (by me) EDG bug that fixed in build 605
+template <__mstring _Str>
+constexpr const __mtypeof<_Str> operator""_mstr() noexcept
{
return _Str;
}
#else
// Use a standard user-defined string literal template
template <__mstring _Str>
-constexpr __mtypeof<_Str> operator""__csz() noexcept
+[[deprecated("Use _mstr instead")]] constexpr __mtypeof<_Str>
+ operator""__csz() noexcept
+{
+ return _Str;
+}
+
+// Use a standard user-defined string literal template
+template <__mstring _Str>
+constexpr __mtypeof<_Str> operator""_mstr() noexcept
{
return _Str;
}
#endif
+STDEXEC_PRAGMA_POP()
+
using __msuccess = int;
template <class _What, class... _With>
@@ -415,7 +444,7 @@
};
inline constexpr __mstring __mbad_substitution =
- "The specified meta-function could not be evaluated with the types provided."__csz;
+ "The specified meta-function could not be evaluated with the types provided."_mstr;
template <__mstring _Diagnostic = __mbad_substitution>
struct _BAD_SUBSTITUTION_
@@ -798,20 +827,6 @@
template <const auto& _Fun, class... _As>
using __result_of = __call_result_t<decltype(_Fun), _As...>;
-#if STDEXEC_CLANG() && (__clang_major__ < 13)
-template <class _Ty>
-constexpr auto __hide_ = [] { return (__mtype<_Ty>(*)())0; };
-#else
-template <class _Ty>
-extern decltype([] { return (__mtype<_Ty>(*)())0; }) __hide_;
-#endif
-
-template <class _Ty>
-using __hide = decltype(__hide_<_Ty>);
-
-template <class _Id>
-using __unhide = __t<__call_result_t<__call_result_t<_Id>>>;
-
// For working around clang's lack of support for CWG#2369:
// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#2369
struct __qcall_result
diff --git a/include/sdbusplus/async/stdexec/any_sender_of.hpp b/include/sdbusplus/async/stdexec/any_sender_of.hpp
index 5336954..42f5302 100644
--- a/include/sdbusplus/async/stdexec/any_sender_of.hpp
+++ b/include/sdbusplus/async/stdexec/any_sender_of.hpp
@@ -966,7 +966,7 @@
template <class _Env>
using __env_t =
- __make_env_t<_Env, __with<get_stop_token_t, in_place_stop_token>>;
+ __env::__join_t<__env::__with<in_place_stop_token, get_stop_token_t>, _Env>;
template <class _ReceiverId>
struct __stoppable_receiver
@@ -1020,9 +1020,10 @@
friend __env_t<env_of_t<_Receiver>>
tag_invoke(_GetEnv, const _Self& __self) noexcept
{
- return __make_env(get_env(__self.__op_->__rcvr_),
- __mkprop(__self.__op_->__stop_source_.get_token(),
- get_stop_token));
+ return __env::__join(
+ __env::__with(__self.__op_->__stop_source_.get_token(),
+ get_stop_token),
+ get_env(__self.__op_->__rcvr_));
}
};
};
diff --git a/include/sdbusplus/async/stdexec/async_scope.hpp b/include/sdbusplus/async/stdexec/async_scope.hpp
index 8c2483f..1669953 100644
--- a/include/sdbusplus/async/stdexec/async_scope.hpp
+++ b/include/sdbusplus/async/stdexec/async_scope.hpp
@@ -254,6 +254,7 @@
struct __nest_sender
{
using _Constrained = stdexec::__t<_ConstrainedId>;
+
struct __t
{
using __id = __nest_sender;
@@ -751,9 +752,8 @@
// async_scope::spawn implementation
template <class _Env>
using __spawn_env_t =
- __result_of<__join_env, _Env,
- __env::__prop<in_place_stop_token(get_stop_token_t)>,
- __env::__prop<__inln::__scheduler(get_scheduler_t)>>;
+ __env::__join_t<_Env, __env::__with<in_place_stop_token, get_stop_token_t>,
+ __env::__with<__inln::__scheduler, get_scheduler_t>>;
template <class _EnvId>
struct __spawn_op_base
@@ -783,9 +783,9 @@
// BUGBUG NOT TO SPEC spawn shouldn't accept senders that can fail.
template <same_as<set_error_t> _Tag>
[[noreturn]] friend void tag_invoke(_Tag, __t&&,
- const std::exception_ptr&) noexcept
+ std::exception_ptr __eptr) noexcept
{
- std::terminate();
+ std::rethrow_exception(std::move(__eptr));
}
friend const __spawn_env_t<_Env>& tag_invoke(get_env_t,
@@ -810,10 +810,11 @@
template <__decays_to<_Sender> _Sndr>
__t(_Sndr&& __sndr, _Env __env, const __impl* __scope) :
__spawn_op_base<_EnvId>{
- __join_env((_Env&&)__env,
- __mkprop(__scope->__stop_source_.get_token(),
- get_stop_token),
- __mkprop(__inln::__scheduler{}, get_scheduler)),
+ __env::__join(
+ (_Env&&)__env,
+ __env::__with(__scope->__stop_source_.get_token(),
+ get_stop_token),
+ __env::__with(__inln::__scheduler{}, get_scheduler)),
[](__spawn_op_base<_EnvId>* __op) {
delete static_cast<__t*>(__op);
}},
diff --git a/include/sdbusplus/async/stdexec/commit.info b/include/sdbusplus/async/stdexec/commit.info
index 6788e94..96d8212 100644
--- a/include/sdbusplus/async/stdexec/commit.info
+++ b/include/sdbusplus/async/stdexec/commit.info
@@ -1 +1 @@
-98f1f7a18dba497859b7705ce60d31e0ba3d204d
+ad16d4a45053f7d16f037e08b51c11c0cb305ecc
diff --git a/include/sdbusplus/async/stdexec/concepts.hpp b/include/sdbusplus/async/stdexec/concepts.hpp
index a5ebe4a..17f5467 100644
--- a/include/sdbusplus/async/stdexec/concepts.hpp
+++ b/include/sdbusplus/async/stdexec/concepts.hpp
@@ -84,6 +84,10 @@
// Avoid using libstdc++'s object concepts because they instantiate a
// lot of templates.
+#if STDEXEC_HAS_BUILTIN(__is_nothrow_destructible)
+template <class _Ty>
+concept destructible = __is_nothrow_destructible(_Ty);
+#else
template <class _Ty>
inline constexpr bool __destructible_ = //
requires {
@@ -100,6 +104,7 @@
template <class T>
concept destructible = __destructible_<T>;
+#endif
#if STDEXEC_HAS_BUILTIN(__is_constructible)
template <class _Ty, class... _As>
diff --git a/include/sdbusplus/async/stdexec/env.hpp b/include/sdbusplus/async/stdexec/env.hpp
index c77176f..30f1a70 100644
--- a/include/sdbusplus/async/stdexec/env.hpp
+++ b/include/sdbusplus/async/stdexec/env.hpp
@@ -23,33 +23,63 @@
namespace exec
{
template <class _Tag, class _Value = void>
-using with_t = stdexec::__with<_Tag, _Value>;
+using with_t = stdexec::__if_c<stdexec::same_as<_Value, void>,
+ stdexec::__env::__without<_Tag>,
+ stdexec::__env::__with<_Value, _Tag>>;
namespace __detail
{
struct __with_t
{
template <class _Tag, class _Value>
- with_t<_Tag, stdexec::__decay_t<_Value>> operator()(_Tag,
- _Value&& __val) const
+ auto operator()(_Tag, _Value&& __val) const
{
- return stdexec::__mkprop((_Value&&)__val, _Tag());
+ return stdexec::__env::__with((_Value&&)__val, _Tag());
}
template <class _Tag>
- with_t<_Tag> operator()(_Tag) const
+ [[deprecated("use exec::without(Tag) instead")]] auto operator()(_Tag) const
{
- return stdexec::__mkprop(_Tag());
+ return stdexec::__env::__without(_Tag());
+ }
+};
+
+struct __without_t
+{
+ template <class _Tag>
+ auto operator()(_Tag) const
+ {
+ return stdexec::__env::__without(_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((_Env&&)__env, (_Base&&)__base);
+ }
+
+ template <stdexec::__nothrow_move_constructible _Env>
+ _Env operator()(_Env&& __env) const noexcept
+ {
+ return (_Env&&)__env;
}
};
} // namespace __detail
inline constexpr __detail::__with_t with{};
+inline constexpr __detail::__without_t without{};
-inline constexpr stdexec::__env::__make_env_t make_env{};
+inline constexpr __detail::__make_env_t make_env{};
template <class... _Ts>
-using make_env_t = stdexec::__make_env_t<_Ts...>;
+using make_env_t = stdexec::__result_of<make_env, _Ts...>;
namespace __read_with_default
{
diff --git a/include/sdbusplus/async/stdexec/execution.hpp b/include/sdbusplus/async/stdexec/execution.hpp
index 87abcd9..cceb182 100644
--- a/include/sdbusplus/async/stdexec/execution.hpp
+++ b/include/sdbusplus/async/stdexec/execution.hpp
@@ -154,7 +154,7 @@
{
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."__csz;
+ "because the attempt to compute the completion signatures failed."_mstr;
template <__mstring _Diagnostic = __unrecognized_sender_type_diagnostic>
struct _UNRECOGNIZED_SENDER_TYPE_;
@@ -293,7 +293,7 @@
__mbool<!__valid_completion_signatures<_Completions>>;
template <__mstring _Msg =
- "Expected an instance of template completion_signatures<>"__csz>
+ "Expected an instance of template completion_signatures<>"_mstr>
struct _INVALID_COMPLETION_SIGNATURES_TYPE_
{
template <class... _Completions>
@@ -406,7 +406,8 @@
-> tag_invoke_result_t<__is_debug_env_t, const _Env&>;
};
template <class _Env>
-using __debug_env_t = __make_env_t<_Env, __with<__is_debug_env_t, bool>>;
+using __debug_env_t =
+ __env::__join_t<__env::__with<bool, __is_debug_env_t>, _Env>;
template <class _Env>
concept __is_debug_env = tag_invocable<__debug::__is_debug_env_t, _Env>;
@@ -590,7 +591,7 @@
{
if constexpr (!__is_debug_env<_Env>)
{
- if (sizeof(_Sender) == ~0)
+ if (sizeof(_Sender) == ~0u)
{ // never true
using _Receiver =
__debug_receiver<__cvref_id<_Sender>, _Env, _Sigs>;
@@ -890,9 +891,9 @@
using _Result = __member_alias_t<_Sender, _Env>;
return (_Result(*)()) nullptr;
}
- else if constexpr (__awaitable<_Sender, __env_promise<_Env>>)
+ else if constexpr (__awaitable<_Sender, __env::__promise<_Env>>)
{
- using _Result = __await_result_t<_Sender, __env_promise<_Env>>;
+ using _Result = __await_result_t<_Sender, __env::__promise<_Env>>;
return (completion_signatures<
// set_value_t() or set_value_t(T)
__minvoke<__remove<void, __qf<set_value_t>>, _Result>,
@@ -919,7 +920,7 @@
// NOT TO SPEC: if we're unable to compute the completion signatures,
// return an error type instead of SFINAE.
- template <class _Sender, class _Env = __default_env>
+ template <class _Sender, class _Env = empty_env>
constexpr auto operator()(_Sender&&, const _Env&) const noexcept
-> decltype(__impl<_Sender, _Env>()())
{
@@ -944,7 +945,7 @@
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>>;
+ || __awaitable<_Sender, __env::__promise<empty_env>>;
} // namespace __detail
template <class _Sender>
@@ -1045,7 +1046,7 @@
template < //
class _Sender, //
- class _Env = __default_env, //
+ class _Env = empty_env, //
class _Tuple = __q<__decayed_tuple>, //
class _Variant = __q<__variant>>
using __try_value_types_of_t = //
@@ -1053,20 +1054,20 @@
template < //
class _Sender, //
- class _Env = __default_env, //
+ class _Env = empty_env, //
class _Tuple = __q<__decayed_tuple>, //
class _Variant = __q<__variant>>
requires sender_in<_Sender, _Env>
using __value_types_of_t = //
__msuccess_or_t<__try_value_types_of_t<_Sender, _Env, _Tuple, _Variant>>;
-template <class _Sender, class _Env = __default_env,
+template <class _Sender, class _Env = empty_env,
class _Variant = __q<__variant>>
using __try_error_types_of_t =
__gather_completions_for<set_error_t, _Sender, _Env, __q<__midentity>,
_Variant>;
-template <class _Sender, class _Env = __default_env,
+template <class _Sender, class _Env = empty_env,
class _Variant = __q<__variant>>
requires sender_in<_Sender, _Env>
using __error_types_of_t =
@@ -1074,50 +1075,50 @@
template < //
class _Sender, //
- class _Env = __default_env, //
+ class _Env = empty_env, //
template <class...> class _Tuple = __decayed_tuple, //
template <class...> class _Variant = __variant>
requires sender_in<_Sender, _Env>
using value_types_of_t =
__value_types_of_t<_Sender, _Env, __q<_Tuple>, __q<_Variant>>;
-template <class _Sender, class _Env = __default_env,
+template <class _Sender, class _Env = empty_env,
template <class...> class _Variant = __variant>
requires sender_in<_Sender, _Env>
using error_types_of_t = __error_types_of_t<_Sender, _Env, __q<_Variant>>;
-template <class _Tag, class _Sender, class _Env = __default_env>
+template <class _Tag, class _Sender, class _Env = empty_env>
using __try_count_of = //
__compl_sigs::__maybe_for_all_sigs<
__completion_signatures_of_t<_Sender, _Env>, __q<__mfront>,
__mcount<_Tag>>;
-template <class _Tag, class _Sender, class _Env = __default_env>
+template <class _Tag, class _Sender, class _Env = empty_env>
requires sender_in<_Sender, _Env>
using __count_of = __msuccess_or_t<__try_count_of<_Tag, _Sender, _Env>>;
-template <class _Tag, class _Sender, class _Env = __default_env>
+template <class _Tag, class _Sender, class _Env = empty_env>
requires __mvalid<__count_of, _Tag, _Sender, _Env>
inline constexpr bool __sends = (__v<__count_of<_Tag, _Sender, _Env>> != 0);
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
requires __mvalid<__count_of, set_stopped_t, _Sender, _Env>
inline constexpr bool sends_stopped = __sends<set_stopped_t, _Sender, _Env>;
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
using __single_sender_value_t =
__value_types_of_t<_Sender, _Env, __msingle_or<void>, __q<__msingle>>;
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
using __single_value_variant_sender_t =
value_types_of_t<_Sender, _Env, __types, __msingle>;
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
concept __single_typed_sender =
sender_in<_Sender, _Env> &&
__mvalid<__single_sender_value_t, _Sender, _Env>;
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
concept __single_value_variant_sender =
sender_in<_Sender, _Env> &&
__mvalid<__single_value_variant_sender_t, _Sender, _Env>;
@@ -1125,7 +1126,7 @@
template <class... Errs>
using __nofail = __mbool<sizeof...(Errs) == 0>;
-template <class _Sender, class _Env = __default_env>
+template <class _Sender, class _Env = empty_env>
concept __nofail_sender = sender_in<_Sender, _Env> &&
(__v<error_types_of_t<_Sender, _Env, __nofail>>);
@@ -1171,7 +1172,7 @@
template < //
class _Sender, //
- class _Env = __default_env, //
+ class _Env = empty_env, //
class _Sigs = completion_signatures<>, //
class _SetValue = __q<__default_set_value>, //
class _SetError = __q<__default_set_error>, //
@@ -1202,7 +1203,7 @@
//
// template <
// sender Sndr,
-// class Env = __default_env,
+// class Env = empty_env,
// class AddlSigs = completion_signatures<>,
// template <class...> class SetValue = __default_set_value,
// template <class> class SetError = __default_set_error,
@@ -1250,7 +1251,7 @@
// SendsStopped>` is an alias for an empty struct
template < //
class _Sender, //
- class _Env = __default_env, //
+ class _Env = empty_env, //
__valid_completion_signatures _Sigs = completion_signatures<>, //
template <class...> class _SetValue = __compl_sigs::__default_set_value, //
template <class> class _SetError = __compl_sigs::__default_set_error, //
@@ -1749,7 +1750,7 @@
template <class _Sig>
using __tag_of_sig_t = decltype(stdexec::__tag_of_sig_((_Sig*)nullptr));
-template <class _Sender, class _SetSig, class _Env = __default_env>
+template <class _Sender, class _SetSig, class _Env = empty_env>
concept sender_of =
sender_in<_Sender, _Env> &&
same_as<__types<_SetSig>, __gather_completions_for<
@@ -2271,10 +2272,11 @@
struct __sexpr_impl<__inln::__schedule_t> : __sexpr_defaults
{
static constexpr auto get_attrs = //
- [](__ignore) noexcept -> __env::__prop<__inln::__scheduler(
- get_completion_scheduler_t<set_value_t>)> {
- return __mkprop(__inln::__scheduler{},
- get_completion_scheduler<set_value_t>);
+ [](__ignore) noexcept
+ -> __env::__with<__inln::__scheduler,
+ get_completion_scheduler_t<set_value_t>> {
+ return __env::__with(__inln::__scheduler{},
+ get_completion_scheduler<set_value_t>);
};
static constexpr auto get_completion_signatures = //
@@ -2919,7 +2921,7 @@
{};
inline constexpr __mstring __not_callable_diag =
- "The specified function is not callable with the arguments provided."__csz;
+ "The specified function is not callable with the arguments provided."_mstr;
template <__mstring _Context, __mstring _Diagnostic = __not_callable_diag>
struct _NOT_CALLABLE_
@@ -2958,7 +2960,7 @@
namespace __then
{
inline constexpr __mstring __then_context =
- "In stdexec::then(Sender, Function)..."__csz;
+ "In stdexec::then(Sender, Function)..."_mstr;
using __on_not_callable = __callable_error<__then_context>;
template <class _Fun, class _CvrefSender, class _Env>
@@ -3041,7 +3043,7 @@
namespace __upon_error
{
inline constexpr __mstring __upon_error_context =
- "In stdexec::upon_error(Sender, Function)..."__csz;
+ "In stdexec::upon_error(Sender, Function)..."_mstr;
using __on_not_callable = __callable_error<__upon_error_context>;
template <class _Fun, class _CvrefSender, class _Env>
@@ -3122,7 +3124,7 @@
namespace __upon_stopped
{
inline constexpr __mstring __upon_stopped_context =
- "In stdexec::upon_stopped(Sender, Function)..."__csz;
+ "In stdexec::upon_stopped(Sender, Function)..."_mstr;
using __on_not_callable = __callable_error<__upon_stopped_context>;
template <class _Fun, class _CvrefSender, class _Env>
@@ -3205,7 +3207,7 @@
namespace __bulk
{
inline constexpr __mstring __bulk_context =
- "In stdexec::bulk(Sender, Shape, Function)..."__csz;
+ "In stdexec::bulk(Sender, Shape, Function)..."_mstr;
using __on_not_callable = __callable_error<__bulk_context>;
template <class _Shape, class _Fun>
@@ -3358,9 +3360,9 @@
namespace __shared
{
template <class _BaseEnv>
-using __env_t = //
- __make_env_t<_BaseEnv, // BUGBUG NOT TO SPEC
- __with<get_stop_token_t, in_place_stop_token>>;
+using __env_t = //
+ __env::__join_t<__env::__with<in_place_stop_token, get_stop_token_t>,
+ _BaseEnv>; // BUGBUG NOT TO SPEC
struct __on_stop_request
{
@@ -3546,8 +3548,9 @@
connect_result_t<_CvrefSender, __receiver_t> __op_state2_;
explicit __shared_state(_CvrefSender&& __sndr, _Env __env) :
- __env_(__make_env((_Env&&)__env, __mkprop(__stop_source_.get_token(),
- get_stop_token))),
+ __env_(__env::__join(
+ __env::__with(__stop_source_.get_token(), get_stop_token),
+ (_Env&&)__env)),
__op_state2_(connect((_CvrefSender&&)__sndr, __receiver_t{this}))
{}
@@ -3906,9 +3909,8 @@
struct __t : receiver_adaptor<__t>
{
using __id = __receiver_with;
- using __env_t =
- __env::__env_join_t<__result_of<_EnvFns, _Operation*>...,
- env_of_t<_Receiver>>;
+ using __env_t = __env::__join_t<__result_of<_EnvFns, _Operation*>...,
+ env_of_t<_Receiver>>;
_Operation* __op_state_;
@@ -3919,8 +3921,8 @@
__env_t get_env() const noexcept
{
- return __join_env(_EnvFns(__op_state_)...,
- stdexec::get_env(__op_state_->*_ReceiverPtr));
+ return __env::__join(_EnvFns(__op_state_)...,
+ stdexec::get_env(__op_state_->*_ReceiverPtr));
}
};
};
@@ -3973,8 +3975,9 @@
template <same_as<get_env_t> _Tag>
friend auto tag_invoke(_Tag, const __receiver_with_sched& __self) noexcept
{
- return __join_env(__mkprop(__self.__sched_, get_scheduler),
- __mkprop(get_domain), get_env(__self.__rcvr_));
+ return __env::__join(__env::__with(__self.__sched_, get_scheduler),
+ __env::__without(get_domain),
+ get_env(__self.__rcvr_));
}
};
@@ -3987,8 +3990,8 @@
template <class _Env, class _Scheduler>
using __result_env_t =
__if_c<__unknown_context<_Scheduler>, _Env,
- __env::__env_join_t<__env::__prop<_Scheduler(get_scheduler_t)>,
- __env::__prop<void(get_domain_t)>, _Env>>;
+ __env::__join_t<__env::__with<_Scheduler, get_scheduler_t>,
+ __env::__without<get_domain_t>, _Env>>;
template <class _Tp>
using __decay_ref = __decay_t<_Tp>&;
@@ -4004,7 +4007,7 @@
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"__csz>,
+ "The function must return a valid sender for the current environment"_mstr>,
_WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>;
};
template <class _Sender, class _Env, class _Set>
@@ -4014,7 +4017,7 @@
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"__csz>,
+ "The function must return a valid sender for the current environment"_mstr>,
_WITH_SENDER_<_Sender>, _WITH_ENVIRONMENT_<_Env>>;
#endif
@@ -4094,7 +4097,7 @@
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"__csz>;
+ "The senders returned by Function do not all share a common domain"_mstr>;
template <class _Set>
using __try_common_domain_fn = //
@@ -4131,10 +4134,11 @@
}
else
{
- return __join_env(__mkprop(get_completion_scheduler<_Set>(
- stdexec::get_env(__child)),
- get_scheduler),
- __mkprop(get_domain), __env);
+ return __env::__join(
+ __env::__with(get_completion_scheduler<_Set>(
+ stdexec::get_env(__child)),
+ get_scheduler),
+ __env::__without(get_domain), __env);
}
}
STDEXEC_UNREACHABLE();
@@ -4160,10 +4164,15 @@
{
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>>((_Fun&&)__fun,
+ (_Child&&)__child);
+ }
else
{
- static_assert(
- __none_of<_Domain, __none_such, dependent_domain>);
+ static_assert(!same_as<_Domain, __none_such>);
return __make_sexpr<__let_t<_Set, _Domain>>((_Fun&&)__fun,
(_Child&&)__child);
}
@@ -4257,8 +4266,8 @@
{
static constexpr auto get_attrs = //
[]<class _Child>(__ignore, const _Child& __child) noexcept {
- return __join_env(__mkprop(_Domain(), get_domain),
- stdexec::get_env(__child));
+ return __env::__join(__env::__with(_Domain(), get_domain),
+ stdexec::get_env(__child));
};
static constexpr auto get_completion_signatures = //
@@ -4759,9 +4768,9 @@
struct __environ
{
struct __t :
- __env::__prop<stdexec::__t<_SchedulerId>(
- get_completion_scheduler_t<set_value_t>,
- get_completion_scheduler_t<set_stopped_t>)>
+ __env::__with<stdexec::__t<_SchedulerId>,
+ get_completion_scheduler_t<set_value_t>,
+ get_completion_scheduler_t<set_stopped_t>>
{
using __id = __environ;
@@ -4873,7 +4882,7 @@
static constexpr auto get_attrs = //
[]<class _Data, class _Child>(const _Data& __data,
const _Child& __child) noexcept {
- return __join_env(__data, stdexec::get_env(__child));
+ return __env::__join(__data, stdexec::get_env(__child));
};
static constexpr auto get_completion_signatures = //
@@ -5002,7 +5011,7 @@
[]<class _Data, class _Child>(
const _Data& __data,
const _Child& __child) noexcept -> decltype(auto) {
- return __join_env(__data, stdexec::get_env(__child));
+ return __env::__join(__data, stdexec::get_env(__child));
};
};
} // namespace __transfer
@@ -5071,7 +5080,7 @@
return []<class _Scheduler>(const _Scheduler& __sched,
const auto&...) noexcept {
using _Env = __t<__schedule_from::__environ<__id<_Scheduler>>>;
- return _Env{{__sched}};
+ return _Env{__sched};
};
}
@@ -5100,7 +5109,7 @@
template <sender _Sender, class... _Envs>
auto operator()(_Sender&& __sndr, _Envs... __envs) const
{
- return __make_sexpr<__write_t>(__join_env(std::move(__envs)...),
+ return __make_sexpr<__write_t>(__env::__join(std::move(__envs)...),
(_Sender&&)__sndr);
}
@@ -5116,7 +5125,7 @@
static auto __transform_env_fn(_Env&& __env) noexcept
{
return [&](__ignore, const auto& __state, __ignore) noexcept {
- return __join_env(__state, (_Env&&)__env);
+ return __env::__join(__state, (_Env&&)__env);
};
}
@@ -5131,14 +5140,14 @@
{
static constexpr auto get_env = //
[](__ignore, const auto& __state, const auto& __rcvr) noexcept {
- return __join_env(__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
-> stdexec::__completion_signatures_of_t<
__child_of<_Self>,
- __env::__env_join_t<const __decay_t<__data_of<_Self>>&, _Env>> {
+ __env::__join_t<const __decay_t<__data_of<_Self>>&, _Env>> {
static_assert(sender_expr_for<_Self, __write_t>);
return {};
};
@@ -5158,8 +5167,8 @@
STDEXEC_ATTRIBUTE((always_inline))
auto __mkenv_sched(_Scheduler __sched)
{
- auto __env = __join_env(__mkprop(__sched, get_scheduler),
- __mkprop(get_domain));
+ auto __env = __env::__join(__env::__with(__sched, get_scheduler),
+ __env::__without(get_domain));
struct __env_t : decltype(__env)
{};
@@ -5207,7 +5216,8 @@
static auto __transform_env_fn(_Env&& __env) noexcept
{
return [&](__ignore, auto __sched, __ignore) noexcept {
- return __join_env(__detail::__mkenv_sched(__sched), (_Env&&)__env);
+ return __env::__join(__detail::__mkenv_sched(__sched),
+ (_Env&&)__env);
};
}
@@ -5347,8 +5357,9 @@
template <class _Env>
auto __mkenv(_Env&& __env, in_place_stop_source& __stop_source) noexcept
{
- return __join_env(__mkprop(__stop_source.get_token(), get_stop_token),
- (_Env&&)__env);
+ return __env::__join(
+ __env::__with(__stop_source.get_token(), get_stop_token),
+ (_Env&&)__env);
}
template <class _Env>
@@ -5364,10 +5375,10 @@
__mconst<int>, __msingle_or<void>>;
template <
- __mstring _Context = "In stdexec::when_all()..."__csz,
+ __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."__csz>
+ "Use stdexec::when_all_with_variant() instead."_mstr>
struct _INVALID_WHEN_ALL_ARGUMENT_;
template <class _Sender, class _Env>
@@ -5596,7 +5607,7 @@
}
else
{
- return __mkprop(_Domain(), get_domain);
+ return __env::__with(_Domain(), get_domain);
}
STDEXEC_UNREACHABLE();
};
@@ -5769,7 +5780,7 @@
}
else
{
- return __mkprop(_Domain(), get_domain);
+ return __env::__with(_Domain(), get_domain);
}
STDEXEC_UNREACHABLE();
};
@@ -5913,7 +5924,7 @@
__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."__csz;
+ "The current execution environment doesn't have a value for the given query."_mstr;
template <class _Tag>
struct _WITH_QUERY_;
@@ -5921,7 +5932,7 @@
template <class _Tag, class _Env>
using __query_failed_error = //
__mexception< //
- _NOT_CALLABLE_<"In stdexec::read()..."__csz, __query_failed_diag>,
+ _NOT_CALLABLE_<"In stdexec::read()..."_mstr, __query_failed_diag>,
_WITH_QUERY_<_Tag>, _WITH_ENVIRONMENT_<_Env>>;
template <class _Tag, class _Env>
@@ -6079,11 +6090,11 @@
namespace __on_v2
{
inline constexpr __mstring __on_context =
- "In stdexec::on(Scheduler, Sender)..."__csz;
+ "In stdexec::on(Scheduler, Sender)..."_mstr;
inline constexpr __mstring __no_scheduler_diag =
- "stdexec::on() requires a scheduler to transition back to."__csz;
+ "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."__csz;
+ "The provided environment lacks a value for the get_scheduler() query."_mstr;
template <__mstring _Context = __on_context,
__mstring _Diagnostic = __no_scheduler_diag,
@@ -6133,7 +6144,8 @@
static auto __transform_env_fn(_Env&& __env) noexcept
{
return [&](__ignore, auto __sched, __ignore) noexcept {
- return __join_env(__detail::__mkenv_sched(__sched), (_Env&&)__env);
+ return __env::__join(__detail::__mkenv_sched(__sched),
+ (_Env&&)__env);
};
}
@@ -6234,18 +6246,15 @@
{
inline auto __make_env(run_loop& __loop) noexcept
{
- return __env::__env_fn{
- [&](__one_of<get_scheduler_t,
- get_delegatee_scheduler_t> auto) noexcept {
- return __loop.get_scheduler();
- }};
+ return __env::__with(__loop.get_scheduler(), get_scheduler,
+ get_delegatee_scheduler);
}
struct __env : __result_of<__make_env, run_loop&>
{
__env();
- __env(run_loop& __loop) noexcept :
+ explicit __env(run_loop& __loop) noexcept :
__result_of<__make_env, run_loop&>{__sync_wait::__make_env(__loop)}
{}
};
@@ -6361,10 +6370,10 @@
using __variant_for_t = __t<__variant_for<_Sender>>;
inline constexpr __mstring __sync_wait_context_diag = //
- "In stdexec::sync_wait()..."__csz;
+ "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."__csz;
+ "than one way. Use stdexec::sync_wait_with_variant() instead."_mstr;
template <__mstring _Context, __mstring _Diagnostic>
struct _INVALID_ARGUMENT_TO_SYNC_WAIT_;
@@ -6404,7 +6413,7 @@
else
{
constexpr __mstring __diag =
- "The stdexec::sender_in<Sender, Environment> concept check has failed."__csz;
+ "The stdexec::sender_in<Sender, Environment> concept check has failed."_mstr;
return __sync_wait_error<__diag, _Sender>();
}
}
@@ -6417,12 +6426,12 @@
{
constexpr __mstring __diag =
"Failed to connect the given sender to sync_wait's internal receiver. "
- "The stdexec::connect(Sender, Receiver) expression is ill-formed."__csz;
+ "The stdexec::connect(Sender, Receiver) expression is ill-formed."_mstr;
return __sync_wait_error<__diag, _Sender>();
}
else
{
- constexpr __mstring __diag = "Unknown concept check failure."__csz;
+ constexpr __mstring __diag = "Unknown concept check failure."_mstr;
return __sync_wait_error<__diag, _Sender>();
}
STDEXEC_UNREACHABLE();
@@ -6555,7 +6564,7 @@
{}
};
-template <auto _Reason = "You cannot pipe one sender into another."__csz>
+template <auto _Reason = "You cannot pipe one sender into another."_mstr>
struct _CANNOT_PIPE_INTO_A_SENDER_
{};
diff --git a/include/sdbusplus/async/stdexec/sequence_senders.hpp b/include/sdbusplus/async/stdexec/sequence_senders.hpp
index 2f7b7e0..c579998 100644
--- a/include/sdbusplus/async/stdexec/sequence_senders.hpp
+++ b/include/sdbusplus/async/stdexec/sequence_senders.hpp
@@ -228,7 +228,7 @@
}
}
- template <class _Sender, class _Env = __default_env>
+ template <class _Sender, class _Env = empty_env>
constexpr auto operator()(_Sender&&, const _Env&) const noexcept
-> decltype(__impl<_Sender, _Env>()())
{
diff --git a/include/sdbusplus/async/stdexec/task.hpp b/include/sdbusplus/async/stdexec/task.hpp
index 56ad9aa..4eeb9ab 100644
--- a/include/sdbusplus/async/stdexec/task.hpp
+++ b/include/sdbusplus/async/stdexec/task.hpp
@@ -367,7 +367,7 @@
////////////////////////////////////////////////////////////////////////////////
// basic_task
template <class _Ty, class _Context = default_task_context<_Ty>>
-class basic_task
+class [[nodiscard]] basic_task
{
struct __promise;