Skip to content

Commit 62853a5

Browse files
dietmarkuehldietmarkuehl
committed
added default_domain
1 parent 3fd5d0a commit 62853a5

10 files changed

+384
-7
lines changed

‎include/Beman/Execution26/detail/continues_on.hpp

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
// include/Beman/Execution26/detail/continues_on.hpp -*-C++-*-
2+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
3+
4+
#ifndef INCLUDED_BEMAN_EXECUTION26_DETAIL_CONTINUES_ON
5+
#define INCLUDED_BEMAN_EXECUTION26_DETAIL_CONTINUES_ON
6+
7+
// ----------------------------------------------------------------------------
8+
9+
namespace Beman::Execution26
10+
{
11+
struct continues_on_t
12+
{
13+
//-dk:TODO provide actual implementation
14+
};
15+
16+
inline constexpr continues_on_t continues_on{};
17+
}
18+
19+
// ----------------------------------------------------------------------------
20+
21+
#endif

‎include/Beman/Execution26/detail/default_domain.hpp

+87
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
// include/Beman/Execution26/detail/default_domain.hpp -*-C++-*-
2+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
3+
4+
#ifndef INCLUDED_BEMAN_EXECUTION26_DETAIL_DEFAULT_DOMAIN
5+
#define INCLUDED_BEMAN_EXECUTION26_DETAIL_DEFAULT_DOMAIN
6+
7+
#include <Beman/Execution26/detail/queryable.hpp>
8+
#include <Beman/Execution26/detail/sender.hpp>
9+
#include <Beman/Execution26/detail/sender_decompose.hpp>
10+
#include <type_traits>
11+
#include <utility>
12+
13+
// ----------------------------------------------------------------------------
14+
15+
namespace Beman::Execution26
16+
{
17+
struct default_domain
18+
{
19+
template <::Beman::Execution26::sender Sender,
20+
::Beman::Execution26::Detail::queryable... Env>
21+
requires (sizeof...(Env) <= 1)
22+
&& requires(Sender&& sender, Env&&... env)
23+
{
24+
::Beman::Execution26::tag_of_t<Sender>().transform_sender(::std::forward<Sender>(sender), ::std::forward<Env>(env)...);
25+
}
26+
static constexpr auto transform_sender(Sender&& sender, Env&&... env)
27+
noexcept(noexcept(::Beman::Execution26::tag_of_t<Sender>().transform_sender(::std::forward<Sender>(sender), ::std::forward<Env>(env)...)))
28+
-> ::Beman::Execution26::sender decltype(auto)
29+
{
30+
return ::Beman::Execution26::tag_of_t<Sender>().transform_sender(::std::forward<Sender>(sender), ::std::forward<Env>(env)...);
31+
}
32+
33+
template <::Beman::Execution26::sender Sender,
34+
::Beman::Execution26::Detail::queryable... Env>
35+
requires (sizeof...(Env) <= 1)
36+
&& (not requires(Sender&& sender, Env&&... env)
37+
{
38+
::Beman::Execution26::tag_of_t<Sender>().transform_sender(::std::forward<Sender>(sender), ::std::forward<Env>(env)...);
39+
})
40+
static constexpr auto transform_sender(Sender&& sender, Env&&...)
41+
noexcept(noexcept(::std::forward<Sender>(sender)))
42+
-> ::Beman::Execution26::sender decltype(auto)
43+
{
44+
return ::std::forward<Sender>(sender);
45+
}
46+
47+
template <::Beman::Execution26::sender Sender,
48+
::Beman::Execution26::Detail::queryable Env>
49+
requires requires(Sender&& sender, Env&& env)
50+
{
51+
::Beman::Execution26::tag_of_t<Sender>().transform_env(::std::forward<Sender>(sender), ::std::forward<Env>(env));
52+
}
53+
static constexpr auto transform_env(Sender&& sender, Env&& env) noexcept
54+
-> ::Beman::Execution26::Detail::queryable decltype(auto)
55+
{
56+
return ::Beman::Execution26::tag_of_t<Sender>().transform_env(::std::forward<Sender>(sender), ::std::forward<Env>(env));
57+
}
58+
59+
template <::Beman::Execution26::sender Sender,
60+
::Beman::Execution26::Detail::queryable Env>
61+
requires (not requires(Sender&& sender, Env&& env)
62+
{
63+
::Beman::Execution26::tag_of_t<Sender>().transform_env(::std::forward<Sender>(sender), ::std::forward<Env>(env));
64+
})
65+
static constexpr auto transform_env(Sender&&, Env&& env) noexcept
66+
-> ::Beman::Execution26::Detail::queryable decltype(auto)
67+
{
68+
return static_cast<Env>(::std::forward<Env>(env));
69+
}
70+
71+
template <typename Tag, ::Beman::Execution26::sender Sender, typename... Args>
72+
requires requires(Sender&& sender, Args&&... args)
73+
{
74+
Tag().apply_sender(::std::forward<Sender>(sender), ::std::forward<Args>(args)...);
75+
}
76+
static constexpr auto apply_sender(Tag, Sender&& sender, Args&&... args)
77+
noexcept(noexcept(Tag().apply_sender(::std::forward<Sender>(sender), ::std::forward<Args>(args)...)))
78+
-> decltype(auto)
79+
{
80+
return Tag().apply_sender(::std::forward<Sender>(sender), ::std::forward<Args>(args)...);
81+
}
82+
};
83+
}
84+
85+
// ----------------------------------------------------------------------------
86+
87+
#endif

‎include/Beman/Execution26/detail/get_completion_signatures.hpp

+2-1
Original file line numberDiff line numberDiff line change
@@ -10,10 +10,11 @@ namespace Beman::Execution26
1010
{
1111
struct get_completion_signatures_t
1212
{
13+
//-dk:TODO add implementation
1314
};
1415
inline constexpr get_completion_signatures_t get_completion_signatures{};
1516
}
1617

1718
// ----------------------------------------------------------------------------
1819

19-
#endif
20+
#endif

‎include/Beman/Execution26/detail/get_domain_late.hpp

+23-6
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,32 @@
11
// include/Beman/Execution26/detail/get_domain_late.hpp -*-C++-*-
2-
// ----------------------------------------------------------------------------
32
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
4-
// ----------------------------------------------------------------------------
53

6-
#ifndef INCLUDED_INCLUDE_BEMAN_EXECUTION26_DETAIL_GET_DOMAIN_LATE
7-
#define INCLUDED_INCLUDE_BEMAN_EXECUTION26_DETAIL_GET_DOMAIN_LATE
4+
#ifndef INCLUDED_BEMAN_EXECUTION26_DETAIL_GET_DOMAIN_LATE
5+
#define INCLUDED_BEMAN_EXECUTION26_DETAIL_GET_DOMAIN_LATE
6+
7+
// #include <Beman/Execution26/detail/continues_on.hpp>
8+
#include <Beman/Execution26/detail/default_domain.hpp>
9+
#include <Beman/Execution26/detail/sender_decompose.hpp>
810

911
// ----------------------------------------------------------------------------
1012

11-
namespace nstd {
12-
namespace xxx {
13+
namespace Beman::Execution26::Detail
14+
{
15+
template <typename Tag>
16+
struct get_domain_late_helper
17+
{
18+
template <typename Sender, typename Env>
19+
static constexpr auto get(Sender const& sender, Env const& env) noexcept
20+
{
21+
(void)sender; (void)env;
22+
return ::Beman::Execution26::default_domain();
23+
}
24+
};
25+
template <typename Sender, typename Env>
26+
constexpr auto get_domain_late(Sender const& sender, Env const& env) noexcept
27+
{
28+
using tag_t = ::Beman::Execution26::tag_of_t<Sender>;
29+
return ::Beman::Execution26::Detail::get_domain_late_helper<tag_t>::get(sender, env);
1330
}
1431
}
1532

‎include/Beman/Execution26/detail/sender_decompose.hpp

+4
Original file line numberDiff line numberDiff line change
@@ -59,6 +59,10 @@ namespace Beman::Execution26::Detail
5959
auto&& [tag, data] = sender;
6060
return ::Beman::Execution26::Detail::sender_meta<decltype(tag), decltype(data), ::std::tuple<>>{};
6161
}
62+
else
63+
{
64+
return ::Beman::Execution26::Detail::sender_meta<void, void, void>{};
65+
}
6266
}
6367
}
6468

‎src/Beman/Execution26/tests/CMakeLists.txt

+1
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
33

44
list(APPEND execution_tests
5+
exec-domain-default.pass
56
exec-get-scheduler.pass
67
exec-get-compl-sched.pass
78
exec-snd-expos.pass

‎src/Beman/Execution26/tests/exec-domain-default.pass.cpp

+216
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,216 @@
1+
// src/Beman/Execution26/tests/exec-domain-default.pass.cpp -*-C++-*-
2+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
3+
4+
#include <Beman/Execution26/detail/default_domain.hpp>
5+
#include <Beman/Execution26/detail/sender.hpp>
6+
#include <Beman/Execution26/detail/sender_decompose.hpp>
7+
#include <test/execution.hpp>
8+
#include <concepts>
9+
10+
// ----------------------------------------------------------------------------
11+
12+
namespace
13+
{
14+
struct env
15+
{
16+
int value{};
17+
auto operator== (env const&) const -> bool = default;
18+
};
19+
struct tagged_env
20+
{
21+
int value{};
22+
auto operator== (tagged_env const&) const -> bool = default;
23+
};
24+
25+
struct non_sender {};
26+
struct simple_sender
27+
{
28+
using sender_concept = test_std::sender_t;
29+
int value{};
30+
auto operator== (simple_sender const&) const -> bool = default;
31+
};
32+
33+
struct simple_tag {};
34+
35+
template <bool Noexcept>
36+
struct tag
37+
{
38+
template <typename Sender, typename... Env>
39+
auto transform_sender(Sender&& sender, Env&&...) noexcept(Noexcept)
40+
{
41+
return simple_sender{sender.value};
42+
}
43+
44+
template <typename Sender, typename Env>
45+
auto transform_env(Sender&&, Env&& e) noexcept
46+
{
47+
return env{e.value};
48+
}
49+
50+
template <typename Sender>
51+
auto apply_sender(Sender&&, int value) noexcept(Noexcept)
52+
{
53+
return value;
54+
}
55+
template <typename Sender>
56+
auto apply_sender(Sender&&, int v0, int v1, int v2) noexcept(Noexcept)
57+
{
58+
return v0 + v1 + v2;
59+
}
60+
template <typename Sender>
61+
auto apply_sender(Sender&&, bool& flag) noexcept(Noexcept) -> bool&
62+
{
63+
return flag;
64+
}
65+
};
66+
67+
template <bool Noexcept>
68+
struct tagged_sender
69+
{
70+
using sender_concept = test_std::sender_t;
71+
tag<Noexcept> t{};
72+
int value{17};
73+
int args{};
74+
};
75+
76+
template <typename Domain>
77+
auto test_transform_sender(Domain)
78+
{
79+
static_assert(test_detail::queryable<env>);
80+
static_assert(test_std::sender<simple_sender>);
81+
static_assert(not requires{ Domain::transform_sender(non_sender{}); });
82+
static_assert(requires{ Domain::transform_sender(simple_sender{}); });
83+
static_assert(requires{ Domain::transform_sender(simple_sender{}, env{}); });
84+
static_assert(not requires{ Domain::transform_sender(simple_sender{}, env{}, env{}); });
85+
static_assert(noexcept(Domain::transform_sender(simple_sender{})));
86+
static_assert(noexcept(Domain::transform_sender(simple_sender{}, env{})));
87+
using simple_rvalue_type = decltype(Domain::transform_sender(simple_sender{}));
88+
static_assert(std::same_as<simple_sender&&, simple_rvalue_type>);
89+
using simple_env_rvalue_type = decltype(Domain::transform_sender(simple_sender{}, env{}));
90+
static_assert(std::same_as<simple_sender&&, simple_env_rvalue_type>);
91+
simple_sender sender;
92+
using simple_lvalue_type = decltype(Domain::transform_sender(sender));
93+
static_assert(std::same_as<simple_sender&, simple_lvalue_type>);
94+
using simple_env_lvalue_type = decltype(Domain::transform_sender(sender, env{}));
95+
static_assert(std::same_as<simple_sender&, simple_env_lvalue_type>);
96+
simple_sender const csender;
97+
using simple_clvalue_type = decltype(Domain::transform_sender(csender));
98+
static_assert(std::same_as<simple_sender const&, simple_clvalue_type>);
99+
using simple_env_clvalue_type = decltype(Domain::transform_sender(csender, env{}));
100+
static_assert(std::same_as<simple_sender const&, simple_env_clvalue_type>);
101+
102+
assert(simple_sender{17} == Domain::transform_sender(simple_sender{17}, env{}));
103+
assert(&sender == &Domain::transform_sender(sender, env{}));
104+
assert(&csender == &Domain::transform_sender(csender, env{}));
105+
106+
static_assert(test_std::sender<tagged_sender<true>>);
107+
static_assert(test_std::sender<tagged_sender<false>>);
108+
static_assert(std::same_as<tag<true>, test_std::tag_of_t<tagged_sender<true>>>);
109+
static_assert(std::same_as<tag<false>, test_std::tag_of_t<tagged_sender<false>>>);
110+
static_assert(requires{ tag<true>().transform_sender(tagged_sender<true>()); });
111+
static_assert(requires{ tag<true>().transform_sender(tagged_sender<true>(), env{}); });
112+
static_assert(requires{ tag<false>().transform_sender(tagged_sender<false>()); });
113+
static_assert(requires{ tag<false>().transform_sender(tagged_sender<false>(), env{}); });
114+
static_assert(requires{ Domain::transform_sender(tagged_sender<true>()); });
115+
static_assert(requires{ Domain::transform_sender(tagged_sender<true>(), env{}); });
116+
static_assert(not requires{ Domain::transform_sender(tagged_sender<true>(), env{}, env{}); });
117+
static_assert(requires{ Domain::transform_sender(tagged_sender<false>()); });
118+
static_assert(requires{ Domain::transform_sender(tagged_sender<false>(), env{}); });
119+
static_assert(not requires{ Domain::transform_sender(tagged_sender<false>(), env{}, env{}); });
120+
static_assert(noexcept(Domain::transform_sender(tagged_sender<true>())));
121+
static_assert(noexcept(Domain::transform_sender(tagged_sender<true>(), env{})));
122+
static_assert(not noexcept(Domain::transform_sender(tagged_sender<false>())));
123+
static_assert(not noexcept(Domain::transform_sender(tagged_sender<false>(), env{})));
124+
{
125+
using type = decltype(Domain::transform_sender(tagged_sender<true>()));
126+
static_assert(std::same_as<simple_sender, type>);
127+
assert(simple_sender{17} == Domain::transform_sender(tagged_sender<true>()));
128+
}
129+
{
130+
using type = decltype(Domain::transform_sender(tagged_sender<true>(), env{}));
131+
static_assert(std::same_as<simple_sender, type>);
132+
assert(simple_sender{17} == Domain::transform_sender(tagged_sender<true>(), env{}));
133+
}
134+
{
135+
using type = decltype(Domain::transform_sender(tagged_sender<false>()));
136+
static_assert(std::same_as<simple_sender, type>);
137+
assert(simple_sender{17} == Domain::transform_sender(tagged_sender<false>()));
138+
}
139+
{
140+
using type = decltype(Domain::transform_sender(tagged_sender<false>(), env{}));
141+
static_assert(std::same_as<simple_sender, type>);
142+
assert(simple_sender{17} == Domain::transform_sender(tagged_sender<false>(), env{}));
143+
}
144+
//-dk:TODO test returning a non-sender doesn't work
145+
}
146+
147+
template <typename Domain>
148+
auto test_transform_env(Domain)
149+
{
150+
static_assert(test_detail::queryable<env>);
151+
static_assert(test_std::sender<simple_sender>);
152+
static_assert(requires{ Domain::transform_env(simple_sender{}, env{}); });
153+
static_assert(noexcept(Domain::transform_env(simple_sender{}, env{})));
154+
{
155+
using type = decltype(Domain::transform_env(simple_sender{}, env{}));
156+
static_assert(std::same_as<env, type>);
157+
assert(env{17} == Domain::transform_env(simple_sender{}, env{17}));
158+
}
159+
{
160+
env e{17};
161+
using type = decltype(Domain::transform_env(simple_sender{}, e));
162+
static_assert(std::same_as<env&, type>);
163+
assert(&e == &Domain::transform_env(simple_sender{}, e));
164+
}
165+
{
166+
env const ce{17};
167+
using type = decltype(Domain::transform_env(simple_sender{}, ce));
168+
static_assert(std::same_as<env const&, type>);
169+
assert(&ce == &Domain::transform_env(simple_sender{}, ce));
170+
}
171+
172+
static_assert(test_std::sender<tagged_sender<true>>);
173+
static_assert(requires{ tag<true>{}.transform_env(tagged_sender<true>(), env{}); });
174+
static_assert(std::same_as<env, decltype(tag<true>{}.transform_env(tagged_sender<true>(), env{}))>);
175+
static_assert(requires{ Domain::transform_env(tagged_sender<true>{}, env{}); });
176+
static_assert(noexcept(Domain::transform_env(tagged_sender<true>{}, env{})));
177+
{
178+
using type = decltype(Domain::transform_env(tagged_sender<true>{}, env{}));
179+
static_assert(std::same_as<env, type>);
180+
assert(env{17} == Domain::transform_env(simple_sender{}, env{17}));
181+
}
182+
}
183+
184+
template <typename Domain>
185+
auto test_apply_sender(Domain) -> void
186+
{
187+
static_assert(test_std::sender<simple_sender>);
188+
static_assert(not requires{ Domain().apply_sender(simple_tag{}, simple_sender{}); });
189+
static_assert(not requires{ Domain().apply_sender(simple_tag{}, simple_sender{}, 0); });
190+
191+
static_assert(not requires{ Domain().apply_sender(tag<true>{}, simple_sender{}); });
192+
static_assert(requires{ Domain().apply_sender(tag<true>{}, simple_sender{}, 0); });
193+
static_assert(not requires{ Domain().apply_sender(tag<true>{}, simple_sender{}, 0, 0); });
194+
static_assert(requires{ Domain().apply_sender(tag<true>{}, simple_sender{}, 0, 0, 0); });
195+
static_assert(noexcept(Domain().apply_sender(tag<true>{}, simple_sender{}, 0)));
196+
static_assert(noexcept(Domain().apply_sender(tag<true>{}, simple_sender{}, 0, 0, 0)));
197+
static_assert(not noexcept(Domain().apply_sender(tag<false>{}, simple_sender{}, 0)));
198+
static_assert(not noexcept(Domain().apply_sender(tag<false>{}, simple_sender{}, 0, 0, 0)));
199+
200+
assert(17 == Domain().apply_sender(tag<true>{}, simple_sender{}, 17));
201+
assert(15 == Domain().apply_sender(tag<true>{}, simple_sender{}, 4, 5, 6));
202+
203+
bool flag{};
204+
assert(&flag == &Domain().apply_sender(tag<true>{}, simple_sender{}, flag));
205+
}
206+
}
207+
208+
// ----------------------------------------------------------------------------
209+
210+
auto main() -> int
211+
{
212+
test_std::default_domain domain{};
213+
test_transform_sender(domain);
214+
test_transform_env(domain);
215+
test_apply_sender(domain);
216+
}

0 commit comments

Comments
 (0)