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

Update for Net-TS Asio (API Change):

Browse Source 
fix #769

The following classes are removed:

* handler_type
* async_result
* async_completion
* is_dynamic_buffer
* is_const_buffer_sequence
* is_mutable_buffer_sequence
* handler_alloc

Actions Required:

* Use BOOST_ASIO_HANDLER_TYPE instead of handler_type
* Use BOOST_ASIO_INITFN_RESULT_TYPE instead of async_result
* Use boost::asio::async_completion
* Use boost::asio::is_dynamic_buffer
* Use boost::asio::is_const_buffer_sequence
* Use boost::asio::is_mutable_buffer_sequence
* boost::asio::associated_allocator_t replaces handler_alloc
This commit is contained in:
Vinnie Falco committed 2017-10-23 17:11:27 -07:00
1 parent 9dc9ca13b9
commit 3a28e999af
173 files changed
+3214 -4138
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

include/boost/beast/core/impl/buffered_read_stream.ipp
+33 -40
View File
@@ -16,9 +16,10 @@
#include <boost/beast/core/read_size.hpp>
#include <boost/beast/core/type_traits.hpp>
#include <boost/beast/core/detail/config.hpp>
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/associated_allocator.hpp>
#include <boost/asio/associated_executor.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/asio/post.hpp>
#include <boost/throw_exception.hpp>
namespace boost {
@@ -48,28 +49,28 @@ public:
{
}
using allocator_type =
boost::asio::associated_allocator_t<Handler>;
allocator_type
get_allocator() const noexcept
{
return boost::asio::get_associated_allocator(h_);
}
using executor_type = boost::asio::associated_executor_t<
Handler, decltype(s_.get_executor())>;
executor_type get_executor() const noexcept
{
return boost::asio::get_associated_executor(
h_, s_.get_executor());
}
void
operator()(error_code const& ec,
std::size_t bytes_transferred);
friend
void* asio_handler_allocate(
std::size_t size, read_some_op* op)
{
using boost::asio::asio_handler_allocate;
return asio_handler_allocate(
size, std::addressof(op->h_));
}
friend
void asio_handler_deallocate(
void* p, std::size_t size, read_some_op* op)
{
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p, size, std::addressof(op->h_));
}
friend
bool asio_handler_is_continuation(read_some_op* op)
{
@@ -77,14 +78,6 @@ public:
return asio_handler_is_continuation(
std::addressof(op->h_));
}
template<class Function>
friend
void asio_handler_invoke(Function&& f, read_some_op* op)
{
using boost::asio::asio_handler_invoke;
asio_handler_invoke(f, std::addressof(op->h_));
}
};
template<class Stream, class DynamicBuffer>
@@ -116,9 +109,9 @@ read_some_op<MutableBufferSequence, Handler>::operator()(
}
step_ = 3;
s_.get_io_service().post(
return boost::asio::post(
s_.get_executor(),
bind_handler(std::move(*this), ec, 0));
return;
case 1:
// upcall
@@ -153,11 +146,11 @@ auto
buffered_read_stream<Stream, DynamicBuffer>::
async_write_some(ConstBufferSequence const& buffers,
WriteHandler&& handler) ->
async_return_type<WriteHandler, void(error_code)>
BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, void(error_code))
{
static_assert(is_async_write_stream<next_layer_type>::value,
"AsyncWriteStream requirements not met");
static_assert(is_const_buffer_sequence<
static_assert(boost::asio::is_const_buffer_sequence<
ConstBufferSequence>::value,
"ConstBufferSequence requirements not met");
static_assert(is_completion_handler<WriteHandler,
@@ -176,7 +169,7 @@ read_some(
{
static_assert(is_sync_read_stream<next_layer_type>::value,
"SyncReadStream requirements not met");
static_assert(is_mutable_buffer_sequence<
static_assert(boost::asio::is_mutable_buffer_sequence<
MutableBufferSequence>::value,
"MutableBufferSequence requirements not met");
error_code ec;
@@ -195,7 +188,7 @@ read_some(MutableBufferSequence const& buffers,
{
static_assert(is_sync_read_stream<next_layer_type>::value,
"SyncReadStream requirements not met");
static_assert(is_mutable_buffer_sequence<
static_assert(boost::asio::is_mutable_buffer_sequence<
MutableBufferSequence>::value,
"MutableBufferSequence requirements not met");
using boost::asio::buffer_size;
@@ -226,20 +219,20 @@ auto
buffered_read_stream<Stream, DynamicBuffer>::
async_read_some(MutableBufferSequence const& buffers,
ReadHandler&& handler) ->
async_return_type<ReadHandler, void(error_code)>
BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, void(error_code))
{
static_assert(is_async_read_stream<next_layer_type>::value,
"Stream requirements not met");
static_assert(is_mutable_buffer_sequence<
"AsyncReadStream requirements not met");
static_assert(boost::asio::is_mutable_buffer_sequence<
MutableBufferSequence>::value,
"MutableBufferSequence requirements not met");
if(buffer_.size() == 0 && capacity_ == 0)
return next_layer_.async_read_some(buffers,
std::forward<ReadHandler>(handler));
async_completion<ReadHandler,
boost::asio::async_completion<ReadHandler,
void(error_code, std::size_t)> init{handler};
read_some_op<MutableBufferSequence, handler_type<
ReadHandler, void(error_code, std::size_t)>>{
read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
ReadHandler, void(error_code, std::size_t))>{
init.completion_handler, *this, buffers}(
error_code{}, 0);
return init.result.get();
include/boost/beast/core/impl/buffers_adapter.ipp
+43 -34
View File
@@ -90,11 +90,10 @@ public:
reference
operator*() const
{
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
return value_type{buffer_cast<void const*>(*it_),
(ba_->out_ == ba_->bs_.end() ||
it_ != ba_->out_) ? buffer_size(*it_) : ba_->out_pos_} +
value_type const b = *it_;
return value_type{b.data(),
(ba_->out_ == boost::asio::buffer_sequence_end(ba_->bs_) ||
it_ != ba_->out_) ? b.size() : ba_->out_pos_} +
(it_ == ba_->begin_ ? ba_->in_pos_ : 0);
}
@@ -233,11 +232,10 @@ public:
reference
operator*() const
{
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
return value_type{buffer_cast<void*>(*it_),
value_type const b = *it_;
return value_type{b.data(),
it_ == std::prev(ba_->end_) ?
ba_->out_end_ : buffer_size(*it_)} +
ba_->out_end_ : b.size()} +
(it_ == ba_->out_ ? ba_->out_pos_ : 0);
}
@@ -288,7 +286,9 @@ private:
template<class MutableBufferSequence>
inline
auto
buffers_adapter<MutableBufferSequence>::mutable_buffers_type::begin() const ->
buffers_adapter<MutableBufferSequence>::
mutable_buffers_type::
begin() const ->
const_iterator
{
return const_iterator{*ba_, ba_->out_};
@@ -297,7 +297,9 @@ buffers_adapter<MutableBufferSequence>::mutable_buffers_type::begin() const ->
template<class MutableBufferSequence>
inline
auto
buffers_adapter<MutableBufferSequence>::mutable_buffers_type::end() const ->
buffers_adapter<MutableBufferSequence>::
mutable_buffers_type::
end() const ->
const_iterator
{
return const_iterator{*ba_, ba_->end_};
@@ -309,9 +311,9 @@ template<class MutableBufferSequence>
buffers_adapter<MutableBufferSequence>::buffers_adapter(
buffers_adapter&& other)
: buffers_adapter(std::move(other),
std::distance<iter_type>(other.bs_.begin(), other.begin_),
std::distance<iter_type>(other.bs_.begin(), other.out_),
std::distance<iter_type>(other.bs_.begin(), other.end_))
std::distance<iter_type>(boost::asio::buffer_sequence_begin(other.bs_), other.begin_),
std::distance<iter_type>(boost::asio::buffer_sequence_begin(other.bs_), other.out_),
std::distance<iter_type>(boost::asio::buffer_sequence_begin(other.bs_), other.end_))
{
}
@@ -319,9 +321,9 @@ template<class MutableBufferSequence>
buffers_adapter<MutableBufferSequence>::buffers_adapter(
buffers_adapter const& other)
: buffers_adapter(other,
std::distance<iter_type>(other.bs_.begin(), other.begin_),
std::distance<iter_type>(other.bs_.begin(), other.out_),
std::distance<iter_type>(other.bs_.begin(), other.end_))
std::distance<iter_type>(boost::asio::buffer_sequence_begin(other.bs_), other.begin_),
std::distance<iter_type>(boost::asio::buffer_sequence_begin(other.bs_), other.out_),
std::distance<iter_type>(boost::asio::buffer_sequence_begin(other.bs_), other.end_))
{
}
@@ -331,15 +333,18 @@ buffers_adapter<MutableBufferSequence>::operator=(
buffers_adapter&& other) -> buffers_adapter&
{
auto const nbegin = std::distance<iter_type>(
other.bs_.begin(), other.begin_);
boost::asio::buffer_sequence_begin(other.bs_),
other.begin_);
auto const nout = std::distance<iter_type>(
other.bs_.begin(), other.out_);
boost::asio::buffer_sequence_begin(other.bs_),
other.out_);
auto const nend = std::distance<iter_type>(
other.bs_.begin(), other.end_);
boost::asio::buffer_sequence_begin(other.bs_),
other.end_);
bs_ = std::move(other.bs_);
begin_ = std::next(bs_.begin(), nbegin);
out_ = std::next(bs_.begin(), nout);
end_ = std::next(bs_.begin(), nend);
begin_ = std::next(boost::asio::buffer_sequence_begin(bs_), nbegin);
out_ = std::next(boost::asio::buffer_sequence_begin(bs_), nout);
end_ = std::next(boost::asio::buffer_sequence_begin(bs_), nend);
max_size_ = other.max_size_;
in_pos_ = other.in_pos_;
in_size_ = other.in_size_;
@@ -354,15 +359,18 @@ buffers_adapter<MutableBufferSequence>::operator=(
buffers_adapter const& other) -> buffers_adapter&
{
auto const nbegin = std::distance<iter_type>(
other.bs_.begin(), other.begin_);
boost::asio::buffer_sequence_begin(other.bs_),
other.begin_);
auto const nout = std::distance<iter_type>(
other.bs_.begin(), other.out_);
boost::asio::buffer_sequence_begin(other.bs_),
other.out_);
auto const nend = std::distance<iter_type>(
other.bs_.begin(), other.end_);
boost::asio::buffer_sequence_begin(other.bs_),
other.end_);
bs_ = other.bs_;
begin_ = std::next(bs_.begin(), nbegin);
out_ = std::next(bs_.begin(), nout);
end_ = std::next(bs_.begin(), nend);
begin_ = std::next(boost::asio::buffer_sequence_begin(bs_), nbegin);
out_ = std::next(boost::asio::buffer_sequence_begin(bs_), nout);
end_ = std::next(boost::asio::buffer_sequence_begin(bs_), nend);
max_size_ = other.max_size_;
in_pos_ = other.in_pos_;
in_size_ = other.in_size_;
@@ -375,9 +383,9 @@ template<class MutableBufferSequence>
buffers_adapter<MutableBufferSequence>::buffers_adapter(
MutableBufferSequence const& bs)
: bs_(bs)
, begin_(bs_.begin())
, out_(bs_.begin())
, end_(bs_.begin())
, begin_(boost::asio::buffer_sequence_begin(bs_))
, out_ (boost::asio::buffer_sequence_begin(bs_))
, end_ (boost::asio::buffer_sequence_begin(bs_))
, max_size_(boost::asio::buffer_size(bs_))
{
}
@@ -389,13 +397,14 @@ buffers_adapter<MutableBufferSequence>::prepare(std::size_t n) ->
{
using boost::asio::buffer_size;
end_ = out_;
if(end_ != bs_.end())
if(end_ != boost::asio::buffer_sequence_end(bs_))
{
auto size = buffer_size(*end_) - out_pos_;
if(n > size)
{
n -= size;
while(++end_ != bs_.end())
while(++end_ !=
boost::asio::buffer_sequence_end(bs_))
{
size = buffer_size(*end_);
if(n < size)
include/boost/beast/core/impl/buffers_cat.ipp
+17 -9
View File
@@ -30,7 +30,7 @@ class buffers_cat_view<Bn...>::const_iterator
std::size_t n_;
std::tuple<Bn...> const* bn_;
std::array<char, detail::max_sizeof<
typename Bn::const_iterator...>()> buf_;
typename detail::buffer_sequence_iterator<Bn>::type...>()> buf_;
friend class buffers_cat_view<Bn...>;
@@ -38,8 +38,8 @@ class buffers_cat_view<Bn...>::const_iterator
using C = std::integral_constant<std::size_t, I>;
template<std::size_t I>
using iter_t = typename std::tuple_element<
I, std::tuple<Bn...>>::type::const_iterator;
using iter_t = typename detail::buffer_sequence_iterator<
typename std::tuple_element<I, std::tuple<Bn...>>::type>::type;
template<std::size_t I>
iter_t<I>&
@@ -123,7 +123,8 @@ private:
{
n_ = I;
new(&buf_[0]) iter_t<I>{
std::get<I>(*bn_).begin()};
boost::asio::buffer_sequence_begin(
std::get<I>(*bn_))};
return;
}
construct(C<I+1>{});
@@ -138,7 +139,8 @@ private:
{
n_ = I;
new(&buf_[0]) iter_t<I>{
std::get<I>(*bn_).end()};
boost::asio::buffer_sequence_end(
std::get<I>(*bn_))};
return;
}
BOOST_THROW_EXCEPTION(std::logic_error{
@@ -154,7 +156,8 @@ private:
{
n_ = I;
new(&buf_[0]) iter_t<I>{
std::get<I>(*bn_).end()};
boost::asio::buffer_sequence_end(
std::get<I>(*bn_))};
return;
}
rconstruct(C<I-1>{});
@@ -268,7 +271,8 @@ private:
if(n_ == I)
{
if(++iter<I>() !=
std::get<I>(*bn_).end())
boost::asio::buffer_sequence_end(
std::get<I>(*bn_)))
return;
using Iter = iter_t<I>;
iter<I>().~Iter();
@@ -292,7 +296,9 @@ private:
{
if(n_ == I)
{
if(iter<I>() != std::get<I>(*bn_).begin())
if(iter<I>() !=
boost::asio::buffer_sequence_begin(
std::get<I>(*bn_)))
{
--iter<I>();
return;
@@ -309,7 +315,9 @@ private:
decrement(C<0> const&)
{
auto constexpr I = 0;
if(iter<I>() != std::get<I>(*bn_).begin())
if(iter<I>() !=
boost::asio::buffer_sequence_begin(
std::get<I>(*bn_)))
{
--iter<I>();
return;
include/boost/beast/core/impl/buffers_prefix.ipp
+20 -16
View File
@@ -27,10 +27,8 @@ boost::asio::const_buffer
buffers_prefix(std::size_t size,
boost::asio::const_buffer buffer)
{
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
return {buffer_cast<void const*>(buffer),
(std::min)(size, buffer_size(buffer))};
return {buffer.data(),
(std::min)(size, buffer.size())};
}
inline
@@ -38,10 +36,8 @@ boost::asio::mutable_buffer
buffers_prefix(std::size_t size,
boost::asio::mutable_buffer buffer)
{
using boost::asio::buffer_cast;
using boost::asio::buffer_size;
return {buffer_cast<void*>(buffer),
(std::min)(size, buffer_size(buffer))};
return {buffer.data(),
(std::min)(size, buffer.size())};
}
} // detail
@@ -138,7 +134,7 @@ private:
std::false_type)
: b_(&b)
, remain_(b_->size_)
, it_(b_->bs_.begin())
, it_(boost::asio::buffer_sequence_begin(b_->bs_))
{
}
};
@@ -149,7 +145,7 @@ buffers_prefix_view<BufferSequence>::
setup(std::size_t size)
{
size_ = 0;
end_ = bs_.begin();
end_ = boost::asio::buffer_sequence_begin(bs_);
auto const last = bs_.end();
while(end_ != last)
{
@@ -170,7 +166,8 @@ buffers_prefix_view<BufferSequence>::
buffers_prefix_view(buffers_prefix_view&& other)
: buffers_prefix_view(std::move(other),
std::distance<iter_type>(
other.bs_.begin(), other.end_))
boost::asio::buffer_sequence_begin(other.bs_),
other.end_))
{
}
@@ -179,7 +176,8 @@ buffers_prefix_view<BufferSequence>::
buffers_prefix_view(buffers_prefix_view const& other)
: buffers_prefix_view(other,
std::distance<iter_type>(
other.bs_.begin(), other.end_))
boost::asio::buffer_sequence_begin(other.bs_),
other.end_))
{
}
@@ -190,10 +188,13 @@ operator=(buffers_prefix_view&& other) ->
buffers_prefix_view&
{
auto const dist = std::distance<iter_type>(
other.bs_.begin(), other.end_);
boost::asio::buffer_sequence_begin(other.bs_),
other.end_);
bs_ = std::move(other.bs_);
size_ = other.size_;
end_ = std::next(bs_.begin(), dist);
end_ = std::next(
boost::asio::buffer_sequence_begin(bs_),
dist);
return *this;
}
@@ -204,10 +205,13 @@ operator=(buffers_prefix_view const& other) ->
buffers_prefix_view&
{
auto const dist = std::distance<iter_type>(
other.bs_.begin(), other.end_);
boost::asio::buffer_sequence_begin(other.bs_),
other.end_);
bs_ = other.bs_;
size_ = other.size_;
end_ = std::next(bs_.begin(), dist);
end_ = std::next(
boost::asio::buffer_sequence_begin(bs_),
dist);
return *this;
}
include/boost/beast/core/impl/buffers_suffix.ipp
+25 -15
View File
@@ -25,8 +25,8 @@ class buffers_suffix<Buffers>::const_iterator
{
friend class buffers_suffix<Buffers>;
using iter_type =
typename Buffers::const_iterator;
using iter_type = typename
detail::buffer_sequence_iterator<Buffers>::type;
iter_type it_;
buffers_suffix const* b_ = nullptr;
@@ -117,7 +117,7 @@ private:
template<class Buffers>
buffers_suffix<Buffers>::
buffers_suffix()
: begin_(bs_.begin())
: begin_(boost::asio::buffer_sequence_begin(bs_))
{
}
@@ -126,7 +126,8 @@ buffers_suffix<Buffers>::
buffers_suffix(buffers_suffix&& other)
: buffers_suffix(std::move(other),
std::distance<iter_type>(
other.bs_.begin(), other.begin_))
boost::asio::buffer_sequence_begin(
other.bs_), other.begin_))
{
}
@@ -135,7 +136,8 @@ buffers_suffix<Buffers>::
buffers_suffix(buffers_suffix const& other)
: buffers_suffix(other,
std::distance<iter_type>(
other.bs_.begin(), other.begin_))
boost::asio::buffer_sequence_begin(
other.bs_), other.begin_))
{
}
@@ -143,11 +145,11 @@ template<class Buffers>
buffers_suffix<Buffers>::
buffers_suffix(Buffers const& bs)
: bs_(bs)
, begin_(bs_.begin())
, begin_(boost::asio::buffer_sequence_begin(bs_))
{
static_assert(
is_const_buffer_sequence<Buffers>::value||
is_mutable_buffer_sequence<Buffers>::value,
boost::asio::is_const_buffer_sequence<Buffers>::value||
boost::asio::is_mutable_buffer_sequence<Buffers>::value,
"BufferSequence requirements not met");
}
@@ -156,7 +158,7 @@ template<class... Args>
buffers_suffix<Buffers>::
buffers_suffix(boost::in_place_init_t, Args&&... args)
: bs_(std::forward<Args>(args)...)
, begin_(bs_.begin())
, begin_(boost::asio::buffer_sequence_begin(bs_))
{
static_assert(sizeof...(Args) > 0,
"Missing constructor arguments");
@@ -172,9 +174,12 @@ operator=(buffers_suffix&& other) ->
buffers_suffix&
{
auto const dist = std::distance<iter_type>(
other.bs_.begin(), other.begin_);
boost::asio::buffer_sequence_begin(other.bs_),
other.begin_);
bs_ = std::move(other.bs_);
begin_ = std::next(bs_.begin(), dist);
begin_ = std::next(
boost::asio::buffer_sequence_begin(bs_),
dist);
skip_ = other.skip_;
return *this;
}
@@ -186,9 +191,11 @@ operator=(buffers_suffix const& other) ->
buffers_suffix&
{
auto const dist = std::distance<iter_type>(
other.bs_.begin(), other.begin_);
boost::asio::buffer_sequence_begin(other.bs_),
other.begin_);
bs_ = other.bs_;
begin_ = std::next(bs_.begin(), dist);
begin_ = std::next(
boost::asio::buffer_sequence_begin(bs_), dist);
skip_ = other.skip_;
return *this;
}
@@ -210,7 +217,8 @@ buffers_suffix<Buffers>::
end() const ->
const_iterator
{
return const_iterator{*this, bs_.end()};
return const_iterator{*this,
boost::asio::buffer_sequence_end(bs_)};
}
template<class Buffers>
@@ -219,7 +227,9 @@ buffers_suffix<Buffers>::
consume(std::size_t amount)
{
using boost::asio::buffer_size;
for(;amount > 0 && begin_ != bs_.end(); ++begin_)
auto const end =
boost::asio::buffer_sequence_end(bs_);
for(;amount > 0 && begin_ != end; ++begin_)
{
auto const len =
buffer_size(*begin_) - skip_;
include/boost/beast/core/impl/handler_ptr.ipp
+29 -19
View File
@@ -10,9 +10,7 @@
#ifndef BOOST_BEAST_IMPL_HANDLER_PTR_HPP
#define BOOST_BEAST_IMPL_HANDLER_PTR_HPP
#include <boost/asio/handler_alloc_hook.hpp>
#include <boost/asio/handler_continuation_hook.hpp>
#include <boost/asio/handler_invoke_hook.hpp>
#include <boost/asio/associated_allocator.hpp>
#include <boost/assert.hpp>
#include <memory>
@@ -27,10 +25,11 @@ P(DeducedHandler&& h, Args&&... args)
: n(1)
, handler(std::forward<DeducedHandler>(h))
{
using boost::asio::asio_handler_allocate;
t = reinterpret_cast<T*>(
asio_handler_allocate(
sizeof(T), std::addressof(handler)));
typename std::allocator_traits<
boost::asio::associated_allocator_t<Handler>>::
template rebind_alloc<T> alloc{
boost::asio::get_associated_allocator(handler)};
t = std::allocator_traits<decltype(alloc)>::allocate(alloc, 1);
try
{
t = new(t) T{handler,
@@ -38,9 +37,8 @@ P(DeducedHandler&& h, Args&&... args)
}
catch(...)
{
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
t, sizeof(T), std::addressof(handler));
std::allocator_traits<
decltype(alloc)>::deallocate(alloc, t, 1);
throw;
}
}
@@ -56,9 +54,13 @@ handler_ptr<T, Handler>::
if(p_->t)
{
p_->t->~T();
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p_->t, sizeof(T), std::addressof(p_->handler));
typename std::allocator_traits<
boost::asio::associated_allocator_t<Handler>>::
template rebind_alloc<T> alloc{
boost::asio::get_associated_allocator(
p_->handler)};
std::allocator_traits<
decltype(alloc)>::deallocate(alloc, p_->t, 1);
}
delete p_;
}
@@ -108,9 +110,13 @@ release_handler() ->
BOOST_ASSERT(p_);
BOOST_ASSERT(p_->t);
p_->t->~T();
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p_->t, sizeof(T), std::addressof(p_->handler));
typename std::allocator_traits<
boost::asio::associated_allocator_t<Handler>>::
template rebind_alloc<T> alloc{
boost::asio::get_associated_allocator(
p_->handler)};
std::allocator_traits<
decltype(alloc)>::deallocate(alloc, p_->t, 1);
p_->t = nullptr;
return std::move(p_->handler);
}
@@ -124,9 +130,13 @@ invoke(Args&&... args)
BOOST_ASSERT(p_);
BOOST_ASSERT(p_->t);
p_->t->~T();
using boost::asio::asio_handler_deallocate;
asio_handler_deallocate(
p_->t, sizeof(T), std::addressof(p_->handler));
typename std::allocator_traits<
boost::asio::associated_allocator_t<Handler>>::
template rebind_alloc<T> alloc{
boost::asio::get_associated_allocator(
p_->handler)};
std::allocator_traits<
decltype(alloc)>::deallocate(alloc, p_->t, 1);
p_->t = nullptr;
p_->handler(std::forward<Args>(args)...);
}
include/boost/beast/core/impl/read_size.ipp
+2 -1
View File
@@ -38,7 +38,8 @@ std::size_t
read_size(DynamicBuffer& buffer,
std::size_t max_size, std::false_type)
{
static_assert(is_dynamic_buffer<DynamicBuffer>::value,
static_assert(
boost::asio::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer requirements not met");
BOOST_ASSERT(max_size >= 1);
auto const size = buffer.size();