Use async_initiate

include/boost/beast/http/impl/file_body_win32.ipp

@@ -32,7 +32,7 @@ namespace beast {
 namespace http {
 
 namespace detail {
-template<class, class, class, bool, class>
+template<class, class, bool, class, class>
 class write_some_win32_op;
 } // detail
 
@@ -52,7 +52,7 @@ struct basic_file_body<file_win32>
         friend class reader;
         friend struct basic_file_body<file_win32>;
 
-        template<class, class, class, bool, class>
+        template<class, class, bool, class, class>
         friend class detail::write_some_win32_op;
         template<
             class Protocol, class Executor,
@@ -102,7 +102,7 @@ struct basic_file_body<file_win32>
 
     class writer
     {
-        template<class, class, class, bool, class>
+        template<class, class, bool, class, class>
         friend class detail::write_some_win32_op;
         template<
             class Protocol, class Executor,
@@ -328,7 +328,8 @@ public:
 
 template<
     class Protocol, class Executor,
-    class Handler, bool isRequest, class Fields>
+    bool isRequest, class Fields,
+    class Handler>
 class write_some_win32_op
     : public beast::async_op_base<Handler, Executor>
 {
@@ -433,6 +434,39 @@ public:
     }
 };
 
+struct run_write_some_win32_op
+{
+    template<
+        class Protocol, class Executor,
+        bool isRequest, class Fields,
+        class WriteHandler>
+    void
+    operator()(
+        WriteHandler&& h,
+        net::basic_stream_socket<
+            Protocol, Executor>& s,
+        serializer<isRequest,
+            basic_file_body<file_win32>, Fields>& sr)
+    {
+        // 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_win32_op<
+            Protocol, Executor,
+            isRequest, Fields,
+            typename std::decay<WriteHandler>::type>(
+                std::forward<WriteHandler>(h),
+                s,
+                sr);
+    }
+};
+
 #endif
 
 } // detail
@@ -520,17 +554,14 @@ async_write_some(
     serializer<isRequest,
         basic_file_body<file_win32>, Fields>& sr,
     WriteHandler&& handler)
-{
-    
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    detail::write_some_win32_op<
-        Protocol, Executor,
-        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
-            void(error_code, std::size_t)),
-        isRequest, Fields>{
-            std::move(init.completion_handler), sock, sr}();
-    return init.result.get();
+{  
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            detail::run_write_some_win32_op{},
+            handler,
+            sock,
+            sr);
 }
 
 #endif

include/boost/beast/http/impl/read.ipp

@@ -179,10 +179,10 @@ class read_msg_op
 public:
     template<class Handler_>
     read_msg_op(
+        Handler_&& h,
         Stream& s,
         DynamicBuffer& b,
-        message_type& m,
-        Handler_&& h)
+        message_type& m)
         : stable_async_op_base<
             Handler, beast::executor_type<Stream>>(
                 std::forward<Handler_>(h), s.get_executor())
@@ -203,6 +203,42 @@ public:
     }
 };
 
+struct run_read_msg_op
+{
+    template<
+        class ReadHandler,
+        class AsyncReadStream,
+        class DynamicBuffer,
+        bool isRequest, class Body, class Allocator>
+    void
+    operator()(
+        ReadHandler&& h,
+        AsyncReadStream& s,
+        DynamicBuffer& b,
+        message<isRequest, Body,
+            basic_fields<Allocator>>& m)
+    {
+        // 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_msg_op<
+            AsyncReadStream,
+            DynamicBuffer,
+            isRequest, Body, Allocator,
+            typename std::decay<ReadHandler>::type>(
+                std::forward<ReadHandler>(h),
+                s,
+                b,
+                m);
+    }
+};
+
 } // detail
 
 //------------------------------------------------------------------------------
@@ -266,19 +302,12 @@ async_read_some(
     basic_parser<isRequest, Derived>& parser,
     ReadHandler&& handler)
 {
-    static_assert(
-        is_async_read_stream<AsyncReadStream>::value,
-        "AsyncReadStream type requirements not met");
-    static_assert(
-        net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        ReadHandler, void(error_code, std::size_t));
-    beast::detail::async_read(stream, buffer,
+    return beast::detail::async_read(
+        stream,
+        buffer,
         detail::read_some_condition<
-            isRequest, Derived>{parser}, std::move(
-                init.completion_handler));
-    return init.result.get();
+            isRequest, Derived>{parser},
+        std::forward<ReadHandler>(handler));
 }
 
 //------------------------------------------------------------------------------
@@ -343,20 +372,13 @@ async_read_header(
     basic_parser<isRequest, Derived>& parser,
     ReadHandler&& handler)
 {
-    static_assert(
-        is_async_read_stream<AsyncReadStream>::value,
-        "AsyncReadStream type requirements not met");
-    static_assert(
-        net::is_dynamic_buffer<DynamicBuffer>::value,
-        "DynamicBuffer type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        ReadHandler, void(error_code, std::size_t));
     parser.eager(false);
-    beast::detail::async_read(stream, buffer,
+    return beast::detail::async_read(
+        stream,
+        buffer,
         detail::read_header_condition<
-            isRequest, Derived>{parser}, std::move(
-                init.completion_handler));
-    return init.result.get();
+            isRequest, Derived>{parser},
+        std::forward<ReadHandler>(handler));
 }
 
 //------------------------------------------------------------------------------
@@ -427,14 +449,13 @@ async_read(
     static_assert(
         net::is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        ReadHandler, void(error_code, std::size_t));
     parser.eager(true);
-    beast::detail::async_read(stream, buffer,
+    return beast::detail::async_read(
+        stream,
+        buffer,
         detail::read_all_condition<
-            isRequest, Derived>{parser}, std::move(
-                init.completion_handler));
-    return init.result.get();
+            isRequest, Derived>{parser},
+        std::forward<ReadHandler>(handler));
 }
 
 //------------------------------------------------------------------------------
@@ -521,17 +542,14 @@ async_read(
         "Body type requirements not met");
     static_assert(is_body_reader<Body>::value,
         "BodyReader type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        ReadHandler, void(error_code, std::size_t));
-    detail::read_msg_op<
-        AsyncReadStream,
-        DynamicBuffer,
-        isRequest, Body, Allocator,
-        BOOST_ASIO_HANDLER_TYPE(
-            ReadHandler, void(error_code, std::size_t))>(
-                stream, buffer, msg, std::move(
-                    init.completion_handler));
-    return init.result.get();
+    return net::async_initiate<
+        ReadHandler,
+        void(error_code, std::size_t)>(
+            detail::run_read_msg_op{},
+            handler,
+            stream,
+            buffer,
+            msg);
 }
 
 } // http

include/boost/beast/http/impl/write.ipp

@@ -30,7 +30,8 @@ namespace http {
 namespace detail {
 
 template<
-    class Stream, class Handler,
+    class Handler,
+    class Stream,
     bool isRequest, class Body, class Fields>
 class write_some_op
     : public beast::async_op_base<
@@ -150,7 +151,9 @@ struct serializer_is_done
 //------------------------------------------------------------------------------
 
 template<
-    class Stream, class Handler, class Predicate,
+    class Handler,
+    class Stream,
+    class Predicate,
     bool isRequest, class Body, class Fields>
 class write_op
     : public beast::async_op_base<
@@ -211,7 +214,8 @@ public:
 //------------------------------------------------------------------------------
 
 template<
-    class Stream, class Handler,
+    class Handler,
+    class Stream,
     bool isRequest, class Body, class Fields>
 class write_msg_op
     : public beast::stable_async_op_base<
@@ -225,8 +229,8 @@ public:
         class Handler_,
         class... Args>
     write_msg_op(
-        Stream& s,
         Handler_&& h,
+        Stream& s,
         Args&&... args)
         : stable_async_op_base<
             Handler, beast::executor_type<Stream>>(
@@ -253,6 +257,138 @@ public:
     }
 };
 
+struct run_write_some_op
+{
+    template<
+        class WriteHandler,
+        class Stream, 
+        bool isRequest, class Body, class Fields>
+    void
+    operator()(
+        WriteHandler&& h,
+        Stream& s,
+        serializer<isRequest, Body, Fields>& sr)
+    {
+        // 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,
+            Stream,
+            isRequest, Body, Fields>(
+                std::forward<WriteHandler>(h),
+                s,
+                sr);
+    }
+};
+
+struct run_write_op
+{
+    template<
+        class WriteHandler,
+        class Stream,
+        class Predicate,
+        bool isRequest, class Body, class Fields>
+    void
+    operator()(
+        WriteHandler&& h,
+        Stream& s,
+        Predicate const&,
+        serializer<isRequest, Body, Fields>& sr)
+    {
+        // 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_op<
+            typename std::decay<WriteHandler>::type,
+            Stream,
+            Predicate,
+            isRequest, Body, Fields>(
+                std::forward<WriteHandler>(h),
+                s,
+                sr);
+    }
+};
+
+struct run_write_msg_op
+{
+    template<
+        class WriteHandler,
+        class Stream,
+        bool isRequest, class Body, class Fields,
+        class... Args>
+    void
+    operator()(
+        WriteHandler&& h,
+        Stream& s,
+        message<isRequest, Body, Fields>& m,
+        std::false_type,
+        Args&&... args)
+    {
+        // 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_msg_op<
+            typename std::decay<WriteHandler>::type,
+            Stream,
+            isRequest, Body, Fields>(
+                std::forward<WriteHandler>(h),
+                s,
+                m,
+                std::forward<Args>(args)...);
+    }
+
+    template<
+        class WriteHandler,
+        class Stream,
+        bool isRequest, class Body, class Fields,
+        class... Args>
+    void
+    operator()(
+        WriteHandler&& h,
+        Stream& s,
+        message<isRequest, Body, Fields> const& m,
+        std::true_type,
+        Args&&... args)
+    {
+        // 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_msg_op<
+            typename std::decay<WriteHandler>::type,
+            Stream,
+            isRequest, Body, Fields>(
+                std::forward<WriteHandler>(h),
+                s,
+                m,
+                std::forward<Args>(args)...);
+    }
+};
+
 //------------------------------------------------------------------------------
 
 template<class Stream>
@@ -341,15 +477,13 @@ async_write_some_impl(
     serializer<isRequest, Body, Fields>& sr,
     WriteHandler&& handler)
 {
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    detail::write_some_op<
-        AsyncWriteStream,
-        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
-            void(error_code, std::size_t)),
-        isRequest, Body, Fields>(
-            std::move(init.completion_handler), stream, sr);
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            run_write_some_op{},
+            handler,
+            stream,
+            sr);
 }
 
 } // detail
@@ -498,16 +632,14 @@ async_write_header(
     static_assert(is_body_writer<Body>::value,
         "BodyWriter type requirements not met");
     sr.split(true);
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    detail::write_op<
-        AsyncWriteStream,
-        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
-            void(error_code, std::size_t)),
-        detail::serializer_is_header_done,
-        isRequest, Body, Fields>{
-        std::move(init.completion_handler), stream, sr};
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            detail::run_write_op{},
+            handler,
+            stream,
+            detail::serializer_is_header_done{},
+            sr);
 }
 
 //------------------------------------------------------------------------------
@@ -574,16 +706,14 @@ async_write(
     static_assert(is_body_writer<Body>::value,
         "BodyWriter type requirements not met");
     sr.split(false);
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    detail::write_op<
-        AsyncWriteStream,
-        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
-            void(error_code, std::size_t)),
-        detail::serializer_is_done,
-        isRequest, Body, Fields>{
-            std::move(init.completion_handler), stream, sr};
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            detail::run_write_op{},
+            handler,
+            stream,
+            detail::serializer_is_done{},
+            sr);
 }
 
 //------------------------------------------------------------------------------
@@ -698,15 +828,14 @@ async_write(
         "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
         "BodyWriter type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    detail::write_msg_op<
-        AsyncWriteStream,
-        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
-            void(error_code, std::size_t)),
-        isRequest, Body, Fields>(stream,
-            std::move(init.completion_handler), msg);
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            detail::run_write_msg_op{},
+            handler,
+            stream,
+            msg,
+            std::false_type{});
 }
 
 template<
@@ -729,15 +858,14 @@ async_write(
         "Body type requirements not met");
     static_assert(is_body_writer<Body>::value,
         "BodyWriter type requirements not met");
-    BOOST_BEAST_HANDLER_INIT(
-        WriteHandler, void(error_code, std::size_t));
-    detail::write_msg_op<
-        AsyncWriteStream,
-        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
-            void(error_code, std::size_t)),
-        isRequest, Body, Fields>(stream,
-            std::move(init.completion_handler), msg);
-    return init.result.get();
+    return net::async_initiate<
+        WriteHandler,
+        void(error_code, std::size_t)>(
+            detail::run_write_msg_op{},
+            handler,
+            stream,
+            msg,
+            std::true_type{});
 }
 
 //------------------------------------------------------------------------------