Merge pull request #37 from beman-project/add-overview

Add overview

Author: dietmarkuehl

CMakeLists.txt

@@ -12,7 +12,7 @@ set(TARGET_LIBRARY beman_${TARGET_NAME})
 set(TARGET_ALIAS beman::${TARGET_NAME})
 set(TARGETS_EXPORT_NAME ${CMAKE_PROJECT_NAME}Targets)
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 26)
 
 include(CTest)
 if(BUILD_TESTING)

README.md

@@ -1,3 +1,6 @@
+<!--
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
 # beman.execution26: Building Block For Asynchronous Programs
 
 `beman.execution26` provides the basic vocabulary for asynchronous

docs/overview.md

@@ -7,6 +7,7 @@ set(BEMAN_EXECUTION26_LIBRARY beman_${TARGET_NAME})
 
 set(EXAMPLES
   stop_token
+  stopping
 )
 
 foreach(EXAMPLE ${EXAMPLES})

examples/CMakeLists.txt

@@ -0,0 +1,113 @@
+// examples/stopping.cpp                                              -*-C++-*-
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// The example shows a bit of how cancellation works:
+// It creates work with a sender injecting a stop token 
+// which gets started in a thread. To stop this thread
+// the corresponding stop source is requested to stop.
+
+#include <beman/execution26/execution.hpp>
+#include <beman/execution26/stop_token.hpp>
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <cassert>
+
+using namespace std::chrono;
+namespace ex = beman::execution26;
+
+// ----------------------------------------------------------------------------
+
+struct env
+{
+    ex::inplace_stop_token token;
+
+    env(ex::inplace_stop_token token): token(token) {}
+
+    auto query(ex::get_stop_token_t const&) const noexcept {
+        return this->token;
+    }
+};
+
+template <typename Sender>
+struct inject_cancel_sender
+{
+    using sender_concept = ex::sender_t;
+
+
+    template <typename Receiver>
+    struct receiver
+    {
+        using receiver_concept = ex::receiver_t;
+
+        std::remove_cvref_t<Receiver> inner_receiver;
+        ex::inplace_stop_token        token{};
+
+        auto get_env() const noexcept -> env {
+            return {this->token};
+        }
+
+        template <typename... T>
+        auto set_value(T&&... t) noexcept -> void {
+            ex::set_value(std::move(inner_receiver), std::forward<T>(t)...);
+        }
+        template <typename E>
+        auto set_error(E&& e) noexcept -> void {
+            ex::set_error(std::move(inner_receiver), std::forward<E>(e));
+        }
+        auto set_stopped() noexcept -> void {
+            ex::set_stopped(std::move(inner_receiver));
+        }
+    };
+
+    template <typename E>
+    auto get_completion_signatures(E const&) {
+        return ex::get_completion_signatures(this->sender, env{ex::inplace_stop_token{}});
+    }
+
+    ex::inplace_stop_token token{};
+    Sender sender;
+
+    template <typename Receiver>
+    auto connect(Receiver&& recv) && {
+        return ex::connect(std::move(sender), receiver<Receiver>{std::forward<Receiver>(recv), this->token});
+    }
+};
+
+template <typename S>
+inject_cancel_sender(ex::inplace_stop_token, S&&) -> inject_cancel_sender<std::decay_t<S>>;
+
+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::inplace_stop_source source;
+
+    std::thread t([token=source.get_token()]{
+        ex::sync_wait(
+            inject_cancel_sender{token,
+                ex::read_env(ex::get_stop_token)
+                | ex::then([](ex::inplace_stop_token tok){
+                    while (not tok.stop_requested())
+                    {
+                        std::cout << "sleeping\n";
+                        std::this_thread::sleep_for(1s);
+                    }
+                })
+            });
+        }
+    );
+
+    std::cin.get();
+    std::cout << "requesting stop\n";
+    source.request_stop();
+
+    t.join();
+}
+

examples/stopping.cpp

@@ -28,10 +28,7 @@ namespace
         }
 
         template <typename Tag>
-        auto query(test_std::get_completion_scheduler_t<Tag> const&) const noexcept
-        {
-            return scheduler{this->value};
-        }
+        auto query(test_std::get_completion_scheduler_t<Tag> const&) const noexcept;
     };
 
     struct scheduler
@@ -53,6 +50,13 @@ namespace
         auto schedule() noexcept -> sender { return {this->value}; }
         auto operator== (scheduler const&) const -> bool = default;
     }; 
+        
+    template <bool Noexcept, typename Scheduler>
+        template <typename Tag>
+    auto env<Noexcept, Scheduler>::query(test_std::get_completion_scheduler_t<Tag> const&) const noexcept
+    {
+        return scheduler{this->value};
+    }
 
     template <bool Expect, typename Scheduler = void>
     auto test_get_delegation_scheduler(auto&& env) -> void