| /* Copyright (c) 2023 Maikel Nadolski |
| * Copyright (c) 2023 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 "../stdexec/concepts.hpp" |
| #include "../stdexec/execution.hpp" |
| #include "../stdexec/functional.hpp" |
| |
| #include <sdbusplus/async/stdexec/sequence_senders.hpp> |
| |
| #include <cstddef> |
| #include <utility> |
| |
| 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 const _VTable* operator()(__mtype<_VTable>, |
| __mtype<_Tp>) const noexcept |
| { |
| return stdexec::tag_invoke(__create_vtable_t{}, __mtype<_VTable>{}, |
| __mtype<_Tp>{}); |
| } |
| }; |
| |
| inline constexpr __create_vtable_t __create_vtable{}; |
| |
| template <class _Sig> |
| struct __query_vfun; |
| |
| template <class _Tag, class _Ret, class... _As> |
| struct __query_vfun<_Tag (*const)(_Ret (*)(_As...))> |
| { |
| _Ret (*__fn_)(void*, _As...); |
| |
| _Ret operator()(_Tag, void* __rcvr, _As&&... __as) const |
| { |
| return __fn_(__rcvr, (_As&&)__as...); |
| } |
| }; |
| |
| template <class _Tag, class _Ret, class... _As> |
| struct __query_vfun<_Tag (*)(_Ret (*)(_As...))> |
| { |
| _Ret (*__fn_)(void*, _As...); |
| |
| _Ret operator()(_Tag, void* __rcvr, _As&&... __as) const |
| { |
| return __fn_(__rcvr, (_As&&)__as...); |
| } |
| }; |
| |
| template <class _Tag, class _Ret, class... _As> |
| struct __query_vfun<_Tag (*const)(_Ret (*)(_As...) noexcept)> |
| { |
| _Ret (*__fn_)(void*, _As...) noexcept; |
| |
| _Ret operator()(_Tag, void* __rcvr, _As&&... __as) const noexcept |
| { |
| return __fn_(__rcvr, (_As&&)__as...); |
| } |
| }; |
| |
| template <class _Tag, class _Ret, class... _As> |
| struct __query_vfun<_Tag (*)(_Ret (*)(_As...) noexcept)> |
| { |
| _Ret (*__fn_)(void*, _As...) noexcept; |
| |
| _Ret operator()(_Tag, void* __rcvr, _As&&... __as) const noexcept |
| { |
| return __fn_(__rcvr, (_As&&)__as...); |
| } |
| }; |
| |
| template <class> |
| struct __query_vfun_fn; |
| |
| template <class _EnvProvider> |
| requires __callable<get_env_t, const _EnvProvider&> |
| struct __query_vfun_fn<_EnvProvider> |
| { |
| 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...) |
| { |
| return +[](void* __env_provider, _As... __as) -> _Ret { |
| return _Tag{}(get_env(*(const _EnvProvider*)__env_provider), |
| (_As&&)__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 |
| { |
| return +[](void* __env_provider, _As... __as) noexcept -> _Ret { |
| static_assert( |
| __nothrow_callable<_Tag, const env_of_t<_EnvProvider>&, |
| _As...>); |
| return _Tag{}(get_env(*(const _EnvProvider*)__env_provider), |
| (_As&&)__as...); |
| }; |
| } |
| }; |
| |
| template <class _Queryable> |
| requires(!__callable<get_env_t, const _Queryable&>) |
| struct __query_vfun_fn<_Queryable> |
| { |
| template <class _Tag, class _Ret, class... _As> |
| requires __callable<_Tag, const _Queryable&, _As...> |
| constexpr _Ret (*operator()(_Tag (*)(_Ret (*)(_As...))) |
| const noexcept)(void*, _As...) |
| { |
| return +[](void* __queryable, _As... __as) -> _Ret { |
| return _Tag{}(*(const _Queryable*)__queryable, (_As&&)__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 |
| { |
| return +[](void* __env_provider, _As... __as) noexcept -> _Ret { |
| static_assert(__nothrow_callable<_Tag, const _Queryable&, _As...>); |
| return _Tag{}(*(const _Queryable*)__env_provider, (_As&&)__as...); |
| }; |
| } |
| }; |
| |
| 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, (_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, (_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...) |
| { |
| return +[](void* __storage, _As... __as) -> void { |
| return _Tag{}(__mtype<_Tp>{}, *(_Storage*)__storage, |
| (_As&&)__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 |
| { |
| return +[](void* __storage, _As... __as) noexcept -> void { |
| static_assert( |
| __nothrow_callable<_Tag, __mtype<_Tp>, _Storage&, _As...>); |
| return _Tag{}(__mtype<_Tp>{}, *(_Storage*)__storage, |
| (_As&&)__as...); |
| }; |
| } |
| }; |
| |
| 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&>); |
| 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, |
| (_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 const __storage_vtable<_ParentVTable, _StorageCPOs...>* |
| __default_storage_vtable( |
| __storage_vtable<_ParentVTable, _StorageCPOs...>*) noexcept |
| { |
| 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>{}((_StorageCPOs*)nullptr)}...}; |
| |
| template <class _Vtable, class _Allocator, bool _Copyable = false, |
| std::size_t _Alignment = alignof(std::max_align_t), |
| std::size_t _InlineSize = 3 * sizeof(void*)> |
| struct __storage |
| { |
| class __t; |
| }; |
| |
| template <class _Vtable, class _Allocator, |
| std::size_t _Alignment = alignof(std::max_align_t), |
| std::size_t _InlineSize = 3 * sizeof(void*)> |
| 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; |
| |
| template <class _Tp> |
| static constexpr const __vtable_t* __get_vtable_of_type() noexcept |
| { |
| return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete>; |
| } |
| |
| 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>((_Tp&&)__object); |
| } |
| else |
| { |
| __construct_large<_Dp>((_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>((_Args&&)__args...); |
| } |
| else |
| { |
| __construct_large<_Tp>((_Args&&)__args...); |
| } |
| } |
| |
| ~__t() |
| { |
| __reset(); |
| } |
| |
| void __reset() noexcept |
| { |
| (*__vtable_)(__delete, this); |
| __object_pointer_ = nullptr; |
| __vtable_ = __default_storage_vtable((__vtable_t*)nullptr); |
| } |
| |
| const _Vtable* __get_vtable() const noexcept |
| { |
| return __vtable_; |
| } |
| |
| void* __get_object_pointer() const noexcept |
| { |
| 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>; |
| _Alloc __alloc{__allocator_}; |
| std::allocator_traits<_Alloc>::construct(__alloc, __pointer, |
| (_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, |
| (_As&&)__args...); |
| } |
| catch (...) |
| { |
| std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, |
| 1); |
| throw; |
| } |
| __object_pointer_ = __pointer; |
| } |
| |
| template <class _Tp> |
| friend void tag_invoke(__delete_t, __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); |
| } |
| } |
| |
| private: |
| const __vtable_t* __vtable_{ |
| __default_storage_vtable((__vtable_t*)nullptr)}; |
| void* __object_pointer_{nullptr}; |
| alignas(__alignment) std::byte __buffer_[__buffer_size]{}; |
| STDEXEC_ATTRIBUTE((no_unique_address)) _Allocator __allocator_{}; |
| }; |
| }; |
| |
| template <class _Vtable, class _Allocator, bool _Copyable, |
| std::size_t _Alignment, std::size_t _InlineSize> |
| class __storage<_Vtable, _Allocator, _Copyable, _Alignment, _InlineSize>::__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); |
| |
| 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< |
| _Copyable, |
| __storage_vtable<_Vtable, __with_delete, __with_move, __with_copy>, |
| __storage_vtable<_Vtable, __with_delete, __with_move>>; |
| |
| template <class _Tp> |
| static constexpr const __vtable_t* __get_vtable_of_type() noexcept |
| { |
| 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>; |
| } |
| } |
| |
| public: |
| using __id = __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>((_Tp&&)__object); |
| } |
| else |
| { |
| __construct_large<_Dp>((_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>((_Args&&)__args...); |
| } |
| else |
| { |
| __construct_large<_Tp>((_Args&&)__args...); |
| } |
| } |
| |
| __t(const __t& __other) |
| requires(_Copyable) |
| { |
| (*__other.__vtable_)(__copy_construct, this, __other); |
| } |
| |
| __t& operator=(const __t& __other) |
| requires(_Copyable) |
| { |
| __t tmp(__other); |
| return *this = std::move(tmp); |
| } |
| |
| __t(__t&& __other) noexcept |
| { |
| (*__other.__vtable_)(__move_construct, this, (__t&&)__other); |
| } |
| |
| __t& operator=(__t&& __other) noexcept |
| { |
| __reset(); |
| (*__other.__vtable_)(__move_construct, this, (__t&&)__other); |
| return *this; |
| } |
| |
| ~__t() |
| { |
| __reset(); |
| } |
| |
| void __reset() noexcept |
| { |
| (*__vtable_)(__delete, this); |
| __object_pointer_ = nullptr; |
| __vtable_ = __default_storage_vtable((__vtable_t*)nullptr); |
| } |
| |
| const _Vtable* __get_vtable() const noexcept |
| { |
| return __vtable_; |
| } |
| |
| void* __get_object_pointer() const noexcept |
| { |
| 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>; |
| _Alloc __alloc{__allocator_}; |
| std::allocator_traits<_Alloc>::construct(__alloc, __pointer, |
| (_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, |
| (_As&&)__args...); |
| } |
| catch (...) |
| { |
| std::allocator_traits<_Alloc>::deallocate(__alloc, __pointer, 1); |
| throw; |
| } |
| __object_pointer_ = __pointer; |
| } |
| |
| template <class _Tp> |
| friend void tag_invoke(__delete_t, __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); |
| } |
| } |
| |
| template <class _Tp> |
| friend void tag_invoke(__move_construct_t, __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>((_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; |
| } |
| __self.__vtable_ = std::exchange( |
| __other.__vtable_, __default_storage_vtable((__vtable_t*)nullptr)); |
| } |
| |
| template <class _Tp> |
| requires _Copyable |
| friend void tag_invoke(__copy_construct_t, __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); |
| } |
| __self.__vtable_ = __other.__vtable_; |
| } |
| |
| const __vtable_t* __vtable_{__default_storage_vtable((__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> |
| friend const __empty_vtable* tag_invoke(__create_vtable_t, |
| __mtype<__empty_vtable>, |
| __mtype<_Sender>) noexcept |
| { |
| 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, class _Allocator = std::allocator<std::byte>> |
| using __copyable_storage_t = __t<__storage<_VTable, _Allocator, true>>; |
| |
| template <class _Tag, class... _As> |
| _Tag __tag_type(_Tag (*)(_As...)); |
| |
| template <class _Tag, class... _As> |
| _Tag __tag_type(_Tag (*)(_As...) noexcept); |
| |
| 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 _Sig> |
| struct __rcvr_vfun; |
| |
| template <class _Sigs, class... _Queries> |
| struct __vtable |
| { |
| class __t; |
| }; |
| |
| template <class _Sigs, class... _Queries> |
| struct __ref; |
| |
| template <class _Tag, class... _As> |
| struct __rcvr_vfun<_Tag(_As...)> |
| { |
| void (*__fn_)(void*, _As...) noexcept; |
| }; |
| |
| template <class _Rcvr> |
| struct __rcvr_vfun_fn |
| { |
| template <class _Tag, class... _As> |
| constexpr void (*operator()(_Tag (*)(_As...)) |
| const noexcept)(void*, _As...) noexcept |
| { |
| return +[](void* __rcvr, _As... __as) noexcept -> void { |
| _Tag{}((_Rcvr&&)*(_Rcvr*)__rcvr, (_As&&)__as...); |
| }; |
| } |
| }; |
| |
| template <class... _Sigs, class... _Queries> |
| struct __vtable<completion_signatures<_Sigs...>, _Queries...> |
| { |
| class __t : public __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> && ...) |
| friend const __t* tag_invoke(__create_vtable_t, __mtype<__t>, |
| __mtype<_Rcvr>) noexcept |
| { |
| static const __t __vtable_{ |
| {__rcvr_vfun_fn<_Rcvr>{}((_Sigs*)nullptr)}..., |
| {__query_vfun_fn<_Rcvr>{}((_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: |
| #endif |
| using __vtable_t = |
| stdexec::__t<__vtable<completion_signatures<_Sigs...>, _Queries...>>; |
| |
| struct __env_t |
| { |
| const __vtable_t* __vtable_; |
| void* __rcvr_; |
| in_place_stop_token __token_; |
| |
| template <class _Tag, class... _As> |
| requires __callable<const __vtable_t&, _Tag, void*, _As...> |
| friend auto |
| tag_invoke(_Tag, const __env_t& __self, _As&&... __as) noexcept( |
| __nothrow_callable<const __vtable_t&, _Tag, void*, _As...>) |
| -> __call_result_t<const __vtable_t&, _Tag, void*, _As...> |
| { |
| return (*__self.__vtable_)(_Tag{}, __self.__rcvr_, (_As&&)__as...); |
| } |
| |
| friend in_place_stop_token tag_invoke(get_stop_token_t, |
| const __env_t& __self) noexcept |
| { |
| return __self.__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 <__completion_tag _Tag, __decays_to<__ref> _Self, class... _As> |
| requires __one_of<_Tag(_As...), _Sigs...> |
| friend void tag_invoke(_Tag, _Self&& __self, _As&&... __as) noexcept |
| { |
| (*static_cast<const __rcvr_vfun<_Tag(_As...)>*>(__self.__env_.__vtable_) |
| ->__fn_)(((_Self&&)__self).__env_.__rcvr_, (_As&&)__as...); |
| } |
| |
| template <std::same_as<__ref> Self> |
| friend const __env_t& tag_invoke(get_env_t, const Self& __self) noexcept |
| { |
| return __self.__env_; |
| } |
| }; |
| |
| __mbool<true> __test_never_stop_token( |
| get_stop_token_t (*)(never_stop_token (*)() noexcept)); |
| |
| template <class _Tag, class _Ret, class... _As> |
| __mbool<false> __test_never_stop_token(_Tag (*)(_Ret (*)(_As...) noexcept)); |
| |
| template <class _Tag, class _Ret, class... _As> |
| __mbool<false> __test_never_stop_token(_Tag (*)(_Ret (*)(_As...))); |
| |
| 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<__remove_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...> |
| friend auto |
| tag_invoke(_Tag, const __env_t& __self, _As&&... __as) noexcept( |
| __nothrow_callable<const __vtable_t&, _Tag, void*, _As...>) |
| -> __call_result_t<const __vtable_t&, _Tag, void*, _As...> |
| { |
| return (*__self.__vtable_)(_Tag{}, __self.__rcvr_, (_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 <__completion_tag _Tag, __decays_to<__ref> _Self, class... _As> |
| requires __one_of<_Tag(_As...), _Sigs...> |
| friend void tag_invoke(_Tag, _Self&& __self, _As&&... __as) noexcept |
| { |
| (*static_cast<const __rcvr_vfun<_Tag(_As...)>*>(__self.__env_.__vtable_) |
| ->__fn_)(((_Self&&)__self).__env_.__rcvr_, (_As&&)__as...); |
| } |
| |
| template <std::same_as<__ref> Self> |
| friend const __env_t& tag_invoke(get_env_t, const Self& __self) noexcept |
| { |
| return __self.__env_; |
| } |
| }; |
| } // namespace __rec |
| |
| class __operation_vtable |
| { |
| public: |
| void (*__start_)(void*) noexcept; |
| |
| private: |
| template <class _Op> |
| friend const __operation_vtable* tag_invoke(__create_vtable_t, |
| __mtype<__operation_vtable>, |
| __mtype<_Op>) noexcept |
| { |
| 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>); |
| 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::in_place_stop_source& __source_; |
| |
| void operator()() const noexcept |
| { |
| __source_.request_stop(); |
| } |
| }; |
| |
| template <class _Receiver> |
| struct __operation_base |
| { |
| STDEXEC_ATTRIBUTE((no_unique_address)) _Receiver __rcvr_; |
| stdexec::in_place_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<__env::__with<in_place_stop_token, get_stop_token_t>, _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 <same_as<set_next_t> _SetNext, same_as<__t> _Self, class _Item> |
| requires __callable<_SetNext, _Receiver&, _Item> |
| friend auto tag_invoke(_SetNext, _Self& __self, _Item&& __item) |
| { |
| return _SetNext{}(__self.__op_->__rcvr_, |
| static_cast<_Item&&>(__item)); |
| } |
| |
| template <same_as<set_value_t> _SetValue, same_as<__t> _Self, |
| class... _Args> |
| requires __callable<_SetValue, _Receiver&&, _Args...> |
| friend void tag_invoke(_SetValue, _Self&& __self, |
| _Args&&... __args) noexcept |
| { |
| __self.__op_->__on_stop_.reset(); |
| _SetValue{}(static_cast<_Receiver&&>(__self.__op_->__rcvr_), |
| static_cast<_Args&&>(__args)...); |
| } |
| |
| template <same_as<set_error_t> _SetError, same_as<__t> _Self, |
| class _Error> |
| requires __callable<_SetError, _Receiver&&, _Error> |
| friend void tag_invoke(_SetError, _Self&& __self, |
| _Error&& __err) noexcept |
| { |
| __self.__op_->__on_stop_.reset(); |
| _SetError{}(static_cast<_Receiver&&>(__self.__op_->__rcvr_), |
| static_cast<_Error&&>(__err)); |
| } |
| |
| template <same_as<set_stopped_t> _SetStopped, same_as<__t> _Self> |
| requires __callable<_SetStopped, _Receiver&&> |
| friend void tag_invoke(_SetStopped, _Self&& __self) noexcept |
| { |
| __self.__op_->__on_stop_.reset(); |
| _SetStopped{}(static_cast<_Receiver&&>(__self.__op_->__rcvr_)); |
| } |
| |
| template <same_as<get_env_t> _GetEnv, same_as<__t> _Self> |
| friend __env_t<env_of_t<_Receiver>> |
| tag_invoke(_GetEnv, const _Self& __self) noexcept |
| { |
| return __env::__join( |
| __env::__with(__self.__op_->__stop_source_.get_token(), |
| get_stop_token), |
| get_env(__self.__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_)} |
| {} |
| |
| private: |
| __stoppable_receiver_t<_ReceiverId> __rec_; |
| __immovable_operation_storage __storage_{}; |
| |
| friend void tag_invoke(start_t, __t& __self) noexcept |
| { |
| __self.__on_stop_.emplace( |
| stdexec::get_stop_token(stdexec::get_env(__self.__rcvr_)), |
| __on_stop_t{__self.__stop_source_}); |
| STDEXEC_ASSERT(__self.__storage_.__get_vtable()->__start_); |
| __self.__storage_.__get_vtable()->__start_( |
| __self.__storage_.__get_object_pointer()); |
| } |
| }; |
| }; |
| |
| template <class _ReceiverId> |
| struct __operation<_ReceiverId, false> |
| { |
| using _Receiver = stdexec::__t<_ReceiverId>; |
| |
| class __t |
| { |
| public: |
| using __id = __operation; |
| |
| template <class _Sender> |
| __t(_Sender&& __sender, _Receiver&& __receiver) : |
| __rec_{static_cast<_Receiver&&>(__receiver)}, |
| __storage_{__sender.__connect(__rec_)} |
| {} |
| |
| private: |
| STDEXEC_ATTRIBUTE((no_unique_address)) _Receiver __rec_; |
| __immovable_operation_storage __storage_{}; |
| |
| friend void tag_invoke(start_t, __t& __self) noexcept |
| { |
| STDEXEC_ASSERT(__self.__storage_.__get_vtable()->__start_); |
| __self.__storage_.__get_vtable()->__start_( |
| __self.__storage_.__get_object_pointer()); |
| } |
| }; |
| }; |
| |
| template <class _Queries> |
| class __query_vtable; |
| |
| template <template <class...> class _List, typename... _Queries> |
| class __query_vtable<_List<_Queries...>> : public __query_vfun<_Queries>... |
| { |
| public: |
| using __query_vfun<_Queries>::operator()...; |
| |
| private: |
| template <class _EnvProvider> |
| requires(__callable<__query_vfun_fn<_EnvProvider>, _Queries> && ...) |
| friend const __query_vtable* tag_invoke(__create_vtable_t, |
| __mtype<__query_vtable>, |
| __mtype<_EnvProvider>) noexcept |
| { |
| static const __query_vtable __vtable{ |
| {__query_vfun_fn<_EnvProvider>{}((_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_in_place_stop_token = |
| __v<__mapply<__mall_of<__q<__is_not_stop_token_query_v>>, |
| _ReceiverQueries>>; |
| |
| class __vtable : public __query_vtable<_SenderQueries> |
| { |
| public: |
| using __id = __vtable; |
| |
| const __query_vtable<_SenderQueries>& __queries() const noexcept |
| { |
| return *this; |
| } |
| |
| __immovable_operation_storage (*__connect_)(void*, __receiver_ref_t); |
| |
| private: |
| template <sender_to<__receiver_ref_t> _Sender> |
| friend const __vtable* tag_invoke(__create_vtable_t, __mtype<__vtable>, |
| __mtype<_Sender>) noexcept |
| { |
| 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>, __conv{[&] { |
| return stdexec::connect((_Sender&&)__sender, |
| (__receiver_ref_t&&)__receiver); |
| }}}; |
| }}; |
| return &__vtable_; |
| } |
| }; |
| |
| class __env_t |
| { |
| public: |
| __env_t(const __vtable* __vtable, void* __sender) noexcept : |
| __vtable_{__vtable}, __sender_{__sender} |
| {} |
| |
| private: |
| const __vtable* __vtable_; |
| void* __sender_; |
| |
| template <class _Tag, class... _As> |
| requires __callable<const __query_vtable<_SenderQueries>&, _Tag, |
| void*, _As...> |
| friend auto |
| tag_invoke(_Tag, const __env_t& __self, _As&&... __as) noexcept( |
| __nothrow_callable<const __query_vtable<_SenderQueries>&, _Tag, |
| void*, _As...>) |
| -> __call_result_t<const __query_vtable<_SenderQueries>&, _Tag, |
| void*, _As...> |
| { |
| return __self.__vtable_->__queries()(_Tag{}, __self.__sender_, |
| (_As&&)__as...); |
| } |
| }; |
| |
| class __t |
| { |
| public: |
| using __id = __sender; |
| using completion_signatures = _Sigs; |
| using sender_concept = stdexec::sender_t; |
| |
| __t(const __t&) = delete; |
| __t& operator=(const __t&) = delete; |
| |
| __t(__t&&) = default; |
| __t& operator=(__t&&) = default; |
| |
| template <__not_decays_to<__t> _Sender> |
| requires sender_to<_Sender, __receiver_ref<_Sigs, _ReceiverQueries>> |
| __t(_Sender&& __sndr) : __storage_{(_Sender&&)__sndr} |
| {} |
| |
| __immovable_operation_storage __connect(__receiver_ref_t __receiver) |
| { |
| return __storage_.__get_vtable()->__connect_( |
| __storage_.__get_object_pointer(), |
| (__receiver_ref_t&&)__receiver); |
| } |
| |
| explicit operator bool() const noexcept |
| { |
| return __get_object_pointer(__storage_) != nullptr; |
| } |
| |
| private: |
| __unique_storage_t<__vtable> __storage_; |
| |
| template <receiver_of<_Sigs> _Rcvr> |
| friend stdexec::__t<__operation<stdexec::__id<__decay_t<_Rcvr>>, |
| __with_in_place_stop_token>> |
| tag_invoke(connect_t, __t&& __self, _Rcvr&& __rcvr) |
| { |
| return {(__t&&)__self, (_Rcvr&&)__rcvr}; |
| } |
| |
| friend __env_t tag_invoke(get_env_t, const __t& __self) noexcept |
| { |
| return {__self.__storage_.__get_vtable(), |
| __self.__storage_.__get_object_pointer()}; |
| } |
| }; |
| }; |
| |
| template <class _ScheduleSender, class _SchedulerQueries = __types<>> |
| class __scheduler |
| { |
| public: |
| template <class _Scheduler> |
| requires(!__decays_to<_Scheduler, __scheduler>) && scheduler<_Scheduler> |
| __scheduler(_Scheduler&& __scheduler) : |
| __storage_{(_Scheduler&&)__scheduler} |
| {} |
| |
| using __sender_t = _ScheduleSender; |
| |
| private: |
| class __vtable : public __query_vtable<_SchedulerQueries> |
| { |
| public: |
| __sender_t (*__schedule_)(void*) noexcept; |
| bool (*__equal_to_)(const void*, const void* other) noexcept; |
| |
| const __query_vtable<_SchedulerQueries>& __queries() const noexcept |
| { |
| return *this; |
| } |
| |
| private: |
| template <scheduler _Scheduler> |
| friend const __vtable* tag_invoke(__create_vtable_t, __mtype<__vtable>, |
| __mtype<_Scheduler>) noexcept |
| { |
| static const __vtable __vtable_{ |
| {*__create_vtable(__mtype<__query_vtable<_SchedulerQueries>>{}, |
| __mtype<_Scheduler>{})}, |
| [](void* __object_pointer) noexcept -> __sender_t { |
| const _Scheduler& __scheduler = |
| *static_cast<const _Scheduler*>(__object_pointer); |
| return __sender_t{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_; |
| } |
| }; |
| |
| template <same_as<__scheduler> _Self> |
| friend __sender_t tag_invoke(schedule_t, const _Self& __self) noexcept |
| { |
| STDEXEC_ASSERT(__self.__storage_.__get_vtable()->__schedule_); |
| return __self.__storage_.__get_vtable()->__schedule_( |
| __self.__storage_.__get_object_pointer()); |
| } |
| |
| template <class _Tag, same_as<__scheduler> _Self, class... _As> |
| requires __callable<const __query_vtable<_SchedulerQueries>&, _Tag, |
| void*, _As...> |
| friend auto tag_invoke(_Tag, const _Self& __self, _As&&... __as) noexcept( |
| __nothrow_callable<const __query_vtable<_SchedulerQueries>&, _Tag, |
| void*, _As...>) |
| -> __call_result_t<const __query_vtable<_SchedulerQueries>&, _Tag, |
| void*, _As...> |
| { |
| return __self.__storage_.__get_vtable()->__queries()( |
| _Tag{}, __self.__storage_.__get_object_pointer(), (_As&&)__as...); |
| } |
| |
| friend bool operator==(const __scheduler& __self, |
| const __scheduler& __other) noexcept |
| { |
| 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); |
| } |
| |
| friend bool operator!=(const __scheduler& __self, |
| const __scheduler& __other) noexcept |
| { |
| return !(__self == __other); |
| } |
| |
| __copyable_storage_t<__vtable> __storage_{}; |
| }; |
| } // namespace __any |
| |
| 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)...>; |
| using __env_t = stdexec::env_of_t<__receiver_base>; |
| __receiver_base __receiver_; |
| |
| template <class _Tag, stdexec::__decays_to<any_receiver_ref> Self, |
| class... _As> |
| requires stdexec::tag_invocable< |
| _Tag, stdexec::__copy_cvref_t<Self, __receiver_base>, _As...> |
| friend auto tag_invoke(_Tag, Self&& __self, _As&&... __as) noexcept( |
| std::is_nothrow_invocable_v< |
| _Tag, stdexec::__copy_cvref_t<Self, __receiver_base>, _As...>) |
| { |
| return stdexec::tag_invoke(_Tag{}, ((Self&&)__self).__receiver_, |
| (_As&&)__as...); |
| } |
| |
| 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 <auto... _SenderQueries> |
| 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( |
| std::is_nothrow_invocable_v< |
| _Tag, stdexec::__copy_cvref_t<Self, __sender_base>, _As...>) |
| { |
| return stdexec::tag_invoke(_Tag{}, ((Self&&)__self).__sender_, |
| (_As&&)__as...); |
| } |
| |
| 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_((_Sender&&)__sender) |
| {} |
| |
| template <auto... _SchedulerQueries> |
| class any_scheduler |
| { |
| using __schedule_completions = |
| stdexec::__concat_completion_signatures_t< |
| _Completions, |
| stdexec::completion_signatures<stdexec::set_value_t()>>; |
| using __schedule_receiver = |
| any_receiver_ref<__schedule_completions, _ReceiverQueries...>; |
| |
| template <typename _Tag, typename _Sig> |
| static _Tag __ret_fn(_Tag (*const)(_Sig)); |
| |
| template <class _Tag> |
| struct __ret_equals_to |
| { |
| template <class _Sig> |
| using __f = |
| std::is_same<_Tag, decltype(__ret_fn((_Sig) nullptr))>; |
| }; |
| |
| using schedule_sender_queries = stdexec::__minvoke< |
| stdexec::__remove_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 |
| |
| 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>; |
| #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>>; |
| #endif |
| using __schedule_sender = |
| stdexec::__mapply<stdexec::__q<__schedule_sender_fn>, |
| schedule_sender_queries>; |
| |
| using __scheduler_base = |
| __any::__scheduler<__schedule_sender, |
| queries<_SchedulerQueries...>>; |
| |
| __scheduler_base __scheduler_; |
| |
| public: |
| using __t = any_scheduler; |
| using __id = any_scheduler; |
| |
| template <class _Scheduler> |
| requires(!stdexec::__decays_to<_Scheduler, any_scheduler> && |
| stdexec::scheduler<_Scheduler>) |
| any_scheduler(_Scheduler&& __scheduler) : |
| __scheduler_{(_Scheduler&&)__scheduler} |
| {} |
| |
| private: |
| template <class _Tag, stdexec::__decays_to<any_scheduler> Self, |
| class... _As> |
| requires stdexec::tag_invocable< |
| _Tag, stdexec::__copy_cvref_t<Self, __scheduler_base>, |
| _As...> |
| friend auto tag_invoke(_Tag, Self&& __self, _As&&... __as) noexcept( |
| std::is_nothrow_invocable_v< |
| _Tag, stdexec::__copy_cvref_t<Self, __scheduler_base>, |
| _As...>) |
| { |
| return stdexec::tag_invoke( |
| _Tag{}, ((Self&&)__self).__scheduler_, (_As&&)__as...); |
| } |
| |
| friend bool |
| operator==(const any_scheduler& __self, |
| const any_scheduler& __other) noexcept = default; |
| }; |
| }; |
| }; |
| } // namespace exec |