Merge pull request #63 from beman-project/add-simple-sender-creation-example

Add simple sender creation example

Author: dietmarkuehl

Makefile

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 SANITIZERS = release debug msan asan usan tsan
-.PHONY: default run update check ce todo distclean clean build test all $(SANITIZERS)
+.PHONY: default run update check ce todo distclean clean build test all format $(SANITIZERS)
 
 COMPILER=system
 CXX_BASE=$(CXX:$(dir $(CXX))%=%)
@@ -79,6 +79,9 @@ check:
 		< $$h sed -n "/^ *# *include <Beman\//s@.*[</]Beman/\(.*\).hpp>.*@$$from \1@p"; \
 	done | tsort > /dev/null
 
+format:
+	clang-format -i `git diff --name-only main | egrep '\.[ch]pp'`
+
 todo:
 	bin/mk-todo.py
 

examples/CMakeLists.txt

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # cmake-format: on
 
-list(APPEND EXAMPLES when_all-cancel stop_token stopping allocator)
+list(APPEND EXAMPLES sender-demo when_all-cancel stop_token stopping allocator)
 
 foreach(EXAMPLE ${EXAMPLES})
   set(EXAMPLE_TARGET ${TARGET_PREFIX}.examples.${EXAMPLE})

examples/just_stopped.cpp

@@ -0,0 +1,17 @@
+#include <beman/execution26/execution.hpp>
+namespace ex = beman::execution26;
+
+struct receiver {
+    using receiver_concept = ex::receiver_t;
+    auto set_value(auto&&...) noexcept -> void {}
+    auto set_error(auto&&) noexcept -> void {}
+    auto set_stopped() noexcept -> void {}
+};
+
+int main() {
+    // ex::sync_wait(ex::just_stopped() | ex::then([]{}));
+    auto then = ex::just_stopped() | ex::then([] {});
+    static_assert(std::same_as<void, decltype(ex::get_completion_signatures(then, ex::empty_env()))>);
+
+    ex::connect(ex::just_stopped() | ex::then([] {}), receiver{});
+}

examples/sender-demo.cpp

@@ -0,0 +1,63 @@
+#include <beman/execution26/execution.hpp>
+#include <type_traits>
+#include <string>
+#include <memory_resource>
+#include <utility>
+#include <iostream>
+
+namespace ex = beman::execution26;
+
+template <typename Receiver>
+struct just_op_state {
+    using operation_state_concept = ex::operation_state_t;
+    std::remove_cvref_t<Receiver> rec;
+    std::pmr::string              value;
+
+    template <typename R>
+    just_op_state(R&& r, std::pmr::string&& value)
+        : rec(std::forward<R>(r)), value(std::move(value), ex::get_allocator(ex::get_env(rec))) {}
+
+    void start() & noexcept { ex::set_value(std::move(rec), std::move(value)); }
+};
+
+struct test_receiver {
+    using receiver_concept = ex::receiver_t;
+    auto set_value(auto&&...) && noexcept -> void { std::cout << "set_value\n"; }
+    auto set_error(auto&&) && noexcept -> void { std::cout << "set_error\n"; }
+    auto set_stopped() && noexcept -> void { std::cout << "set_stopped\n"; }
+};
+
+static_assert(ex::receiver<test_receiver>);
+static_assert(ex::operation_state<just_op_state<test_receiver>>);
+
+template <typename T>
+struct just_sender {
+    using sender_concept        = ex::sender_t;
+    using completion_signatures = ex::completion_signatures<ex::set_value_t(T)>;
+
+    T value;
+    template <ex::receiver Receiver>
+    auto connect(Receiver&& r) && -> just_op_state<Receiver> {
+        return {std::forward<Receiver>(r), std::move(value)};
+    }
+};
+
+static_assert(ex::sender<just_sender<std::pmr::string>>);
+static_assert(ex::sender_in<just_sender<std::pmr::string>>);
+
+int main() {
+    auto j = just_sender{std::pmr::string("value")};
+    auto t = std::move(j) | ex::then([](std::pmr::string v) { return v + " then"; });
+    auto w = ex::when_all(std::move(t));
+    auto e = ex::detail::write_env(std::move(w),
+                                   ex::detail::make_env(ex::get_allocator, std::pmr::polymorphic_allocator<>()));
+
+    std::cout << "before start\n";
+    auto r = ex::sync_wait(std::move(e));
+    if (r) {
+        auto [v] = *r;
+        std::cout << "produced='" << v << "'\n";
+    } else
+        std::cout << "operation was cancelled\n";
+    std::cout << "after start\n";
+}

include/beman/execution26/detail/get_allocator.hpp

@@ -19,7 +19,9 @@ struct get_allocator_t {
     auto operator()(Object&&) const =
         BEMAN_EXECUTION26_DELETE("the object requires a const query(get_allocator_t) overload");
     template <typename Object>
-        requires(not requires(const Object& object, const get_allocator_t& tag) { object.query(tag); })
+        requires(
+                    not requires(const Object& object, const get_allocator_t& tag) { object.query(tag); } &&
+                    not requires(Object&& object, const get_allocator_t& tag) { ::std::as_const(object).query(tag); })
     auto
     operator()(Object&&) const = BEMAN_EXECUTION26_DELETE("the object requires a query(get_allocator_t) overload");
     template <typename Object>
@@ -28,6 +30,7 @@ struct get_allocator_t {
                 })
     auto
     operator()(Object&&) const = BEMAN_EXECUTION26_DELETE("the query(get_allocator_t) overload needs to be noexcept");
+
     template <typename Object>
         requires(not requires(const Object& object, const get_allocator_t& tag) {
                     { object.query(tag) } noexcept -> ::beman::execution26::detail::simple_allocator<>;
@@ -36,7 +39,10 @@ struct get_allocator_t {
     operator()(Object&&) const = BEMAN_EXECUTION26_DELETE("the query(get_allocator_t) overload needs to be noexcept");
 
     template <typename Object>
-    auto operator()(Object&& object) const {
+        requires(requires(const Object& object, const get_allocator_t& tag) {
+            { object.query(tag) } noexcept -> ::beman::execution26::detail::simple_allocator<>;
+        })
+    auto operator()(Object&& object) const noexcept {
         return ::std::as_const(object).query(*this);
     }
 

include/beman/execution26/detail/simple_allocator.hpp

@@ -10,11 +10,13 @@
 // ----------------------------------------------------------------------------
 
 namespace beman::execution26::detail {
-template <typename Alloc = bool>
-concept simple_allocator = requires(Alloc alloc, ::std::size_t n) {
-    { *alloc.allocate(n) } -> ::std::same_as<typename Alloc::value_type&>;
-    alloc.deallocate(alloc.allocate(n), n);
-} && ::std::copy_constructible<Alloc> && ::std::equality_comparable<Alloc>;
+template <typename Alloc>
+concept simple_allocator =
+    requires(::std::remove_cvref_t<Alloc> alloc, ::std::size_t n) {
+        { *alloc.allocate(n) } -> ::std::same_as<typename ::std::remove_cvref_t<Alloc>::value_type&>;
+        alloc.deallocate(alloc.allocate(n), n);
+    } && ::std::copy_constructible<::std::remove_cvref_t<Alloc>> &&
+    ::std::equality_comparable<::std::remove_cvref_t<Alloc>>;
 } // namespace beman::execution26::detail
 
 // ----------------------------------------------------------------------------

include/beman/execution26/detail/when_all.hpp

@@ -231,13 +231,20 @@ template <typename Data, typename Env, typename... Sender>
 struct completion_signatures_for_impl<
     ::beman::execution26::detail::basic_sender<::beman::execution26::detail::when_all_t, Data, Sender...>,
     Env> {
+    template <typename... E>
+    struct error_comps_t {
+        using type = ::beman::execution26::completion_signatures<::beman::execution26::set_error_t(E)...>;
+    };
+    template <typename... E>
+    using error_comps = typename error_comps_t<E...>::type;
+
     using value_types =
         typename ::beman::execution26::detail::when_all_value_types<::beman::execution26::detail::meta::combine<
             ::beman::execution26::
                 value_types_of_t<Sender, Env, ::beman::execution26::detail::type_list, ::std::type_identity_t>...>>::
             type;
     using error_types = ::beman::execution26::detail::meta::unique<::beman::execution26::detail::meta::combine<
-        ::beman::execution26::error_types_of_t<Sender, Env, ::beman::execution26::completion_signatures>...>>;
+        ::beman::execution26::error_types_of_t<Sender, Env, error_comps>...>>;
     using type        = ::beman::execution26::detail::meta::combine<value_types, error_types>;
 };
 } // namespace beman::execution26::detail