boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-08-02 22:34:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Type check completion handlers

Browse Source 
fix #988
This commit is contained in:
Vinnie Falco
2018-01-26 08:58:19 -08:00
parent 908f84cb3c
commit d855bdefd8
13 changed files with 78 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
CHANGELOG.md
View File

@@ -1,3 +1,9 @@
Version 154:
* Type check completion handlers
--------------------------------------------------------------------------------
Version 153: Version 153:
* Remove BOOST_VERSION checks * Remove BOOST_VERSION checks

12
include/boost/beast/core/detail/type_traits.hpp
View File

@@ -437,6 +437,18 @@ buffers_range(Buffers const& buffers)
return buffers_range_adaptor<Buffers>{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 } // detail
} // beast } // beast
} // boost } // boost

4
include/boost/beast/core/impl/buffered_read_stream.ipp
View File

@@ -233,8 +233,8 @@ async_read_some(
if(buffer_.size() == 0 && capacity_ == 0) if(buffer_.size() == 0 && capacity_ == 0)
return next_layer_.async_read_some(buffers, return next_layer_.async_read_some(buffers,
std::forward<ReadHandler>(handler)); std::forward<ReadHandler>(handler));
boost::asio::async_completion<ReadHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; ReadHandler, void(error_code, std::size_t));
read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE( read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
ReadHandler, void(error_code, std::size_t))>{ ReadHandler, void(error_code, std::size_t))>{
std::move(init.completion_handler), *this, buffers}( std::move(init.completion_handler), *this, buffers}(

4
include/boost/beast/http/impl/file_body_win32.ipp
View File

@@ -564,8 +564,8 @@ async_write_some(
basic_file_body<file_win32>, Fields>& sr, basic_file_body<file_win32>, Fields>& sr,
WriteHandler&& handler) WriteHandler&& handler)
{ {
boost::asio::async_completion<WriteHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; WriteHandler, void(error_code, std::size_t));
detail::write_some_win32_op< detail::write_some_win32_op<
Protocol, Protocol,
BOOST_ASIO_HANDLER_TYPE(WriteHandler, BOOST_ASIO_HANDLER_TYPE(WriteHandler,

18
include/boost/beast/http/impl/read.ipp
View File

@@ -526,8 +526,8 @@ async_read_some(
boost::asio::is_dynamic_buffer<DynamicBuffer>::value, boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
BOOST_ASSERT(! parser.is_done()); BOOST_ASSERT(! parser.is_done());
boost::asio::async_completion<ReadHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; ReadHandler, void(error_code, std::size_t));
detail::read_some_op<AsyncReadStream, detail::read_some_op<AsyncReadStream,
DynamicBuffer, isRequest, Derived, BOOST_ASIO_HANDLER_TYPE( DynamicBuffer, isRequest, Derived, BOOST_ASIO_HANDLER_TYPE(
ReadHandler, void(error_code, std::size_t))>{ ReadHandler, void(error_code, std::size_t))>{
@@ -614,8 +614,8 @@ async_read_header(
boost::asio::is_dynamic_buffer<DynamicBuffer>::value, boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
parser.eager(false); parser.eager(false);
boost::asio::async_completion<ReadHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; ReadHandler, void(error_code, std::size_t));
detail::read_op<AsyncReadStream, DynamicBuffer, detail::read_op<AsyncReadStream, DynamicBuffer,
isRequest, Derived, detail::parser_is_header_done, isRequest, Derived, detail::parser_is_header_done,
BOOST_ASIO_HANDLER_TYPE(ReadHandler, void(error_code, std::size_t))>{ BOOST_ASIO_HANDLER_TYPE(ReadHandler, void(error_code, std::size_t))>{
@@ -702,9 +702,8 @@ async_read(
boost::asio::is_dynamic_buffer<DynamicBuffer>::value, boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
parser.eager(true); parser.eager(true);
boost::asio::async_completion< BOOST_BEAST_HANDLER_INIT(
ReadHandler, ReadHandler, void(error_code, std::size_t));
void(error_code, std::size_t)> init{handler};
detail::read_op<AsyncReadStream, DynamicBuffer, detail::read_op<AsyncReadStream, DynamicBuffer,
isRequest, Derived, detail::parser_is_done, isRequest, Derived, detail::parser_is_done,
BOOST_ASIO_HANDLER_TYPE(ReadHandler, void(error_code, std::size_t))>{ BOOST_ASIO_HANDLER_TYPE(ReadHandler, void(error_code, std::size_t))>{
@@ -794,9 +793,8 @@ async_read(
"Body requirements not met"); "Body requirements not met");
static_assert(is_body_reader<Body>::value, static_assert(is_body_reader<Body>::value,
"BodyReader requirements not met"); "BodyReader requirements not met");
boost::asio::async_completion< BOOST_BEAST_HANDLER_INIT(
ReadHandler, ReadHandler, void(error_code, std::size_t));
void(error_code, std::size_t)> init{handler};
detail::read_msg_op< detail::read_msg_op<
AsyncReadStream, AsyncReadStream,
DynamicBuffer, DynamicBuffer,

20
include/boost/beast/http/impl/write.ipp
View File

@@ -471,9 +471,8 @@ async_write_some_impl(
serializer<isRequest, Body, Fields>& sr, serializer<isRequest, Body, Fields>& sr,
WriteHandler&& handler) WriteHandler&& handler)
{ {
boost::asio::async_completion< BOOST_BEAST_HANDLER_INIT(
WriteHandler, WriteHandler, void(error_code, std::size_t));
void(error_code, std::size_t)> init{handler};
detail::write_some_op< detail::write_some_op<
AsyncWriteStream, AsyncWriteStream,
BOOST_ASIO_HANDLER_TYPE(WriteHandler, BOOST_ASIO_HANDLER_TYPE(WriteHandler,
@@ -629,9 +628,8 @@ async_write_header(
static_assert(is_body_writer<Body>::value, static_assert(is_body_writer<Body>::value,
"BodyWriter requirements not met"); "BodyWriter requirements not met");
sr.split(true); sr.split(true);
boost::asio::async_completion< BOOST_BEAST_HANDLER_INIT(
WriteHandler, WriteHandler, void(error_code, std::size_t));
void(error_code, std::size_t)> init{handler};
detail::write_op< detail::write_op<
AsyncWriteStream, AsyncWriteStream,
BOOST_ASIO_HANDLER_TYPE(WriteHandler, BOOST_ASIO_HANDLER_TYPE(WriteHandler,
@@ -706,9 +704,8 @@ async_write(
static_assert(is_body_writer<Body>::value, static_assert(is_body_writer<Body>::value,
"BodyWriter requirements not met"); "BodyWriter requirements not met");
sr.split(false); sr.split(false);
boost::asio::async_completion< BOOST_BEAST_HANDLER_INIT(
WriteHandler, WriteHandler, void(error_code, std::size_t));
void(error_code, std::size_t)> init{handler};
detail::write_op< detail::write_op<
AsyncWriteStream, AsyncWriteStream,
BOOST_ASIO_HANDLER_TYPE(WriteHandler, BOOST_ASIO_HANDLER_TYPE(WriteHandler,
@@ -780,9 +777,8 @@ async_write(
"Body requirements not met"); "Body requirements not met");
static_assert(is_body_writer<Body>::value, static_assert(is_body_writer<Body>::value,
"BodyWriter requirements not met"); "BodyWriter requirements not met");
boost::asio::async_completion< BOOST_BEAST_HANDLER_INIT(
WriteHandler, WriteHandler, void(error_code, std::size_t));
void(error_code, std::size_t)> init{handler};
detail::write_msg_op< detail::write_msg_op<
AsyncWriteStream, AsyncWriteStream,
BOOST_ASIO_HANDLER_TYPE(WriteHandler, BOOST_ASIO_HANDLER_TYPE(WriteHandler,

24
include/boost/beast/websocket/impl/accept.ipp
View File

@@ -544,8 +544,8 @@ async_accept(
{ {
static_assert(is_async_stream<next_layer_type>::value, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
boost::asio::async_completion<AcceptHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; AcceptHandler, void(error_code));
reset(); reset();
accept_op< accept_op<
decltype(&default_decorate_res), decltype(&default_decorate_res),
@@ -573,8 +573,8 @@ async_accept_ex(
static_assert(detail::is_response_decorator< static_assert(detail::is_response_decorator<
ResponseDecorator>::value, ResponseDecorator>::value,
"ResponseDecorator requirements not met"); "ResponseDecorator requirements not met");
boost::asio::async_completion<AcceptHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; AcceptHandler, void(error_code));
reset(); reset();
accept_op< accept_op<
ResponseDecorator, ResponseDecorator,
@@ -604,8 +604,8 @@ async_accept(
static_assert(boost::asio::is_const_buffer_sequence< static_assert(boost::asio::is_const_buffer_sequence<
ConstBufferSequence>::value, ConstBufferSequence>::value,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
boost::asio::async_completion<AcceptHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; AcceptHandler, void(error_code));
reset(); reset();
accept_op< accept_op<
decltype(&default_decorate_res), decltype(&default_decorate_res),
@@ -640,8 +640,8 @@ async_accept_ex(
static_assert(detail::is_response_decorator< static_assert(detail::is_response_decorator<
ResponseDecorator>::value, ResponseDecorator>::value,
"ResponseDecorator requirements not met"); "ResponseDecorator requirements not met");
boost::asio::async_completion<AcceptHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; AcceptHandler, void(error_code));
reset(); reset();
accept_op< accept_op<
ResponseDecorator, ResponseDecorator,
@@ -666,8 +666,8 @@ async_accept(
{ {
static_assert(is_async_stream<next_layer_type>::value, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
boost::asio::async_completion<AcceptHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; AcceptHandler, void(error_code));
reset(); reset();
using boost::asio::asio_handler_is_continuation; using boost::asio::asio_handler_is_continuation;
response_op< response_op<
@@ -698,8 +698,8 @@ async_accept_ex(
static_assert(detail::is_response_decorator< static_assert(detail::is_response_decorator<
ResponseDecorator>::value, ResponseDecorator>::value,
"ResponseDecorator requirements not met"); "ResponseDecorator requirements not met");
boost::asio::async_completion<AcceptHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; AcceptHandler, void(error_code));
reset(); reset();
using boost::asio::asio_handler_is_continuation; using boost::asio::asio_handler_is_continuation;
response_op< response_op<

4
include/boost/beast/websocket/impl/close.ipp
View File

@@ -435,8 +435,8 @@ async_close(close_reason const& cr, CloseHandler&& handler)
{ {
static_assert(is_async_stream<next_layer_type>::value, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
boost::asio::async_completion<CloseHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; CloseHandler, void(error_code));
close_op<BOOST_ASIO_HANDLER_TYPE( close_op<BOOST_ASIO_HANDLER_TYPE(
CloseHandler, void(error_code))>{ CloseHandler, void(error_code))>{
std::move(init.completion_handler), *this, cr}( std::move(init.completion_handler), *this, cr}(

16
include/boost/beast/websocket/impl/handshake.ipp
View File

@@ -160,8 +160,8 @@ async_handshake(string_view host,
{ {
static_assert(is_async_stream<next_layer_type>::value, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
boost::asio::async_completion<HandshakeHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; HandshakeHandler, void(error_code));
handshake_op<BOOST_ASIO_HANDLER_TYPE( handshake_op<BOOST_ASIO_HANDLER_TYPE(
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code))>{
std::move(init.completion_handler), *this, nullptr, host, 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, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
boost::asio::async_completion<HandshakeHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; HandshakeHandler, void(error_code));
handshake_op<BOOST_ASIO_HANDLER_TYPE( handshake_op<BOOST_ASIO_HANDLER_TYPE(
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code))>{
std::move(init.completion_handler), *this, &res, host, std::move(init.completion_handler), *this, &res, host,
@@ -205,8 +205,8 @@ async_handshake_ex(string_view host,
static_assert(detail::is_request_decorator< static_assert(detail::is_request_decorator<
RequestDecorator>::value, RequestDecorator>::value,
"RequestDecorator requirements not met"); "RequestDecorator requirements not met");
boost::asio::async_completion<HandshakeHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; HandshakeHandler, void(error_code));
handshake_op<BOOST_ASIO_HANDLER_TYPE( handshake_op<BOOST_ASIO_HANDLER_TYPE(
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code))>{
std::move(init.completion_handler), *this, nullptr, host, std::move(init.completion_handler), *this, nullptr, host,
@@ -230,8 +230,8 @@ async_handshake_ex(response_type& res,
static_assert(detail::is_request_decorator< static_assert(detail::is_request_decorator<
RequestDecorator>::value, RequestDecorator>::value,
"RequestDecorator requirements not met"); "RequestDecorator requirements not met");
boost::asio::async_completion<HandshakeHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; HandshakeHandler, void(error_code));
handshake_op<BOOST_ASIO_HANDLER_TYPE( handshake_op<BOOST_ASIO_HANDLER_TYPE(
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code))>{
std::move(init.completion_handler), *this, &res, host, std::move(init.completion_handler), *this, &res, host,

8
include/boost/beast/websocket/impl/ping.ipp
View File

@@ -237,8 +237,8 @@ async_ping(ping_data const& payload, WriteHandler&& handler)
{ {
static_assert(is_async_stream<next_layer_type>::value, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
boost::asio::async_completion<WriteHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; WriteHandler, void(error_code));
ping_op<BOOST_ASIO_HANDLER_TYPE( ping_op<BOOST_ASIO_HANDLER_TYPE(
WriteHandler, void(error_code))>{ WriteHandler, void(error_code))>{
std::move(init.completion_handler), *this, 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, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
boost::asio::async_completion<WriteHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code)> init{handler}; WriteHandler, void(error_code));
ping_op<BOOST_ASIO_HANDLER_TYPE( ping_op<BOOST_ASIO_HANDLER_TYPE(
WriteHandler, void(error_code))>{ WriteHandler, void(error_code))>{
std::move(init.completion_handler), *this, std::move(init.completion_handler), *this,

12
include/boost/beast/websocket/impl/read.ipp
View File

@@ -895,8 +895,8 @@ async_read(DynamicBuffer& buffer, ReadHandler&& handler)
static_assert( static_assert(
boost::asio::is_dynamic_buffer<DynamicBuffer>::value, boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
boost::asio::async_completion< BOOST_BEAST_HANDLER_INIT(
ReadHandler, void(error_code, std::size_t)> init{handler}; ReadHandler, void(error_code, std::size_t));
read_op< read_op<
DynamicBuffer, DynamicBuffer,
BOOST_ASIO_HANDLER_TYPE( BOOST_ASIO_HANDLER_TYPE(
@@ -983,8 +983,8 @@ async_read_some(
static_assert( static_assert(
boost::asio::is_dynamic_buffer<DynamicBuffer>::value, boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
boost::asio::async_completion<ReadHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; ReadHandler, void(error_code, std::size_t));
read_op< read_op<
DynamicBuffer, DynamicBuffer,
BOOST_ASIO_HANDLER_TYPE( BOOST_ASIO_HANDLER_TYPE(
@@ -1368,8 +1368,8 @@ async_read_some(
static_assert(boost::asio::is_mutable_buffer_sequence< static_assert(boost::asio::is_mutable_buffer_sequence<
MutableBufferSequence>::value, MutableBufferSequence>::value,
"MutableBufferSequence requirements not met"); "MutableBufferSequence requirements not met");
boost::asio::async_completion<ReadHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; ReadHandler, void(error_code, std::size_t));
read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE( read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
ReadHandler, void(error_code, std::size_t))>{ ReadHandler, void(error_code, std::size_t))>{
std::move(init.completion_handler), *this, buffers}( std::move(init.completion_handler), *this, buffers}(

8
include/boost/beast/websocket/impl/write.ipp
View File

@@ -814,8 +814,8 @@ async_write_some(bool fin,
static_assert(boost::asio::is_const_buffer_sequence< static_assert(boost::asio::is_const_buffer_sequence<
ConstBufferSequence>::value, ConstBufferSequence>::value,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
boost::asio::async_completion<WriteHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; WriteHandler, void(error_code, std::size_t));
write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE( write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
WriteHandler, void(error_code, std::size_t))>{ WriteHandler, void(error_code, std::size_t))>{
std::move(init.completion_handler), *this, fin, bs}( std::move(init.completion_handler), *this, fin, bs}(
@@ -870,8 +870,8 @@ async_write(
static_assert(boost::asio::is_const_buffer_sequence< static_assert(boost::asio::is_const_buffer_sequence<
ConstBufferSequence>::value, ConstBufferSequence>::value,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
boost::asio::async_completion<WriteHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; WriteHandler, void(error_code, std::size_t));
write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE( write_some_op<ConstBufferSequence, BOOST_ASIO_HANDLER_TYPE(
WriteHandler, void(error_code, std::size_t))>{ WriteHandler, void(error_code, std::size_t))>{
std::move(init.completion_handler), *this, true, bs}( std::move(init.completion_handler), *this, true, bs}(

8
test/extras/include/boost/beast/test/stream.hpp
View File

@@ -479,8 +479,8 @@ async_read_some(
using boost::asio::buffer_copy; using boost::asio::buffer_copy;
using boost::asio::buffer_size; using boost::asio::buffer_size;
BOOST_ASSERT(buffer_size(buffers) > 0); BOOST_ASSERT(buffer_size(buffers) > 0);
boost::asio::async_completion<ReadHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; ReadHandler, void(error_code, std::size_t));
if(in_->fc) if(in_->fc)
{ {
error_code ec; error_code ec;
@@ -598,8 +598,8 @@ async_write_some(ConstBufferSequence const& buffers,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
using boost::asio::buffer_copy; using boost::asio::buffer_copy;
using boost::asio::buffer_size; using boost::asio::buffer_size;
boost::asio::async_completion<WriteHandler, BOOST_BEAST_HANDLER_INIT(
void(error_code, std::size_t)> init{handler}; WriteHandler, void(error_code, std::size_t));
auto out = out_.lock(); auto out = out_.lock();
if(! out) if(! out)
return boost::asio::post( return boost::asio::post(