boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-08-03 06:44:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

Qualify buffer_copy, don't qualify buffer_size:

Browse Source 
fix #1416

* Calls to buffer_copy are qualified as net::buffer_copy
* Calls to buffer_size are made unqualified, permitting
  argument dependent lookup to take effect.
This commit is contained in:
Vinnie Falco
2019-02-02 10:53:54 -08:00
parent 5b0b218d96
commit a142969c5d
34 changed files with 162 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@@ -3,6 +3,7 @@ Version 209:
* Faster http::string_to_field * Faster http::string_to_field
* async_echo supports move-only handlers * async_echo supports move-only handlers
* test::stream maintains a handler work guard * test::stream maintains a handler work guard
* Qualify buffer_copy, don't qualify buffer_size
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------

6
include/boost/beast/_experimental/core/detail/flat_stream.hpp
View File

@@ -42,15 +42,15 @@ public:
auto last = net::buffer_sequence_end(buffers); auto last = net::buffer_sequence_end(buffers);
if(first != last) if(first != last)
{ {
result.size = net::buffer_size(*first); using net::buffer_size;
result.size = buffer_size(*first);
if(result.size < limit) if(result.size < limit)
{ {
auto it = first; auto it = first;
auto prev = first; auto prev = first;
while(++it != last) while(++it != last)
{ {
auto const n = auto const n = buffer_size(*it);
net::buffer_size(*it);
if(result.size + n > limit) if(result.size + n > limit)
break; break;
result.size += n; result.size += n;

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

@@ -18,7 +18,6 @@
#include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/buffers_suffix.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/beast/core/detail/get_executor_type.hpp>
#include <boost/beast/core/handler_ptr.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>
@@ -240,12 +239,11 @@ public:
goto upcall; goto upcall;
} }
d_.s.copy_ = static_cast<unsigned char>( d_.s.copy_ = static_cast<unsigned char>(
buffer_copy( net::buffer_copy(
net::buffer(d_.s.buf_), net::buffer(d_.s.buf_),
icy_stream::version() + d_.b.max_size())); icy_stream::version() + d_.b.max_size()));
bytes_transferred = buffer_copy( bytes_transferred = net::buffer_copy(
d_.b.value(), d_.b.value(), icy_stream::version());
icy_stream::version());
goto upcall; goto upcall;
} }

10
include/boost/beast/core/buffers_suffix.hpp
View File

@@ -44,7 +44,8 @@ namespace beast {
void send(SyncWriteStream& stream, ConstBufferSequence const& buffers) void send(SyncWriteStream& stream, ConstBufferSequence const& buffers)
{ {
buffers_suffix<ConstBufferSequence> bs{buffers}; buffers_suffix<ConstBufferSequence> bs{buffers};
while(net::buffer_size(bs) > 0) using net::buffer_size;
while(buffer_size(bs) > 0)
bs.consume(stream.write_some(bs)); bs.consume(stream.write_some(bs));
} }
@endcode @endcode
@@ -79,13 +80,6 @@ public:
*/ */
#if BOOST_BEAST_DOXYGEN #if BOOST_BEAST_DOXYGEN
using value_type = __see_below__; using value_type = __see_below__;
#elif 0
using value_type = typename std::conditional<
std::is_convertible<typename
std::iterator_traits<iter_type>::value_type,
net::mutable_buffer>::value,
net::mutable_buffer,
net::const_buffer>::type;
#else #else
using value_type = buffers_type<BufferSequence>; using value_type = buffers_type<BufferSequence>;
#endif #endif

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

@@ -161,8 +161,6 @@ read_some(MutableBufferSequence const& buffers,
static_assert(net::is_mutable_buffer_sequence< static_assert(net::is_mutable_buffer_sequence<
MutableBufferSequence>::value, MutableBufferSequence>::value,
"MutableBufferSequence requirements not met"); "MutableBufferSequence requirements not met");
using net::buffer_size;
using net::buffer_copy;
if(buffer_.size() == 0) if(buffer_.size() == 0)
{ {
if(capacity_ == 0) if(capacity_ == 0)
@@ -178,7 +176,7 @@ read_some(MutableBufferSequence const& buffers,
ec = {}; ec = {};
} }
auto bytes_transferred = auto bytes_transferred =
buffer_copy(buffers, buffer_.data()); net::buffer_copy(buffers, buffer_.data());
buffer_.consume(bytes_transferred); buffer_.consume(bytes_transferred);
return bytes_transferred; return bytes_transferred;
} }

20
include/boost/beast/core/impl/buffers_adaptor.hpp
View File

@@ -415,7 +415,12 @@ buffers_adaptor(
, begin_(net::buffer_sequence_begin(bs_)) , begin_(net::buffer_sequence_begin(bs_))
, out_ (net::buffer_sequence_begin(bs_)) , out_ (net::buffer_sequence_begin(bs_))
, end_ (net::buffer_sequence_begin(bs_)) , end_ (net::buffer_sequence_begin(bs_))
, max_size_(net::buffer_size(bs_)) , max_size_(
[&]
{
using net::buffer_size;
return buffer_size(bs_);
}())
{ {
} }
@@ -497,14 +502,15 @@ prepare(std::size_t n) ->
end_ = out_; end_ = out_;
if(end_ != net::buffer_sequence_end(bs_)) if(end_ != net::buffer_sequence_end(bs_))
{ {
auto size = net::buffer_size(*end_) - out_pos_; using net::buffer_size;
auto size = buffer_size(*end_) - out_pos_;
if(n > size) if(n > size)
{ {
n -= size; n -= size;
while(++end_ != while(++end_ !=
net::buffer_sequence_end(bs_)) net::buffer_sequence_end(bs_))
{ {
size = net::buffer_size(*end_); size = buffer_size(*end_);
if(n < size) if(n < size)
{ {
out_end_ = n; out_end_ = n;
@@ -539,8 +545,9 @@ commit(std::size_t n) noexcept
auto const last = std::prev(end_); auto const last = std::prev(end_);
while(out_ != last) while(out_ != last)
{ {
using net::buffer_size;
auto const avail = auto const avail =
net::buffer_size(*out_) - out_pos_; buffer_size(*out_) - out_pos_;
if(n < avail) if(n < avail)
{ {
out_pos_ += n; out_pos_ += n;
@@ -557,7 +564,7 @@ commit(std::size_t n) noexcept
n, out_end_ - out_pos_); n, out_end_ - out_pos_);
out_pos_ += n; out_pos_ += n;
in_size_ += n; in_size_ += n;
if(out_pos_ == net::buffer_size(*out_)) if(out_pos_ == buffer_size(*out_))
{ {
++out_; ++out_;
out_pos_ = 0; out_pos_ = 0;
@@ -572,8 +579,9 @@ consume(std::size_t n) noexcept
{ {
while(begin_ != out_) while(begin_ != out_)
{ {
using net::buffer_size;
auto const avail = auto const avail =
net::buffer_size(*begin_) - in_pos_; buffer_size(*begin_) - in_pos_;
if(n < avail) if(n < avail)
{ {
in_size_ -= n; in_size_ -= n;

3
include/boost/beast/core/impl/buffers_prefix.hpp
View File

@@ -149,7 +149,8 @@ setup(std::size_t size)
auto const last = bs_.end(); auto const last = bs_.end();
while(end_ != last) while(end_ != last)
{ {
auto const len = net::buffer_size(*end_++); using net::buffer_size;
auto const len = buffer_size(*end_++);
if(len >= size) if(len >= size)
{ {
size_ += size; size_ += size;

3
include/boost/beast/core/impl/buffers_suffix.hpp
View File

@@ -206,8 +206,9 @@ consume(std::size_t amount)
net::buffer_sequence_end(bs_); net::buffer_sequence_end(bs_);
for(;amount > 0 && begin_ != end; ++begin_) for(;amount > 0 && begin_ != end; ++begin_)
{ {
using net::buffer_size;
auto const len = auto const len =
net::buffer_size(*begin_) - skip_; buffer_size(*begin_) - skip_;
if(amount < len) if(amount < len)
{ {
skip_ += amount; skip_ += amount;

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

@@ -90,8 +90,7 @@ flat_static_buffer<N>::
flat_static_buffer(flat_static_buffer const& other) flat_static_buffer(flat_static_buffer const& other)
: flat_static_buffer_base(buf_, N) : flat_static_buffer_base(buf_, N)
{ {
using net::buffer_copy; this->commit(net::buffer_copy(
this->commit(buffer_copy(
this->prepare(other.size()), other.data())); this->prepare(other.size()), other.data()));
} }
@@ -101,11 +100,10 @@ flat_static_buffer<N>::
operator=(flat_static_buffer const& other) -> operator=(flat_static_buffer const& other) ->
flat_static_buffer<N>& flat_static_buffer<N>&
{ {
using net::buffer_copy;
if(this == &other) if(this == &other)
return *this; return *this;
this->consume(this->size()); this->consume(this->size());
this->commit(buffer_copy( this->commit(net::buffer_copy(
this->prepare(other.size()), other.data())); this->prepare(other.size()), other.data()));
return *this; return *this;
} }

3
include/boost/beast/http/basic_dynamic_body.hpp
View File

@@ -88,7 +88,6 @@ struct basic_dynamic_body
put(ConstBufferSequence const& buffers, put(ConstBufferSequence const& buffers,
error_code& ec) error_code& ec)
{ {
using net::buffer_copy;
using net::buffer_size; using net::buffer_size;
auto const n = buffer_size(buffers); auto const n = buffer_size(buffers);
if(body_.size() > body_.max_size() - n) if(body_.size() > body_.max_size() - n)
@@ -104,7 +103,7 @@ struct basic_dynamic_body
if(ec) if(ec)
return 0; return 0;
auto const bytes_transferred = auto const bytes_transferred =
buffer_copy(*mb, buffers); net::buffer_copy(*mb, buffers);
body_.commit(bytes_transferred); body_.commit(bytes_transferred);
return bytes_transferred; return bytes_transferred;
} }

5
include/boost/beast/http/buffer_body.hpp
View File

@@ -121,19 +121,18 @@ struct buffer_body
put(ConstBufferSequence const& buffers, put(ConstBufferSequence const& buffers,
error_code& ec) error_code& ec)
{ {
using net::buffer_size;
using net::buffer_copy;
if(! body_.data) if(! body_.data)
{ {
ec = error::need_buffer; ec = error::need_buffer;
return 0; return 0;
} }
auto const bytes_transferred = auto const bytes_transferred =
buffer_copy(net::buffer( net::buffer_copy(net::buffer(
body_.data, body_.size), buffers); body_.data, body_.size), buffers);
body_.data = static_cast<char*>( body_.data = static_cast<char*>(
body_.data) + bytes_transferred; body_.data) + bytes_transferred;
body_.size -= bytes_transferred; body_.size -= bytes_transferred;
using net::buffer_size;
if(bytes_transferred == buffer_size(buffers)) if(bytes_transferred == buffer_size(buffers))
ec = {}; ec = {};
else else

10
include/boost/beast/http/impl/basic_parser.ipp
View File

@@ -94,8 +94,6 @@ put(ConstBufferSequence const& buffers,
static_assert(net::is_const_buffer_sequence< static_assert(net::is_const_buffer_sequence<
ConstBufferSequence>::value, ConstBufferSequence>::value,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
using net::buffer_copy;
using net::buffer_size;
auto const p = net::buffer_sequence_begin(buffers); auto const p = net::buffer_sequence_begin(buffers);
auto const last = net::buffer_sequence_end(buffers); auto const last = net::buffer_sequence_end(buffers);
if(p == last) if(p == last)
@@ -108,6 +106,7 @@ put(ConstBufferSequence const& buffers,
// single buffer // single buffer
return put(net::const_buffer(*p), ec); return put(net::const_buffer(*p), ec);
} }
using net::buffer_size;
auto const size = buffer_size(buffers); auto const size = buffer_size(buffers);
if(size <= max_stack_buffer) if(size <= max_stack_buffer)
return put_from_stack(size, buffers, ec); return put_from_stack(size, buffers, ec);
@@ -118,7 +117,7 @@ put(ConstBufferSequence const& buffers,
buf_len_ = size; buf_len_ = size;
} }
// flatten // flatten
buffer_copy(net::buffer( net::buffer_copy(net::buffer(
buf_.get(), buf_len_), buffers); buf_.get(), buf_len_), buffers);
return put(net::const_buffer{ return put(net::const_buffer{
buf_.get(), buf_len_}, ec); buf_.get(), buf_len_}, ec);
@@ -304,9 +303,8 @@ put_from_stack(std::size_t size,
error_code& ec) error_code& ec)
{ {
char buf[max_stack_buffer]; char buf[max_stack_buffer];
using net::buffer; net::buffer_copy(net::mutable_buffer(
using net::buffer_copy; buf, sizeof(buf)), buffers);
buffer_copy(buffer(buf, sizeof(buf)), buffers);
return put(net::const_buffer{ return put(net::const_buffer{
buf, size}, ec); buf, size}, ec);
} }

24
include/boost/beast/http/impl/chunk_encode.ipp
View File

@@ -89,7 +89,11 @@ template<class ConstBufferSequence>
chunk_body<ConstBufferSequence>:: chunk_body<ConstBufferSequence>::
chunk_body(ConstBufferSequence const& buffers) chunk_body(ConstBufferSequence const& buffers)
: view_( : view_(
net::buffer_size(buffers), [&]
{
using net::buffer_size;
return buffer_size(buffers);
}(),
net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0},
chunk_crlf{}, chunk_crlf{},
buffers, buffers,
@@ -103,7 +107,11 @@ chunk_body(
ConstBufferSequence const& buffers, ConstBufferSequence const& buffers,
string_view extensions) string_view extensions)
: view_( : view_(
net::buffer_size(buffers), [&]
{
using net::buffer_size;
return buffer_size(buffers);
}(),
net::const_buffer{ net::const_buffer{
extensions.data(), extensions.size()}, extensions.data(), extensions.size()},
chunk_crlf{}, chunk_crlf{},
@@ -122,7 +130,11 @@ chunk_body(
typename std::decay<ChunkExtensions>::type>>( typename std::decay<ChunkExtensions>::type>>(
std::forward<ChunkExtensions>(extensions))) std::forward<ChunkExtensions>(extensions)))
, view_( , view_(
net::buffer_size(buffers), [&]
{
using net::buffer_size;
return buffer_size(buffers);
}(),
exts_->str(), exts_->str(),
chunk_crlf{}, chunk_crlf{},
buffers, buffers,
@@ -141,7 +153,11 @@ chunk_body(
typename std::decay<ChunkExtensions>::type>>(allocator, typename std::decay<ChunkExtensions>::type>>(allocator,
std::forward<ChunkExtensions>(extensions))) std::forward<ChunkExtensions>(extensions)))
, view_( , view_(
net::buffer_size(buffers), [&]
{
using net::buffer_size;
return buffer_size(buffers);
}(),
exts_->str(), exts_->str(),
chunk_crlf{}, chunk_crlf{},
buffers, buffers,

3
include/boost/beast/http/span_body.hpp
View File

@@ -96,7 +96,6 @@ public:
error_code& ec) error_code& ec)
{ {
using net::buffer_size; using net::buffer_size;
using net::buffer_copy;
auto const n = buffer_size(buffers); auto const n = buffer_size(buffers);
auto const len = body_.size(); auto const len = body_.size();
if(n > len) if(n > len)
@@ -105,7 +104,7 @@ public:
return 0; return 0;
} }
ec = {}; ec = {};
buffer_copy(net::buffer( net::buffer_copy(net::buffer(
body_.data(), n), buffers); body_.data(), n), buffers);
body_ = value_type{ body_ = value_type{
body_.data() + n, body_.size() - n}; body_.data() + n, body_.size() - n};

1
include/boost/beast/http/string_body.hpp
View File

@@ -118,7 +118,6 @@ public:
error_code& ec) error_code& ec)
{ {
using net::buffer_size; using net::buffer_size;
using net::buffer_copy;
auto const extra = buffer_size(buffers); auto const extra = buffer_size(buffers);
auto const size = body_.size(); auto const size = body_.size();
try try

3
include/boost/beast/http/vector_body.hpp
View File

@@ -112,7 +112,6 @@ public:
error_code& ec) error_code& ec)
{ {
using net::buffer_size; using net::buffer_size;
using net::buffer_copy;
auto const n = buffer_size(buffers); auto const n = buffer_size(buffers);
auto const len = body_.size(); auto const len = body_.size();
try try
@@ -125,7 +124,7 @@ public:
return 0; return 0;
} }
ec = {}; ec = {};
return buffer_copy(net::buffer( return net::buffer_copy(net::buffer(
&body_[0] + len, n), buffers); &body_[0] + len, n), buffers);
} }

17
include/boost/beast/websocket/detail/frame.hpp
View File

@@ -184,8 +184,6 @@ template<class DynamicBuffer>
void void
write(DynamicBuffer& db, frame_header const& fh) write(DynamicBuffer& db, frame_header const& fh)
{ {
using net::buffer;
using net::buffer_copy;
using namespace boost::endian; using namespace boost::endian;
std::size_t n; std::size_t n;
std::uint8_t b[14]; std::uint8_t b[14];
@@ -220,8 +218,8 @@ write(DynamicBuffer& db, frame_header const& fh)
native_to_little_uint32(fh.key, &b[n]); native_to_little_uint32(fh.key, &b[n]);
n += 4; n += 4;
} }
db.commit(buffer_copy( db.commit(net::buffer_copy(
db.prepare(n), buffer(b))); db.prepare(n), net::buffer(b)));
} }
// Read data from buffers // Read data from buffers
@@ -231,12 +229,10 @@ template<class Buffers>
void void
read_ping(ping_data& data, Buffers const& bs) read_ping(ping_data& data, Buffers const& bs)
{ {
using net::buffer_copy;
using net::buffer_size; using net::buffer_size;
using net::mutable_buffer;
BOOST_ASSERT(buffer_size(bs) <= data.max_size()); BOOST_ASSERT(buffer_size(bs) <= data.max_size());
data.resize(buffer_size(bs)); data.resize(buffer_size(bs));
buffer_copy(mutable_buffer{ net::buffer_copy(net::mutable_buffer{
data.data(), data.size()}, bs); data.data(), data.size()}, bs);
} }
@@ -251,9 +247,8 @@ read_close(
error_code& ec) error_code& ec)
{ {
using net::buffer; using net::buffer;
using net::buffer_copy;
using net::buffer_size;
using namespace boost::endian; using namespace boost::endian;
using net::buffer_size;
auto n = buffer_size(bs); auto n = buffer_size(bs);
BOOST_ASSERT(n <= 125); BOOST_ASSERT(n <= 125);
if(n == 0) if(n == 0)
@@ -271,7 +266,7 @@ read_close(
buffers_suffix<Buffers> cb(bs); buffers_suffix<Buffers> cb(bs);
{ {
std::uint8_t b[2]; std::uint8_t b[2];
buffer_copy(buffer(b), cb); net::buffer_copy(buffer(b), cb);
cr.code = big_uint16_to_native(&b[0]); cr.code = big_uint16_to_native(&b[0]);
cb.consume(2); cb.consume(2);
n -= 2; n -= 2;
@@ -285,7 +280,7 @@ read_close(
if(n > 0) if(n > 0)
{ {
cr.reason.resize(n); cr.reason.resize(n);
buffer_copy(buffer(&cr.reason[0], n), cb); net::buffer_copy(buffer(&cr.reason[0], n), cb);
if(! check_utf8( if(! check_utf8(
cr.reason.data(), cr.reason.size())) cr.reason.data(), cr.reason.size()))
{ {

3
include/boost/beast/websocket/detail/stream_base.hpp
View File

@@ -123,7 +123,8 @@ struct impl_base<true>
cb.consume(zs.total_in); cb.consume(zs.total_in);
if(zs.avail_out > 0 && fin) if(zs.avail_out > 0 && fin)
{ {
auto const remain = net::buffer_size(cb); using net::buffer_size;
auto const remain = buffer_size(cb);
if(remain == 0) if(remain == 0)
{ {
// Inspired by Mark Adler // Inspired by Mark Adler

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

@@ -121,15 +121,14 @@ public:
template<class Buffers> template<class Buffers>
void run(Buffers const& buffers) void run(Buffers const& buffers)
{ {
using net::buffer_copy;
using net::buffer_size;
error_code ec; error_code ec;
using net::buffer_size;
auto const mb = beast::detail::dynamic_buffer_prepare( auto const mb = beast::detail::dynamic_buffer_prepare(
ws_.impl_->rd_buf, buffer_size(buffers), ec, ws_.impl_->rd_buf, buffer_size(buffers), ec,
error::buffer_overflow); error::buffer_overflow);
if(ec) if(ec)
return (*this)(ec); return (*this)(ec);
ws_.impl_->rd_buf.commit(buffer_copy(*mb, buffers)); ws_.impl_->rd_buf.commit(net::buffer_copy(*mb, buffers));
(*this)(ec); (*this)(ec);
} }
@@ -296,15 +295,14 @@ accept(
static_assert(net::is_const_buffer_sequence< static_assert(net::is_const_buffer_sequence<
ConstBufferSequence>::value, ConstBufferSequence>::value,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
using net::buffer_copy;
using net::buffer_size;
impl_->reset(); impl_->reset();
using net::buffer_size;
auto const mb = beast::detail::dynamic_buffer_prepare( auto const mb = beast::detail::dynamic_buffer_prepare(
impl_->rd_buf, buffer_size(buffers), ec, impl_->rd_buf, buffer_size(buffers), ec,
error::buffer_overflow); error::buffer_overflow);
if(ec) if(ec)
return; return;
impl_->rd_buf.commit(buffer_copy(*mb, buffers)); impl_->rd_buf.commit(net::buffer_copy(*mb, buffers));
do_accept(&default_decorate_res, ec); do_accept(&default_decorate_res, ec);
} }
@@ -328,15 +326,14 @@ accept_ex(
static_assert(net::is_const_buffer_sequence< static_assert(net::is_const_buffer_sequence<
ConstBufferSequence>::value, ConstBufferSequence>::value,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
using net::buffer_copy;
using net::buffer_size;
impl_->reset(); impl_->reset();
using net::buffer_size;
auto const mb = beast::detail::dynamic_buffer_prepare( auto const mb = beast::detail::dynamic_buffer_prepare(
impl_->rd_buf, buffer_size(buffers), ec, impl_->rd_buf, buffer_size(buffers), ec,
error::buffer_overflow); error::buffer_overflow);
if(ec) if(ec)
return; return;
impl_->rd_buf.commit(buffer_copy(*mb, buffers)); impl_->rd_buf.commit(net::buffer_copy(*mb, buffers));
do_accept(decorator, ec); do_accept(decorator, ec);
} }

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

@@ -12,7 +12,6 @@
#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/handler_ptr.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/get_executor_type.hpp>
#include <boost/beast/websocket/detail/frame.hpp> #include <boost/beast/websocket/detail/frame.hpp>

13
include/boost/beast/websocket/impl/stream.hpp
View File

@@ -282,8 +282,6 @@ parse_fh(
DynamicBuffer& b, DynamicBuffer& b,
error_code& ec) error_code& ec)
{ {
using net::buffer;
using net::buffer_copy;
using net::buffer_size; using net::buffer_size;
if(buffer_size(b.data()) < 2) if(buffer_size(b.data()) < 2)
{ {
@@ -297,7 +295,8 @@ parse_fh(
std::size_t need; std::size_t need;
{ {
std::uint8_t tmp[2]; std::uint8_t tmp[2];
cb.consume(buffer_copy(buffer(tmp), cb)); cb.consume(net::buffer_copy(
net::buffer(tmp), cb));
fh.len = tmp[1] & 0x7f; fh.len = tmp[1] & 0x7f;
switch(fh.len) switch(fh.len)
{ {
@@ -408,7 +407,7 @@ parse_fh(
{ {
std::uint8_t tmp[2]; std::uint8_t tmp[2];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp)); BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
cb.consume(buffer_copy(buffer(tmp), cb)); cb.consume(net::buffer_copy(net::buffer(tmp), cb));
fh.len = detail::big_uint16_to_native(&tmp[0]); fh.len = detail::big_uint16_to_native(&tmp[0]);
if(fh.len < 126) if(fh.len < 126)
{ {
@@ -422,7 +421,7 @@ parse_fh(
{ {
std::uint8_t tmp[8]; std::uint8_t tmp[8];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp)); BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
cb.consume(buffer_copy(buffer(tmp), cb)); cb.consume(net::buffer_copy(net::buffer(tmp), cb));
fh.len = detail::big_uint64_to_native(&tmp[0]); fh.len = detail::big_uint64_to_native(&tmp[0]);
if(fh.len < 65536) if(fh.len < 65536)
{ {
@@ -437,7 +436,7 @@ parse_fh(
{ {
std::uint8_t tmp[4]; std::uint8_t tmp[4];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp)); BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
cb.consume(buffer_copy(buffer(tmp), cb)); cb.consume(net::buffer_copy(net::buffer(tmp), cb));
fh.key = detail::little_uint32_to_native(&tmp[0]); fh.key = detail::little_uint32_to_native(&tmp[0]);
detail::prepare_key(impl_->rd_key, fh.key); detail::prepare_key(impl_->rd_key, fh.key);
} }
@@ -456,7 +455,7 @@ parse_fh(
else else
{ {
if(impl_->rd_size > (std::numeric_limits< if(impl_->rd_size > (std::numeric_limits<
std::uint64_t>::max)() - fh.len) std::uint64_t>::max)() - fh.len)
{ {
// message size exceeds configured limit // message size exceeds configured limit
ec = error::message_too_big; ec = error::message_too_big;

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

@@ -88,10 +88,7 @@ operator()(
bool cont) bool cont)
{ {
using beast::detail::clamp; using beast::detail::clamp;
using net::buffer;
using net::buffer_copy;
using net::buffer_size; using net::buffer_size;
using net::mutable_buffer;
enum enum
{ {
do_nomask_nofrag, do_nomask_nofrag,
@@ -266,9 +263,9 @@ operator()(
detail::write<flat_static_buffer_base>( detail::write<flat_static_buffer_base>(
ws_.impl_->wr_fb, fh_); ws_.impl_->wr_fb, fh_);
n = clamp(remain_, ws_.impl_->wr_buf_size); n = clamp(remain_, ws_.impl_->wr_buf_size);
buffer_copy(buffer( net::buffer_copy(net::buffer(
ws_.impl_->wr_buf.get(), n), cb_); ws_.impl_->wr_buf.get(), n), cb_);
detail::mask_inplace(buffer( detail::mask_inplace(net::buffer(
ws_.impl_->wr_buf.get(), n), key_); ws_.impl_->wr_buf.get(), n), key_);
remain_ -= n; remain_ -= n;
ws_.impl_->wr_cont = ! fin_; ws_.impl_->wr_cont = ! fin_;
@@ -276,7 +273,7 @@ operator()(
BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD
net::async_write( net::async_write(
ws_.impl_->stream, buffers_cat(ws_.impl_->wr_fb.data(), ws_.impl_->stream, buffers_cat(ws_.impl_->wr_fb.data(),
buffer(ws_.impl_->wr_buf.get(), n)), net::buffer(ws_.impl_->wr_buf.get(), n)),
std::move(*this)); std::move(*this));
if(! ws_.impl_->check_ok(ec)) if(! ws_.impl_->check_ok(ec))
goto upcall; goto upcall;
@@ -286,15 +283,15 @@ operator()(
{ {
cb_.consume(ws_.impl_->wr_buf_size); cb_.consume(ws_.impl_->wr_buf_size);
n = clamp(remain_, ws_.impl_->wr_buf_size); n = clamp(remain_, ws_.impl_->wr_buf_size);
buffer_copy(buffer( net::buffer_copy(net::buffer(
ws_.impl_->wr_buf.get(), n), cb_); ws_.impl_->wr_buf.get(), n), cb_);
detail::mask_inplace(buffer( detail::mask_inplace(net::buffer(
ws_.impl_->wr_buf.get(), n), key_); ws_.impl_->wr_buf.get(), n), key_);
remain_ -= n; remain_ -= n;
// Send partial payload // Send partial payload
BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD
net::async_write(ws_.impl_->stream, net::async_write(ws_.impl_->stream,
buffer(ws_.impl_->wr_buf.get(), n), net::buffer(ws_.impl_->wr_buf.get(), n),
std::move(*this)); std::move(*this));
if(! ws_.impl_->check_ok(ec)) if(! ws_.impl_->check_ok(ec))
goto upcall; goto upcall;
@@ -315,9 +312,9 @@ operator()(
fh_.key = ws_.create_mask(); fh_.key = ws_.create_mask();
fh_.fin = fin_ ? remain_ == 0 : false; fh_.fin = fin_ ? remain_ == 0 : false;
detail::prepare_key(key_, fh_.key); detail::prepare_key(key_, fh_.key);
buffer_copy(buffer( net::buffer_copy(net::buffer(
ws_.impl_->wr_buf.get(), n), cb_); ws_.impl_->wr_buf.get(), n), cb_);
detail::mask_inplace(buffer( detail::mask_inplace(net::buffer(
ws_.impl_->wr_buf.get(), n), key_); ws_.impl_->wr_buf.get(), n), key_);
ws_.impl_->wr_fb.clear(); ws_.impl_->wr_fb.clear();
detail::write<flat_static_buffer_base>( detail::write<flat_static_buffer_base>(
@@ -327,7 +324,7 @@ operator()(
BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD
net::async_write(ws_.impl_->stream, net::async_write(ws_.impl_->stream,
buffers_cat(ws_.impl_->wr_fb.data(), buffers_cat(ws_.impl_->wr_fb.data(),
buffer(ws_.impl_->wr_buf.get(), n)), net::buffer(ws_.impl_->wr_buf.get(), n)),
std::move(*this)); std::move(*this));
if(! ws_.impl_->check_ok(ec)) if(! ws_.impl_->check_ok(ec))
goto upcall; goto upcall;
@@ -358,7 +355,7 @@ operator()(
{ {
for(;;) for(;;)
{ {
b = buffer(ws_.impl_->wr_buf.get(), b = net::buffer(ws_.impl_->wr_buf.get(),
ws_.impl_->wr_buf_size); ws_.impl_->wr_buf_size);
more_ = ws_.impl_->deflate(b, cb_, fin_, in_, ec); more_ = ws_.impl_->deflate(b, cb_, fin_, in_, ec);
if(! ws_.impl_->check_ok(ec)) if(! ws_.impl_->check_ok(ec))
@@ -473,8 +470,6 @@ write_some(bool fin,
ConstBufferSequence>::value, ConstBufferSequence>::value,
"ConstBufferSequence requirements not met"); "ConstBufferSequence requirements not met");
using beast::detail::clamp; using beast::detail::clamp;
using net::buffer;
using net::buffer_copy;
using net::buffer_size; using net::buffer_size;
std::size_t bytes_transferred = 0; std::size_t bytes_transferred = 0;
ec = {}; ec = {};
@@ -503,7 +498,7 @@ write_some(bool fin,
ConstBufferSequence> cb{buffers}; ConstBufferSequence> cb{buffers};
for(;;) for(;;)
{ {
auto b = buffer( auto b = net::buffer(
impl_->wr_buf.get(), impl_->wr_buf_size); impl_->wr_buf.get(), impl_->wr_buf_size);
auto const more = impl_->deflate( auto const more = impl_->deflate(
b, cb, fin, bytes_transferred, ec); b, cb, fin, bytes_transferred, ec);
@@ -605,9 +600,11 @@ write_some(bool fin,
buffers_suffix< buffers_suffix<
ConstBufferSequence> cb{buffers}; ConstBufferSequence> cb{buffers};
{ {
auto const n = clamp(remain, impl_->wr_buf_size); auto const n =
auto const b = buffer(impl_->wr_buf.get(), n); clamp(remain, impl_->wr_buf_size);
buffer_copy(b, cb); auto const b =
net::buffer(impl_->wr_buf.get(), n);
net::buffer_copy(b, cb);
cb.consume(n); cb.consume(n);
remain -= n; remain -= n;
detail::mask_inplace(b, key); detail::mask_inplace(b, key);
@@ -620,9 +617,11 @@ write_some(bool fin,
} }
while(remain > 0) while(remain > 0)
{ {
auto const n = clamp(remain, impl_->wr_buf_size); auto const n =
auto const b = buffer(impl_->wr_buf.get(), n); clamp(remain, impl_->wr_buf_size);
buffer_copy(b, cb); auto const b =
net::buffer(impl_->wr_buf.get(), n);
net::buffer_copy(b, cb);
cb.consume(n); cb.consume(n);
remain -= n; remain -= n;
detail::mask_inplace(b, key); detail::mask_inplace(b, key);
@@ -643,9 +642,11 @@ write_some(bool fin,
fh.key = this->create_mask(); fh.key = this->create_mask();
detail::prepared_key key; detail::prepared_key key;
detail::prepare_key(key, fh.key); detail::prepare_key(key, fh.key);
auto const n = clamp(remain, impl_->wr_buf_size); auto const n =
auto const b = buffer(impl_->wr_buf.get(), n); clamp(remain, impl_->wr_buf_size);
buffer_copy(b, cb); auto const b =
net::buffer(impl_->wr_buf.get(), n);
net::buffer_copy(b, cb);
detail::mask_inplace(b, key); detail::mask_inplace(b, key);
fh.len = n; fh.len = n;
remain -= n; remain -= n;

9
test/beast/core/buffer_test.hpp
View File

@@ -183,6 +183,7 @@ test_buffer_sequence(
// bidirectional // bidirectional
{ {
using net::buffer_size;
auto const first = auto const first =
net::buffer_sequence_begin(buffers); net::buffer_sequence_begin(buffers);
auto const last = auto const last =
@@ -194,7 +195,7 @@ test_buffer_sequence(
m = 0; m = 0;
n = length; n = length;
for(it = first; n--; ++it) for(it = first; n--; ++it)
m += net::buffer_size(*it); m += buffer_size(*it);
BEAST_EXPECT(it == last); BEAST_EXPECT(it == last);
BEAST_EXPECT(m == size); BEAST_EXPECT(m == size);
@@ -202,7 +203,7 @@ test_buffer_sequence(
m = 0; m = 0;
n = length; n = length;
for(it = first; n--;) for(it = first; n--;)
m += net::buffer_size(*it++); m += buffer_size(*it++);
BEAST_EXPECT(it == last); BEAST_EXPECT(it == last);
BEAST_EXPECT(m == size); BEAST_EXPECT(m == size);
@@ -210,7 +211,7 @@ test_buffer_sequence(
m = 0; m = 0;
n = length; n = length;
for(it = last; n--;) for(it = last; n--;)
m += net::buffer_size(*--it); m += buffer_size(*--it);
BEAST_EXPECT(it == first); BEAST_EXPECT(it == first);
BEAST_EXPECT(m == size); BEAST_EXPECT(m == size);
@@ -220,7 +221,7 @@ test_buffer_sequence(
for(it = last; n--;) for(it = last; n--;)
{ {
it--; it--;
m += net::buffer_size(*it); m += buffer_size(*it);
} }
BEAST_EXPECT(it == first); BEAST_EXPECT(it == first);
BEAST_EXPECT(m == size); BEAST_EXPECT(m == size);

34
test/beast/core/buffered_read_stream.cpp
View File

@@ -97,16 +97,14 @@ public:
void void
do_read() do_read()
{ {
using net::buffer;
using net::buffer_copy;
s_.resize(13); s_.resize(13);
fc_.emplace(n_); fc_.emplace(n_);
ts_.emplace(ioc_, *fc_, ", world!"); ts_.emplace(ioc_, *fc_, ", world!");
brs_.emplace(*ts_); brs_.emplace(*ts_);
brs_->buffer().commit(buffer_copy( brs_->buffer().commit(net::buffer_copy(
brs_->buffer().prepare(5), buffer("Hello", 5))); brs_->buffer().prepare(5), net::buffer("Hello", 5)));
net::async_read(*brs_, net::async_read(*brs_,
buffer(&s_[0], s_.size()), net::buffer(&s_[0], s_.size()),
std::bind( std::bind(
&loop::on_read, &loop::on_read,
shared_from_this(), shared_from_this(),
@@ -124,8 +122,6 @@ public:
void testRead(yield_context do_yield) void testRead(yield_context do_yield)
{ {
using net::buffer;
using net::buffer_copy;
static std::size_t constexpr limit = 100; static std::size_t constexpr limit = 100;
std::size_t n; std::size_t n;
std::string s; std::string s;
@@ -137,10 +133,10 @@ public:
test::stream ts(ioc_, fc, ", world!"); test::stream ts(ioc_, fc, ", world!");
buffered_read_stream< buffered_read_stream<
test::stream&, multi_buffer> srs(ts); test::stream&, multi_buffer> srs(ts);
srs.buffer().commit(buffer_copy( srs.buffer().commit(net::buffer_copy(
srs.buffer().prepare(5), buffer("Hello", 5))); srs.buffer().prepare(5), net::buffer("Hello", 5)));
error_code ec = test::error::test_failure; error_code ec = test::error::test_failure;
net::read(srs, buffer(&s[0], s.size()), ec); net::read(srs, net::buffer(&s[0], s.size()), ec);
if(! ec) if(! ec)
{ {
BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");
@@ -156,10 +152,10 @@ public:
buffered_read_stream< buffered_read_stream<
test::stream&, multi_buffer> srs(ts); test::stream&, multi_buffer> srs(ts);
srs.capacity(3); srs.capacity(3);
srs.buffer().commit(buffer_copy( srs.buffer().commit(net::buffer_copy(
srs.buffer().prepare(5), buffer("Hello", 5))); srs.buffer().prepare(5), net::buffer("Hello", 5)));
error_code ec = test::error::test_failure; error_code ec = test::error::test_failure;
net::read(srs, buffer(&s[0], s.size()), ec); net::read(srs, net::buffer(&s[0], s.size()), ec);
if(! ec) if(! ec)
{ {
BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");
@@ -174,11 +170,11 @@ public:
test::stream ts(ioc_, fc, ", world!"); test::stream ts(ioc_, fc, ", world!");
buffered_read_stream< buffered_read_stream<
test::stream&, multi_buffer> srs(ts); test::stream&, multi_buffer> srs(ts);
srs.buffer().commit(buffer_copy( srs.buffer().commit(net::buffer_copy(
srs.buffer().prepare(5), buffer("Hello", 5))); srs.buffer().prepare(5), net::buffer("Hello", 5)));
error_code ec = test::error::test_failure; error_code ec = test::error::test_failure;
net::async_read( net::async_read(
srs, buffer(&s[0], s.size()), do_yield[ec]); srs, net::buffer(&s[0], s.size()), do_yield[ec]);
if(! ec) if(! ec)
{ {
BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");
@@ -194,11 +190,11 @@ public:
buffered_read_stream< buffered_read_stream<
test::stream&, multi_buffer> srs(ts); test::stream&, multi_buffer> srs(ts);
srs.capacity(3); srs.capacity(3);
srs.buffer().commit(buffer_copy( srs.buffer().commit(net::buffer_copy(
srs.buffer().prepare(5), buffer("Hello", 5))); srs.buffer().prepare(5), net::buffer("Hello", 5)));
error_code ec = test::error::test_failure; error_code ec = test::error::test_failure;
net::async_read( net::async_read(
srs, buffer(&s[0], s.size()), do_yield[ec]); srs, net::buffer(&s[0], s.size()), do_yield[ec]);
if(! ec) if(! ec)
{ {
BEAST_EXPECT(s == "Hello, world!"); BEAST_EXPECT(s == "Hello, world!");

6
test/beast/core/buffers_cat.cpp
View File

@@ -298,12 +298,8 @@ public:
void void
testGccWarning2() testGccWarning2()
{ {
using net::buffer;
using net::buffer_copy;
using net::const_buffer;
char out[64]; char out[64];
const_buffer buffers("Hello, world!", 13); net::const_buffer buffers("Hello, world!", 13);
std::size_t i = 3; std::size_t i = 3;
buffers_suffix<net::const_buffer> cb{buffers}; buffers_suffix<net::const_buffer> cb{buffers};
cb.consume(i); cb.consume(i);

5
test/beast/http/basic_parser.cpp
View File

@@ -156,7 +156,8 @@ public:
parsegrind(ConstBufferSequence const& buffers, parsegrind(ConstBufferSequence const& buffers,
Test const& test, bool skip = false) Test const& test, bool skip = false)
{ {
auto const size = net::buffer_size(buffers); using net::buffer_size;
auto const size = buffer_size(buffers);
for(std::size_t i = 1; i < size - 1; ++i) for(std::size_t i = 1; i < size - 1; ++i)
{ {
Parser p; Parser p;
@@ -174,7 +175,7 @@ public:
n = p.put(cb, ec); n = p.put(cb, ec);
if(! BEAST_EXPECTS(! ec, ec.message())) if(! BEAST_EXPECTS(! ec, ec.message()))
continue; continue;
if(! BEAST_EXPECT(n == net::buffer_size(cb))) if(! BEAST_EXPECT(n == buffer_size(cb)))
continue; continue;
if(p.need_eof()) if(p.need_eof())
{ {

3
test/beast/http/file_body.cpp
View File

@@ -33,8 +33,9 @@ public:
void void
operator()(error_code&, ConstBufferSequence const& buffers) operator()(error_code&, ConstBufferSequence const& buffers)
{ {
using net::buffer_size;
buffer.commit(net::buffer_copy( buffer.commit(net::buffer_copy(
buffer.prepare(net::buffer_size(buffers)), buffer.prepare(buffer_size(buffers)),
buffers)); buffers));
} }
}; };

22
test/beast/http/read.cpp
View File

@@ -39,16 +39,14 @@ public:
void void
failMatrix(char const* s, yield_context do_yield) failMatrix(char const* s, yield_context do_yield)
{ {
using net::buffer;
using net::buffer_copy;
static std::size_t constexpr limit = 100; static std::size_t constexpr limit = 100;
std::size_t n; std::size_t n;
auto const len = strlen(s); auto const len = strlen(s);
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
multi_buffer b; multi_buffer b;
b.commit(buffer_copy( b.commit(net::buffer_copy(
b.prepare(len), buffer(s, len))); b.prepare(len), net::buffer(s, len)));
test::fail_count fc(n); test::fail_count fc(n);
test::stream ts{ioc_, fc}; test::stream ts{ioc_, fc};
test_parser<isRequest> p(fc); test_parser<isRequest> p(fc);
@@ -63,8 +61,8 @@ public:
{ {
static std::size_t constexpr pre = 10; static std::size_t constexpr pre = 10;
multi_buffer b; multi_buffer b;
b.commit(buffer_copy( b.commit(net::buffer_copy(
b.prepare(pre), buffer(s, pre))); b.prepare(pre), net::buffer(s, pre)));
test::fail_count fc(n); test::fail_count fc(n);
test::stream ts{ioc_, fc, test::stream ts{ioc_, fc,
std::string(s + pre, len - pre)}; std::string(s + pre, len - pre)};
@@ -79,8 +77,8 @@ public:
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
multi_buffer b; multi_buffer b;
b.commit(buffer_copy( b.commit(net::buffer_copy(
b.prepare(len), buffer(s, len))); b.prepare(len), net::buffer(s, len)));
test::fail_count fc(n); test::fail_count fc(n);
test::stream ts{ioc_, fc}; test::stream ts{ioc_, fc};
test_parser<isRequest> p(fc); test_parser<isRequest> p(fc);
@@ -94,8 +92,8 @@ public:
for(n = 0; n < limit; ++n) for(n = 0; n < limit; ++n)
{ {
multi_buffer b; multi_buffer b;
b.commit(buffer_copy( b.commit(net::buffer_copy(
b.prepare(len), buffer(s, len))); b.prepare(len), net::buffer(s, len)));
test::fail_count fc(n); test::fail_count fc(n);
test::stream ts{ioc_, fc}; test::stream ts{ioc_, fc};
test_parser<isRequest> p(fc); test_parser<isRequest> p(fc);
@@ -110,8 +108,8 @@ public:
{ {
static std::size_t constexpr pre = 10; static std::size_t constexpr pre = 10;
multi_buffer b; multi_buffer b;
b.commit(buffer_copy( b.commit(net::buffer_copy(
b.prepare(pre), buffer(s, pre))); b.prepare(pre), net::buffer(s, pre)));
test::fail_count fc(n); test::fail_count fc(n);
test::stream ts(ioc_, fc, test::stream ts(ioc_, fc,
std::string{s + pre, len - pre}); std::string{s + pre, len - pre});

3
test/beast/http/serializer.cpp
View File

@@ -91,7 +91,8 @@ public:
operator()(error_code&, operator()(error_code&,
ConstBufferSequence const& buffers) ConstBufferSequence const& buffers)
{ {
size = net::buffer_size(buffers); using net::buffer_size;
size = buffer_size(buffers);
} }
}; };

3
test/beast/http/span_body.cpp
View File

@@ -23,6 +23,7 @@ struct span_body_test
void void
testSpanBody() testSpanBody()
{ {
using net::buffer_size;
{ {
using B = span_body<char const>; using B = span_body<char const>;
request<B> req; request<B> req;
@@ -42,7 +43,7 @@ struct span_body_test
BEAST_EXPECTS(! ec, ec.message()); BEAST_EXPECTS(! ec, ec.message());
if(! BEAST_EXPECT(buf != boost::none)) if(! BEAST_EXPECT(buf != boost::none))
return; return;
BEAST_EXPECT(net::buffer_size(buf->first) == 3); BEAST_EXPECT(buffer_size(buf->first) == 3);
BEAST_EXPECT(! buf->second); BEAST_EXPECT(! buf->second);
} }
{ {

3
test/beast/websocket/test.hpp
View File

@@ -434,9 +434,8 @@ public:
DynamicBuffer& buffer, DynamicBuffer& buffer,
ConstBufferSequence const& buffers) ConstBufferSequence const& buffers)
{ {
using net::buffer_copy;
using net::buffer_size; using net::buffer_size;
buffer.commit(buffer_copy( buffer.commit(net::buffer_copy(
buffer.prepare(buffer_size(buffers)), buffer.prepare(buffer_size(buffers)),
buffers)); buffers));
} }

3
test/bench/wsload/wsload.cpp
View File

@@ -187,8 +187,9 @@ private:
void void
do_write() do_write()
{ {
using net::buffer_size;
std::geometric_distribution<std::size_t> dist{ std::geometric_distribution<std::size_t> dist{
double(4) / net::buffer_size(tb_)}; double(4) / buffer_size(tb_)};
ws_.async_write_some(true, ws_.async_write_some(true,
boost::beast::buffers_prefix(dist(rng_), tb_), boost::beast::buffers_prefix(dist(rng_), tb_),
alloc_.wrap(std::bind( alloc_.wrap(std::bind(

3
test/doc/exemplars.cpp
View File

@@ -164,7 +164,8 @@ struct BodyReader
// The specification requires this to indicate "no error" // The specification requires this to indicate "no error"
ec = {}; ec = {};
return net::buffer_size(buffers); using net::buffer_size;
return buffer_size(buffers);
} }
/** Called when the body is complete. /** Called when the body is complete.

19
test/doc/http_snippets.cpp
View File

@@ -272,10 +272,11 @@ void fxx() {
auto const cb3 = get_next_chunk_body(); auto const cb3 = get_next_chunk_body();
// Manually emit a chunk by first writing the chunk-size header with the correct size // Manually emit a chunk by first writing the chunk-size header with the correct size
using net::buffer_size;
net::write(sock, chunk_header{ net::write(sock, chunk_header{
net::buffer_size(cb1) + buffer_size(cb1) +
net::buffer_size(cb2) + buffer_size(cb2) +
net::buffer_size(cb3)}); buffer_size(cb3)});
// And then output the chunk body in three pieces ("chunk the chunk") // And then output the chunk body in three pieces ("chunk the chunk")
net::write(sock, cb1); net::write(sock, cb1);
@@ -367,7 +368,8 @@ print_cxx14(message<isRequest, Body, Fields> const& m)
{ {
ec = {}; ec = {};
std::cout << buffers(buffer); std::cout << buffers(buffer);
sr.consume(net::buffer_size(buffer)); using net::buffer_size;
sr.consume(buffer_size(buffer));
}); });
} }
while(! ec && ! sr.is_done()); while(! ec && ! sr.is_done());
@@ -394,7 +396,8 @@ struct lambda
{ {
ec = {}; ec = {};
std::cout << buffers(buffer); std::cout << buffers(buffer);
sr.consume(net::buffer_size(buffer)); using net::buffer_size;
sr.consume(buffer_size(buffer));
} }
}; };
@@ -435,7 +438,8 @@ split_print_cxx14(message<isRequest, Body, Fields> const& m)
{ {
ec = {}; ec = {};
std::cout << buffers(buffer); std::cout << buffers(buffer);
sr.consume(net::buffer_size(buffer)); using net::buffer_size;
sr.consume(buffer_size(buffer));
}); });
} }
while(! sr.is_header_done()); while(! sr.is_header_done());
@@ -449,7 +453,8 @@ split_print_cxx14(message<isRequest, Body, Fields> const& m)
{ {
ec = {}; ec = {};
std::cout << buffers(buffer); std::cout << buffers(buffer);
sr.consume(net::buffer_size(buffer)); using net::buffer_size;
sr.consume(buffer_size(buffer));
}); });
} }
while(! ec && ! sr.is_done()); while(! ec && ! sr.is_done());