cancellable

example/Jamfile.v2

@@ -114,6 +114,10 @@ exe filament
     : filament.cpp
     ;
 
+exe cancellable
+    : cancellable.cpp
+    ;
+
 #exe backtrace
 #    : backtrace.cpp
 #    ;

example/cancellable.cpp

@@ -0,0 +1,135 @@
+
+//          Copyright Nat Goodspeed, Oliver Kowalke 2019.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <memory>
+
+#include <boost/context/fiber_context.hpp>
+
+namespace ctx = boost::context;
+
+// cancellable is a wrapper class that binds a cancellation-function along
+// with an associated fiber_context. It uses the tactic seen earlier in the
+// example 'filament' class to continually update the fiber_context
+// representing the fiber of interest.
+class cancellable {
+private:
+    ctx::fiber_context                                          f_;
+    std::function<ctx::fiber_context(ctx::fiber_context&&)>     cancel_;
+
+public:
+    cancellable() :
+        f_{},
+        cancel_{} {
+    }
+
+    template< typename CANCEL >
+    cancellable(ctx::fiber_context&& f, CANCEL&& cancel):
+        f_{std::move(f)},
+        cancel_{std::forward<CANCEL>(cancel)} {
+    }
+
+    ~cancellable() {
+        if (f_) {
+            std::move(f_).resume_with([this](ctx::fiber_context&& f)->ctx::fiber_context{
+                return cancel_(std::move(f));
+            });
+        }
+    }
+
+    cancellable(cancellable const&) = delete;
+    cancellable & operator=(cancellable const&) = delete;
+
+    cancellable(cancellable&& other) :
+        f_{},
+        cancel_{} {
+        f_ = std::move(other.f_);
+        cancel_ = std::move(other.cancel_);
+    }
+
+    cancellable & operator=(cancellable&& other) {
+        if ( this != & other) {
+            f_ = std::move(other.f_);
+            cancel_ = std::move(other.cancel_);
+        }
+        return * this;
+    }
+
+    void resume_next(cancellable& cable){
+        std::move(cable.f_).resume_with([this](ctx::fiber_context&& f)->ctx::fiber_context{
+            if ( nullptr == cancel_) {
+                // implicit fiber_context
+                return std::move(f);
+            }
+            f_=std::move(f);
+            return {};
+        });
+    }
+};
+
+// unwind_exception is an exception used internally by launch() to unwind the
+// stack of a suspended fiber when the referencing fiber_context instance is
+// destroyed.
+class unwind_exception: public std::runtime_error {
+public:
+    unwind_exception(ctx::fiber_context&& previous):
+        std::runtime_error{"unwinding std::fiber_context"},
+        previous_{std::make_shared<ctx::fiber_context>(std::move(previous))}
+    {}
+
+    std::shared_ptr<ctx::fiber_context> get_previous() const {
+        return previous_;
+    }
+
+private:
+    // Directly storing fiber_context would make unwind_exception move-only.
+    // Instead, store a shared_ptr so unwind_exception remains copyable.
+    std::shared_ptr<ctx::fiber_context> previous_;
+};
+
+// launch() is a factory function that returns a cancellable representing a
+// new fiber that will run the passed entry_function. It implicitly provides a
+// top-level wrapper and a cancellation-function. If the cancellable
+// representing this new fiber is eventually destroyed, ~cancellable() will
+// call this cancellation-function, which will throw unwind_exception. The
+// top-level wrapper will catch it and return the bound fiber_context, thereby
+// resuming the fiber that called ~cancellable().
+template <typename Fn>
+cancellable launch(Fn&& entry_function) {
+    return cancellable{ctx::fiber_context(
+        // entry-function passed to std::fiber_context constructor binds
+        // entry_function, calls it within try/catch, catches
+        // unwind_exception, extracts its shared_ptr<fiber_context>,
+        // dereferences it and returns that fiber_context.
+        [entry=std::move(entry_function)]
+        (ctx::fiber_context&& previous) {
+            try {
+                return entry(std::move(previous));
+            }
+            catch (unwind_exception const& unwind) {
+                return std::move(*unwind.get_previous());
+            }
+        }),
+        // cancellation-function passed to cancellable constructor
+        // throws unwind_exception, binding passed fiber_context instance.
+        [](ctx::fiber_context&& previous)->ctx::fiber_context{
+            throw unwind_exception{std::move(previous)};
+            return {};
+        }};
+}
+
+int main() {
+    cancellable c = launch([](ctx::fiber_context && f){
+            std::cout << "cancellable entered" << std::endl;
+            return std::move(f);
+    });
+    cancellable m;
+    m.resume_next(c);
+    std::cout << "main: done" << std::endl;
+    return EXIT_SUCCESS;
+}