feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity

Replace asynchronous helper macros with template aliases (API Change)

Browse Source
This commit is contained in:
Vinnie Falco
2017-05-12 17:13:03 -07:00
parent 043386aeb3
commit aa8a0a2a4b
20 changed files with 207 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@@ -7,6 +7,7 @@ API Changes
* Return http::error::end_of_stream on HTTP read eof * Return http::error::end_of_stream on HTTP read eof
* Remove placeholders * Remove placeholders
* Move prepare_buffers to prepare_buffer.hpp * Move prepare_buffers to prepare_buffer.hpp
* Replace asynchronous helper macros with template aliases
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------

7
doc/quickref.xml
View File

@@ -153,6 +153,7 @@
<simplelist type="vert" columns="1"> <simplelist type="vert" columns="1">
<member><link linkend="beast.ref.async_completion">async_completion</link></member> <member><link linkend="beast.ref.async_completion">async_completion</link></member>
<member><link linkend="beast.ref.async_result">async_result</link></member> <member><link linkend="beast.ref.async_result">async_result</link></member>
<member><link linkend="beast.ref.async_return_type">async_return_type</link></member>
<member><link linkend="beast.ref.basic_flat_buffer">basic_flat_buffer</link></member> <member><link linkend="beast.ref.basic_flat_buffer">basic_flat_buffer</link></member>
<member><link linkend="beast.ref.basic_multi_buffer">basic_multi_buffer</link></member> <member><link linkend="beast.ref.basic_multi_buffer">basic_multi_buffer</link></member>
<member><link linkend="beast.ref.buffers_adapter">buffers_adapter</link></member> <member><link linkend="beast.ref.buffers_adapter">buffers_adapter</link></member>
@@ -165,6 +166,7 @@
<member><link linkend="beast.ref.flat_buffer">flat_buffer</link></member> <member><link linkend="beast.ref.flat_buffer">flat_buffer</link></member>
<member><link linkend="beast.ref.handler_alloc">handler_alloc</link></member> <member><link linkend="beast.ref.handler_alloc">handler_alloc</link></member>
<member><link linkend="beast.ref.handler_ptr">handler_ptr</link></member> <member><link linkend="beast.ref.handler_ptr">handler_ptr</link></member>
<member><link linkend="beast.ref.handler_type">handler_type</link></member>
<member><link linkend="beast.ref.multi_buffer">multi_buffer</link></member> <member><link linkend="beast.ref.multi_buffer">multi_buffer</link></member>
<member><link linkend="beast.ref.static_buffer">static_buffer</link></member> <member><link linkend="beast.ref.static_buffer">static_buffer</link></member>
<member><link linkend="beast.ref.static_buffer_n">static_buffer_n</link></member> <member><link linkend="beast.ref.static_buffer_n">static_buffer_n</link></member>
@@ -185,11 +187,6 @@
<member><link linkend="beast.ref.system_category">system_category</link></member> <member><link linkend="beast.ref.system_category">system_category</link></member>
<member><link linkend="beast.ref.to_static_string">to_static_string</link></member> <member><link linkend="beast.ref.to_static_string">to_static_string</link></member>
</simplelist> </simplelist>
<bridgehead renderas="sect3">Macros</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.BEAST_HANDLER_TYPE">BEAST_HANDLER_TYPE</link></member>
<member><link linkend="beast.ref.BEAST_INITFN_RESULT_TYPE">BEAST_INITFN_RESULT_TYPE</link></member>
</simplelist>
</entry> </entry>
<entry valign="top"> <entry valign="top">
<bridgehead renderas="sect3">Type Traits</bridgehead> <bridgehead renderas="sect3">Type Traits</bridgehead>

8
extras/beast/test/fail_stream.hpp
View File

@@ -103,8 +103,8 @@ public:
} }
template<class MutableBufferSequence, class ReadHandler> template<class MutableBufferSequence, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some(MutableBufferSequence const& buffers, async_read_some(MutableBufferSequence const& buffers,
ReadHandler&& handler) ReadHandler&& handler)
{ {
@@ -139,8 +139,8 @@ public:
} }
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code, std::size_t)) WriteHandler, void(error_code, std::size_t)>
async_write_some(ConstBufferSequence const& buffers, async_write_some(ConstBufferSequence const& buffers,
WriteHandler&& handler) WriteHandler&& handler)
{ {

8
extras/beast/test/string_iostream.hpp
View File

@@ -78,8 +78,8 @@ public:
} }
template<class MutableBufferSequence, class ReadHandler> template<class MutableBufferSequence, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some(MutableBufferSequence const& buffers, async_read_some(MutableBufferSequence const& buffers,
ReadHandler&& handler) ReadHandler&& handler)
{ {
@@ -124,8 +124,8 @@ public:
} }
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code, std::size_t)) WriteHandler, void(error_code, std::size_t)>
async_write_some(ConstBufferSequence const& buffers, async_write_some(ConstBufferSequence const& buffers,
WriteHandler&& handler) WriteHandler&& handler)
{ {

8
extras/beast/test/string_istream.hpp
View File

@@ -76,8 +76,8 @@ public:
} }
template<class MutableBufferSequence, class ReadHandler> template<class MutableBufferSequence, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some(MutableBufferSequence const& buffers, async_read_some(MutableBufferSequence const& buffers,
ReadHandler&& handler) ReadHandler&& handler)
{ {
@@ -115,8 +115,8 @@ public:
} }
template<class ConstBuffeSequence, class WriteHandler> template<class ConstBuffeSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code, std::size_t)) WriteHandler, void(error_code, std::size_t)>
async_write_some(ConstBuffeSequence const& buffers, async_write_some(ConstBuffeSequence const& buffers,
WriteHandler&& handler) WriteHandler&& handler)
{ {

8
extras/beast/test/string_ostream.hpp
View File

@@ -59,8 +59,8 @@ public:
} }
template<class MutableBufferSequence, class ReadHandler> template<class MutableBufferSequence, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some(MutableBufferSequence const& buffers, async_read_some(MutableBufferSequence const& buffers,
ReadHandler&& handler) ReadHandler&& handler)
{ {
@@ -98,8 +98,8 @@ public:
} }
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code, std::size_t)) WriteHandler, void(error_code, std::size_t)>
async_write_some(ConstBufferSequence const& buffers, async_write_some(ConstBufferSequence const& buffers,
WriteHandler&& handler) WriteHandler&& handler)
{ {

46
include/beast/core/async_result.hpp
View File

@@ -37,7 +37,7 @@ namespace beast {
completion token types. The primary template assumes that the completion token types. The primary template assumes that the
@b CompletionToken is the completion handler. @b CompletionToken is the completion handler.
@see @ref BEAST_INITFN_RESULT_TYPE, @ref BEAST_HANDLER_TYPE @see @ref async_completion, @ref async_return_type, @ref handler_type
*/ */
template<class CompletionToken, class Signature> template<class CompletionToken, class Signature>
class async_result class async_result
@@ -118,6 +118,8 @@ public:
@note See <a href="http://cplusplus.github.io/networking-ts/draft.pdf"> @note See <a href="http://cplusplus.github.io/networking-ts/draft.pdf">
Working Draft, C++ Extensions for Networking</a> Working Draft, C++ Extensions for Networking</a>
@see @ref async_return_type, @ref handler_type
*/ */
template<class CompletionToken, class Signature> template<class CompletionToken, class Signature>
struct async_completion struct async_completion
@@ -150,7 +152,7 @@ struct async_completion
// CompletionToken is not invokable with the given signature // CompletionToken is not invokable with the given signature
static_assert(is_CompletionHandler< static_assert(is_CompletionHandler<
completion_handler_type, Signature>::value, completion_handler_type, Signature>::value,
"CompletionToken requirements not met (Signature mismatch)"); "CompletionToken requirements not met: signature mismatch");
} }
/// The final completion handler, callable with the specified signature. /// The final completion handler, callable with the specified signature.
@@ -165,23 +167,41 @@ struct async_completion
CompletionToken>::type, Signature> result; CompletionToken>::type, Signature> result;
}; };
/// @file /** Convert a completion token to the correct completion handler type.
/** @def BEAST_INITFN_RESULT_TYPE(ct, sig) This helps asynchronous initiation functions to meet the
requirements of the Extensible Asynchronous Model.
A macro to customize the return value of asynchronous initiation functions. @tparam CompletionToken Specifies the model used to obtain the result of
the asynchronous operation.
@tparam Signature The call signature for the completion handler type invoked
on completion of the asynchronous operation.
@see @ref async_completion, @ref async_return_type
*/ */
#define BEAST_INITFN_RESULT_TYPE(ct, sig) \ template<class CompletionToken, typename Signature>
typename async_result< \ using handler_type = typename beast::async_result<
typename std::decay<ct>::type, sig>::return_type typename std::decay<CompletionToken>::type,
Signature>::completion_handler_type;
/** @def BEAST_HANDLER_TYPE(ct, sig) /** Determine the return value of an asynchronous initiation function
A helper macro to convert a completion token to a completion handler type. This helps asynchronous initiation functions to meet the
requirements of the Extensible Asynchronous Model.
@tparam CompletionToken Specifies the model used to obtain the result of
the asynchronous operation.
@tparam Signature The call signature for the completion handler type invoked
on completion of the asynchronous operation.
@see @ref async_completion, @ref handler_type
*/ */
#define BEAST_HANDLER_TYPE(ct, sig) \ template<class CompletionToken, typename Signature>
typename async_result< \ using async_return_type = typename beast::async_result<
typename std::decay<ct>::type, sig>::completion_handler_type typename std::decay<CompletionToken>::type,
Signature>::return_type;
} // beast } // beast

4
include/beast/core/buffered_read_stream.hpp
View File

@@ -272,7 +272,7 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class MutableBufferSequence, class ReadHandler> template<class MutableBufferSequence, class ReadHandler>
BEAST_INITFN_RESULT_TYPE(ReadHandler, void(error_code)) async_return_type<ReadHandler, void(error_code)>
async_read_some(MutableBufferSequence const& buffers, async_read_some(MutableBufferSequence const& buffers,
ReadHandler&& handler); ReadHandler&& handler);
@@ -343,7 +343,7 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE(WriteHandler, void(error_code)) async_return_type<WriteHandler, void(error_code)>
async_write_some(ConstBufferSequence const& buffers, async_write_some(ConstBufferSequence const& buffers,
WriteHandler&& handler); WriteHandler&& handler);
}; };

8
include/beast/core/impl/buffered_read_stream.ipp
View File

@@ -162,7 +162,7 @@ auto
buffered_read_stream<Stream, DynamicBuffer>:: buffered_read_stream<Stream, DynamicBuffer>::
async_write_some(ConstBufferSequence const& buffers, async_write_some(ConstBufferSequence const& buffers,
WriteHandler&& handler) -> WriteHandler&& handler) ->
BEAST_INITFN_RESULT_TYPE(WriteHandler, void(error_code)) async_return_type<WriteHandler, void(error_code)>
{ {
static_assert(is_AsyncWriteStream<next_layer_type>::value, static_assert(is_AsyncWriteStream<next_layer_type>::value,
"AsyncWriteStream requirements not met"); "AsyncWriteStream requirements not met");
@@ -230,7 +230,7 @@ auto
buffered_read_stream<Stream, DynamicBuffer>:: buffered_read_stream<Stream, DynamicBuffer>::
async_read_some(MutableBufferSequence const& buffers, async_read_some(MutableBufferSequence const& buffers,
ReadHandler&& handler) -> ReadHandler&& handler) ->
BEAST_INITFN_RESULT_TYPE(ReadHandler, void(error_code)) async_return_type<ReadHandler, void(error_code)>
{ {
static_assert(is_AsyncReadStream<next_layer_type>::value, static_assert(is_AsyncReadStream<next_layer_type>::value,
"Stream requirements not met"); "Stream requirements not met");
@@ -239,8 +239,8 @@ async_read_some(MutableBufferSequence const& buffers,
"MutableBufferSequence requirements not met"); "MutableBufferSequence requirements not met");
async_completion<ReadHandler, async_completion<ReadHandler,
void(error_code, std::size_t)> init{handler}; void(error_code, std::size_t)> init{handler};
read_some_op<MutableBufferSequence, BEAST_HANDLER_TYPE( read_some_op<MutableBufferSequence, handler_type<
ReadHandler, void(error_code, std::size_t))>{ ReadHandler, void(error_code, std::size_t)>>{
init.completion_handler, *this, buffers}; init.completion_handler, *this, buffers};
return init.result.get(); return init.result.get();
} }

40
include/beast/http/impl/async_read.ipp
View File

@@ -575,8 +575,8 @@ template<
class DynamicBuffer, class DynamicBuffer,
bool isRequest, class Derived, bool isRequest, class Derived,
class ReadHandler> class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some( async_read_some(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,
@@ -590,15 +590,15 @@ async_read_some(
case parse_state::header: case parse_state::header:
case parse_state::chunk_header: case parse_state::chunk_header:
detail::read_some_buffer_op<AsyncReadStream, detail::read_some_buffer_op<AsyncReadStream,
DynamicBuffer, isRequest, true, Derived, BEAST_HANDLER_TYPE( DynamicBuffer, isRequest, true, Derived, handler_type<
ReadHandler, void(error_code, std::size_t))>{ ReadHandler, void(error_code, std::size_t)>>{
init.completion_handler, stream, dynabuf, parser}; init.completion_handler, stream, dynabuf, parser};
break; break;
default: default:
detail::read_some_body_op<AsyncReadStream, detail::read_some_body_op<AsyncReadStream,
DynamicBuffer, isRequest, Derived, BEAST_HANDLER_TYPE( DynamicBuffer, isRequest, Derived, handler_type<
ReadHandler, void(error_code, std::size_t))>{ ReadHandler, void(error_code, std::size_t)>>{
init.completion_handler, stream, dynabuf, parser}; init.completion_handler, stream, dynabuf, parser};
break; break;
} }
@@ -611,8 +611,8 @@ template<
bool isRequest, class Derived, bool isRequest, class Derived,
class ReadHandler> class ReadHandler>
inline inline
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some( async_read_some(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,
@@ -622,8 +622,8 @@ async_read_some(
async_completion<ReadHandler, async_completion<ReadHandler,
void(error_code, std::size_t)> init{handler}; void(error_code, std::size_t)> init{handler};
detail::read_some_buffer_op<AsyncReadStream, detail::read_some_buffer_op<AsyncReadStream,
DynamicBuffer, isRequest, false, Derived, BEAST_HANDLER_TYPE( DynamicBuffer, isRequest, false, Derived, handler_type<
ReadHandler, void(error_code, std::size_t))>{ ReadHandler, void(error_code, std::size_t)>>{
init.completion_handler, stream, dynabuf, parser}; init.completion_handler, stream, dynabuf, parser};
return init.result.get(); return init.result.get();
} }
@@ -637,8 +637,8 @@ template<
class DynamicBuffer, class DynamicBuffer,
bool isRequest, bool isDirect, class Derived, bool isRequest, bool isDirect, class Derived,
class ReadHandler> class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some( async_read_some(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,
@@ -659,8 +659,8 @@ template<
class DynamicBuffer, class DynamicBuffer,
bool isRequest, bool isDirect, class Derived, bool isRequest, bool isDirect, class Derived,
class ReadHandler> class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
async_read( async_read(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,
@@ -675,8 +675,8 @@ async_read(
async_completion<ReadHandler, async_completion<ReadHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
detail::parse_op<AsyncReadStream, DynamicBuffer, detail::parse_op<AsyncReadStream, DynamicBuffer,
isRequest, isDirect, Derived, BEAST_HANDLER_TYPE( isRequest, isDirect, Derived, handler_type<
ReadHandler, void(error_code))>{ ReadHandler, void(error_code)>>{
init.completion_handler, stream, dynabuf, parser}; init.completion_handler, stream, dynabuf, parser};
return init.result.get(); return init.result.get();
} }
@@ -686,8 +686,8 @@ template<
class DynamicBuffer, class DynamicBuffer,
bool isRequest, class Body, class Fields, bool isRequest, class Body, class Fields,
class ReadHandler> class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
async_read( async_read(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,
@@ -708,8 +708,8 @@ async_read(
async_completion<ReadHandler, async_completion<ReadHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
detail::read_message_op<AsyncReadStream, DynamicBuffer, detail::read_message_op<AsyncReadStream, DynamicBuffer,
isRequest, Body, Fields, BEAST_HANDLER_TYPE( isRequest, Body, Fields, handler_type<
ReadHandler, void(error_code))>{ ReadHandler, void(error_code)>>{
init.completion_handler, stream, dynabuf, msg}; init.completion_handler, stream, dynabuf, msg};
return init.result.get(); return init.result.get();
} }

14
include/beast/http/impl/write.ipp
View File

@@ -213,8 +213,8 @@ write(SyncWriteStream& stream,
template<class AsyncWriteStream, template<class AsyncWriteStream,
bool isRequest, class Fields, bool isRequest, class Fields,
class WriteHandler> class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_write(AsyncWriteStream& stream, async_write(AsyncWriteStream& stream,
header<isRequest, Fields> const& msg, header<isRequest, Fields> const& msg,
WriteHandler&& handler) WriteHandler&& handler)
@@ -231,7 +231,7 @@ async_write(AsyncWriteStream& stream,
os << "\r\n"; os << "\r\n";
} }
detail::write_streambuf_op<AsyncWriteStream, detail::write_streambuf_op<AsyncWriteStream,
BEAST_HANDLER_TYPE(WriteHandler, void(error_code))>{ handler_type<WriteHandler, void(error_code)>>{
init.completion_handler, stream, std::move(b)}; init.completion_handler, stream, std::move(b)};
return init.result.get(); return init.result.get();
} }
@@ -641,8 +641,8 @@ write(SyncWriteStream& stream,
template<class AsyncWriteStream, template<class AsyncWriteStream,
bool isRequest, class Body, class Fields, bool isRequest, class Body, class Fields,
class WriteHandler> class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_write(AsyncWriteStream& stream, async_write(AsyncWriteStream& stream,
message<isRequest, Body, Fields> const& msg, message<isRequest, Body, Fields> const& msg,
WriteHandler&& handler) WriteHandler&& handler)
@@ -658,8 +658,8 @@ async_write(AsyncWriteStream& stream,
"Writer requirements not met"); "Writer requirements not met");
async_completion<WriteHandler, async_completion<WriteHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
detail::write_op<AsyncWriteStream, BEAST_HANDLER_TYPE( detail::write_op<AsyncWriteStream, handler_type<
WriteHandler, void(error_code)), isRequest, WriteHandler, void(error_code)>, isRequest,
Body, Fields>{init.completion_handler, stream, msg}; Body, Fields>{init.completion_handler, stream, msg};
return init.result.get(); return init.result.get();
} }

12
include/beast/http/read.hpp
View File

@@ -194,8 +194,8 @@ template<
class DynamicBuffer, class DynamicBuffer,
bool isRequest, bool isDirect, class Derived, bool isRequest, bool isDirect, class Derived,
class ReadHandler> class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code, std::size_t)) ReadHandler, void(error_code, std::size_t)>
async_read_some( async_read_some(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,
@@ -344,8 +344,8 @@ template<
class DynamicBuffer, class DynamicBuffer,
bool isRequest, bool isDirect, class Derived, bool isRequest, bool isDirect, class Derived,
class ReadHandler> class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
async_read( async_read(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,
@@ -499,8 +499,8 @@ template<
class DynamicBuffer, class DynamicBuffer,
bool isRequest, class Body, class Fields, bool isRequest, class Body, class Fields,
class ReadHandler> class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
async_read( async_read(
AsyncReadStream& stream, AsyncReadStream& stream,
DynamicBuffer& dynabuf, DynamicBuffer& dynabuf,

8
include/beast/http/write.hpp
View File

@@ -121,8 +121,8 @@ write(SyncWriteStream& stream,
template<class AsyncWriteStream, template<class AsyncWriteStream,
bool isRequest, class Fields, bool isRequest, class Fields,
class WriteHandler> class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_write(AsyncWriteStream& stream, async_write(AsyncWriteStream& stream,
header<isRequest, Fields> const& msg, header<isRequest, Fields> const& msg,
WriteHandler&& handler); WriteHandler&& handler);
@@ -236,8 +236,8 @@ write(SyncWriteStream& stream,
template<class AsyncWriteStream, template<class AsyncWriteStream,
bool isRequest, class Body, class Fields, bool isRequest, class Body, class Fields,
class WriteHandler> class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_write(AsyncWriteStream& stream, async_write(AsyncWriteStream& stream,
message<isRequest, Body, Fields> const& msg, message<isRequest, Body, Fields> const& msg,
WriteHandler&& handler); WriteHandler&& handler);

60
include/beast/websocket/impl/accept.ipp
View File

@@ -590,8 +590,8 @@ accept_ex(http::header<true, Fields> const& req,
template<class NextLayer> template<class NextLayer>
template<class AcceptHandler> template<class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept(AcceptHandler&& handler) async_accept(AcceptHandler&& handler)
{ {
@@ -601,15 +601,15 @@ async_accept(AcceptHandler&& handler)
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
accept_op<decltype(&default_decorate_res), accept_op<decltype(&default_decorate_res),
BEAST_HANDLER_TYPE(AcceptHandler, void(error_code))>{ handler_type<AcceptHandler, void(error_code)>>{
init.completion_handler, *this, &default_decorate_res}; init.completion_handler, *this, &default_decorate_res};
return init.result.get(); return init.result.get();
} }
template<class NextLayer> template<class NextLayer>
template<class ResponseDecorator, class AcceptHandler> template<class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept_ex(ResponseDecorator const& decorator, async_accept_ex(ResponseDecorator const& decorator,
AcceptHandler&& handler) AcceptHandler&& handler)
@@ -622,16 +622,16 @@ async_accept_ex(ResponseDecorator const& decorator,
async_completion<AcceptHandler, async_completion<AcceptHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
accept_op<ResponseDecorator, BEAST_HANDLER_TYPE( accept_op<ResponseDecorator, handler_type<
AcceptHandler, void(error_code))>{ AcceptHandler, void(error_code)>>{
init.completion_handler, *this, decorator}; init.completion_handler, *this, decorator};
return init.result.get(); return init.result.get();
} }
template<class NextLayer> template<class NextLayer>
template<class ConstBufferSequence, class AcceptHandler> template<class ConstBufferSequence, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept(ConstBufferSequence const& buffers, async_accept(ConstBufferSequence const& buffers,
AcceptHandler&& handler) AcceptHandler&& handler)
@@ -645,7 +645,7 @@ async_accept(ConstBufferSequence const& buffers,
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
accept_op<decltype(&default_decorate_res), accept_op<decltype(&default_decorate_res),
BEAST_HANDLER_TYPE(AcceptHandler, void(error_code))>{ handler_type<AcceptHandler, void(error_code)>>{
init.completion_handler, *this, buffers, &default_decorate_res}; init.completion_handler, *this, buffers, &default_decorate_res};
return init.result.get(); return init.result.get();
} }
@@ -653,8 +653,8 @@ async_accept(ConstBufferSequence const& buffers,
template<class NextLayer> template<class NextLayer>
template<class ConstBufferSequence, template<class ConstBufferSequence,
class ResponseDecorator, class AcceptHandler> class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept_ex(ConstBufferSequence const& buffers, async_accept_ex(ConstBufferSequence const& buffers,
ResponseDecorator const& decorator, ResponseDecorator const& decorator,
@@ -671,16 +671,16 @@ async_accept_ex(ConstBufferSequence const& buffers,
async_completion<AcceptHandler, async_completion<AcceptHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
accept_op<ResponseDecorator, BEAST_HANDLER_TYPE( accept_op<ResponseDecorator, handler_type<
AcceptHandler, void(error_code))>{ AcceptHandler, void(error_code)>>{
init.completion_handler, *this, buffers, decorator}; init.completion_handler, *this, buffers, decorator};
return init.result.get(); return init.result.get();
} }
template<class NextLayer> template<class NextLayer>
template<class Fields, class AcceptHandler> template<class Fields, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept(http::header<true, Fields> const& req, async_accept(http::header<true, Fields> const& req,
AcceptHandler&& handler) AcceptHandler&& handler)
@@ -690,8 +690,8 @@ async_accept(http::header<true, Fields> const& req,
async_completion<AcceptHandler, async_completion<AcceptHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
response_op<BEAST_HANDLER_TYPE( response_op<handler_type<
AcceptHandler, void(error_code))>{init.completion_handler, AcceptHandler, void(error_code)>>{init.completion_handler,
*this, req, &default_decorate_res, *this, req, &default_decorate_res,
beast_asio_helpers::is_continuation( beast_asio_helpers::is_continuation(
init.completion_handler)}; init.completion_handler)};
@@ -701,8 +701,8 @@ async_accept(http::header<true, Fields> const& req,
template<class NextLayer> template<class NextLayer>
template<class Fields, template<class Fields,
class ResponseDecorator, class AcceptHandler> class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept_ex(http::header<true, Fields> const& req, async_accept_ex(http::header<true, Fields> const& req,
ResponseDecorator const& decorator, AcceptHandler&& handler) ResponseDecorator const& decorator, AcceptHandler&& handler)
@@ -715,8 +715,8 @@ async_accept_ex(http::header<true, Fields> const& req,
async_completion<AcceptHandler, async_completion<AcceptHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
response_op<BEAST_HANDLER_TYPE( response_op<handler_type<
AcceptHandler, void(error_code))>{ AcceptHandler, void(error_code)>>{
init.completion_handler, *this, req, decorator, init.completion_handler, *this, req, decorator,
beast_asio_helpers::is_continuation( beast_asio_helpers::is_continuation(
init.completion_handler)}; init.completion_handler)};
@@ -726,8 +726,8 @@ async_accept_ex(http::header<true, Fields> const& req,
template<class NextLayer> template<class NextLayer>
template<class Fields, template<class Fields,
class ConstBufferSequence, class AcceptHandler> class ConstBufferSequence, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept(http::header<true, Fields> const& req, async_accept(http::header<true, Fields> const& req,
ConstBufferSequence const& buffers, ConstBufferSequence const& buffers,
@@ -741,8 +741,8 @@ async_accept(http::header<true, Fields> const& req,
async_completion<AcceptHandler, async_completion<AcceptHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
response_op<BEAST_HANDLER_TYPE( response_op<handler_type<
AcceptHandler, void(error_code))>{ AcceptHandler, void(error_code)>>{
init.completion_handler, *this, req, buffers, init.completion_handler, *this, req, buffers,
&default_decorate_res, beast_asio_helpers:: &default_decorate_res, beast_asio_helpers::
is_continuation(init.completion_handler)}; is_continuation(init.completion_handler)};
@@ -752,8 +752,8 @@ async_accept(http::header<true, Fields> const& req,
template<class NextLayer> template<class NextLayer>
template<class Fields, class ConstBufferSequence, template<class Fields, class ConstBufferSequence,
class ResponseDecorator, class AcceptHandler> class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_accept_ex(http::header<true, Fields> const& req, async_accept_ex(http::header<true, Fields> const& req,
ConstBufferSequence const& buffers, ConstBufferSequence const& buffers,
@@ -771,8 +771,8 @@ async_accept_ex(http::header<true, Fields> const& req,
async_completion<AcceptHandler, async_completion<AcceptHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
reset(); reset();
response_op<BEAST_HANDLER_TYPE( response_op<handler_type<
AcceptHandler, void(error_code))>{init.completion_handler, AcceptHandler, void(error_code)>>{init.completion_handler,
*this, req, buffers, decorator, *this, req, buffers, decorator,
beast_asio_helpers::is_continuation( beast_asio_helpers::is_continuation(
init.completion_handler)}; init.completion_handler)};

8
include/beast/websocket/impl/close.ipp
View File

@@ -197,8 +197,8 @@ upcall:
template<class NextLayer> template<class NextLayer>
template<class CloseHandler> template<class CloseHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
CloseHandler, void(error_code)) CloseHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_close(close_reason const& cr, CloseHandler&& handler) async_close(close_reason const& cr, CloseHandler&& handler)
{ {
@@ -206,8 +206,8 @@ async_close(close_reason const& cr, CloseHandler&& handler)
"AsyncStream requirements not met"); "AsyncStream requirements not met");
async_completion<CloseHandler, async_completion<CloseHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
close_op<BEAST_HANDLER_TYPE( close_op<handler_type<
CloseHandler, void(error_code))>{ CloseHandler, void(error_code)>>{
init.completion_handler, *this, cr}; init.completion_handler, *this, cr};
return init.result.get(); return init.result.get();
} }

32
include/beast/websocket/impl/handshake.ipp
View File

@@ -160,8 +160,8 @@ operator()(error_code ec, bool again)
template<class NextLayer> template<class NextLayer>
template<class HandshakeHandler> template<class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_handshake(string_view const& host, async_handshake(string_view const& host,
string_view const& target, string_view const& target,
@@ -171,8 +171,8 @@ async_handshake(string_view const& host,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
async_completion<HandshakeHandler, async_completion<HandshakeHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
handshake_op<BEAST_HANDLER_TYPE( handshake_op<handler_type<
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, nullptr, host, init.completion_handler, *this, nullptr, host,
target, &default_decorate_req}; target, &default_decorate_req};
return init.result.get(); return init.result.get();
@@ -180,8 +180,8 @@ async_handshake(string_view const& host,
template<class NextLayer> template<class NextLayer>
template<class HandshakeHandler> template<class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_handshake(response_type& res, async_handshake(response_type& res,
string_view const& host, string_view const& host,
@@ -192,8 +192,8 @@ async_handshake(response_type& res,
"AsyncStream requirements not met"); "AsyncStream requirements not met");
async_completion<HandshakeHandler, async_completion<HandshakeHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
handshake_op<BEAST_HANDLER_TYPE( handshake_op<handler_type<
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, &res, host, init.completion_handler, *this, &res, host,
target, &default_decorate_req}; target, &default_decorate_req};
return init.result.get(); return init.result.get();
@@ -201,8 +201,8 @@ async_handshake(response_type& res,
template<class NextLayer> template<class NextLayer>
template<class RequestDecorator, class HandshakeHandler> template<class RequestDecorator, class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_handshake_ex(string_view const& host, async_handshake_ex(string_view const& host,
string_view const& target, string_view const& target,
@@ -216,8 +216,8 @@ async_handshake_ex(string_view const& host,
"RequestDecorator requirements not met"); "RequestDecorator requirements not met");
async_completion<HandshakeHandler, async_completion<HandshakeHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
handshake_op<BEAST_HANDLER_TYPE( handshake_op<handler_type<
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, nullptr, host, init.completion_handler, *this, nullptr, host,
target, decorator}; target, decorator};
return init.result.get(); return init.result.get();
@@ -225,8 +225,8 @@ async_handshake_ex(string_view const& host,
template<class NextLayer> template<class NextLayer>
template<class RequestDecorator, class HandshakeHandler> template<class RequestDecorator, class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_handshake_ex(response_type& res, async_handshake_ex(response_type& res,
string_view const& host, string_view const& host,
@@ -241,8 +241,8 @@ async_handshake_ex(response_type& res,
"RequestDecorator requirements not met"); "RequestDecorator requirements not met");
async_completion<HandshakeHandler, async_completion<HandshakeHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
handshake_op<BEAST_HANDLER_TYPE( handshake_op<handler_type<
HandshakeHandler, void(error_code))>{ HandshakeHandler, void(error_code)>>{
init.completion_handler, *this, &res, host, init.completion_handler, *this, &res, host,
target, decorator}; target, decorator};
return init.result.get(); return init.result.get();

16
include/beast/websocket/impl/ping.ipp
View File

@@ -195,8 +195,8 @@ upcall:
template<class NextLayer> template<class NextLayer>
template<class WriteHandler> template<class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_ping(ping_data const& payload, WriteHandler&& handler) async_ping(ping_data const& payload, WriteHandler&& handler)
{ {
@@ -204,16 +204,16 @@ async_ping(ping_data const& payload, WriteHandler&& handler)
"AsyncStream requirements requirements not met"); "AsyncStream requirements requirements not met");
async_completion<WriteHandler, async_completion<WriteHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
ping_op<BEAST_HANDLER_TYPE( ping_op<handler_type<
WriteHandler, void(error_code))>{ WriteHandler, void(error_code)>>{
init.completion_handler, *this, opcode::ping, payload}; init.completion_handler, *this, opcode::ping, payload};
return init.result.get(); return init.result.get();
} }
template<class NextLayer> template<class NextLayer>
template<class WriteHandler> template<class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_pong(ping_data const& payload, WriteHandler&& handler) async_pong(ping_data const& payload, WriteHandler&& handler)
{ {
@@ -221,8 +221,8 @@ async_pong(ping_data const& payload, WriteHandler&& handler)
"AsyncStream requirements requirements not met"); "AsyncStream requirements requirements not met");
async_completion<WriteHandler, async_completion<WriteHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
ping_op<BEAST_HANDLER_TYPE( ping_op<handler_type<
WriteHandler, void(error_code))>{ WriteHandler, void(error_code)>>{
init.completion_handler, *this, opcode::pong, payload}; init.completion_handler, *this, opcode::pong, payload};
return init.result.get(); return init.result.get();
} }

16
include/beast/websocket/impl/read.ipp
View File

@@ -686,8 +686,8 @@ upcall:
template<class NextLayer> template<class NextLayer>
template<class DynamicBuffer, class ReadHandler> template<class DynamicBuffer, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_read_frame(frame_info& fi, async_read_frame(frame_info& fi,
DynamicBuffer& dynabuf, ReadHandler&& handler) DynamicBuffer& dynabuf, ReadHandler&& handler)
@@ -698,8 +698,8 @@ async_read_frame(frame_info& fi,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
async_completion<ReadHandler, async_completion<ReadHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
read_frame_op<DynamicBuffer, BEAST_HANDLER_TYPE( read_frame_op<DynamicBuffer, handler_type<
ReadHandler, void(error_code))>{init.completion_handler, ReadHandler, void(error_code)>>{init.completion_handler,
*this, fi, dynabuf}; *this, fi, dynabuf};
return init.result.get(); return init.result.get();
} }
@@ -1098,8 +1098,8 @@ upcall:
template<class NextLayer> template<class NextLayer>
template<class DynamicBuffer, class ReadHandler> template<class DynamicBuffer, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_read(opcode& op, async_read(opcode& op,
DynamicBuffer& dynabuf, ReadHandler&& handler) DynamicBuffer& dynabuf, ReadHandler&& handler)
@@ -1110,8 +1110,8 @@ async_read(opcode& op,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
async_completion<ReadHandler, async_completion<ReadHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
read_op<DynamicBuffer, BEAST_HANDLER_TYPE( read_op<DynamicBuffer, handler_type<
ReadHandler, void(error_code))>{init.completion_handler, ReadHandler, void(error_code)>>{init.completion_handler,
*this, op, dynabuf}; *this, op, dynabuf};
return init.result.get(); return init.result.get();
} }

16
include/beast/websocket/impl/write.ipp
View File

@@ -545,8 +545,8 @@ upcall:
template<class NextLayer> template<class NextLayer>
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_write_frame(bool fin, async_write_frame(bool fin,
ConstBufferSequence const& bs, WriteHandler&& handler) ConstBufferSequence const& bs, WriteHandler&& handler)
@@ -558,8 +558,8 @@ async_write_frame(bool fin,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
async_completion<WriteHandler, async_completion<WriteHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
write_frame_op<ConstBufferSequence, BEAST_HANDLER_TYPE( write_frame_op<ConstBufferSequence, handler_type<
WriteHandler, void(error_code))>{init.completion_handler, WriteHandler, void(error_code)>>{init.completion_handler,
*this, fin, bs}; *this, fin, bs};
return init.result.get(); return init.result.get();
} }
@@ -895,8 +895,8 @@ operator()(error_code ec, bool again)
template<class NextLayer> template<class NextLayer>
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
stream<NextLayer>:: stream<NextLayer>::
async_write(ConstBufferSequence const& bs, WriteHandler&& handler) async_write(ConstBufferSequence const& bs, WriteHandler&& handler)
{ {
@@ -907,8 +907,8 @@ async_write(ConstBufferSequence const& bs, WriteHandler&& handler)
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
async_completion<WriteHandler, async_completion<WriteHandler,
void(error_code)> init{handler}; void(error_code)> init{handler};
write_op<ConstBufferSequence, BEAST_HANDLER_TYPE( write_op<ConstBufferSequence, handler_type<
WriteHandler, void(error_code))>{ WriteHandler, void(error_code)>>{
init.completion_handler, *this, bs}; init.completion_handler, *this, bs};
return init.result.get(); return init.result.get();
} }

76
include/beast/websocket/stream.hpp
View File

@@ -970,8 +970,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class AcceptHandler> template<class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept(AcceptHandler&& handler); async_accept(AcceptHandler&& handler);
/** Start reading and responding to a WebSocket HTTP Upgrade request. /** Start reading and responding to a WebSocket HTTP Upgrade request.
@@ -1025,8 +1025,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class ResponseDecorator, class AcceptHandler> template<class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept_ex(ResponseDecorator const& decorator, async_accept_ex(ResponseDecorator const& decorator,
AcceptHandler&& handler); AcceptHandler&& handler);
@@ -1079,8 +1079,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class ConstBufferSequence, class AcceptHandler> template<class ConstBufferSequence, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept(ConstBufferSequence const& buffers, async_accept(ConstBufferSequence const& buffers,
AcceptHandler&& handler); AcceptHandler&& handler);
@@ -1143,8 +1143,8 @@ public:
*/ */
template<class ConstBufferSequence, template<class ConstBufferSequence,
class ResponseDecorator, class AcceptHandler> class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept_ex(ConstBufferSequence const& buffers, async_accept_ex(ConstBufferSequence const& buffers,
ResponseDecorator const& decorator, ResponseDecorator const& decorator,
AcceptHandler&& handler); AcceptHandler&& handler);
@@ -1195,8 +1195,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class Fields, class AcceptHandler> template<class Fields, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept(http::header<true, Fields> const& req, async_accept(http::header<true, Fields> const& req,
AcceptHandler&& handler); AcceptHandler&& handler);
@@ -1256,8 +1256,8 @@ public:
*/ */
template<class Fields, template<class Fields,
class ResponseDecorator, class AcceptHandler> class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept_ex(http::header<true, Fields> const& req, async_accept_ex(http::header<true, Fields> const& req,
ResponseDecorator const& decorator, ResponseDecorator const& decorator,
AcceptHandler&& handler); AcceptHandler&& handler);
@@ -1316,8 +1316,8 @@ public:
*/ */
template<class Fields, template<class Fields,
class ConstBufferSequence, class AcceptHandler> class ConstBufferSequence, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept(http::header<true, Fields> const& req, async_accept(http::header<true, Fields> const& req,
ConstBufferSequence const& buffers, ConstBufferSequence const& buffers,
AcceptHandler&& handler); AcceptHandler&& handler);
@@ -1385,8 +1385,8 @@ public:
*/ */
template<class Fields, class ConstBufferSequence, template<class Fields, class ConstBufferSequence,
class ResponseDecorator, class AcceptHandler> class ResponseDecorator, class AcceptHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
AcceptHandler, void(error_code)) AcceptHandler, void(error_code)>
async_accept_ex(http::header<true, Fields> const& req, async_accept_ex(http::header<true, Fields> const& req,
ConstBufferSequence const& buffers, ConstBufferSequence const& buffers,
ResponseDecorator const& decorator, ResponseDecorator const& decorator,
@@ -1863,8 +1863,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class HandshakeHandler> template<class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
async_handshake(string_view const& host, async_handshake(string_view const& host,
string_view const& target, string_view const& target,
HandshakeHandler&& handler); HandshakeHandler&& handler);
@@ -1915,8 +1915,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class HandshakeHandler> template<class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
async_handshake(response_type& res, async_handshake(response_type& res,
string_view const& host, string_view const& host,
string_view const& target, string_view const& target,
@@ -1973,8 +1973,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class RequestDecorator, class HandshakeHandler> template<class RequestDecorator, class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
async_handshake_ex(string_view const& host, async_handshake_ex(string_view const& host,
string_view const& target, string_view const& target,
RequestDecorator const& decorator, RequestDecorator const& decorator,
@@ -2035,8 +2035,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class RequestDecorator, class HandshakeHandler> template<class RequestDecorator, class HandshakeHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code)>
async_handshake_ex(response_type& res, async_handshake_ex(response_type& res,
string_view const& host, string_view const& host,
string_view const& target, string_view const& target,
@@ -2145,8 +2145,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class CloseHandler> template<class CloseHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
CloseHandler, void(error_code)) CloseHandler, void(error_code)>
async_close(close_reason const& cr, CloseHandler&& handler); async_close(close_reason const& cr, CloseHandler&& handler);
/** Send a WebSocket ping frame. /** Send a WebSocket ping frame.
@@ -2223,8 +2223,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class WriteHandler> template<class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_ping(ping_data const& payload, WriteHandler&& handler); async_ping(ping_data const& payload, WriteHandler&& handler);
/** Send a WebSocket pong frame. /** Send a WebSocket pong frame.
@@ -2316,8 +2316,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class WriteHandler> template<class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_pong(ping_data const& payload, WriteHandler&& handler); async_pong(ping_data const& payload, WriteHandler&& handler);
/** Read a message from the stream. /** Read a message from the stream.
@@ -2460,8 +2460,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class DynamicBuffer, class ReadHandler> template<class DynamicBuffer, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
async_read(opcode& op, DynamicBuffer& dynabuf, ReadHandler&& handler); async_read(opcode& op, DynamicBuffer& dynabuf, ReadHandler&& handler);
/** Read a message frame from the stream. /** Read a message frame from the stream.
@@ -2614,8 +2614,8 @@ public:
manner equivalent to using boost::asio::io_service::post(). manner equivalent to using boost::asio::io_service::post().
*/ */
template<class DynamicBuffer, class ReadHandler> template<class DynamicBuffer, class ReadHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
ReadHandler, void(error_code)) ReadHandler, void(error_code)>
async_read_frame(frame_info& fi, async_read_frame(frame_info& fi,
DynamicBuffer& dynabuf, ReadHandler&& handler); DynamicBuffer& dynabuf, ReadHandler&& handler);
@@ -2736,8 +2736,8 @@ public:
manner equivalent to using `boost::asio::io_service::post`. manner equivalent to using `boost::asio::io_service::post`.
*/ */
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_write(ConstBufferSequence const& buffers, async_write(ConstBufferSequence const& buffers,
WriteHandler&& handler); WriteHandler&& handler);
@@ -2848,8 +2848,8 @@ public:
); @endcode ); @endcode
*/ */
template<class ConstBufferSequence, class WriteHandler> template<class ConstBufferSequence, class WriteHandler>
BEAST_INITFN_RESULT_TYPE( async_return_type<
WriteHandler, void(error_code)) WriteHandler, void(error_code)>
async_write_frame(bool fin, async_write_frame(bool fin,
ConstBufferSequence const& buffers, WriteHandler&& handler); ConstBufferSequence const& buffers, WriteHandler&& handler);