Skip to content

Commit 37d7741

Browse files
dietmarkuehldietmarkuehl
committed
clang-format
1 parent 1d55931 commit 37d7741

File tree

2 files changed

+40
-68
lines changed

2 files changed

+40
-68
lines changed

‎examples/intro-5-consumer.cpp

+25-43
Original file line numberDiff line numberDiff line change
@@ -14,50 +14,42 @@ using namespace std::string_literals;
1414
enum class success { one };
1515
enum class failure { fail_one };
1616

17-
struct expected_to_channel_t
18-
{
17+
struct expected_to_channel_t {
1918
template <typename Receiver>
20-
struct own_receiver
21-
{
19+
struct own_receiver {
2220
using receiver_concept = ex::receiver_t;
2321
Receiver* receiver;
2422
template <typename Value, typename Error>
2523
auto set_value(std::expected<Value, Error>&& exp) noexcept -> void {
2624
if (exp) {
27-
std::cout << "received an expected with value from child/upstream\n" << std::flush;
28-
ex::set_value(std::move(*receiver), exp.value_or(Value{}));
29-
std::cout << "set_value\n" << std::flush;
30-
}
31-
else {
32-
std::cout << "received an expected with error from child/upstream\n";
33-
ex::set_error(std::move(*receiver), exp.error_or(Error{}));
25+
std::cout << "received an expected with value from child/upstream\n" << std::flush;
26+
ex::set_value(std::move(*receiver), exp.value_or(Value{}));
27+
std::cout << "set_value\n" << std::flush;
28+
} else {
29+
std::cout << "received an expected with error from child/upstream\n";
30+
ex::set_error(std::move(*receiver), exp.error_or(Error{}));
3431
}
3532
}
3633
template <typename Error>
37-
auto set_error(Error&& error) noexcept -> void{
34+
auto set_error(Error&& error) noexcept -> void {
3835
std::cout << "received an error from child/upstream";
3936
ex::set_error(std::move(*receiver), std::forward<Error>(error));
4037
}
41-
auto set_stopped() noexcept -> void{
38+
auto set_stopped() noexcept -> void {
4239
std::cout << "received an cancelletion from child/upstream";
4340
ex::set_stopped(std::move(*receiver));
4441
}
4542
};
4643
template <ex::sender CSender, ex::receiver Receiver>
47-
struct state
48-
{
44+
struct state {
4945
using operation_state_concept = ex::operation_state_t;
5046
using child_state_t = decltype(ex::connect(std::declval<CSender>(), std::declval<own_receiver<Receiver>>()));
51-
Receiver parent_receiver;
47+
Receiver parent_receiver;
5248
child_state_t child_state;
5349
template <ex::sender S, ex::receiver R>
5450
state(S&& child_sender, R&& parent_receiver)
55-
: parent_receiver(std::forward<R>(parent_receiver))
56-
, child_state(ex::connect(
57-
std::forward<S>(child_sender),
58-
own_receiver<Receiver>{&this->parent_receiver})
59-
)
60-
{
51+
: parent_receiver(std::forward<R>(parent_receiver)),
52+
child_state(ex::connect(std::forward<S>(child_sender), own_receiver<Receiver>{&this->parent_receiver})) {
6153
}
6254
void start() & noexcept {
6355
std::cout << "starting execpted_to_channel\n";
@@ -66,46 +58,36 @@ struct expected_to_channel_t
6658
};
6759

6860
template <ex::sender CSender>
69-
struct sender
70-
{
61+
struct sender {
7162
using sender_concept = ex::sender_t;
7263
// value_types_of<CSender....> -> set_value_t(std::expected<T, E>)
7364
// -> completion_signatures<set_value_t(T), set_error_t(E)>
7465
// -> + error_type_of<CSender...>
7566
// -> + sends_stopped<CSender...> -> set_stopped_t()
7667
// -> unique
77-
using completion_signatures = ex::completion_signatures<
78-
ex::set_value_t(success),
79-
ex::set_error_t(failure)
80-
>;
68+
using completion_signatures = ex::completion_signatures<ex::set_value_t(success), ex::set_error_t(failure)>;
8169
CSender child_sender;
8270

8371
template <ex::receiver Receiver>
84-
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) &&
85-
{
86-
return { std::move(this->child_sender), std::forward<Receiver>(receiver) };
72+
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) && {
73+
return {std::move(this->child_sender), std::forward<Receiver>(receiver)};
8774
}
8875
template <ex::receiver Receiver>
89-
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) const&
90-
{
91-
return { this->child_sender, std::forward<Receiver>(receiver) };
76+
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) const& {
77+
return {this->child_sender, std::forward<Receiver>(receiver)};
9278
}
9379
};
9480

9581
template <ex::sender CSender>
9682
sender<std::remove_cvref_t<CSender>> operator()(CSender&& child_sender) const {
97-
return { std::forward<CSender>(child_sender) };
83+
return {std::forward<CSender>(child_sender)};
9884
}
9985
auto operator()() const { return ex::detail::sender_adaptor{*this}; }
10086
};
10187
inline constexpr expected_to_channel_t expected_to_channel{};
10288

103-
int main()
104-
{
105-
ex::sync_wait(
106-
ex::just(std::expected<success, failure>(success::one))
107-
| expected_to_channel()
108-
| ex::then([](success) noexcept { std::cout << "success\n"; })
109-
| ex::upon_error([](failure) noexcept { std::cout << "fail\n"; })
110-
);
89+
int main() {
90+
ex::sync_wait(ex::just(std::expected<success, failure>(success::one)) | expected_to_channel() |
91+
ex::then([](success) noexcept { std::cout << "success\n"; }) |
92+
ex::upon_error([](failure) noexcept { std::cout << "fail\n"; }));
11193
}

‎examples/intro-timer.hpp

+15-25
Original file line numberDiff line numberDiff line change
@@ -14,15 +14,15 @@
1414
// ----------------------------------------------------------------------------
1515

1616
namespace intro {
17-
namespace ex = beman::execution26;
18-
struct timer;
19-
}
17+
namespace ex = beman::execution26;
18+
struct timer;
19+
} // namespace intro
2020

2121
// ----------------------------------------------------------------------------
2222

2323
struct intro::timer {
2424
struct state_base {
25-
virtual ~state_base() = default;
25+
virtual ~state_base() = default;
2626
virtual void complete() = 0;
2727
};
2828
template <typename Receiver>
@@ -69,8 +69,7 @@ struct intro::timer {
6969
}
7070

7171
template <typename Receiver>
72-
struct run_state
73-
{
72+
struct run_state {
7473
struct recv {
7574
using receiver_concept = ex::receiver_t;
7675
run_state* self;
@@ -80,7 +79,7 @@ struct intro::timer {
8079
auto set_stopped() noexcept -> void { this->self->run_one(); }
8180
};
8281
using operation_state_concept = ex::operation_state_t;
83-
using scheduler_t = decltype(ex::get_delegation_scheduler(ex::get_env(std::declval<Receiver&>())));
82+
using scheduler_t = decltype(ex::get_delegation_scheduler(ex::get_env(std::declval<Receiver&>())));
8483
static_assert(ex::receiver<recv>);
8584
static_assert(ex::scheduler<scheduler_t>);
8685
static_assert(ex::sender<decltype(ex::schedule(std::declval<scheduler_t>()))>);
@@ -89,20 +88,15 @@ struct intro::timer {
8988
state_t state;
9089
template <typename S, typename R>
9190
state_ctor(S&& sender, R&& receiver)
92-
: state(ex::connect(std::forward<S>(sender), std::forward<R>(receiver)))
93-
{
94-
}
91+
: state(ex::connect(std::forward<S>(sender), std::forward<R>(receiver))) {}
9592
};
9693

97-
timer* self;
98-
Receiver receiver;
94+
timer* self;
95+
Receiver receiver;
9996
std::optional<state_ctor> state{};
10097

10198
auto schedule_one() {
102-
this->state.emplace(
103-
ex::schedule(ex::get_delegation_scheduler(ex::get_env(this->receiver))),
104-
recv{this}
105-
);
99+
this->state.emplace(ex::schedule(ex::get_delegation_scheduler(ex::get_env(this->receiver))), recv{this});
106100
ex::start(this->state->state);
107101
}
108102
auto run_one() {
@@ -112,21 +106,17 @@ struct intro::timer {
112106
else
113107
ex::set_value(std::move(this->receiver));
114108
}
115-
auto start() & noexcept -> void {
116-
this->schedule_one();
117-
}
109+
auto start() & noexcept -> void { this->schedule_one(); }
118110
};
119-
struct run_sender
120-
{
121-
using sender_concept = ex::sender_t;
111+
struct run_sender {
112+
using sender_concept = ex::sender_t;
122113
using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
123114

124115
timer* self;
125116

126117
template <typename Receiver>
127-
run_state<std::remove_cvref_t<Receiver>> connect(Receiver&& receiver)
128-
{
129-
return { self, std::forward<Receiver>(receiver) };
118+
run_state<std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) {
119+
return {self, std::forward<Receiver>(receiver)};
130120
}
131121
};
132122

0 commit comments

Comments
 (0)