Use async_initiate

include/boost/beast/websocket/impl/accept.hpp

@@ -241,7 +241,7 @@ public:
 // read and respond to an upgrade request
 //
 template<class NextLayer, bool deflateSupported>
-template<class Decorator, class Handler>
+template<class Handler, class Decorator>
 class stream<NextLayer, deflateSupported>::accept_op
     : public beast::stable_async_op_base<
         Handler, beast::executor_type<stream>>
@@ -256,8 +256,8 @@ public:
     accept_op(
         Handler_&& h,
         boost::shared_ptr<impl_type> const& sp,
-        Buffers const& buffers,
-        Decorator const& decorator)
+        Decorator const& decorator,
+        Buffers const& buffers)
         : stable_async_op_base<Handler,
             beast::executor_type<stream>>(
                 std::forward<Handler_>(h),
@@ -325,6 +325,74 @@ public:
     }
 };
 
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_response_op
+{
+    template<
+        class AcceptHandler,
+        class Body, class Allocator,
+        class Decorator>
+    void
+    operator()(
+        AcceptHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        http::request<Body,
+            http::basic_fields<Allocator>> const& m,
+        Decorator const& d)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<AcceptHandler,
+                void(error_code)>::value,
+            "AcceptHandler type requirements not met");
+
+        response_op<
+            typename std::decay<AcceptHandler>::type>(
+                std::forward<AcceptHandler>(h),
+                sp,
+                m,
+                d);
+    }
+};
+
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_accept_op
+{
+    template<
+        class AcceptHandler,
+        class Decorator,
+        class Buffers>
+    void
+    operator()(
+        AcceptHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        Decorator const& d,
+        Buffers const& b)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<AcceptHandler,
+                void(error_code)>::value,
+            "AcceptHandler type requirements not met");
+
+        accept_op<
+            typename std::decay<AcceptHandler>::type,
+            Decorator>(
+                std::forward<AcceptHandler>(h),
+                sp,
+                d,
+                b);
+    }
+};
+
 //------------------------------------------------------------------------------
 
 template<class NextLayer, bool deflateSupported>
@@ -488,17 +556,15 @@ async_accept(
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        AcceptHandler, void(error_code));
     impl_->reset();
-    accept_op<
-        decltype(&default_decorate_res),
-        BOOST_ASIO_HANDLER_TYPE(
-            AcceptHandler, void(error_code))>(
-                std::move(init.completion_handler),
-                impl_, net::const_buffer{},
-                &default_decorate_res);;
-    return init.result.get();
+    return net::async_initiate<
+        AcceptHandler,
+        void(error_code)>(
+            run_accept_op{},
+            handler,
+            impl_,
+            &default_decorate_res,
+            net::const_buffer{});
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -517,17 +583,15 @@ async_accept_ex(
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        AcceptHandler, void(error_code));
     impl_->reset();
-    accept_op<
-        ResponseDecorator,
-        BOOST_ASIO_HANDLER_TYPE(
-            AcceptHandler, void(error_code))>(
-                std::move(init.completion_handler),
-                impl_, net::const_buffer{},
-                decorator);
-    return init.result.get();
+    return net::async_initiate<
+        AcceptHandler,
+        void(error_code)>(
+            run_accept_op{},
+            handler,
+            impl_,
+            decorator,
+            net::const_buffer{});
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -548,16 +612,15 @@ async_accept(
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        AcceptHandler, void(error_code));
     impl_->reset();
-    accept_op<
-        decltype(&default_decorate_res),
-        BOOST_ASIO_HANDLER_TYPE(
-            AcceptHandler, void(error_code))>(
-                std::move(init.completion_handler),
-                    impl_, buffers, &default_decorate_res);
-    return init.result.get();
+    return net::async_initiate<
+        AcceptHandler,
+        void(error_code)>(
+            run_accept_op{},
+            handler,
+            impl_,
+            &default_decorate_res,
+            buffers);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -583,16 +646,15 @@ async_accept_ex(
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        AcceptHandler, void(error_code));
     impl_->reset();
-    accept_op<
-        ResponseDecorator,
-        BOOST_ASIO_HANDLER_TYPE(
-            AcceptHandler, void(error_code))>(
-                std::move(init.completion_handler),
-                    impl_, buffers, decorator);
-    return init.result.get();
+    return net::async_initiate<
+        AcceptHandler,
+        void(error_code)>(
+            run_accept_op{},
+            handler,
+            impl_,
+            decorator,
+            buffers);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -608,15 +670,15 @@ async_accept(
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        AcceptHandler, void(error_code));
     impl_->reset();
-    response_op<
-        BOOST_ASIO_HANDLER_TYPE(
-            AcceptHandler, void(error_code))>(
-                std::move(init.completion_handler),
-                    impl_, req, &default_decorate_res);
-    return init.result.get();
+    return net::async_initiate<
+        AcceptHandler,
+        void(error_code)>(
+            run_response_op{},
+            handler,
+            impl_,
+            req,
+            &default_decorate_res);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -637,15 +699,15 @@ async_accept_ex(
     static_assert(detail::is_response_decorator<
         ResponseDecorator>::value,
             "ResponseDecorator requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        AcceptHandler, void(error_code));
     impl_->reset();
-    response_op<
-        BOOST_ASIO_HANDLER_TYPE(
-            AcceptHandler, void(error_code))>(
-                std::move(init.completion_handler),
-                    impl_, req, decorator);
-    return init.result.get();
+    return net::async_initiate<
+        AcceptHandler,
+        void(error_code)>(
+            run_response_op{},
+            handler,
+            impl_,
+            req,
+            decorator);
 }
 
 //------------------------------------------------------------------------------

include/boost/beast/websocket/impl/close.hpp

@@ -230,6 +230,34 @@ public:
     }
 };
 
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_close_op
+{
+    template<class CloseHandler>
+    void
+    operator()(
+        CloseHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        close_reason const& cr)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<CloseHandler,
+                void(error_code)>::value,
+            "CloseHandler type requirements not met");
+
+        close_op<
+            typename std::decay<CloseHandler>::type>(
+                std::forward<CloseHandler>(h),
+                sp,
+                cr);
+    }
+};
+
 //------------------------------------------------------------------------------
 
 template<class NextLayer, bool deflateSupported>
@@ -360,12 +388,13 @@ async_close(close_reason const& cr, CloseHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        CloseHandler, void(error_code));
-    close_op<BOOST_ASIO_HANDLER_TYPE(
-        CloseHandler, void(error_code))>(
-            std::move(init.completion_handler), impl_, cr);
-    return init.result.get();
+    return net::async_initiate<
+        CloseHandler,
+        void(error_code)>(
+            run_close_op{},
+            handler,
+            impl_,
+            cr);
 }
 
 } // websocket

include/boost/beast/websocket/impl/handshake.hpp

@@ -74,6 +74,7 @@ public:
         d_.req = sp->build_request(
             key_, host, target, decorator);
         sp->reset(); // VFALCO I don't like this
+        (*this)({}, 0, false);
     }
 
     void
@@ -157,6 +158,37 @@ public:
     }
 };
 
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_handshake_op
+{
+    template<class HandshakeHandler, class Decorator>
+    void operator()(
+        HandshakeHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        response_type* r,
+        string_view host, string_view target,
+        Decorator const& d)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<HandshakeHandler,
+                void(error_code)>::value,
+            "HandshakeHandler type requirements not met");
+
+        handshake_op<
+            typename std::decay<HandshakeHandler>::type>(
+                std::forward<HandshakeHandler>(h),
+                sp,
+                r,
+                host, target,
+                d);
+    }
+};
+
 //------------------------------------------------------------------------------
 
 template<class NextLayer, bool deflateSupported>
@@ -241,14 +273,15 @@ async_handshake(string_view host,
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        HandshakeHandler, void(error_code));
-    handshake_op<BOOST_ASIO_HANDLER_TYPE(
-        HandshakeHandler, void(error_code))>(
-            std::move(init.completion_handler),
-                impl_, nullptr, host, target,
-                    &default_decorate_req)();
-    return init.result.get();
+    return net::async_initiate<
+        HandshakeHandler,
+        void(error_code)>(
+            run_handshake_op{},
+            handler,
+            impl_,
+            nullptr,
+            host, target,
+            &default_decorate_req);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -263,14 +296,15 @@ async_handshake(response_type& res,
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        HandshakeHandler, void(error_code));
-    handshake_op<BOOST_ASIO_HANDLER_TYPE(
-        HandshakeHandler, void(error_code))>(
-            std::move(init.completion_handler),
-                impl_, &res, host, target,
-                    &default_decorate_req)();
-    return init.result.get();
+    return net::async_initiate<
+        HandshakeHandler,
+        void(error_code)>(
+            run_handshake_op{},
+            handler,
+            impl_,
+            &res,
+            host, target,
+            &default_decorate_req);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -442,14 +476,15 @@ async_handshake_ex(string_view host,
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        HandshakeHandler, void(error_code));
-    handshake_op<BOOST_ASIO_HANDLER_TYPE(
-        HandshakeHandler, void(error_code))>(
-            std::move(init.completion_handler),
-                impl_, nullptr, host, target,
-                    decorator)();
-    return init.result.get();
+    return net::async_initiate<
+        HandshakeHandler,
+        void(error_code)>(
+            run_handshake_op{},
+            handler,
+            impl_,
+            nullptr,
+            host, target,
+            decorator);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -472,19 +507,17 @@ async_handshake_ex(response_type& res,
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        HandshakeHandler, void(error_code));
-    handshake_op<BOOST_ASIO_HANDLER_TYPE(
-        HandshakeHandler, void(error_code))>(
-            std::move(init.completion_handler),
-                impl_, &res, host, target,
-                    decorator)();
-    return init.result.get();
+    return net::async_initiate<
+        HandshakeHandler,
+        void(error_code)>(
+            run_handshake_op{},
+            handler,
+            impl_,
+            &res,
+            host, target,
+            decorator);
 }
 
-
-
-
 } // websocket
 } // beast
 } // boost

include/boost/beast/websocket/impl/ping.hpp

@@ -200,6 +200,36 @@ public:
     }
 };
 
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_ping_op
+{
+    template<class WriteHandler>
+    void
+    operator()(
+        WriteHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        detail::opcode op,
+        ping_data const& p)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<WriteHandler,
+                void(error_code)>::value,
+            "WriteHandler type requirements not met");
+
+        ping_op<
+            typename std::decay<WriteHandler>::type>(
+                std::forward<WriteHandler>(h),
+                sp,
+                op,
+                p);
+    }
+};
+
 //------------------------------------------------------------------------------
 
 template<class NextLayer, bool deflateSupported>
@@ -263,13 +293,14 @@ async_ping(ping_data const& payload, WriteHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code));
-    ping_op<BOOST_ASIO_HANDLER_TYPE(
-        WriteHandler, void(error_code))>(
-            std::move(init.completion_handler), impl_,
-                detail::opcode::ping, payload);
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code)>(
+            run_ping_op{},
+            handler,
+            impl_,
+            detail::opcode::ping,
+            payload);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -281,13 +312,14 @@ async_pong(ping_data const& payload, WriteHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code));
-    ping_op<BOOST_ASIO_HANDLER_TYPE(
-        WriteHandler, void(error_code))>(
-            std::move(init.completion_handler), impl_,
-                detail::opcode::pong, payload);
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code)>(
+            run_ping_op{},
+            handler,
+            impl_,
+            detail::opcode::pong,
+            payload);
 }
 
 } // websocket

include/boost/beast/websocket/impl/read.hpp

@@ -43,9 +43,7 @@ namespace websocket {
     Also reads and handles control frames.
 */
 template<class NextLayer, bool deflateSupported>
-template<
-    class MutableBufferSequence,
-    class Handler>
+template<class Handler, class MutableBufferSequence>
 class stream<NextLayer, deflateSupported>::read_some_op
     : public beast::async_op_base<
         Handler, beast::executor_type<stream>>
@@ -613,9 +611,7 @@ public:
 //------------------------------------------------------------------------------
 
 template<class NextLayer, bool deflateSupported>
-template<
-    class DynamicBuffer,
-    class Handler>
+template<class Handler,  class DynamicBuffer>
 class stream<NextLayer, deflateSupported>::read_op
     : public beast::async_op_base<
         Handler, beast::executor_type<stream>>
@@ -674,7 +670,7 @@ public:
 
                 // VFALCO TODO use boost::beast::bind_continuation
                 BOOST_ASIO_CORO_YIELD
-                read_some_op<mutable_buffers_type, read_op>(
+                read_some_op<read_op, mutable_buffers_type>(
                     std::move(*this), sp, *mb);
                 b_.commit(bytes_transferred);
                 bytes_written_ += bytes_transferred;
@@ -689,6 +685,72 @@ public:
     }
 };
 
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_read_some_op
+{
+    template<
+        class ReadHandler,
+        class MutableBufferSequence>
+    void
+    operator()(
+        ReadHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        MutableBufferSequence const& b)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<ReadHandler,
+                void(error_code, std::size_t)>::value,
+            "ReadHandler type requirements not met");
+
+        read_some_op<
+            typename std::decay<ReadHandler>::type,
+            MutableBufferSequence>(
+                std::forward<ReadHandler>(h),
+                sp,
+                b);
+    }
+};
+
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_read_op
+{
+    template<
+        class ReadHandler,
+        class DynamicBuffer>
+    void
+    operator()(
+        ReadHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        DynamicBuffer& b,
+        std::size_t limit,
+        bool some)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<ReadHandler,
+                void(error_code, std::size_t)>::value,
+            "ReadHandler type requirements not met");
+
+        read_op<
+            typename std::decay<ReadHandler>::type,
+            DynamicBuffer>(
+                std::forward<ReadHandler>(h),
+                sp,
+                b,
+                limit,
+                some);
+    }
+};
+
 //------------------------------------------------------------------------------
 
 template<class NextLayer, bool deflateSupported>
@@ -743,13 +805,15 @@ async_read(DynamicBuffer& buffer, ReadHandler&& handler)
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        ReadHandler, void(error_code, std::size_t));
-    read_op<DynamicBuffer, BOOST_ASIO_HANDLER_TYPE(
-        ReadHandler, void(error_code, std::size_t))>(
-            std::move(init.completion_handler),
-                impl_, buffer, 0, false);
-    return init.result.get();
+    return net::async_initiate<
+        ReadHandler,
+        void(error_code, std::size_t)>(
+            run_read_op{},
+            handler,
+            impl_,
+            buffer,
+            0,
+            false);
 }
 
 //------------------------------------------------------------------------------
@@ -819,13 +883,15 @@ async_read_some(
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        ReadHandler, void(error_code, std::size_t));
-    read_op<DynamicBuffer, BOOST_ASIO_HANDLER_TYPE(
-        ReadHandler, void(error_code, std::size_t))>(
-            std::move(init.completion_handler),
-                impl_, buffer, limit, true);
-    return init.result.get();
+    return net::async_initiate<
+        ReadHandler,
+        void(error_code, std::size_t)>(
+            run_read_op{},
+            handler,
+            impl_,
+            buffer,
+            limit,
+            true);
 }
 
 //------------------------------------------------------------------------------
@@ -1200,12 +1266,13 @@ async_read_some(
     static_assert(net::is_mutable_buffer_sequence<
             MutableBufferSequence>::value,
         "MutableBufferSequence type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        ReadHandler, void(error_code, std::size_t));
-    read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
-        ReadHandler, void(error_code, std::size_t))>(
-            std::move(init.completion_handler), impl_, buffers);
-    return init.result.get();
+    return net::async_initiate<
+        ReadHandler,
+        void(error_code, std::size_t)>(
+            run_read_some_op{},
+            handler,
+            impl_,
+            buffers);
 }
 
 } // websocket

include/boost/beast/websocket/impl/write.hpp

@@ -37,7 +37,7 @@ namespace beast {
 namespace websocket {
 
 template<class NextLayer, bool deflateSupported>
-template<class Buffers, class Handler>
+template<class Handler, class Buffers>
 class stream<NextLayer, deflateSupported>::write_some_op
     : public beast::async_op_base<
         Handler, beast::executor_type<stream>>
@@ -430,6 +430,39 @@ operator()(
     }
 }
 
+template<class NextLayer, bool deflateSupported>
+struct stream<NextLayer, deflateSupported>::
+    run_write_some_op
+{
+    template<
+        class WriteHandler,
+        class ConstBufferSequence>
+    void
+    operator()(
+        WriteHandler&& h,
+        boost::shared_ptr<impl_type> const& sp,
+        bool fin,
+        ConstBufferSequence const& b)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<WriteHandler,
+                void(error_code, std::size_t)>::value,
+            "WriteHandler type requirements not met");
+
+        write_some_op<
+            typename std::decay<WriteHandler>::type,
+            ConstBufferSequence>(
+                std::forward<WriteHandler>(h),
+                sp,
+                fin,
+                b);
+    }
+};
+
 //------------------------------------------------------------------------------
 
 template<class NextLayer, bool deflateSupported>
@@ -676,12 +709,14 @@ async_write_some(bool fin,
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
-        WriteHandler, void(error_code, std::size_t))>(
-            std::move(init.completion_handler), impl_, fin, bs);
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            run_write_some_op{},
+            handler,
+            impl_,
+            fin,
+            bs);
 }
 
 //------------------------------------------------------------------------------
@@ -731,12 +766,14 @@ async_write(
     static_assert(net::is_const_buffer_sequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
-        WriteHandler, void(error_code, std::size_t))>(
-            std::move(init.completion_handler), impl_, true, bs);
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            run_write_some_op{},
+            handler,
+            impl_,
+            true,
+            bs);
 }
 
 } // websocket