get_executor() works on initiation objects

This is required for the new `asio::cancel_at` and `asio::cancel_after`
completion token adapters to work.

Author: ashtum

include/boost/beast/_experimental/http/impl/icy_stream.hpp

@@ -167,11 +167,20 @@ class read_op
 
 struct run_read_op
 {
+    icy_stream* self;
+
+    using executor_type = typename icy_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<class ReadHandler, class Buffers>
     void
     operator()(
         ReadHandler&& h,
-        icy_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -186,7 +195,7 @@ struct run_read_op
         read_op<
             Buffers,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h), *s, b);
+                std::forward<ReadHandler>(h), *self, b);
     }
 };
 
@@ -292,9 +301,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            typename ops::run_read_op{},
+            typename ops::run_read_op{this},
             handler,
-            this,
             buffers);
 }
 

include/boost/beast/_experimental/test/impl/stream.hpp

@@ -27,7 +27,27 @@ namespace boost {
 namespace beast {
 namespace test {
 
-//------------------------------------------------------------------------------
+namespace detail
+{
+template<class To>
+struct extract_executor_op
+{
+    To operator()(net::any_io_executor& ex) const
+    {
+        assert(ex.template target<To>());
+        return *ex.template target<To>();
+    }
+};
+
+template<>
+struct extract_executor_op<net::any_io_executor>
+{
+    net::any_io_executor operator()(net::any_io_executor& ex) const
+    {
+        return ex;
+    }
+};
+} // detail
 
 template<class Executor>
 template<class Handler, class Buffers>
@@ -163,13 +183,22 @@ class basic_stream<Executor>::read_op : public detail::stream_read_op_base
 template<class Executor>
 struct basic_stream<Executor>::run_read_op
 {
+    boost::shared_ptr<detail::stream_state> const& in;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return detail::extract_executor_op<Executor>()(in->exec);
+    }
+
     template<
         class ReadHandler,
         class MutableBufferSequence>
     void
     operator()(
         ReadHandler&& h,
-        boost::shared_ptr<detail::stream_state> const& in,
         MutableBufferSequence const& buffers)
     {
         // If you get an error on the following line it means
@@ -197,13 +226,22 @@ struct basic_stream<Executor>::run_read_op
 template<class Executor>
 struct basic_stream<Executor>::run_write_op
 {
+    boost::shared_ptr<detail::stream_state> const& in_;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return detail::extract_executor_op<Executor>()(in_->exec);
+    }
+
     template<
         class WriteHandler,
         class ConstBufferSequence>
     void
     operator()(
         WriteHandler&& h,
-        boost::shared_ptr<detail::stream_state> in_,
         boost::weak_ptr<detail::stream_state> out_,
         ConstBufferSequence const& buffers)
     {
@@ -336,9 +374,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            run_read_op{},
+            run_read_op{in_},
             handler,
-            in_,
             buffers);
 }
 
@@ -420,9 +457,8 @@ async_write_some(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            run_write_op{},
+            run_write_op{in_},
             handler,
-            in_,
             out_,
             buffers);
 }
@@ -467,28 +503,6 @@ connect(stream& to, Arg1&& arg1, ArgN&&... argn)
     return from;
 }
 
-namespace detail
-{
-template<class To>
-struct extract_executor_op
-{
-    To operator()(net::any_io_executor& ex) const
-    {
-        assert(ex.template target<To>());
-        return *ex.template target<To>();
-    }
-};
-
-template<>
-struct extract_executor_op<net::any_io_executor>
-{
-    net::any_io_executor operator()(net::any_io_executor& ex) const
-    {
-        return ex;
-    }
-};
-}
-
 template<class Executor>
 auto basic_stream<Executor>::get_executor() noexcept -> executor_type
 {

include/boost/beast/core/detail/impl/read.hpp

@@ -104,17 +104,26 @@ class read_op
 
 //------------------------------------------------------------------------------
 
+template <typename AsyncReadStream>
 struct run_read_op
 {
+    AsyncReadStream* stream;
+
+    using executor_type = typename AsyncReadStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
-        class AsyncReadStream,
         class DynamicBuffer,
         class Condition,
         class ReadHandler>
     void
     operator()(
         ReadHandler&& h,
-        AsyncReadStream* s,
         DynamicBuffer* b,
         Condition&& c)
     {
@@ -133,7 +142,7 @@ struct run_read_op
             typename std::decay<Condition>::type,
             typename std::decay<ReadHandler>::type>(
                 std::forward<ReadHandler>(h),
-                *s,
+                *stream,
                 *b,
                 std::forward<Condition>(c));
     }
@@ -234,9 +243,8 @@ async_read(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            typename dynamic_read_ops::run_read_op{},
+            typename dynamic_read_ops::run_read_op<AsyncReadStream>{&stream},
             handler,
-            &stream,
             &buffer,
             std::forward<CompletionCondition>(cond));
 }

include/boost/beast/core/detect_ssl.hpp

@@ -348,6 +348,7 @@ class detect_ssl_op;
 // authors of composed operations need to write it this way to get the
 // very best performance, for example when using Coroutines TS (`co_await`).
 
+template <typename AsyncReadStream>
 struct run_detect_ssl_op
 {
     // The implementation of `net::async_initiate` captures the
@@ -361,20 +362,29 @@ struct run_detect_ssl_op
     // token into the "real handler" which must have the correct
     // signature, in this case `void(error_code, boost::tri_bool)`.
 
+    AsyncReadStream* stream;
+
+    using executor_type = typename AsyncReadStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
         class DetectHandler,
-        class AsyncReadStream,
         class DynamicBuffer>
-    void operator()(
+    void
+    operator()(
         DetectHandler&& h,
-        AsyncReadStream* s, // references are passed as pointers
         DynamicBuffer* b)
     {
         detect_ssl_op<
             typename std::decay<DetectHandler>::type,
             AsyncReadStream,
             DynamicBuffer>(
-                std::forward<DetectHandler>(h), *s, *b);
+                std::forward<DetectHandler>(h), *stream, *b);
     }
 };
 
@@ -423,9 +433,8 @@ async_detect_ssl(
     return net::async_initiate<
         CompletionToken,
         void(error_code, bool)>(
-            detail::run_detect_ssl_op{},
+            detail::run_detect_ssl_op<AsyncReadStream>{&stream},
             token,
-            &stream, // pass the reference by pointer
             &buffer);
 }