boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-07-30 21:07:26 +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
* role_type is in boost/beast/core/role.hpp (API Change)
* Cleanup in test::stream internals
* Pass references as pointers to async_initiate
Actions Required:

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

@ -304,7 +304,7 @@ struct run_read_op
void
operator()(
ReadHandler&& h,
icy_stream& s,
icy_stream* s,
Buffers const& b)
{
// If you get an error on the following line it means
@ -319,7 +319,7 @@ struct run_read_op
read_op<
Buffers,
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)>(
typename ops::run_read_op{},
handler,
*this,
this,
buffers);
}

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

@ -114,7 +114,7 @@ struct stream::run_read_op
void
operator()(
ReadHandler&& h,
stream& s,
std::shared_ptr<state> const& in,
MutableBufferSequence const& buffers)
{
// 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,
"ReadHandler type requirements not met");
s.initiate_read(
initiate_read(
in,
std::unique_ptr<read_op_base>{
new read_op<
typename std::decay<ReadHandler>::type,
MutableBufferSequence>(
std::move(h),
*s.in_,
*in,
buffers)},
buffer_size(buffers));
}
@ -278,7 +279,7 @@ async_read_some(
void(error_code, std::size_t)>(
run_read_op{},
handler,
*this,
in_,
buffers);
}

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

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

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

@ -96,19 +96,10 @@ namespace test {
*/
class stream
{
struct read_op_base
{
virtual ~read_op_base() = default;
virtual void operator()(error_code ec) = 0;
};
struct state;
BOOST_BEAST_DECL void initiate_read(std::unique_ptr<read_op_base>&& op, std::size_t buf_size);
template<class Handler, class Buffers>
class read_op;
struct run_read_op;
struct run_write_op;
std::shared_ptr<state> in_;
std::weak_ptr<state> out_;
enum class status
{
@ -116,6 +107,12 @@ class stream
eof,
};
struct read_op_base
{
virtual ~read_op_base() = default;
virtual void operator()(error_code ec) = 0;
};
struct state
{
friend class stream;
@ -146,8 +143,19 @@ class stream
notify_read();
};
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;
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:
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
operator()(
ReadHandler&& h,
AsyncReadStream& s,
DynamicBuffer& b,
AsyncReadStream* s,
DynamicBuffer* b,
Condition&& c)
{
// 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<ReadHandler>::type>(
std::forward<ReadHandler>(h),
s,
b,
*s,
*b,
std::forward<Condition>(c));
}
@ -248,8 +248,8 @@ async_read(
void(error_code, std::size_t)>(
typename dynamic_read_ops::run_read_op{},
handler,
stream,
buffer,
&stream,
&buffer,
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>
void operator()(
DetectHandler&& h,
AsyncReadStream& s,
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), *s, b);
}
};
@ -423,14 +421,18 @@ async_detect_ssl(
// `net::async_result` for the type of `CompletionToken`,
// the `initiation` object will be invoked with the saved
// 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<
CompletionToken,
void(error_code, boost::tribool)>(
detail::run_detect_ssl_op{},
token,
stream,
&stream, // pass the reference by pointer
buffer);
}

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

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

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

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

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

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

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

@ -444,9 +444,9 @@ struct run_write_some_win32_op
operator()(
WriteHandler&& h,
net::basic_stream_socket<
Protocol, Executor>& s,
Protocol, Executor>* s,
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
// that your handler does not meet the documented type
@ -461,9 +461,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), *s, *sr);
}
};
@ -560,8 +558,8 @@ async_write_some(
void(error_code, std::size_t)>(
detail::run_write_some_win32_op{},
handler,
sock,
sr);
&sock,
&sr);
}
#endif

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

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

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

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

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

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

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

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

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

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

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

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

8
test/doc/core_1_refresher.cpp
View File

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