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

Pass references as pointers to async_initiate

Browse Source
This commit is contained in:
Vinnie Falco
2019-02-26 07:17:24 -08:00
parent ab9a4c66e0
commit 7953ac281f
18 changed files with 165 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -3,6 +3,7 @@ Version 221:
* Rename to async_base, stable_async_base * Rename to async_base, stable_async_base
* role_type is in boost/beast/core/role.hpp (API Change) * role_type is in boost/beast/core/role.hpp (API Change)
* Cleanup in test::stream internals * Cleanup in test::stream internals
* Pass references as pointers to async_initiate
Actions Required: Actions Required:

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

@ -304,7 +304,7 @@ struct run_read_op
void void
operator()( operator()(
ReadHandler&& h, ReadHandler&& h,
icy_stream& s, icy_stream* s,
Buffers const& b) Buffers const& b)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -319,7 +319,7 @@ struct run_read_op
read_op< read_op<
Buffers, Buffers,
typename std::decay<ReadHandler>::type>( typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), s, b); std::forward<ReadHandler>(h), *s, b);
} }
}; };
@ -490,7 +490,7 @@ async_read_some(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
typename ops::run_read_op{}, typename ops::run_read_op{},
handler, handler,
*this, this,
buffers); buffers);
} }

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

@ -114,7 +114,7 @@ struct stream::run_read_op
void void
operator()( operator()(
ReadHandler&& h, ReadHandler&& h,
stream& s, std::shared_ptr<state> const& in,
MutableBufferSequence const& buffers) MutableBufferSequence const& buffers)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -126,13 +126,14 @@ struct stream::run_read_op
void(error_code, std::size_t)>::value, void(error_code, std::size_t)>::value,
"ReadHandler type requirements not met"); "ReadHandler type requirements not met");
s.initiate_read( initiate_read(
in,
std::unique_ptr<read_op_base>{ std::unique_ptr<read_op_base>{
new read_op< new read_op<
typename std::decay<ReadHandler>::type, typename std::decay<ReadHandler>::type,
MutableBufferSequence>( MutableBufferSequence>(
std::move(h), std::move(h),
*s.in_, *in,
buffers)}, buffers)},
buffer_size(buffers)); buffer_size(buffers));
} }
@ -278,7 +279,7 @@ async_read_some(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
run_read_op{}, run_read_op{},
handler, handler,
*this, in_,
buffers); buffers);
} }

2
include/boost/beast/_experimental/test/impl/stream.ipp
View File

@ -21,7 +21,9 @@ namespace beast {
namespace test { namespace test {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void stream::initiate_read( void stream::initiate_read(
std::shared_ptr<state> const& in_,
std::unique_ptr<stream::read_op_base>&& op, std::unique_ptr<stream::read_op_base>&& op,
std::size_t buf_size) std::size_t buf_size)
{ {

36
include/boost/beast/_experimental/test/stream.hpp
View File

@ -96,19 +96,10 @@ namespace test {
*/ */
class stream class stream
{ {
struct read_op_base struct state;
{
virtual ~read_op_base() = default;
virtual void operator()(error_code ec) = 0;
};
BOOST_BEAST_DECL void initiate_read(std::unique_ptr<read_op_base>&& op, std::size_t buf_size); std::shared_ptr<state> in_;
std::weak_ptr<state> out_;
template<class Handler, class Buffers>
class read_op;
struct run_read_op;
struct run_write_op;
enum class status enum class status
{ {
@ -116,6 +107,12 @@ class stream
eof, eof,
}; };
struct read_op_base
{
virtual ~read_op_base() = default;
virtual void operator()(error_code ec) = 0;
};
struct state struct state
{ {
friend class stream; friend class stream;
@ -146,8 +143,19 @@ class stream
notify_read(); notify_read();
}; };
std::shared_ptr<state> in_; template<class Handler, class Buffers>
std::weak_ptr<state> out_; class read_op;
struct run_read_op;
struct run_write_op;
BOOST_BEAST_DECL
static
void
initiate_read(
std::shared_ptr<state> const& in,
std::unique_ptr<read_op_base>&& op,
std::size_t buf_size);
public: public:
using buffer_type = flat_buffer; using buffer_type = flat_buffer;

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

@ -119,8 +119,8 @@ struct run_read_op
void void
operator()( operator()(
ReadHandler&& h, ReadHandler&& h,
AsyncReadStream& s, AsyncReadStream* s,
DynamicBuffer& b, DynamicBuffer* b,
Condition&& c) Condition&& c)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -138,8 +138,8 @@ struct run_read_op
typename std::decay<Condition>::type, typename std::decay<Condition>::type,
typename std::decay<ReadHandler>::type>( typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), std::forward<ReadHandler>(h),
s, *s,
b, *b,
std::forward<Condition>(c)); std::forward<Condition>(c));
} }
@ -248,8 +248,8 @@ async_read(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
typename dynamic_read_ops::run_read_op{}, typename dynamic_read_ops::run_read_op{},
handler, handler,
stream, &stream,
buffer, &buffer,
std::forward<CompletionCondition>(cond)); std::forward<CompletionCondition>(cond));
} }

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

@ -370,16 +370,14 @@ struct run_detect_ssl_op
class DynamicBuffer> class DynamicBuffer>
void operator()( void operator()(
DetectHandler&& h, DetectHandler&& h,
AsyncReadStream& s, AsyncReadStream* s, // references are passed as pointers
DynamicBuffer& b) DynamicBuffer& b)
{ {
detect_ssl_op< detect_ssl_op<
typename std::decay<DetectHandler>::type, typename std::decay<DetectHandler>::type,
AsyncReadStream, AsyncReadStream,
DynamicBuffer>( DynamicBuffer>(
std::forward<DetectHandler>(h), std::forward<DetectHandler>(h), *s, b);
s,
b);
} }
}; };
@ -423,14 +421,18 @@ async_detect_ssl(
// `net::async_result` for the type of `CompletionToken`, // `net::async_result` for the type of `CompletionToken`,
// the `initiation` object will be invoked with the saved // the `initiation` object will be invoked with the saved
// parameters and the actual completion handler. Our // parameters and the actual completion handler. Our
// initiating object is `run_detect_ssl_op` // initiating object is `run_detect_ssl_op`.
//
// Non-const references need to be passed as pointers,
// since we don't want a decay-copy.
return net::async_initiate< return net::async_initiate<
CompletionToken, CompletionToken,
void(error_code, boost::tribool)>( void(error_code, boost::tribool)>(
detail::run_detect_ssl_op{}, detail::run_detect_ssl_op{},
token, token,
stream, &stream, // pass the reference by pointer
buffer); buffer);
} }

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

@ -538,7 +538,7 @@ struct run_read_op
void void
operator()( operator()(
ReadHandler&& h, ReadHandler&& h,
basic_stream& s, basic_stream* s,
Buffers const& b) Buffers const& b)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -554,7 +554,7 @@ struct run_read_op
true, true,
Buffers, Buffers,
typename std::decay<ReadHandler>::type>( typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), s, b); std::forward<ReadHandler>(h), *s, b);
} }
}; };
@ -564,7 +564,7 @@ struct run_write_op
void void
operator()( operator()(
WriteHandler&& h, WriteHandler&& h,
basic_stream& s, basic_stream* s,
Buffers const& b) Buffers const& b)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -580,7 +580,7 @@ struct run_write_op
false, false,
Buffers, Buffers,
typename std::decay<WriteHandler>::type>( typename std::decay<WriteHandler>::type>(
std::forward<WriteHandler>(h), s, b); std::forward<WriteHandler>(h), *s, b);
} }
}; };
@ -590,7 +590,7 @@ struct run_connect_op
void void
operator()( operator()(
ConnectHandler&& h, ConnectHandler&& h,
basic_stream& s, basic_stream* s,
endpoint_type const& ep) endpoint_type const& ep)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -603,7 +603,7 @@ struct run_connect_op
"ConnectHandler type requirements not met"); "ConnectHandler type requirements not met");
connect_op<typename std::decay<ConnectHandler>::type>( connect_op<typename std::decay<ConnectHandler>::type>(
std::forward<ConnectHandler>(h), s, ep); std::forward<ConnectHandler>(h), *s, ep);
} }
}; };
@ -616,7 +616,7 @@ struct run_connect_range_op
void void
operator()( operator()(
RangeConnectHandler&& h, RangeConnectHandler&& h,
basic_stream& s, basic_stream* s,
EndpointSequence const& eps, EndpointSequence const& eps,
Condition const& cond) Condition const& cond)
{ {
@ -630,7 +630,7 @@ struct run_connect_range_op
"RangeConnectHandler type requirements not met"); "RangeConnectHandler type requirements not met");
connect_op<typename std::decay<RangeConnectHandler>::type>( connect_op<typename std::decay<RangeConnectHandler>::type>(
std::forward<RangeConnectHandler>(h), s, eps, cond); std::forward<RangeConnectHandler>(h), *s, eps, cond);
} }
}; };
@ -643,7 +643,7 @@ struct run_connect_iter_op
void void
operator()( operator()(
IteratorConnectHandler&& h, IteratorConnectHandler&& h,
basic_stream& s, basic_stream* s,
Iterator begin, Iterator end, Iterator begin, Iterator end,
Condition const& cond) Condition const& cond)
{ {
@ -657,7 +657,7 @@ struct run_connect_iter_op
"IteratorConnectHandler type requirements not met"); "IteratorConnectHandler type requirements not met");
connect_op<typename std::decay<IteratorConnectHandler>::type>( connect_op<typename std::decay<IteratorConnectHandler>::type>(
std::forward<IteratorConnectHandler>(h), s, begin, end, cond); std::forward<IteratorConnectHandler>(h), *s, begin, end, cond);
} }
}; };
@ -813,7 +813,7 @@ async_connect(
void(error_code)>( void(error_code)>(
typename ops::run_connect_op{}, typename ops::run_connect_op{},
handler, handler,
*this, this,
ep); ep);
} }
@ -834,7 +834,7 @@ async_connect(
void(error_code, typename Protocol::endpoint)>( void(error_code, typename Protocol::endpoint)>(
typename ops::run_connect_range_op{}, typename ops::run_connect_range_op{},
handler, handler,
*this, this,
endpoints, endpoints,
detail::any_endpoint{}); detail::any_endpoint{});
} }
@ -858,7 +858,7 @@ async_connect(
void(error_code, typename Protocol::endpoint)>( void(error_code, typename Protocol::endpoint)>(
typename ops::run_connect_range_op{}, typename ops::run_connect_range_op{},
handler, handler,
*this, this,
endpoints, endpoints,
connect_condition); connect_condition);
} }
@ -879,7 +879,7 @@ async_connect(
void(error_code, Iterator)>( void(error_code, Iterator)>(
typename ops::run_connect_iter_op{}, typename ops::run_connect_iter_op{},
handler, handler,
*this, this,
begin, end, begin, end,
detail::any_endpoint{}); detail::any_endpoint{});
} }
@ -902,7 +902,7 @@ async_connect(
void(error_code, Iterator)>( void(error_code, Iterator)>(
typename ops::run_connect_iter_op{}, typename ops::run_connect_iter_op{},
handler, handler,
*this, this,
begin, end, begin, end,
connect_condition); connect_condition);
} }
@ -926,7 +926,7 @@ async_read_some(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
typename ops::run_read_op{}, typename ops::run_read_op{},
handler, handler,
*this, this,
buffers); buffers);
} }
@ -947,7 +947,7 @@ async_write_some(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
typename ops::run_write_op{}, typename ops::run_write_op{},
handler, handler,
*this, this,
buffers); buffers);
} }

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

@ -109,7 +109,7 @@ struct run_read_op
void void
operator()( operator()(
ReadHandler&& h, ReadHandler&& h,
buffered_read_stream& s, buffered_read_stream* s,
Buffers const& b) Buffers const& b)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -124,9 +124,7 @@ struct run_read_op
read_op< read_op<
Buffers, Buffers,
typename std::decay<ReadHandler>::type>( typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), std::forward<ReadHandler>(h), *s, b);
s,
b);
} }
}; };
@ -236,7 +234,7 @@ async_read_some(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
typename ops::run_read_op{}, typename ops::run_read_op{},
handler, handler,
*this, this,
buffers); buffers);
} }

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

@ -81,7 +81,7 @@ struct run_write_op
void void
operator()( operator()(
WriteHandler&& h, WriteHandler&& h,
flat_stream& s, flat_stream* s,
Buffers const& b) Buffers const& b)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -95,9 +95,7 @@ struct run_write_op
write_op< write_op<
typename std::decay<WriteHandler>::type>( typename std::decay<WriteHandler>::type>(
std::forward<WriteHandler>(h), std::forward<WriteHandler>(h), *s, b);
s,
b);
} }
}; };
@ -248,7 +246,7 @@ async_write_some(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
typename ops::run_write_op{}, typename ops::run_write_op{},
handler, handler,
*this, this,
buffers); buffers);
} }

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

@ -444,9 +444,9 @@ struct run_write_some_win32_op
operator()( operator()(
WriteHandler&& h, WriteHandler&& h,
net::basic_stream_socket< net::basic_stream_socket<
Protocol, Executor>& s, Protocol, Executor>* s,
serializer<isRequest, serializer<isRequest,
basic_file_body<file_win32>, Fields>& sr) basic_file_body<file_win32>, Fields>* sr)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
// that your handler does not meet the documented type // that your handler does not meet the documented type
@ -461,9 +461,7 @@ struct run_write_some_win32_op
Protocol, Executor, Protocol, Executor,
isRequest, Fields, isRequest, Fields,
typename std::decay<WriteHandler>::type>( typename std::decay<WriteHandler>::type>(
std::forward<WriteHandler>(h), std::forward<WriteHandler>(h), *s, *sr);
s,
sr);
} }
}; };
@ -560,8 +558,8 @@ async_write_some(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
detail::run_write_some_win32_op{}, detail::run_write_some_win32_op{},
handler, handler,
sock, &sock,
sr); &sr);
} }
#endif #endif

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

@ -223,10 +223,10 @@ struct run_read_msg_op
void void
operator()( operator()(
ReadHandler&& h, ReadHandler&& h,
AsyncReadStream& s, AsyncReadStream* s,
DynamicBuffer& b, DynamicBuffer* b,
message<isRequest, Body, message<isRequest, Body,
basic_fields<Allocator>>& m) basic_fields<Allocator>>* m)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
// that your handler does not meet the documented type // that your handler does not meet the documented type
@ -242,10 +242,7 @@ struct run_read_msg_op
DynamicBuffer, DynamicBuffer,
isRequest, Body, Allocator, isRequest, Body, Allocator,
typename std::decay<ReadHandler>::type>( typename std::decay<ReadHandler>::type>(
std::forward<ReadHandler>(h), std::forward<ReadHandler>(h), *s, *b, *m);
s,
b,
m);
} }
}; };
@ -556,10 +553,7 @@ async_read(
ReadHandler, ReadHandler,
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
detail::run_read_msg_op{}, detail::run_read_msg_op{},
handler, handler, &stream, &buffer, &msg);
stream,
buffer,
msg);
} }
} // http } // http

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

@ -267,8 +267,8 @@ struct run_write_some_op
void void
operator()( operator()(
WriteHandler&& h, WriteHandler&& h,
Stream& s, Stream* s,
serializer<isRequest, Body, Fields>& sr) serializer<isRequest, Body, Fields>* sr)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
// that your handler does not meet the documented type // that your handler does not meet the documented type
@ -283,9 +283,7 @@ struct run_write_some_op
typename std::decay<WriteHandler>::type, typename std::decay<WriteHandler>::type,
Stream, Stream,
isRequest, Body, Fields>( isRequest, Body, Fields>(
std::forward<WriteHandler>(h), std::forward<WriteHandler>(h), *s, *sr);
s,
sr);
} }
}; };
@ -299,9 +297,9 @@ struct run_write_op
void void
operator()( operator()(
WriteHandler&& h, WriteHandler&& h,
Stream& s, Stream* s,
Predicate const&, Predicate const&,
serializer<isRequest, Body, Fields>& sr) serializer<isRequest, Body, Fields>* sr)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
// that your handler does not meet the documented type // that your handler does not meet the documented type
@ -317,9 +315,7 @@ struct run_write_op
Stream, Stream,
Predicate, Predicate,
isRequest, Body, Fields>( isRequest, Body, Fields>(
std::forward<WriteHandler>(h), std::forward<WriteHandler>(h), *s, *sr);
s,
sr);
} }
}; };
@ -333,8 +329,8 @@ struct run_write_msg_op
void void
operator()( operator()(
WriteHandler&& h, WriteHandler&& h,
Stream& s, Stream* s,
message<isRequest, Body, Fields>& m, message<isRequest, Body, Fields>* m,
std::false_type, std::false_type,
Args&&... args) Args&&... args)
{ {
@ -351,9 +347,7 @@ struct run_write_msg_op
typename std::decay<WriteHandler>::type, typename std::decay<WriteHandler>::type,
Stream, Stream,
isRequest, Body, Fields>( isRequest, Body, Fields>(
std::forward<WriteHandler>(h), std::forward<WriteHandler>(h), *s, *m,
s,
m,
std::forward<Args>(args)...); std::forward<Args>(args)...);
} }
@ -365,8 +359,8 @@ struct run_write_msg_op
void void
operator()( operator()(
WriteHandler&& h, WriteHandler&& h,
Stream& s, Stream* s,
message<isRequest, Body, Fields> const& m, message<isRequest, Body, Fields> const* m,
std::true_type, std::true_type,
Args&&... args) Args&&... args)
{ {
@ -383,9 +377,7 @@ struct run_write_msg_op
typename std::decay<WriteHandler>::type, typename std::decay<WriteHandler>::type,
Stream, Stream,
isRequest, Body, Fields>( isRequest, Body, Fields>(
std::forward<WriteHandler>(h), std::forward<WriteHandler>(h), *s, *m,
s,
m,
std::forward<Args>(args)...); std::forward<Args>(args)...);
} }
}; };
@ -483,8 +475,8 @@ async_write_some_impl(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
run_write_some_op{}, run_write_some_op{},
handler, handler,
stream, &stream,
sr); &sr);
} }
} // detail } // detail
@ -638,9 +630,9 @@ async_write_header(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
detail::run_write_op{}, detail::run_write_op{},
handler, handler,
stream, &stream,
detail::serializer_is_header_done{}, detail::serializer_is_header_done{},
sr); &sr);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -712,9 +704,9 @@ async_write(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
detail::run_write_op{}, detail::run_write_op{},
handler, handler,
stream, &stream,
detail::serializer_is_done{}, detail::serializer_is_done{},
sr); &sr);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -834,8 +826,8 @@ async_write(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
detail::run_write_msg_op{}, detail::run_write_msg_op{},
handler, handler,
stream, &stream,
msg, &msg,
std::false_type{}); std::false_type{});
} }
@ -864,8 +856,8 @@ async_write(
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
detail::run_write_msg_op{}, detail::run_write_msg_op{},
handler, handler,
stream, &stream,
msg, &msg,
std::true_type{}); std::true_type{});
} }

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

@ -338,7 +338,7 @@ struct stream<NextLayer, deflateSupported>::
AcceptHandler&& h, AcceptHandler&& h,
boost::shared_ptr<impl_type> const& sp, boost::shared_ptr<impl_type> const& sp,
http::request<Body, http::request<Body,
http::basic_fields<Allocator>> const& m, http::basic_fields<Allocator>> const* m,
Decorator const& d) Decorator const& d)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
@ -352,10 +352,7 @@ struct stream<NextLayer, deflateSupported>::
response_op< response_op<
typename std::decay<AcceptHandler>::type>( typename std::decay<AcceptHandler>::type>(
std::forward<AcceptHandler>(h), std::forward<AcceptHandler>(h), sp, *m, d);
sp,
m,
d);
} }
}; };
@ -677,7 +674,7 @@ async_accept(
run_response_op{}, run_response_op{},
handler, handler,
impl_, impl_,
req, &req,
&default_decorate_res); &default_decorate_res);
} }
@ -706,7 +703,7 @@ async_accept_ex(
run_response_op{}, run_response_op{},
handler, handler,
impl_, impl_,
req, &req,
decorator); decorator);
} }

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

@ -41,15 +41,19 @@ class stream<NextLayer, deflateSupported>::handshake_op
{ {
struct data struct data
{ {
data() = default; // for msvc
// VFALCO This really should be two separate // VFALCO This really should be two separate
// composed operations, to save on memory // composed operations, to save on memory
http::request<http::empty_body> req; request_type req;
http::response_parser< http::response_parser<
typename response_type::body_type> p; typename response_type::body_type> p;
flat_buffer fb; flat_buffer fb;
bool overflow; bool overflow = false; // could be a member of the op
explicit
data(request_type&& req_)
: req(std::move(req_))
{
}
}; };
boost::weak_ptr<impl_type> wp_; boost::weak_ptr<impl_type> wp_;
@ -58,23 +62,23 @@ class stream<NextLayer, deflateSupported>::handshake_op
data& d_; data& d_;
public: public:
template<class Handler_, class Decorator> template<class Handler_>
handshake_op( handshake_op(
Handler_&& h, Handler_&& h,
boost::shared_ptr<impl_type> const& sp, boost::shared_ptr<impl_type> const& sp,
response_type* res_p, request_type&& req,
string_view host, string_view target, detail::sec_ws_key_type key,
Decorator const& decorator) response_type* res_p)
: stable_async_base<Handler, : stable_async_base<Handler,
beast::executor_type<stream>>( beast::executor_type<stream>>(
std::forward<Handler_>(h), std::forward<Handler_>(h),
sp->stream.get_executor()) sp->stream.get_executor())
, wp_(sp) , wp_(sp)
, key_(key)
, res_p_(res_p) , res_p_(res_p)
, d_(beast::allocate_stable<data>(*this)) , d_(beast::allocate_stable<data>(
*this, std::move(req)))
{ {
d_.req = sp->build_request(
key_, host, target, decorator);
sp->reset(); // VFALCO I don't like this sp->reset(); // VFALCO I don't like this
(*this)({}, 0, false); (*this)({}, 0, false);
} }
@ -164,13 +168,13 @@ template<class NextLayer, bool deflateSupported>
struct stream<NextLayer, deflateSupported>:: struct stream<NextLayer, deflateSupported>::
run_handshake_op run_handshake_op
{ {
template<class HandshakeHandler, class Decorator> template<class HandshakeHandler>
void operator()( void operator()(
HandshakeHandler&& h, HandshakeHandler&& h,
boost::shared_ptr<impl_type> const& sp, boost::shared_ptr<impl_type> const& sp,
response_type* r, request_type&& req,
string_view host, string_view target, detail::sec_ws_key_type key,
Decorator const& d) response_type* res_p)
{ {
// If you get an error on the following line it means // If you get an error on the following line it means
// that your handler does not meet the documented type // that your handler does not meet the documented type
@ -184,10 +188,7 @@ struct stream<NextLayer, deflateSupported>::
handshake_op< handshake_op<
typename std::decay<HandshakeHandler>::type>( typename std::decay<HandshakeHandler>::type>(
std::forward<HandshakeHandler>(h), std::forward<HandshakeHandler>(h),
sp, sp, std::move(req), key, res_p);
r,
host, target,
d);
} }
}; };
@ -269,21 +270,25 @@ template<class HandshakeHandler>
BOOST_ASIO_INITFN_RESULT_TYPE( BOOST_ASIO_INITFN_RESULT_TYPE(
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code))
stream<NextLayer, deflateSupported>:: stream<NextLayer, deflateSupported>::
async_handshake(string_view host, async_handshake(
string_view host,
string_view target, string_view target,
HandshakeHandler&& handler) HandshakeHandler&& handler)
{ {
static_assert(is_async_stream<next_layer_type>::value, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream type requirements not met"); "AsyncStream type requirements not met");
detail::sec_ws_key_type key;
auto req = impl_->build_request(
key, host, target, &default_decorate_req);
return net::async_initiate< return net::async_initiate<
HandshakeHandler, HandshakeHandler,
void(error_code)>( void(error_code)>(
run_handshake_op{}, run_handshake_op{},
handler, handler,
impl_, impl_,
nullptr, std::move(req),
host, target, key,
&default_decorate_req); nullptr);
} }
template<class NextLayer, bool deflateSupported> template<class NextLayer, bool deflateSupported>
@ -291,22 +296,26 @@ template<class HandshakeHandler>
BOOST_ASIO_INITFN_RESULT_TYPE( BOOST_ASIO_INITFN_RESULT_TYPE(
HandshakeHandler, void(error_code)) HandshakeHandler, void(error_code))
stream<NextLayer, deflateSupported>:: stream<NextLayer, deflateSupported>::
async_handshake(response_type& res, async_handshake(
response_type& res,
string_view host, string_view host,
string_view target, string_view target,
HandshakeHandler&& handler) HandshakeHandler&& handler)
{ {
static_assert(is_async_stream<next_layer_type>::value, static_assert(is_async_stream<next_layer_type>::value,
"AsyncStream type requirements not met"); "AsyncStream type requirements not met");
detail::sec_ws_key_type key;
auto req = impl_->build_request(
key, host, target, &default_decorate_req);
return net::async_initiate< return net::async_initiate<
HandshakeHandler, HandshakeHandler,
void(error_code)>( void(error_code)>(
run_handshake_op{}, run_handshake_op{},
handler, handler,
impl_, impl_,
&res, std::move(req),
host, target, key,
&default_decorate_req); &res);
} }
template<class NextLayer, bool deflateSupported> template<class NextLayer, bool deflateSupported>
@ -478,15 +487,18 @@ 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");
detail::sec_ws_key_type key;
auto req = impl_->build_request(
key, host, target, decorator);
return net::async_initiate< return net::async_initiate<
HandshakeHandler, HandshakeHandler,
void(error_code)>( void(error_code)>(
run_handshake_op{}, run_handshake_op{},
handler, handler,
impl_, impl_,
nullptr, std::move(req),
host, target, key,
decorator); nullptr);
} }
template<class NextLayer, bool deflateSupported> template<class NextLayer, bool deflateSupported>
@ -509,15 +521,18 @@ 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");
detail::sec_ws_key_type key;
auto req = impl_->build_request(
key, host, target, decorator);
return net::async_initiate< return net::async_initiate<
HandshakeHandler, HandshakeHandler,
void(error_code)>( void(error_code)>(
run_handshake_op{}, run_handshake_op{},
handler, handler,
impl_, impl_,
&res, std::move(req),
host, target, key,
decorator); &res);
} }
} // websocket } // websocket

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

@ -727,7 +727,7 @@ struct stream<NextLayer, deflateSupported>::
operator()( operator()(
ReadHandler&& h, ReadHandler&& h,
boost::shared_ptr<impl_type> const& sp, boost::shared_ptr<impl_type> const& sp,
DynamicBuffer& b, DynamicBuffer* b,
std::size_t limit, std::size_t limit,
bool some) bool some)
{ {
@ -745,7 +745,7 @@ struct stream<NextLayer, deflateSupported>::
DynamicBuffer>( DynamicBuffer>(
std::forward<ReadHandler>(h), std::forward<ReadHandler>(h),
sp, sp,
b, *b,
limit, limit,
some); some);
} }
@ -811,7 +811,7 @@ async_read(DynamicBuffer& buffer, ReadHandler&& handler)
run_read_op{}, run_read_op{},
handler, handler,
impl_, impl_,
buffer, &buffer,
0, 0,
false); false);
} }
@ -889,7 +889,7 @@ async_read_some(
run_read_op{}, run_read_op{},
handler, handler,
impl_, impl_,
buffer, &buffer,
limit, limit,
true); true);
} }

3
test/beast/core/rate_policy.cpp
View File

@ -18,9 +18,6 @@ class RatePolicy
{ {
friend class rate_policy_access; friend class rate_policy_access;
static std::size_t constexpr all =
(std::numeric_limits<std::size_t>::max)();
std::size_t std::size_t
available_read_bytes(); available_read_bytes();

8
test/doc/core_1_refresher.cpp
View File

@ -343,7 +343,7 @@ template<
class CompletionToken> class CompletionToken>
auto auto
async_write( async_write(
AsyncWriteStream& stream, AsyncWriteStream* stream, // references are passed as pointers
ConstBufferSequence const& buffers, ConstBufferSequence const& buffers,
CompletionToken&& token) // a handler, or a special object. CompletionToken&& token) // a handler, or a special object.
-> ->
@ -379,9 +379,9 @@ async_write(
return net::async_initiate< return net::async_initiate<
CompletionToken, CompletionToken,
void(error_code, std::size_t)>( void(error_code, std::size_t)>(
run_async_write{}, // the "initiation" object. run_async_write{}, // The "initiation" object.
token, // must be first. token, // Token must come before other arguments.
stream, // additional captured arguments are &stream, // Additional captured arguments are
buffers); // forwarded to the initiation object. buffers); // forwarded to the initiation object.
//] //]