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

Add executor_type trait

Browse Source
This commit is contained in:
Vinnie Falco
2019-02-04 21:52:54 -08:00
parent 42d83b221a
commit 9cee4e053f
21 changed files with 97 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@@ -4,6 +4,7 @@ Version 210:
* Fix stable_async_op_base javadoc * Fix stable_async_op_base javadoc
* Better handling of stream timeouts * Better handling of stream timeouts
* Add stream_traits.hpp * Add stream_traits.hpp
* Add executor_type trait
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------

7
doc/qbk/03_core/2_streams.qbk
View File

@@ -58,8 +58,13 @@ and also provides them as public interfaces so users may use the
same techniques to augment their own code. The use of these type same techniques to augment their own code. The use of these type
checks helps provide more concise errors during compilation: checks helps provide more concise errors during compilation:
[table Stream Type Checks [table Type Traits and Metafunctions
[[Name][Description]] [[Name][Description]]
[[
[link beast.ref.boost__beast__executor_type `executor_type`]
][
An alias for the type of object returned by `get_executor`.
]]
[[ [[
[link beast.ref.boost__beast__has_get_executor `has_get_executor`] [link beast.ref.boost__beast__has_get_executor `has_get_executor`]
][ ][

1
doc/qbk/quickref.xml
View File

@@ -76,6 +76,7 @@
<entry valign="top"> <entry valign="top">
<bridgehead renderas="sect3">Type Traits</bridgehead> <bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1"> <simplelist type="vert" columns="1">
<member><link linkend="beast.ref.boost__beast__executor_type">executor_type</link>&nbsp;<emphasis role="green">&#128946;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__lowest_layer_type">lowest_layer_type</link>&nbsp;<emphasis role="green">&#128946;</emphasis></member> <member><link linkend="beast.ref.boost__beast__lowest_layer_type">lowest_layer_type</link>&nbsp;<emphasis role="green">&#128946;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__has_get_executor">has_get_executor</link></member> <member><link linkend="beast.ref.boost__beast__has_get_executor">has_get_executor</link></member>
<member><link linkend="beast.ref.boost__beast__is_async_read_stream">is_async_read_stream</link></member> <member><link linkend="beast.ref.boost__beast__is_async_read_stream">is_async_read_stream</link></member>

5
doc/qbk/release_notes.qbk
View File

@@ -40,7 +40,7 @@ New websocket-chat-multi example
* Eligible member functions are declared `noexcept` * Eligible member functions are declared `noexcept`
* ([issue 1345]) Better `flat_buffer`, `multi_buffer` * ([issue 1345]) Better `flat_buffer`, `multi_buffer`
* Add `reserve()`, `max_size()`, `shrink_to_fit()` * Add `clear`, `reserve()`, `max_size()`, `shrink_to_fit()`
* Respect Allocator `max_size()` * Respect Allocator `max_size()`
* Specify exception safety * Specify exception safety
@@ -53,7 +53,7 @@ New websocket-chat-multi example
* Faster `http::string_to_field` * Faster `http::string_to_field`
* New file <boost/beast/core/buffer_type.hpp> * New file <boost/beast/core/buffer_traits.hpp>
* New variadic `is_const_buffer_sequence` * New variadic `is_const_buffer_sequence`
* New variadic `is_mutable_buffer_sequence` * New variadic `is_mutable_buffer_sequence`
* New `buffers_iterator_type` trait * New `buffers_iterator_type` trait
@@ -69,6 +69,7 @@ New websocket-chat-multi example
* `saved_handler` * `saved_handler`
* `buffers_range_ref` * `buffers_range_ref`
* `dynamic_buffer_ref` * `dynamic_buffer_ref`
* `executor_type`
* `get_lowest_layer` and `lowest_layer_type` * `get_lowest_layer` and `lowest_layer_type`
* `close_socket` and `beast_close_socket` * `close_socket` and `beast_close_socket`
* `error` and `condition` * `error` and `condition`

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

@@ -10,9 +10,9 @@
#ifndef BOOST_BEAST_CORE_IMPL_FLAT_STREAM_HPP #ifndef BOOST_BEAST_CORE_IMPL_FLAT_STREAM_HPP
#define BOOST_BEAST_CORE_IMPL_FLAT_STREAM_HPP #define BOOST_BEAST_CORE_IMPL_FLAT_STREAM_HPP
#include <boost/beast/core/buffers_prefix.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp> #include <boost/beast/core/buffers_prefix.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/websocket/teardown.hpp> #include <boost/beast/websocket/teardown.hpp>
#include <boost/asio/buffer.hpp> #include <boost/asio/buffer.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
@@ -25,7 +25,7 @@ template<class NextLayer>
template<class ConstBufferSequence, class Handler> template<class ConstBufferSequence, class Handler>
class flat_stream<NextLayer>::write_op class flat_stream<NextLayer>::write_op
: public async_op_base<Handler, : public async_op_base<Handler,
detail::get_executor_type<flat_stream>> beast::executor_type<flat_stream>>
, public net::coroutine , public net::coroutine
{ {
@@ -60,7 +60,7 @@ public:
ConstBufferSequence const& b, ConstBufferSequence const& b,
Handler_&& h) Handler_&& h)
: async_op_base<Handler, : async_op_base<Handler,
detail::get_executor_type<flat_stream>>( beast::executor_type<flat_stream>>(
std::forward<Handler_>(h), std::forward<Handler_>(h),
s.get_executor()) s.get_executor())
, s_(s) , s_(s)

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

@@ -10,15 +10,15 @@
#ifndef BOOST_BEAST_CORE_IMPL_ICY_STREAM_HPP #ifndef BOOST_BEAST_CORE_IMPL_ICY_STREAM_HPP
#define BOOST_BEAST_CORE_IMPL_ICY_STREAM_HPP #define BOOST_BEAST_CORE_IMPL_ICY_STREAM_HPP
#include <boost/beast/core/dynamic_buffer_ref.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/bind_handler.hpp>
#include <boost/beast/core/buffer_size.hpp> #include <boost/beast/core/buffer_size.hpp>
#include <boost/beast/core/buffers_adaptor.hpp> #include <boost/beast/core/buffers_adaptor.hpp>
#include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_prefix.hpp>
#include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/buffers_suffix.hpp>
#include <boost/beast/core/dynamic_buffer_ref.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/detail/buffers_ref.hpp> #include <boost/beast/core/detail/buffers_ref.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/asio/buffers_iterator.hpp> #include <boost/asio/buffers_iterator.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
@@ -121,7 +121,7 @@ template<class NextLayer>
template<class MutableBufferSequence, class Handler> template<class MutableBufferSequence, class Handler>
class icy_stream<NextLayer>::read_op class icy_stream<NextLayer>::read_op
: public beast::stable_async_op_base<Handler, : public beast::stable_async_op_base<Handler,
beast::detail::get_executor_type<icy_stream>> beast::executor_type<icy_stream>>
, public net::coroutine , public net::coroutine
{ {
// VFALCO We need a stable reference to `b` // VFALCO We need a stable reference to `b`
@@ -151,7 +151,7 @@ public:
icy_stream& s, icy_stream& s,
MutableBufferSequence const& b) MutableBufferSequence const& b)
: stable_async_op_base<Handler, : stable_async_op_base<Handler,
beast::detail::get_executor_type<icy_stream>>( beast::executor_type<icy_stream>>(
std::forward<Handler_>(h), s.get_executor()) std::forward<Handler_>(h), s.get_executor())
, d_(beast::allocate_stable<data>(*this, s, b)) , d_(beast::allocate_stable<data>(*this, s, b))
{ {

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

@@ -13,8 +13,8 @@
#include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/config.hpp>
#include <boost/beast/core/error.hpp> #include <boost/beast/core/error.hpp>
#include <boost/beast/core/multi_buffer.hpp> #include <boost/beast/core/multi_buffer.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/asio/async_result.hpp> #include <boost/asio/async_result.hpp>
#include <boost/asio/buffer.hpp> #include <boost/asio/buffer.hpp>
#include <boost/asio/io_context.hpp> #include <boost/asio/io_context.hpp>
@@ -148,7 +148,7 @@ public:
} }
using executor_type = using executor_type =
detail::get_executor_type<next_layer_type>; beast::executor_type<next_layer_type>;
/** Get the executor associated with the object. /** Get the executor associated with the object.

35
include/boost/beast/core/detail/get_executor_type.hpp
View File

@@ -1,35 +0,0 @@
//
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/beast
//
#ifndef BOOST_BEAST_DETAIL_GET_EXECUTOR_TYPE
#define BOOST_BEAST_DETAIL_GET_EXECUTOR_TYPE
#include <boost/config/workaround.hpp>
#include <utility>
namespace boost {
namespace beast {
namespace detail {
// Workaround for ICE on gcc 4.8
#if BOOST_WORKAROUND(BOOST_GCC, < 40900)
template<class T>
using get_executor_type =
typename std::decay<T>::type::executor_type;
#else
template<class T>
using get_executor_type =
decltype(std::declval<T&>().get_executor());
#endif
} // detail
} // beast
} // boost
#endif

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

@@ -13,7 +13,7 @@
#include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/bind_handler.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/flat_static_buffer.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp> #include <boost/beast/core/stream_traits.hpp>
#include <boost/asio/basic_stream_socket.hpp> #include <boost/asio/basic_stream_socket.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
@@ -37,7 +37,7 @@ template<
class read_op class read_op
: public net::coroutine : public net::coroutine
, public async_op_base< , public async_op_base<
Handler, get_executor_type<Stream>> Handler, beast::executor_type<Stream>>
{ {
Stream& s_; Stream& s_;
DynamicBuffer& b_; DynamicBuffer& b_;
@@ -54,7 +54,7 @@ public:
Condition cond, Condition cond,
Handler_&& h) Handler_&& h)
: async_op_base<Handler, : async_op_base<Handler,
get_executor_type<Stream>>( beast::executor_type<Stream>>(
std::forward<Handler_>(h), std::forward<Handler_>(h),
s.get_executor()) s.get_executor())
, s_(s) , s_(s)
@@ -115,7 +115,7 @@ template<
class read_non_blocking_op class read_non_blocking_op
: public net::coroutine : public net::coroutine
, public async_op_base<Handler, , public async_op_base<Handler,
get_executor_type<net::basic_stream_socket<Protocol>>> beast::executor_type<net::basic_stream_socket<Protocol>>>
{ {
net::basic_stream_socket<Protocol>& s_; net::basic_stream_socket<Protocol>& s_;
DynamicBuffer& b_; DynamicBuffer& b_;
@@ -133,7 +133,7 @@ public:
DynamicBuffer& b, DynamicBuffer& b,
Condition cond, Condition cond,
Handler_&& h) Handler_&& h)
: async_op_base<Handler, get_executor_type< : async_op_base<Handler, beast::executor_type<
net::basic_stream_socket<Protocol>>>( net::basic_stream_socket<Protocol>>>(
s.get_executor(), std::forward<Handler_>(h)) s.get_executor(), std::forward<Handler_>(h))
, s_(s) , s_(s)

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

@@ -14,8 +14,8 @@
#include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/bind_handler.hpp>
#include <boost/beast/core/error.hpp> #include <boost/beast/core/error.hpp>
#include <boost/beast/core/read_size.hpp> #include <boost/beast/core/read_size.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
@@ -27,7 +27,7 @@ template<class MutableBufferSequence, class Handler>
class buffered_read_stream< class buffered_read_stream<
Stream, DynamicBuffer>::read_some_op Stream, DynamicBuffer>::read_some_op
: public async_op_base< : public async_op_base<
Handler, detail::get_executor_type<buffered_read_stream>> Handler, beast::executor_type<buffered_read_stream>>
{ {
buffered_read_stream& s_; buffered_read_stream& s_;
MutableBufferSequence b_; MutableBufferSequence b_;
@@ -43,7 +43,7 @@ public:
buffered_read_stream& s, buffered_read_stream& s,
MutableBufferSequence const& b) MutableBufferSequence const& b)
: async_op_base< : async_op_base<
Handler, detail::get_executor_type<buffered_read_stream>>( Handler, beast::executor_type<buffered_read_stream>>(
std::forward<Handler_>(h), s.get_executor()) std::forward<Handler_>(h), s.get_executor())
, s_(s) , s_(s)
, b_(b) , b_(b)

36
include/boost/beast/core/stream_traits.hpp
View File

@@ -16,12 +16,15 @@
namespace boost { namespace boost {
namespace beast { namespace beast {
/** Return the type of the lowest layer of a type representing a stack of stream layers. /** A trait to determine the lowest layer type of a stack of stream layers.
This type alias will return the type of lowest layer object for a type If `t.next_layer()` is well-defined for an object `t` of type `T`,
which defines a stack of stream layers. then `lowest_layer_type<T>` will be an alias for
`lowest_layer_type<decltype(t.next_layer())>`,
otherwise it will be the type
`std::remove_reference<T>`.
@param T The type determine the lowest layer type of. @param T The type to determine the lowest layer type of.
@return The type of the lowest layer. @return The type of the lowest layer.
*/ */
@@ -35,7 +38,7 @@ using lowest_layer_type = detail::lowest_layer_type<T>;
/** Return the lowest layer in a stack of stream layers. /** Return the lowest layer in a stack of stream layers.
If `t.next_layer()` is well-defined, returns If `t.next_layer()` is well-defined, returns
`lowest_layer(t.next_layer())`. Otherwise, it returns `t`. `get_lowest_layer(t.next_layer())`. Otherwise, it returns `t`.
A stream layer is an object of class type which wraps another object through A stream layer is an object of class type which wraps another object through
composition, and meets some or all of the named requirements of the wrapped composition, and meets some or all of the named requirements of the wrapped
@@ -84,6 +87,29 @@ get_lowest_layer(T& t) noexcept
t, detail::has_next_layer<T>{}); t, detail::has_next_layer<T>{});
} }
/** A trait to determine the return type of get_executor.
This type alias will be the type of values returned by
by calling member `get_exector` on an object of type `T&`.
@param T The type to query
@return The type of values returned from `get_executor`.
*/
// Workaround for ICE on gcc 4.8
#if BOOST_BEAST_DOXYGEN
template<class T>
using executor_type = __see_below__;
#elif BOOST_WORKAROUND(BOOST_GCC, < 40900)
template<class T>
using executor_type =
typename std::decay<T>::type::executor_type;
#else
template<class T>
using executor_type =
decltype(std::declval<T&>().get_executor());
#endif
} // beast } // beast
} // boost } // boost

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

@@ -15,7 +15,7 @@
#include <boost/beast/http/parser.hpp> #include <boost/beast/http/parser.hpp>
#include <boost/beast/http/read.hpp> #include <boost/beast/http/read.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp> #include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/detail/read.hpp> #include <boost/beast/core/detail/read.hpp>
#include <boost/asio/error.hpp> #include <boost/asio/error.hpp>
@@ -149,7 +149,7 @@ template<
class Handler> class Handler>
class read_msg_op class read_msg_op
: public beast::stable_async_op_base< : public beast::stable_async_op_base<
Handler, beast::detail::get_executor_type<Stream>> Handler, beast::executor_type<Stream>>
, public net::coroutine , public net::coroutine
{ {
using parser_type = using parser_type =
@@ -184,7 +184,7 @@ public:
message_type& m, message_type& m,
Handler_&& h) Handler_&& h)
: stable_async_op_base< : stable_async_op_base<
Handler, beast::detail::get_executor_type<Stream>>( Handler, beast::executor_type<Stream>>(
std::forward<Handler_>(h), s.get_executor()) std::forward<Handler_>(h), s.get_executor())
, d_(beast::allocate_stable<data>( , d_(beast::allocate_stable<data>(
*this, s, m)) *this, s, m))

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

@@ -15,8 +15,8 @@
#include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/bind_handler.hpp>
#include <boost/beast/core/buffers_range.hpp> #include <boost/beast/core/buffers_range.hpp>
#include <boost/beast/core/ostream.hpp> #include <boost/beast/core/ostream.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
#include <boost/asio/write.hpp> #include <boost/asio/write.hpp>
@@ -35,7 +35,7 @@ template<
bool isRequest, class Body, class Fields> bool isRequest, class Body, class Fields>
class write_some_op class write_some_op
: public beast::async_op_base< : public beast::async_op_base<
Handler, beast::detail::get_executor_type<Stream>> Handler, beast::executor_type<Stream>>
{ {
Stream& s_; Stream& s_;
serializer<isRequest,Body, Fields>& sr_; serializer<isRequest,Body, Fields>& sr_;
@@ -73,7 +73,7 @@ public:
Stream& s, Stream& s,
serializer<isRequest, Body, Fields>& sr) serializer<isRequest, Body, Fields>& sr)
: async_op_base< : async_op_base<
Handler, beast::detail::get_executor_type<Stream>>( Handler, beast::executor_type<Stream>>(
std::forward<Handler_>(h), s.get_executor()) std::forward<Handler_>(h), s.get_executor())
, s_(s) , s_(s)
, sr_(sr) , sr_(sr)
@@ -155,7 +155,7 @@ template<
bool isRequest, class Body, class Fields> bool isRequest, class Body, class Fields>
class write_op class write_op
: public beast::async_op_base< : public beast::async_op_base<
Handler, beast::detail::get_executor_type<Stream>> Handler, beast::executor_type<Stream>>
, public net::coroutine , public net::coroutine
{ {
Stream& s_; Stream& s_;
@@ -169,7 +169,7 @@ public:
Stream& s, Stream& s,
serializer<isRequest, Body, Fields>& sr) serializer<isRequest, Body, Fields>& sr)
: async_op_base< : async_op_base<
Handler, beast::detail::get_executor_type<Stream>>( Handler, beast::executor_type<Stream>>(
std::forward<Handler_>(h), s.get_executor()) std::forward<Handler_>(h), s.get_executor())
, s_(s) , s_(s)
, sr_(sr) , sr_(sr)
@@ -216,7 +216,7 @@ template<
bool isRequest, class Body, class Fields> bool isRequest, class Body, class Fields>
class write_msg_op class write_msg_op
: public beast::stable_async_op_base< : public beast::stable_async_op_base<
Handler, beast::detail::get_executor_type<Stream>> Handler, beast::executor_type<Stream>>
{ {
Stream& s_; Stream& s_;
serializer<isRequest, Body, Fields>& sr_; serializer<isRequest, Body, Fields>& sr_;
@@ -230,7 +230,7 @@ public:
Handler_&& h, Handler_&& h,
Args&&... args) Args&&... args)
: stable_async_op_base< : stable_async_op_base<
Handler, beast::detail::get_executor_type<Stream>>( Handler, beast::executor_type<Stream>>(
std::forward<Handler_>(h), s.get_executor()) std::forward<Handler_>(h), s.get_executor())
, s_(s) , s_(s)
, sr_(beast::allocate_stable< , sr_(beast::allocate_stable<

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

@@ -19,8 +19,8 @@
#include <boost/beast/http/write.hpp> #include <boost/beast/http/write.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_prefix.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/detail/buffer.hpp> #include <boost/beast/core/detail/buffer.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/beast/core/detail/type_traits.hpp> #include <boost/beast/core/detail/type_traits.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
@@ -39,7 +39,7 @@ template<class NextLayer, bool deflateSupported>
template<class Handler> template<class Handler>
class stream<NextLayer, deflateSupported>::response_op class stream<NextLayer, deflateSupported>::response_op
: public beast::stable_async_op_base< : public beast::stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>> Handler, beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
stream<NextLayer, deflateSupported>& ws_; stream<NextLayer, deflateSupported>& ws_;
@@ -57,7 +57,7 @@ public:
http::request<Body, http::basic_fields<Allocator>> const& req, http::request<Body, http::basic_fields<Allocator>> const& req,
Decorator const& decorator) Decorator const& decorator)
: stable_async_op_base< : stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>>( Handler, beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, ws_(ws) , ws_(ws)
, res_(beast::allocate_stable<response_type>(*this, , res_(beast::allocate_stable<response_type>(*this,
@@ -96,7 +96,7 @@ template<class NextLayer, bool deflateSupported>
template<class Decorator, class Handler> template<class Decorator, class Handler>
class stream<NextLayer, deflateSupported>::accept_op class stream<NextLayer, deflateSupported>::accept_op
: public beast::stable_async_op_base< : public beast::stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>> Handler, beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
stream<NextLayer, deflateSupported>& ws_; stream<NextLayer, deflateSupported>& ws_;
@@ -110,7 +110,7 @@ public:
stream<NextLayer, deflateSupported>& ws, stream<NextLayer, deflateSupported>& ws,
Decorator const& decorator) Decorator const& decorator)
: stable_async_op_base< : stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>>( Handler, beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, ws_(ws) , ws_(ws)
, p_(beast::allocate_stable< , p_(beast::allocate_stable<

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

@@ -14,8 +14,8 @@
#include <boost/beast/websocket/detail/mask.hpp> #include <boost/beast/websocket/detail/mask.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/flat_static_buffer.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/config.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
@@ -37,7 +37,7 @@ template<class NextLayer, bool deflateSupported>
template<class Handler> template<class Handler>
class stream<NextLayer, deflateSupported>::close_op class stream<NextLayer, deflateSupported>::close_op
: public beast::stable_async_op_base< : public beast::stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>> Handler, beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
struct state struct state
@@ -69,7 +69,7 @@ public:
stream<NextLayer, deflateSupported>& ws, stream<NextLayer, deflateSupported>& ws,
close_reason const& cr) close_reason const& cr)
: stable_async_op_base< : stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>>( Handler, beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, d_(beast::allocate_stable<state>( , d_(beast::allocate_stable<state>(
*this, ws, cr)) *this, ws, cr))

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

@@ -16,8 +16,8 @@
#include <boost/beast/http/read.hpp> #include <boost/beast/http/read.hpp>
#include <boost/beast/http/write.hpp> #include <boost/beast/http/write.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/assert.hpp> #include <boost/assert.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
@@ -35,7 +35,7 @@ template<class NextLayer, bool deflateSupported>
template<class Handler> template<class Handler>
class stream<NextLayer, deflateSupported>::handshake_op class stream<NextLayer, deflateSupported>::handshake_op
: public beast::stable_async_op_base<Handler, : public beast::stable_async_op_base<Handler,
beast::detail::get_executor_type<stream>> beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
struct data struct data
@@ -72,7 +72,7 @@ public:
Handler_&& h, Handler_&& h,
stream& ws, Args&&... args) stream& ws, Args&&... args)
: stable_async_op_base<Handler, : stable_async_op_base<Handler,
beast::detail::get_executor_type<stream>>( beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, d_(beast::allocate_stable<data>( , d_(beast::allocate_stable<data>(
*this, ws, std::forward<Args>(args)...)) *this, ws, std::forward<Args>(args)...))

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

@@ -12,8 +12,8 @@
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/bind_handler.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/beast/websocket/detail/frame.hpp> #include <boost/beast/websocket/detail/frame.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
@@ -33,7 +33,7 @@ template<class NextLayer, bool deflateSupported>
template<class Handler> template<class Handler>
class stream<NextLayer, deflateSupported>::ping_op class stream<NextLayer, deflateSupported>::ping_op
: public beast::stable_async_op_base< : public beast::stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>> Handler, beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
struct state struct state
@@ -66,7 +66,7 @@ public:
detail::opcode op, detail::opcode op,
ping_data const& payload) ping_data const& payload)
: stable_async_op_base< : stable_async_op_base<
Handler, beast::detail::get_executor_type<stream>>( Handler, beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, d_(beast::allocate_stable<state>( , d_(beast::allocate_stable<state>(
*this, ws, op, payload)) *this, ws, op, payload))

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

@@ -18,11 +18,11 @@
#include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_prefix.hpp>
#include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/buffers_suffix.hpp>
#include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/flat_static_buffer.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/buffer.hpp> #include <boost/beast/core/detail/buffer.hpp>
#include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/clamp.hpp>
#include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/config.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
#include <boost/assert.hpp> #include <boost/assert.hpp>
@@ -47,7 +47,7 @@ template<
class Handler> class Handler>
class stream<NextLayer, deflateSupported>::read_some_op class stream<NextLayer, deflateSupported>::read_some_op
: public beast::async_op_base< : public beast::async_op_base<
Handler, beast::detail::get_executor_type<stream>> Handler, beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
stream& ws_; stream& ws_;
@@ -68,7 +68,7 @@ public:
stream<NextLayer, deflateSupported>& ws, stream<NextLayer, deflateSupported>& ws,
MutableBufferSequence const& bs) MutableBufferSequence const& bs)
: async_op_base< : async_op_base<
Handler, beast::detail::get_executor_type<stream>>( Handler, beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, ws_(ws) , ws_(ws)
, bs_(bs) , bs_(bs)
@@ -631,7 +631,7 @@ template<
class Handler> class Handler>
class stream<NextLayer, deflateSupported>::read_op class stream<NextLayer, deflateSupported>::read_op
: public beast::async_op_base< : public beast::async_op_base<
Handler, beast::detail::get_executor_type<stream>> Handler, beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
stream<NextLayer, deflateSupported>& ws_; stream<NextLayer, deflateSupported>& ws_;
@@ -649,7 +649,7 @@ public:
std::size_t limit, std::size_t limit,
bool some) bool some)
: async_op_base< : async_op_base<
Handler, beast::detail::get_executor_type<stream>>( Handler, beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, ws_(ws) , ws_(ws)
, b_(b) , b_(b)

6
include/boost/beast/websocket/impl/teardown.hpp
View File

@@ -12,8 +12,8 @@
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/bind_handler.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
#include <memory> #include <memory>
@@ -27,7 +27,7 @@ namespace detail {
template<class Handler> template<class Handler>
class teardown_tcp_op class teardown_tcp_op
: public beast::async_op_base< : public beast::async_op_base<
Handler, beast::detail::get_executor_type< Handler, beast::executor_type<
net::ip::tcp::socket>> net::ip::tcp::socket>>
, public net::coroutine , public net::coroutine
{ {
@@ -44,7 +44,7 @@ public:
socket_type& s, socket_type& s,
role_type role) role_type role)
: async_op_base<Handler, : async_op_base<Handler,
beast::detail::get_executor_type< beast::executor_type<
net::ip::tcp::socket>>( net::ip::tcp::socket>>(
std::forward<Handler_>(h), s.get_executor()) std::forward<Handler_>(h), s.get_executor())
, s_(s) , s_(s)

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

@@ -19,10 +19,10 @@
#include <boost/beast/core/buffers_range.hpp> #include <boost/beast/core/buffers_range.hpp>
#include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/buffers_suffix.hpp>
#include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/flat_static_buffer.hpp>
#include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/core/type_traits.hpp> #include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/clamp.hpp>
#include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/config.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp>
#include <boost/beast/websocket/detail/frame.hpp> #include <boost/beast/websocket/detail/frame.hpp>
#include <boost/asio/coroutine.hpp> #include <boost/asio/coroutine.hpp>
#include <boost/assert.hpp> #include <boost/assert.hpp>
@@ -39,7 +39,7 @@ template<class NextLayer, bool deflateSupported>
template<class Buffers, class Handler> template<class Buffers, class Handler>
class stream<NextLayer, deflateSupported>::write_some_op class stream<NextLayer, deflateSupported>::write_some_op
: public beast::async_op_base< : public beast::async_op_base<
Handler, beast::detail::get_executor_type<stream>> Handler, beast::executor_type<stream>>
, public net::coroutine , public net::coroutine
{ {
stream& ws_; stream& ws_;
@@ -64,7 +64,7 @@ public:
bool fin, bool fin,
Buffers const& bs) Buffers const& bs)
: beast::async_op_base<Handler, : beast::async_op_base<Handler,
beast::detail::get_executor_type<stream>>( beast::executor_type<stream>>(
std::forward<Handler_>(h), ws.get_executor()) std::forward<Handler_>(h), ws.get_executor())
, ws_(ws) , ws_(ws)
, cb_(bs) , cb_(bs)

4
test/doc/core_3_layers.cpp
View File

@@ -13,7 +13,7 @@
#include <boost/beast/_experimental/test/stream.hpp> #include <boost/beast/_experimental/test/stream.hpp>
#include <boost/beast/core/async_op_base.hpp> #include <boost/beast/core/async_op_base.hpp>
#include <boost/beast/core/error.hpp> #include <boost/beast/core/error.hpp>
#include <boost/beast/core/detail/get_executor_type.hpp> #include <boost/beast/core/stream_traits.hpp>
#include <boost/beast/websocket.hpp> #include <boost/beast/websocket.hpp>
#include <boost/asio/async_result.hpp> #include <boost/asio/async_result.hpp>
#include <cstdlib> #include <cstdlib>
@@ -75,7 +75,7 @@ class counted_stream
public: public:
/// The type of executor used by this stream /// The type of executor used by this stream
using executor_type = detail::get_executor_type<NextLayer>; using executor_type = beast::executor_type<NextLayer>;
/// Constructor /// Constructor
template <class... Args> template <class... Args>