Skip to content

Commit

Permalink
clang-format
Browse files Browse the repository at this point in the history
  • Loading branch information
@dietmarkuehl
dietmarkuehl committed Jan 20, 2025
1 parent 1d55931 commit 37d7741
Show file tree
Hide file tree
Showing 2 changed files with 40 additions and 68 deletions.
68 changes: 25 additions & 43 deletions examples/intro-5-consumer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,50 +14,42 @@ using namespace std::string_literals;
enum class success { one };
enum class failure { fail_one };

struct expected_to_channel_t
{
struct expected_to_channel_t {
template <typename Receiver>
struct own_receiver
{
struct own_receiver {
using receiver_concept = ex::receiver_t;
Receiver* receiver;
template <typename Value, typename Error>
auto set_value(std::expected<Value, Error>&& exp) noexcept -> void {
if (exp) {
std::cout << "received an expected with value from child/upstream\n" << std::flush;
ex::set_value(std::move(*receiver), exp.value_or(Value{}));
std::cout << "set_value\n" << std::flush;
}
else {
std::cout << "received an expected with error from child/upstream\n";
ex::set_error(std::move(*receiver), exp.error_or(Error{}));
std::cout << "received an expected with value from child/upstream\n" << std::flush;
ex::set_value(std::move(*receiver), exp.value_or(Value{}));
std::cout << "set_value\n" << std::flush;
} else {
std::cout << "received an expected with error from child/upstream\n";
ex::set_error(std::move(*receiver), exp.error_or(Error{}));
}
}
template <typename Error>
auto set_error(Error&& error) noexcept -> void{
auto set_error(Error&& error) noexcept -> void {
std::cout << "received an error from child/upstream";
ex::set_error(std::move(*receiver), std::forward<Error>(error));
}
auto set_stopped() noexcept -> void{
auto set_stopped() noexcept -> void {
std::cout << "received an cancelletion from child/upstream";
ex::set_stopped(std::move(*receiver));
}
};
template <ex::sender CSender, ex::receiver Receiver>
struct state
{
struct state {
using operation_state_concept = ex::operation_state_t;
using child_state_t = decltype(ex::connect(std::declval<CSender>(), std::declval<own_receiver<Receiver>>()));
Receiver parent_receiver;
Receiver parent_receiver;
child_state_t child_state;
template <ex::sender S, ex::receiver R>
state(S&& child_sender, R&& parent_receiver)
: parent_receiver(std::forward<R>(parent_receiver))
, child_state(ex::connect(
std::forward<S>(child_sender),
own_receiver<Receiver>{&this->parent_receiver})
)
{
: parent_receiver(std::forward<R>(parent_receiver)),
child_state(ex::connect(std::forward<S>(child_sender), own_receiver<Receiver>{&this->parent_receiver})) {
}
void start() & noexcept {
std::cout << "starting execpted_to_channel\n";
Expand All @@ -66,46 +58,36 @@ struct expected_to_channel_t
};

template <ex::sender CSender>
struct sender
{
struct sender {
using sender_concept = ex::sender_t;
// value_types_of<CSender....> -> set_value_t(std::expected<T, E>)
// -> completion_signatures<set_value_t(T), set_error_t(E)>
// -> + error_type_of<CSender...>
// -> + sends_stopped<CSender...> -> set_stopped_t()
// -> unique
using completion_signatures = ex::completion_signatures<
ex::set_value_t(success),
ex::set_error_t(failure)
>;
using completion_signatures = ex::completion_signatures<ex::set_value_t(success), ex::set_error_t(failure)>;
CSender child_sender;

template <ex::receiver Receiver>
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) &&
{
return { std::move(this->child_sender), std::forward<Receiver>(receiver) };
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) && {
return {std::move(this->child_sender), std::forward<Receiver>(receiver)};
}
template <ex::receiver Receiver>
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) const&
{
return { this->child_sender, std::forward<Receiver>(receiver) };
state<CSender, std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) const& {
return {this->child_sender, std::forward<Receiver>(receiver)};
}
};

template <ex::sender CSender>
sender<std::remove_cvref_t<CSender>> operator()(CSender&& child_sender) const {
return { std::forward<CSender>(child_sender) };
return {std::forward<CSender>(child_sender)};
}
auto operator()() const { return ex::detail::sender_adaptor{*this}; }
};
inline constexpr expected_to_channel_t expected_to_channel{};

int main()
{
ex::sync_wait(
ex::just(std::expected<success, failure>(success::one))
| expected_to_channel()
| ex::then([](success) noexcept { std::cout << "success\n"; })
| ex::upon_error([](failure) noexcept { std::cout << "fail\n"; })
);
int main() {
ex::sync_wait(ex::just(std::expected<success, failure>(success::one)) | expected_to_channel() |
ex::then([](success) noexcept { std::cout << "success\n"; }) |
ex::upon_error([](failure) noexcept { std::cout << "fail\n"; }));
}
40 changes: 15 additions & 25 deletions examples/intro-timer.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,15 +14,15 @@
// ----------------------------------------------------------------------------

namespace intro {
namespace ex = beman::execution26;
struct timer;
}
namespace ex = beman::execution26;
struct timer;
} // namespace intro

// ----------------------------------------------------------------------------

struct intro::timer {
struct state_base {
virtual ~state_base() = default;
virtual ~state_base() = default;
virtual void complete() = 0;
};
template <typename Receiver>
Expand Down Expand Up @@ -69,8 +69,7 @@ struct intro::timer {
}

template <typename Receiver>
struct run_state
{
struct run_state {
struct recv {
using receiver_concept = ex::receiver_t;
run_state* self;
Expand All @@ -80,7 +79,7 @@ struct intro::timer {
auto set_stopped() noexcept -> void { this->self->run_one(); }
};
using operation_state_concept = ex::operation_state_t;
using scheduler_t = decltype(ex::get_delegation_scheduler(ex::get_env(std::declval<Receiver&>())));
using scheduler_t = decltype(ex::get_delegation_scheduler(ex::get_env(std::declval<Receiver&>())));
static_assert(ex::receiver<recv>);
static_assert(ex::scheduler<scheduler_t>);
static_assert(ex::sender<decltype(ex::schedule(std::declval<scheduler_t>()))>);
Expand All @@ -89,20 +88,15 @@ struct intro::timer {
state_t state;
template <typename S, typename R>
state_ctor(S&& sender, R&& receiver)
: state(ex::connect(std::forward<S>(sender), std::forward<R>(receiver)))
{
}
: state(ex::connect(std::forward<S>(sender), std::forward<R>(receiver))) {}
};

timer* self;
Receiver receiver;
timer* self;
Receiver receiver;
std::optional<state_ctor> state{};

auto schedule_one() {
this->state.emplace(
ex::schedule(ex::get_delegation_scheduler(ex::get_env(this->receiver))),
recv{this}
);
this->state.emplace(ex::schedule(ex::get_delegation_scheduler(ex::get_env(this->receiver))), recv{this});
ex::start(this->state->state);
}
auto run_one() {
Expand All @@ -112,21 +106,17 @@ struct intro::timer {
else
ex::set_value(std::move(this->receiver));
}
auto start() & noexcept -> void {
this->schedule_one();
}
auto start() & noexcept -> void { this->schedule_one(); }
};
struct run_sender
{
using sender_concept = ex::sender_t;
struct run_sender {
using sender_concept = ex::sender_t;
using completion_signatures = ex::completion_signatures<ex::set_value_t()>;

timer* self;

template <typename Receiver>
run_state<std::remove_cvref_t<Receiver>> connect(Receiver&& receiver)
{
return { self, std::forward<Receiver>(receiver) };
run_state<std::remove_cvref_t<Receiver>> connect(Receiver&& receiver) {
return {self, std::forward<Receiver>(receiver)};
}
};

Expand Down

0 comments on commit 37d7741

Please sign in to comment.