Type check completion handlers

fix #988
2025-07-31 21:34:46 +02:00 · 2018-01-26 08:58:19 -08:00
parent 908f84cb3c
commit d855bdefd8
13 changed files with 78 additions and 66 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+Version 154:
+
+* Type check completion handlers
+
+--------------------------------------------------------------------------------
+
 Version 153:

 * Remove BOOST_VERSION checks
--- a/include/boost/beast/core/detail/type_traits.hpp
+++ b/include/boost/beast/core/detail/type_traits.hpp
@@ -437,6 +437,18 @@ buffers_range(Buffers const& buffers)
    return buffers_range_adaptor<Buffers>{buffers};
 }

+/*  If this static assert goes off, it means that the completion
+    handler you provided to an asynchronous initiating function did
+    not have the right signature. Check the parameter types for your
+    completion handler and make sure they match the list of types
+    expected by the initiating function,
+*/
+#define BOOST_BEAST_HANDLER_INIT(type, sig) \
+    static_assert(is_completion_handler< \
+    BOOST_ASIO_HANDLER_TYPE(type, sig), sig>::value, \
+    "CompletionHandler signature requirements not met"); \
+    boost::asio::async_completion<type, sig> init{handler}
+
 } // detail
 } // beast
 } // boost
--- a/include/boost/beast/core/impl/buffered_read_stream.ipp
+++ b/include/boost/beast/core/impl/buffered_read_stream.ipp
@@ -233,8 +233,8 @@ async_read_some(
    if(buffer_.size() == 0 && capacity_ == 0)
        return next_layer_.async_read_some(buffers,
            std::forward<ReadHandler>(handler));
-    boost::asio::async_completion<ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    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), *this, buffers}(
--- a/include/boost/beast/http/impl/file_body_win32.ipp
+++ b/include/boost/beast/http/impl/file_body_win32.ipp
@@ -564,8 +564,8 @@ async_write_some(
        basic_file_body<file_win32>, Fields>& sr,
    WriteHandler&& handler)
 {
-    boost::asio::async_completion<WriteHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code, std::size_t));
    detail::write_some_win32_op<
        Protocol,
        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
--- a/include/boost/beast/http/impl/read.ipp
+++ b/include/boost/beast/http/impl/read.ipp
@@ -526,8 +526,8 @@ async_read_some(
        boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer requirements not met");
    BOOST_ASSERT(! parser.is_done());
-    boost::asio::async_completion<ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        ReadHandler, void(error_code, std::size_t));
    detail::read_some_op<AsyncReadStream,
        DynamicBuffer, isRequest, Derived, BOOST_ASIO_HANDLER_TYPE(
            ReadHandler, void(error_code, std::size_t))>{
@@ -614,8 +614,8 @@ async_read_header(
        boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer requirements not met");
    parser.eager(false);
-    boost::asio::async_completion<ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        ReadHandler, void(error_code, std::size_t));
    detail::read_op<AsyncReadStream, DynamicBuffer,
        isRequest, Derived, detail::parser_is_header_done,
            BOOST_ASIO_HANDLER_TYPE(ReadHandler, void(error_code, std::size_t))>{
@@ -702,9 +702,8 @@ async_read(
        boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer requirements not met");
    parser.eager(true);
-    boost::asio::async_completion<
-        ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        ReadHandler, void(error_code, std::size_t));
    detail::read_op<AsyncReadStream, DynamicBuffer,
        isRequest, Derived, detail::parser_is_done,
            BOOST_ASIO_HANDLER_TYPE(ReadHandler, void(error_code, std::size_t))>{
@@ -794,9 +793,8 @@ async_read(
        "Body requirements not met");
    static_assert(is_body_reader<Body>::value,
        "BodyReader requirements not met");
-    boost::asio::async_completion<
-        ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        ReadHandler, void(error_code, std::size_t));
    detail::read_msg_op<
        AsyncReadStream,
        DynamicBuffer,
--- a/include/boost/beast/http/impl/write.ipp
+++ b/include/boost/beast/http/impl/write.ipp
@@ -471,9 +471,8 @@ async_write_some_impl(
    serializer<isRequest, Body, Fields>& sr,
    WriteHandler&& handler)
 {
-    boost::asio::async_completion<
-        WriteHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code, std::size_t));
    detail::write_some_op<
        AsyncWriteStream,
        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
@@ -629,9 +628,8 @@ async_write_header(
    static_assert(is_body_writer<Body>::value,
        "BodyWriter requirements not met");
    sr.split(true);
-    boost::asio::async_completion<
-        WriteHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code, std::size_t));
    detail::write_op<
        AsyncWriteStream,
        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
@@ -706,9 +704,8 @@ async_write(
    static_assert(is_body_writer<Body>::value,
        "BodyWriter requirements not met");
    sr.split(false);
-    boost::asio::async_completion<
-        WriteHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code, std::size_t));
    detail::write_op<
        AsyncWriteStream,
        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
@@ -780,9 +777,8 @@ async_write(
        "Body requirements not met");
    static_assert(is_body_writer<Body>::value,
        "BodyWriter requirements not met");
-    boost::asio::async_completion<
-        WriteHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code, std::size_t));
    detail::write_msg_op<
        AsyncWriteStream,
        BOOST_ASIO_HANDLER_TYPE(WriteHandler,
--- a/include/boost/beast/websocket/impl/accept.ipp
+++ b/include/boost/beast/websocket/impl/accept.ipp
@@ -544,8 +544,8 @@ async_accept(
 {
    static_assert(is_async_stream<next_layer_type>::value,
        "AsyncStream requirements not met");
-    boost::asio::async_completion<AcceptHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        AcceptHandler, void(error_code));
    reset();
    accept_op<
        decltype(&default_decorate_res),
@@ -573,8 +573,8 @@ async_accept_ex(
    static_assert(detail::is_response_decorator<
        ResponseDecorator>::value,
            "ResponseDecorator requirements not met");
-    boost::asio::async_completion<AcceptHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        AcceptHandler, void(error_code));
    reset();
    accept_op<
        ResponseDecorator,
@@ -604,8 +604,8 @@ async_accept(
    static_assert(boost::asio::is_const_buffer_sequence<
        ConstBufferSequence>::value,
            "ConstBufferSequence requirements not met");
-    boost::asio::async_completion<AcceptHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        AcceptHandler, void(error_code));
    reset();
    accept_op<
        decltype(&default_decorate_res),
@@ -640,8 +640,8 @@ async_accept_ex(
    static_assert(detail::is_response_decorator<
        ResponseDecorator>::value,
            "ResponseDecorator requirements not met");
-    boost::asio::async_completion<AcceptHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        AcceptHandler, void(error_code));
    reset();
    accept_op<
        ResponseDecorator,
@@ -666,8 +666,8 @@ async_accept(
 {
    static_assert(is_async_stream<next_layer_type>::value,
        "AsyncStream requirements not met");
-    boost::asio::async_completion<AcceptHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        AcceptHandler, void(error_code));
    reset();
    using boost::asio::asio_handler_is_continuation;
    response_op<
@@ -698,8 +698,8 @@ async_accept_ex(
    static_assert(detail::is_response_decorator<
        ResponseDecorator>::value,
            "ResponseDecorator requirements not met");
-    boost::asio::async_completion<AcceptHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        AcceptHandler, void(error_code));
    reset();
    using boost::asio::asio_handler_is_continuation;
    response_op<
--- a/include/boost/beast/websocket/impl/close.ipp
+++ b/include/boost/beast/websocket/impl/close.ipp
@@ -435,8 +435,8 @@ async_close(close_reason const& cr, CloseHandler&& handler)
 {
    static_assert(is_async_stream<next_layer_type>::value,
        "AsyncStream requirements not met");
-    boost::asio::async_completion<CloseHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        CloseHandler, void(error_code));
    close_op<BOOST_ASIO_HANDLER_TYPE(
        CloseHandler, void(error_code))>{
            std::move(init.completion_handler), *this, cr}(
--- a/include/boost/beast/websocket/impl/handshake.ipp
+++ b/include/boost/beast/websocket/impl/handshake.ipp
@@ -160,8 +160,8 @@ async_handshake(string_view host,
 {
    static_assert(is_async_stream<next_layer_type>::value,
        "AsyncStream requirements not met");
-    boost::asio::async_completion<HandshakeHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        HandshakeHandler, void(error_code));
    handshake_op<BOOST_ASIO_HANDLER_TYPE(
        HandshakeHandler, void(error_code))>{
            std::move(init.completion_handler), *this, nullptr, host,
@@ -181,8 +181,8 @@ async_handshake(response_type& res,
 {
    static_assert(is_async_stream<next_layer_type>::value,
        "AsyncStream requirements not met");
-    boost::asio::async_completion<HandshakeHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        HandshakeHandler, void(error_code));
    handshake_op<BOOST_ASIO_HANDLER_TYPE(
        HandshakeHandler, void(error_code))>{
            std::move(init.completion_handler), *this, &res, host,
@@ -205,8 +205,8 @@ async_handshake_ex(string_view host,
    static_assert(detail::is_request_decorator<
            RequestDecorator>::value,
        "RequestDecorator requirements not met");
-    boost::asio::async_completion<HandshakeHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        HandshakeHandler, void(error_code));
    handshake_op<BOOST_ASIO_HANDLER_TYPE(
        HandshakeHandler, void(error_code))>{
            std::move(init.completion_handler), *this, nullptr, host,
@@ -230,8 +230,8 @@ async_handshake_ex(response_type& res,
    static_assert(detail::is_request_decorator<
            RequestDecorator>::value,
        "RequestDecorator requirements not met");
-    boost::asio::async_completion<HandshakeHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        HandshakeHandler, void(error_code));
    handshake_op<BOOST_ASIO_HANDLER_TYPE(
        HandshakeHandler, void(error_code))>{
            std::move(init.completion_handler), *this, &res, host,
--- a/include/boost/beast/websocket/impl/ping.ipp
+++ b/include/boost/beast/websocket/impl/ping.ipp
@@ -237,8 +237,8 @@ async_ping(ping_data const& payload, WriteHandler&& handler)
 {
    static_assert(is_async_stream<next_layer_type>::value,
        "AsyncStream requirements not met");
-    boost::asio::async_completion<WriteHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code));
    ping_op<BOOST_ASIO_HANDLER_TYPE(
        WriteHandler, void(error_code))>{
            std::move(init.completion_handler), *this,
@@ -255,8 +255,8 @@ async_pong(ping_data const& payload, WriteHandler&& handler)
 {
    static_assert(is_async_stream<next_layer_type>::value,
        "AsyncStream requirements not met");
-    boost::asio::async_completion<WriteHandler,
-        void(error_code)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code));
    ping_op<BOOST_ASIO_HANDLER_TYPE(
        WriteHandler, void(error_code))>{
            std::move(init.completion_handler), *this,
--- a/include/boost/beast/websocket/impl/read.ipp
+++ b/include/boost/beast/websocket/impl/read.ipp
@@ -895,8 +895,8 @@ async_read(DynamicBuffer& buffer, ReadHandler&& handler)
    static_assert(
        boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer requirements not met");
-    boost::asio::async_completion<
-        ReadHandler, void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        ReadHandler, void(error_code, std::size_t));
    read_op<
        DynamicBuffer,
        BOOST_ASIO_HANDLER_TYPE(
@@ -983,8 +983,8 @@ async_read_some(
    static_assert(
        boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer requirements not met");
-    boost::asio::async_completion<ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        ReadHandler, void(error_code, std::size_t));
    read_op<
        DynamicBuffer,
        BOOST_ASIO_HANDLER_TYPE(
@@ -1368,8 +1368,8 @@ async_read_some(
    static_assert(boost::asio::is_mutable_buffer_sequence<
            MutableBufferSequence>::value,
        "MutableBufferSequence requirements not met");
-    boost::asio::async_completion<ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    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), *this, buffers}(
--- a/include/boost/beast/websocket/impl/write.ipp
+++ b/include/boost/beast/websocket/impl/write.ipp
@@ -814,8 +814,8 @@ async_write_some(bool fin,
    static_assert(boost::asio::is_const_buffer_sequence<
        ConstBufferSequence>::value,
            "ConstBufferSequence requirements not met");
-    boost::asio::async_completion<WriteHandler,
-        void(error_code, std::size_t)> init{handler};
+    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), *this, fin, bs}(
@@ -870,8 +870,8 @@ async_write(
    static_assert(boost::asio::is_const_buffer_sequence<
        ConstBufferSequence>::value,
            "ConstBufferSequence requirements not met");
-    boost::asio::async_completion<WriteHandler,
-        void(error_code, std::size_t)> init{handler};
+    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), *this, true, bs}(
--- a/test/extras/include/boost/beast/test/stream.hpp
+++ b/test/extras/include/boost/beast/test/stream.hpp
@@ -479,8 +479,8 @@ async_read_some(
    using boost::asio::buffer_copy;
    using boost::asio::buffer_size;
    BOOST_ASSERT(buffer_size(buffers) > 0);
-    boost::asio::async_completion<ReadHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        ReadHandler, void(error_code, std::size_t));
    if(in_->fc)
    {
        error_code ec;
@@ -598,8 +598,8 @@ async_write_some(ConstBufferSequence const& buffers,
        "ConstBufferSequence requirements not met");
    using boost::asio::buffer_copy;
    using boost::asio::buffer_size;
-    boost::asio::async_completion<WriteHandler,
-        void(error_code, std::size_t)> init{handler};
+    BOOST_BEAST_HANDLER_INIT(
+        WriteHandler, void(error_code, std::size_t));
    auto out = out_.lock();
    if(! out)
        return boost::asio::post(