boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-07-29 20:37:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

get_executor() works on initiation objects

Browse Source 
This is required for the new `asio::cancel_at` and `asio::cancel_after`
completion token adapters to work.
This commit is contained in:
Mohammad Nejati
2024-07-04 10:24:42 +00:00
committed by Mohammad Nejati
parent 1a2b85b7a4
commit 75812db90a
16 changed files with 344 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
include/boost/beast/_experimental/http/impl/icy_stream.hpp
View File

@ -167,11 +167,20 @@ public:
struct run_read_op
{
icy_stream* self;
using executor_type = typename icy_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<class ReadHandler, class Buffers>
void
operator()(
ReadHandler&& h,
icy_stream* s,
Buffers const& b)
{
// If you get an error on the following line it means
@ -186,7 +195,7 @@ struct run_read_op
read_op<
Buffers,
typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), *s, b);
std::forward<ReadHandler>(h), *self, b);
}
};
@ -292,9 +301,8 @@ async_read_some(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
typename ops::run_read_op{},
typename ops::run_read_op{this},
handler,
this,
buffers);
}

72
include/boost/beast/_experimental/test/impl/stream.hpp
View File

@ -27,7 +27,27 @@ namespace boost {
namespace beast {
namespace test {
//------------------------------------------------------------------------------
namespace detail
{
template<class To>
struct extract_executor_op
{
To operator()(net::any_io_executor& ex) const
{
assert(ex.template target<To>());
return *ex.template target<To>();
}
};
template<>
struct extract_executor_op<net::any_io_executor>
{
net::any_io_executor operator()(net::any_io_executor& ex) const
{
return ex;
}
};
} // detail
template<class Executor>
template<class Handler, class Buffers>
@ -163,13 +183,22 @@ public:
template<class Executor>
struct basic_stream<Executor>::run_read_op
{
boost::shared_ptr<detail::stream_state> const& in;
using executor_type = typename basic_stream::executor_type;
executor_type
get_executor() const noexcept
{
return detail::extract_executor_op<Executor>()(in->exec);
}
template<
class ReadHandler,
class MutableBufferSequence>
void
operator()(
ReadHandler&& h,
boost::shared_ptr<detail::stream_state> const& in,
MutableBufferSequence const& buffers)
{
// If you get an error on the following line it means
@ -197,13 +226,22 @@ struct basic_stream<Executor>::run_read_op
template<class Executor>
struct basic_stream<Executor>::run_write_op
{
boost::shared_ptr<detail::stream_state> const& in_;
using executor_type = typename basic_stream::executor_type;
executor_type
get_executor() const noexcept
{
return detail::extract_executor_op<Executor>()(in_->exec);
}
template<
class WriteHandler,
class ConstBufferSequence>
void
operator()(
WriteHandler&& h,
boost::shared_ptr<detail::stream_state> in_,
boost::weak_ptr<detail::stream_state> out_,
ConstBufferSequence const& buffers)
{
@ -336,9 +374,8 @@ async_read_some(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
run_read_op{},
run_read_op{in_},
handler,
in_,
buffers);
}
@ -420,9 +457,8 @@ async_write_some(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
run_write_op{},
run_write_op{in_},
handler,
in_,
out_,
buffers);
}
@ -467,28 +503,6 @@ connect(stream& to, Arg1&& arg1, ArgN&&... argn)
return from;
}
namespace detail
{
template<class To>
struct extract_executor_op
{
To operator()(net::any_io_executor& ex) const
{
assert(ex.template target<To>());
return *ex.template target<To>();
}
};
template<>
struct extract_executor_op<net::any_io_executor>
{
net::any_io_executor operator()(net::any_io_executor& ex) const
{
return ex;
}
};
}
template<class Executor>
auto basic_stream<Executor>::get_executor() noexcept -> executor_type
{

18
include/boost/beast/core/detail/impl/read.hpp
View File

@ -104,17 +104,26 @@ public:
//------------------------------------------------------------------------------
template <typename AsyncReadStream>
struct run_read_op
{
AsyncReadStream* stream;
using executor_type = typename AsyncReadStream::executor_type;
executor_type
get_executor() const noexcept
{
return stream->get_executor();
}
template<
class AsyncReadStream,
class DynamicBuffer,
class Condition,
class ReadHandler>
void
operator()(
ReadHandler&& h,
AsyncReadStream* s,
DynamicBuffer* b,
Condition&& c)
{
@ -133,7 +142,7 @@ struct run_read_op
typename std::decay<Condition>::type,
typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h),
*s,
*stream,
*b,
std::forward<Condition>(c));
}
@ -234,9 +243,8 @@ async_read(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
typename dynamic_read_ops::run_read_op{},
typename dynamic_read_ops::run_read_op<AsyncReadStream>{&stream},
handler,
&stream,
&buffer,
std::forward<CompletionCondition>(cond));
}

21
include/boost/beast/core/detect_ssl.hpp
View File

@ -348,6 +348,7 @@ class detect_ssl_op;
// authors of composed operations need to write it this way to get the
// very best performance, for example when using Coroutines TS (`co_await`).
template <typename AsyncReadStream>
struct run_detect_ssl_op
{
// The implementation of `net::async_initiate` captures the
@ -361,20 +362,29 @@ struct run_detect_ssl_op
// token into the "real handler" which must have the correct
// signature, in this case `void(error_code, boost::tri_bool)`.
AsyncReadStream* stream;
using executor_type = typename AsyncReadStream::executor_type;
executor_type
get_executor() const noexcept
{
return stream->get_executor();
}
template<
class DetectHandler,
class AsyncReadStream,
class DynamicBuffer>
void operator()(
void
operator()(
DetectHandler&& h,
AsyncReadStream* s, // references are passed as pointers
DynamicBuffer* b)
{
detect_ssl_op<
typename std::decay<DetectHandler>::type,
AsyncReadStream,
DynamicBuffer>(
std::forward<DetectHandler>(h), *s, *b);
std::forward<DetectHandler>(h), *stream, *b);
}
};
@ -423,9 +433,8 @@ async_detect_ssl(
return net::async_initiate<
CompletionToken,
void(error_code, bool)>(
detail::run_detect_ssl_op{},
detail::run_detect_ssl_op<AsyncReadStream>{&stream},
token,
&stream, // pass the reference by pointer
&buffer);
}

86
include/boost/beast/core/impl/basic_stream.hpp
View File

@ -606,11 +606,20 @@ public:
struct run_read_op
{
basic_stream* self;
using executor_type = typename basic_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<class ReadHandler, class Buffers>
void
operator()(
ReadHandler&& h,
basic_stream* s,
Buffers const& b)
{
// If you get an error on the following line it means
@ -626,17 +635,26 @@ struct run_read_op
true,
Buffers,
typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), *s, b);
std::forward<ReadHandler>(h), *self, b);
}
};
struct run_write_op
{
basic_stream* self;
using executor_type = typename basic_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<class WriteHandler, class Buffers>
void
operator()(
WriteHandler&& h,
basic_stream* s,
Buffers const& b)
{
// If you get an error on the following line it means
@ -652,17 +670,26 @@ struct run_write_op
false,
Buffers,
typename std::decay<WriteHandler>::type>(
std::forward<WriteHandler>(h), *s, b);
std::forward<WriteHandler>(h), *self, b);
}
};
struct run_connect_op
{
basic_stream* self;
using executor_type = typename basic_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<class ConnectHandler>
void
operator()(
ConnectHandler&& h,
basic_stream* s,
endpoint_type const& ep)
{
// If you get an error on the following line it means
@ -675,12 +702,22 @@ struct run_connect_op
"ConnectHandler type requirements not met");
connect_op<typename std::decay<ConnectHandler>::type>(
std::forward<ConnectHandler>(h), *s, ep);
std::forward<ConnectHandler>(h), *self, ep);
}
};
struct run_connect_range_op
{
basic_stream* self;
using executor_type = typename basic_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<
class RangeConnectHandler,
class EndpointSequence,
@ -688,7 +725,6 @@ struct run_connect_range_op
void
operator()(
RangeConnectHandler&& h,
basic_stream* s,
EndpointSequence const& eps,
Condition const& cond)
{
@ -702,12 +738,22 @@ struct run_connect_range_op
"RangeConnectHandler type requirements not met");
connect_op<typename std::decay<RangeConnectHandler>::type>(
std::forward<RangeConnectHandler>(h), *s, eps, cond);
std::forward<RangeConnectHandler>(h), *self, eps, cond);
}
};
struct run_connect_iter_op
{
basic_stream* self;
using executor_type = typename basic_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<
class IteratorConnectHandler,
class Iterator,
@ -715,7 +761,6 @@ struct run_connect_iter_op
void
operator()(
IteratorConnectHandler&& h,
basic_stream* s,
Iterator begin, Iterator end,
Condition const& cond)
{
@ -729,7 +774,7 @@ struct run_connect_iter_op
"IteratorConnectHandler type requirements not met");
connect_op<typename std::decay<IteratorConnectHandler>::type>(
std::forward<IteratorConnectHandler>(h), *s, begin, end, cond);
std::forward<IteratorConnectHandler>(h), *self, begin, end, cond);
}
};
@ -895,9 +940,8 @@ async_connect(
return net::async_initiate<
ConnectHandler,
void(error_code)>(
typename ops::run_connect_op{},
typename ops::run_connect_op{this},
handler,
this,
ep);
}
@ -916,9 +960,8 @@ async_connect(
return net::async_initiate<
RangeConnectHandler,
void(error_code, typename Protocol::endpoint)>(
typename ops::run_connect_range_op{},
typename ops::run_connect_range_op{this},
handler,
this,
endpoints,
detail::any_endpoint{});
}
@ -940,9 +983,8 @@ async_connect(
return net::async_initiate<
RangeConnectHandler,
void(error_code, typename Protocol::endpoint)>(
typename ops::run_connect_range_op{},
typename ops::run_connect_range_op{this},
handler,
this,
endpoints,
connect_condition);
}
@ -961,9 +1003,8 @@ async_connect(
return net::async_initiate<
IteratorConnectHandler,
void(error_code, Iterator)>(
typename ops::run_connect_iter_op{},
typename ops::run_connect_iter_op{this},
handler,
this,
begin, end,
detail::any_endpoint{});
}
@ -984,9 +1025,8 @@ async_connect(
return net::async_initiate<
IteratorConnectHandler,
void(error_code, Iterator)>(
typename ops::run_connect_iter_op{},
typename ops::run_connect_iter_op{this},
handler,
this,
begin, end,
connect_condition);
}
@ -1007,9 +1047,8 @@ async_read_some(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
typename ops::run_read_op{},
typename ops::run_read_op{this},
handler,
this,
buffers);
}
@ -1027,9 +1066,8 @@ async_write_some(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
typename ops::run_write_op{},
typename ops::run_write_op{this},
handler,
this,
buffers);
}

16
include/boost/beast/core/impl/buffered_read_stream.hpp
View File

@ -106,11 +106,20 @@ public:
struct run_read_op
{
buffered_read_stream* self;
using executor_type = typename buffered_read_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<class ReadHandler, class Buffers>
void
operator()(
ReadHandler&& h,
buffered_read_stream* s,
Buffers const* b)
{
// If you get an error on the following line it means
@ -125,7 +134,7 @@ struct run_read_op
read_op<
Buffers,
typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), *s, *b);
std::forward<ReadHandler>(h), *self, *b);
}
};
@ -231,9 +240,8 @@ async_read_some(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
typename ops::run_read_op{},
typename ops::run_read_op{this},
handler,
this,
&buffers);
}

16
include/boost/beast/core/impl/flat_stream.hpp
View File

@ -85,11 +85,20 @@ public:
struct run_write_op
{
flat_stream* self;
using executor_type = typename flat_stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->get_executor();
}
template<class WriteHandler, class Buffers>
void
operator()(
WriteHandler&& h,
flat_stream* s,
Buffers const& b)
{
// If you get an error on the following line it means
@ -103,7 +112,7 @@ struct run_write_op
write_op<
typename std::decay<WriteHandler>::type>(
std::forward<WriteHandler>(h), *s, b);
std::forward<WriteHandler>(h), *self, b);
}
};
@ -250,9 +259,8 @@ async_write_some(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
typename ops::run_write_op{},
typename ops::run_write_op{this},
handler,
this,
buffers);
}

23
include/boost/beast/http/impl/file_body_win32.hpp
View File

@ -509,17 +509,23 @@ public:
}
};
template<class Protocol, class Executor>
struct run_write_some_win32_op
{
template<
class Protocol, class Executor,
bool isRequest, class Fields,
class WriteHandler>
net::basic_stream_socket<Protocol, Executor>* stream;
using executor_type = typename net::basic_stream_socket<Protocol, Executor>::executor_type;
executor_type
get_executor() const noexcept
{
return stream->get_executor();
}
template<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)
{
@ -536,7 +542,7 @@ struct run_write_some_win32_op
Protocol, Executor,
isRequest, Fields,
typename std::decay<WriteHandler>::type>(
std::forward<WriteHandler>(h), *s, *sr);
std::forward<WriteHandler>(h), *stream, *sr);
}
};
@ -629,9 +635,8 @@ async_write_some(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
detail::run_write_some_win32_op{},
detail::run_write_some_win32_op<Protocol, Executor>{&sock},
handler,
&sock,
&sr);
}

19
include/boost/beast/http/impl/read.hpp
View File

@ -116,17 +116,26 @@ public:
}
};
template <typename AsyncReadStream>
struct run_read_msg_op
{
AsyncReadStream* stream;
using executor_type = typename AsyncReadStream::executor_type;
executor_type
get_executor() const noexcept
{
return stream->get_executor();
}
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)
@ -145,7 +154,7 @@ struct run_read_msg_op
DynamicBuffer,
isRequest, Body, Allocator,
typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), *s, *b, *m);
std::forward<ReadHandler>(h), *stream, *b, *m);
}
};
@ -710,8 +719,8 @@ async_read(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
detail::run_read_msg_op{},
handler, &stream, &buffer, &msg);
detail::run_read_msg_op<AsyncReadStream>{&stream},
handler, &buffer, &msg);
}
} // http

72
include/boost/beast/http/impl/write.hpp
View File

@ -299,16 +299,25 @@ public:
}
};
template <typename AsyncWriteStream>
struct run_write_some_op
{
AsyncWriteStream* stream;
using executor_type = typename AsyncWriteStream::executor_type;
executor_type
get_executor() const noexcept
{
return stream->get_executor();
}
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
@ -322,23 +331,32 @@ struct run_write_some_op
write_some_op<
typename std::decay<WriteHandler>::type,
Stream,
AsyncWriteStream,
isRequest, Body, Fields>(
std::forward<WriteHandler>(h), *s, *sr);
std::forward<WriteHandler>(h), *stream, *sr);
}
};
template <typename AsyncWriteStream>
struct run_write_op
{
AsyncWriteStream* stream;
using executor_type = typename AsyncWriteStream::executor_type;
executor_type
get_executor() const noexcept
{
return stream->get_executor();
}
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)
{
@ -353,24 +371,33 @@ struct run_write_op
write_op<
typename std::decay<WriteHandler>::type,
Stream,
AsyncWriteStream,
Predicate,
isRequest, Body, Fields>(
std::forward<WriteHandler>(h), *s, *sr);
std::forward<WriteHandler>(h), *stream, *sr);
}
};
template <typename AsyncWriteStream>
struct run_write_msg_op
{
AsyncWriteStream* stream;
using executor_type = typename AsyncWriteStream::executor_type;
executor_type
get_executor() const noexcept
{
return stream->get_executor();
}
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)
@ -386,21 +413,19 @@ struct run_write_msg_op
write_msg_op<
typename std::decay<WriteHandler>::type,
Stream,
AsyncWriteStream,
isRequest, Body, Fields>(
std::forward<WriteHandler>(h), *s, *m,
std::forward<WriteHandler>(h), *stream, *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)
@ -416,9 +441,9 @@ struct run_write_msg_op
write_msg_op<
typename std::decay<WriteHandler>::type,
Stream,
AsyncWriteStream,
isRequest, Body, Fields>(
std::forward<WriteHandler>(h), *s, *m,
std::forward<WriteHandler>(h), *stream, *m,
std::forward<Args>(args)...);
}
};
@ -513,9 +538,8 @@ async_write_some_impl(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
run_write_some_op{},
run_write_some_op<AsyncWriteStream>{&stream},
handler,
&stream,
&sr);
}
@ -666,9 +690,8 @@ async_write_header(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
detail::run_write_op{},
detail::run_write_op<AsyncWriteStream>{&stream},
handler,
&stream,
detail::serializer_is_header_done{},
&sr);
}
@ -739,9 +762,8 @@ async_write(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
detail::run_write_op{},
detail::run_write_op<AsyncWriteStream>{&stream},
handler,
&stream,
detail::serializer_is_done{},
&sr);
}
@ -860,9 +882,8 @@ async_write(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
detail::run_write_msg_op{},
detail::run_write_msg_op<AsyncWriteStream>{&stream},
handler,
&stream,
&msg,
std::false_type{});
}
@ -889,9 +910,8 @@ async_write(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
detail::run_write_msg_op{},
detail::run_write_msg_op<AsyncWriteStream>{&stream},
handler,
&stream,
&msg,
std::true_type{});
}

35
include/boost/beast/websocket/impl/accept.hpp
View File

@ -368,6 +368,16 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_response_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<
class AcceptHandler,
class Body, class Allocator,
@ -375,7 +385,6 @@ struct stream<NextLayer, deflateSupported>::
void
operator()(
AcceptHandler&& h,
boost::shared_ptr<impl_type> const& sp,
http::request<Body,
http::basic_fields<Allocator>> const* m,
Decorator const& d)
@ -391,7 +400,7 @@ struct stream<NextLayer, deflateSupported>::
response_op<
typename std::decay<AcceptHandler>::type>(
std::forward<AcceptHandler>(h), sp, *m, d);
std::forward<AcceptHandler>(h), self, *m, d);
}
};
@ -399,6 +408,16 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_accept_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<
class AcceptHandler,
class Decorator,
@ -406,7 +425,6 @@ struct stream<NextLayer, deflateSupported>::
void
operator()(
AcceptHandler&& h,
boost::shared_ptr<impl_type> const& sp,
Decorator const& d,
Buffers const& b)
{
@ -423,7 +441,7 @@ struct stream<NextLayer, deflateSupported>::
typename std::decay<AcceptHandler>::type,
Decorator>(
std::forward<AcceptHandler>(h),
sp,
self,
d,
b);
}
@ -615,9 +633,8 @@ async_accept(
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_accept_op{},
run_accept_op{impl_},
handler,
impl_,
&default_decorate_res,
net::const_buffer{});
}
@ -648,9 +665,8 @@ async_accept(
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_accept_op{},
run_accept_op{impl_},
handler,
impl_,
&default_decorate_res,
buffers);
}
@ -671,9 +687,8 @@ async_accept(
return net::async_initiate<
AcceptHandler,
void(error_code)>(
run_response_op{},
run_response_op{impl_},
handler,
impl_,
&req,
&default_decorate_res);
}

16
include/boost/beast/websocket/impl/close.hpp
View File

@ -302,11 +302,20 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_close_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<class CloseHandler>
void
operator()(
CloseHandler&& h,
boost::shared_ptr<impl_type> const& sp,
close_reason const& cr)
{
// If you get an error on the following line it means
@ -321,7 +330,7 @@ struct stream<NextLayer, deflateSupported>::
close_op<
typename std::decay<CloseHandler>::type>(
std::forward<CloseHandler>(h),
sp,
self,
cr);
}
};
@ -458,9 +467,8 @@ async_close(close_reason const& cr, CloseHandler&& handler)
return net::async_initiate<
CloseHandler,
void(error_code)>(
run_close_op{},
run_close_op{impl_},
handler,
impl_,
cr);
}

19
include/boost/beast/websocket/impl/handshake.hpp
View File

@ -188,10 +188,19 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_handshake_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<class HandshakeHandler>
void operator()(
HandshakeHandler&& h,
boost::shared_ptr<impl_type> const& sp,
request_type&& req,
detail::sec_ws_key_type key,
response_type* res_p)
@ -208,7 +217,7 @@ struct stream<NextLayer, deflateSupported>::
handshake_op<
typename std::decay<HandshakeHandler>::type>(
std::forward<HandshakeHandler>(h),
sp, std::move(req), key, res_p);
self, std::move(req), key, res_p);
}
};
@ -311,9 +320,8 @@ async_handshake(
return net::async_initiate<
HandshakeHandler,
void(error_code)>(
run_handshake_op{},
run_handshake_op{impl_},
handler,
impl_,
std::move(req),
key,
nullptr);
@ -338,9 +346,8 @@ async_handshake(
return net::async_initiate<
HandshakeHandler,
void(error_code)>(
run_handshake_op{},
run_handshake_op{impl_},
handler,
impl_,
std::move(req),
key,
&res);

19
include/boost/beast/websocket/impl/ping.hpp
View File

@ -245,11 +245,20 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_ping_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<class WriteHandler>
void
operator()(
WriteHandler&& h,
boost::shared_ptr<impl_type> const& sp,
detail::opcode op,
ping_data const& p)
{
@ -265,7 +274,7 @@ struct stream<NextLayer, deflateSupported>::
ping_op<
typename std::decay<WriteHandler>::type>(
std::forward<WriteHandler>(h),
sp,
self,
op,
p);
}
@ -336,9 +345,8 @@ async_ping(ping_data const& payload, PingHandler&& handler)
return net::async_initiate<
PingHandler,
void(error_code)>(
run_ping_op{},
run_ping_op{impl_},
handler,
impl_,
detail::opcode::ping,
payload);
}
@ -354,9 +362,8 @@ async_pong(ping_data const& payload, PongHandler&& handler)
return net::async_initiate<
PongHandler,
void(error_code)>(
run_ping_op{},
run_ping_op{impl_},
handler,
impl_,
detail::opcode::pong,
payload);
}

35
include/boost/beast/websocket/impl/read.hpp
View File

@ -819,13 +819,22 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_read_some_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<
class ReadHandler,
class MutableBufferSequence>
void
operator()(
ReadHandler&& h,
boost::shared_ptr<impl_type> const& sp,
MutableBufferSequence const& b)
{
// If you get an error on the following line it means
@ -841,7 +850,7 @@ struct stream<NextLayer, deflateSupported>::
typename std::decay<ReadHandler>::type,
MutableBufferSequence>(
std::forward<ReadHandler>(h),
sp,
self,
b);
}
};
@ -850,13 +859,22 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_read_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<
class ReadHandler,
class DynamicBuffer>
void
operator()(
ReadHandler&& h,
boost::shared_ptr<impl_type> const& sp,
DynamicBuffer* b,
std::size_t limit,
bool some)
@ -874,7 +892,7 @@ struct stream<NextLayer, deflateSupported>::
typename std::decay<ReadHandler>::type,
DynamicBuffer>(
std::forward<ReadHandler>(h),
sp,
self,
*b,
limit,
some);
@ -937,9 +955,8 @@ async_read(DynamicBuffer& buffer, ReadHandler&& handler)
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
run_read_op{},
run_read_op{impl_},
handler,
impl_,
&buffer,
0,
false);
@ -1014,9 +1031,8 @@ async_read_some(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
run_read_op{},
run_read_op{impl_},
handler,
impl_,
&buffer,
limit,
true);
@ -1395,9 +1411,8 @@ async_read_some(
return net::async_initiate<
ReadHandler,
void(error_code, std::size_t)>(
run_read_some_op{},
run_read_some_op{impl_},
handler,
impl_,
buffers);
}

19
include/boost/beast/websocket/impl/write.hpp
View File

@ -559,13 +559,22 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>::
run_write_some_op
{
boost::shared_ptr<impl_type> const& self;
using executor_type = typename stream::executor_type;
executor_type
get_executor() const noexcept
{
return self->stream().get_executor();
}
template<
class WriteHandler,
class ConstBufferSequence>
void
operator()(
WriteHandler&& h,
boost::shared_ptr<impl_type> const& sp,
bool fin,
ConstBufferSequence const& b)
{
@ -582,7 +591,7 @@ struct stream<NextLayer, deflateSupported>::
typename std::decay<WriteHandler>::type,
ConstBufferSequence>(
std::forward<WriteHandler>(h),
sp,
self,
fin,
b);
}
@ -836,9 +845,8 @@ async_write_some(bool fin,
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
run_write_some_op{},
run_write_some_op{impl_},
handler,
impl_,
fin,
bs);
}
@ -892,9 +900,8 @@ async_write(
return net::async_initiate<
WriteHandler,
void(error_code, std::size_t)>(
run_write_some_op{},
run_write_some_op{impl_},
handler,
impl_,
true,
bs);
}