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

Rename to buffer_bytes

Browse Source
This commit is contained in:
Vinnie Falco
2019-03-05 08:47:02 -08:00
parent 6ccdcdf51d
commit 9f2b0ce1db
62 changed files with 206 additions and 258 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
CHANGELOG.md
View File

@ -1,3 +1,9 @@
Version 229:
* Rename to buffer_bytes
--------------------------------------------------------------------------------
Version 228:
* Fix UB in decorator:

2
doc/qbk/03_core/5_buffers.qbk
View File

@ -21,7 +21,7 @@ transferred.
[table Buffer Algorithms and Types
[[Name][Description]]
[[
[link beast.ref.boost__beast__buffer_size `buffer_size`]
[link beast.ref.boost__beast__buffer_bytes `buffer_bytes`]
][
This is a more reliable version of
[@boost:/doc/html/boost_asio/reference/buffer_size.html `net::buffer_size`]

2
doc/qbk/quickref.xml
View File

@ -144,7 +144,7 @@
</entry><entry valign="top">
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member><link linkend="beast.ref.boost__beast__buffer_size">buffer_size</link>&nbsp;<emphasis role="green">&#9733;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__buffer_bytes">buffer_bytes</link>&nbsp;<emphasis role="green">&#9733;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__buffers_cat">buffers_cat</link></member>
<member><link linkend="beast.ref.boost__beast__buffers_front">buffers_front</link></member>
<member><link linkend="beast.ref.boost__beast__buffers_prefix">buffers_prefix</link></member>

2
doc/qbk/release_notes.qbk
View File

@ -154,7 +154,7 @@
is preferred over `handler_ptr`
* New
`buffer_size`
`buffer_bytes`
replacement for `net::buffer_size`
* New:

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

@ -45,7 +45,7 @@ buffer_shift(MutableBuffers const& out, ConstBuffers const& in)
auto out_pos = net::buffer_sequence_end(out);
auto const in_begin = net::buffer_sequence_begin(in);
auto const out_begin = net::buffer_sequence_begin(out);
BOOST_ASSERT(buffer_size(in) == buffer_size(out));
BOOST_ASSERT(buffer_bytes(in) == buffer_bytes(out));
if(in_pos == in_begin || out_pos == out_begin)
return;
net::const_buffer cb{*--in_pos};

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

@ -109,7 +109,7 @@ class stream::read_op : public stream::read_op_base
b_, sp->b.data(), sp->read_max);
sp->b.consume(bytes_transferred);
}
else if (buffer_size(b_) > 0)
else if (buffer_bytes(b_) > 0)
{
ec = net::error::eof;
}
@ -177,7 +177,7 @@ struct stream::run_read_op
std::move(h),
in,
buffers)},
buffer_size(buffers));
buffer_bytes(buffers));
}
};
@ -217,7 +217,7 @@ struct stream::run_write_op
return upcall(ec, n);
// A request to write 0 bytes to a stream is a no-op.
if(buffer_size(buffers) == 0)
if(buffer_bytes(buffers) == 0)
return upcall(ec, n);
// connection closed
@ -227,7 +227,7 @@ struct stream::run_write_op
// copy buffers
n = std::min<std::size_t>(
buffer_size(buffers), in_->write_max);
buffer_bytes(buffers), in_->write_max);
{
std::lock_guard<std::mutex> lock(out->m);
n = net::buffer_copy(out->b.prepare(n), buffers);
@ -273,7 +273,7 @@ read_some(MutableBufferSequence const& buffers,
return 0;
// A request to read 0 bytes from a stream is a no-op.
if(buffer_size(buffers) == 0)
if(buffer_bytes(buffers) == 0)
{
ec = {};
return 0;
@ -357,7 +357,7 @@ write_some(
return 0;
// A request to write 0 bytes to a stream is a no-op.
if(buffer_size(buffers) == 0)
if(buffer_bytes(buffers) == 0)
{
ec = {};
return 0;
@ -373,7 +373,7 @@ write_some(
// copy buffers
auto n = std::min<std::size_t>(
buffer_size(buffers), in_->write_max);
buffer_bytes(buffers), in_->write_max);
{
std::lock_guard<std::mutex> lock(out->m);
n = net::buffer_copy(out->b.prepare(n), buffers);

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

@ -99,7 +99,7 @@ void stream::initiate_read(
}
// A request to read 0 bytes from a stream is a no-op.
if(buf_size == 0 || buffer_size(in_->b.data()) > 0)
if(buf_size == 0 || buffer_bytes(in_->b.data()) > 0)
{
lock.unlock();
(*op)(ec);
@ -273,7 +273,7 @@ stream::
str() const
{
auto const bs = in_->b.data();
if(buffer_size(bs) == 0)
if(buffer_bytes(bs) == 0)
return {};
auto const b = beast::buffers_front(bs);
return {static_cast<char const*>(b.data()), b.size()};

16
include/boost/beast/core/buffer_size.hpp
View File

@ -1,16 +0,0 @@
//
// Copyright (c) 2016-2019 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_BUFFER_SIZE_HPP
#define BOOST_BEAST_BUFFER_SIZE_HPP
#include <boost/beast/core/detail/config.hpp>
#include <boost/beast/core/buffer_traits.hpp>
#endif

8
include/boost/beast/core/buffer_traits.hpp
View File

@ -143,11 +143,11 @@ using buffers_iterator_type =
This function is designed as an easier-to-use replacement for
`net::buffer_size`. It recognizes customization points found through
argument-dependent lookup. The call `beast::buffer_size(b)` is
argument-dependent lookup. The call `beast::buffer_bytes(b)` is
equivalent to performing:
@code
using namespace net;
buffer_size(b);
buffer_bytes(b);
@endcode
In addition this handles types which are convertible to
`net::const_buffer`; these are not handled by `net::buffer_size`.
@ -162,9 +162,9 @@ using buffers_iterator_type =
#if BOOST_BEAST_DOXYGEN
template<class Buffers>
void
buffer_size(Buffers const& buffers);
buffer_bytes(Buffers const& buffers);
#else
BOOST_BEAST_INLINE_VARIABLE(buffer_size, detail::buffer_size_impl)
BOOST_BEAST_INLINE_VARIABLE(buffer_bytes, detail::buffer_bytes_impl)
#endif
} // beast

2
include/boost/beast/core/buffers_prefix.hpp
View File

@ -129,7 +129,7 @@ public:
#if ! BOOST_BEAST_DOXYGEN
std::size_t
buffer_size_impl() const noexcept
buffer_bytes_impl() const noexcept
{
return size_;
}

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

@ -44,7 +44,7 @@ namespace beast {
void send(SyncWriteStream& stream, ConstBufferSequence const& buffers)
{
buffers_suffix<ConstBufferSequence> bs{buffers};
while(buffer_size(bs) > 0)
while(buffer_bytes(bs) > 0)
bs.consume(stream.write_some(bs));
}
@endcode

2
include/boost/beast/core/buffers_to_string.hpp
View File

@ -49,7 +49,7 @@ buffers_to_string(ConstBufferSequence const& buffers)
net::is_const_buffer_sequence<ConstBufferSequence>::value,
"ConstBufferSequence type requirements not met");
std::string result;
result.reserve(buffer_size(buffers));
result.reserve(buffer_bytes(buffers));
for(auto const buffer : buffers_range_ref(buffers))
result.append(static_cast<char const*>(
buffer.data()), buffer.size());

48
include/boost/beast/core/detail/buffer_traits.hpp
View File

@ -46,65 +46,35 @@ struct buffers_iterator_type_helper<
#endif
template<class T, class = void>
struct has_buffer_size_impl : std::false_type
struct buffer_bytes_impl
{
};
template<class T>
struct has_buffer_size_impl<T, boost::void_t<
decltype(std::declval<std::size_t&>() =
std::declval<T const&>().buffer_size_impl())>>
: std::true_type
{
};
struct buffer_size_impl
{
template<
class B,
class = typename std::enable_if<
std::is_convertible<
B, net::const_buffer>::value>::type>
std::size_t
operator()(B const& b) const
operator()(net::const_buffer b) const noexcept
{
return net::const_buffer(b).size();
}
template<
class B,
class = typename std::enable_if<
! std::is_convertible<
B, net::const_buffer>::value>::type,
class = typename std::enable_if<
net::is_const_buffer_sequence<B>::value &&
! has_buffer_size_impl<B>::value>::type>
std::size_t
operator()(B const& b) const
operator()(net::mutable_buffer b) const noexcept
{
using net::buffer_size;
return buffer_size(b);
return net::mutable_buffer(b).size();
}
template<
class B,
class = typename std::enable_if<
! std::is_convertible<B, net::const_buffer>::value>::type,
class = typename std::enable_if<
net::is_const_buffer_sequence<B>::value>::type,
class = typename std::enable_if<
has_buffer_size_impl<B>::value>::type>
net::is_const_buffer_sequence<B>::value>::type>
std::size_t
operator()(B const& b) const
operator()(B const& b) const noexcept
{
return b.buffer_size_impl();
using net::buffer_size;
return buffer_size(b);
}
};
/** Return `true` if a buffer sequence is empty
This is sometimes faster than using @ref buffer_size
This is sometimes faster than using @ref buffer_bytes
*/
template<class ConstBufferSequence>
bool

4
include/boost/beast/core/detail/flat_stream.hpp
View File

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

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

@ -401,7 +401,7 @@ buffers_adaptor(MutableBufferSequence const& bs)
, max_size_(
[&bs]
{
return buffer_size(bs);
return buffer_bytes(bs);
}())
{
}
@ -418,7 +418,7 @@ buffers_adaptor(
, max_size_(
[&]
{
return buffer_size(bs_);
return buffer_bytes(bs_);
}())
{
}
@ -501,14 +501,14 @@ prepare(std::size_t n) ->
end_ = out_;
if(end_ != net::buffer_sequence_end(bs_))
{
auto size = buffer_size(*end_) - out_pos_;
auto size = buffer_bytes(*end_) - out_pos_;
if(n > size)
{
n -= size;
while(++end_ !=
net::buffer_sequence_end(bs_))
{
size = buffer_size(*end_);
size = buffer_bytes(*end_);
if(n < size)
{
out_end_ = n;
@ -544,7 +544,7 @@ commit(std::size_t n) noexcept
while(out_ != last)
{
auto const avail =
buffer_size(*out_) - out_pos_;
buffer_bytes(*out_) - out_pos_;
if(n < avail)
{
out_pos_ += n;
@ -561,7 +561,7 @@ commit(std::size_t n) noexcept
n, out_end_ - out_pos_);
out_pos_ += n;
in_size_ += n;
if(out_pos_ == buffer_size(*out_))
if(out_pos_ == buffer_bytes(*out_))
{
++out_;
out_pos_ = 0;
@ -577,7 +577,7 @@ consume(std::size_t n) noexcept
while(begin_ != out_)
{
auto const avail =
buffer_size(*begin_) - in_pos_;
buffer_bytes(*begin_) - in_pos_;
if(n < avail)
{
in_size_ -= n;

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

@ -150,7 +150,7 @@ setup(std::size_t size)
auto const last = bs_.end();
while(end_ != last)
{
auto const len = buffer_size(*end_++);
auto const len = buffer_bytes(*end_++);
if(len >= size)
{
size_ += size;
@ -282,12 +282,6 @@ public:
std::forward<Args>(args)...))
{
}
std::size_t
buffer_size_impl() const noexcept
{
return this->size();
}
};
//------------------------------------------------------------------------------
@ -324,12 +318,6 @@ public:
std::forward<Args>(args)...))
{
}
std::size_t
buffer_size_impl() const noexcept
{
return this->size();
}
};
} // beast

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

@ -208,7 +208,7 @@ consume(std::size_t amount)
for(;amount > 0 && begin_ != end; ++begin_)
{
auto const len =
buffer_size(*begin_) - skip_;
buffer_bytes(*begin_) - skip_;
if(amount < len)
{
skip_ += amount;

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

@ -196,7 +196,7 @@ public:
const_iterator end() const noexcept;
std::size_t
buffer_size() const noexcept
buffer_bytes() const noexcept
{
return b_->size();
}
@ -1242,7 +1242,7 @@ basic_multi_buffer<Allocator>::
debug_check() const
{
#ifndef NDEBUG
BOOST_ASSERT(buffer_size(data()) == in_size_);
BOOST_ASSERT(buffer_bytes(data()) == in_size_);
if(list_.empty())
{
BOOST_ASSERT(in_pos_ == 0);

2
include/boost/beast/core/make_printable.hpp
View File

@ -75,7 +75,7 @@ operator<<(std::ostream& os,
print (ConstBufferSequence const& buffers)
{
std::cout <<
"Buffer size: " << buffer_size(buffers) << " bytes\n"
"Buffer size: " << buffer_bytes(buffers) << " bytes\n"
"Buffer data: '" << make_printable(buffers) << "'\n";
}
@endcode

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

@ -88,7 +88,7 @@ struct basic_dynamic_body
put(ConstBufferSequence const& buffers,
error_code& ec)
{
auto const n = buffer_size(buffers);
auto const n = buffer_bytes(buffers);
if(body_.size() > body_.max_size() - n)
{
ec = error::buffer_overflow;

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

@ -133,7 +133,7 @@ struct buffer_body
body_.data = static_cast<char*>(
body_.data) + bytes_transferred;
body_.size -= bytes_transferred;
if(bytes_transferred == buffer_size(buffers))
if(bytes_transferred == buffer_bytes(buffers))
ec = {};
else
ec = error::need_buffer;

2
include/boost/beast/http/impl/basic_parser.hpp
View File

@ -40,7 +40,7 @@ put(ConstBufferSequence const& buffers,
// single buffer
return put(net::const_buffer(*p), ec);
}
auto const size = buffer_size(buffers);
auto const size = buffer_bytes(buffers);
if(size <= max_stack_buffer)
return put_from_stack(size, buffers, ec);
if(size > buf_len_)

8
include/boost/beast/http/impl/chunk_encode.hpp
View File

@ -90,7 +90,7 @@ template<class ConstBufferSequence>
chunk_body<ConstBufferSequence>::
chunk_body(ConstBufferSequence const& buffers)
: view_(
buffer_size(buffers),
buffer_bytes(buffers),
net::const_buffer{nullptr, 0},
chunk_crlf{},
buffers,
@ -104,7 +104,7 @@ chunk_body(
ConstBufferSequence const& buffers,
string_view extensions)
: view_(
buffer_size(buffers),
buffer_bytes(buffers),
net::const_buffer{
extensions.data(), extensions.size()},
chunk_crlf{},
@ -123,7 +123,7 @@ chunk_body(
typename std::decay<ChunkExtensions>::type>>(
std::forward<ChunkExtensions>(extensions)))
, view_(
buffer_size(buffers),
buffer_bytes(buffers),
exts_->str(),
chunk_crlf{},
buffers,
@ -142,7 +142,7 @@ chunk_body(
typename std::decay<ChunkExtensions>::type>>(allocator,
std::forward<ChunkExtensions>(extensions)))
, view_(
buffer_size(buffers),
buffer_bytes(buffers),
exts_->str(),
chunk_crlf{},
buffers,

44
include/boost/beast/http/impl/serializer.hpp
View File

@ -165,7 +165,7 @@ next(error_code& ec, Visit&& visit)
v_.template emplace<7>(
boost::in_place_init,
fwr_->get(),
buffer_size(result->first),
buffer_bytes(result->first),
net::const_buffer{nullptr, 0},
chunk_crlf{},
result->first,
@ -178,7 +178,7 @@ next(error_code& ec, Visit&& visit)
v_.template emplace<4>(
boost::in_place_init,
fwr_->get(),
buffer_size(result->first),
buffer_bytes(result->first),
net::const_buffer{nullptr, 0},
chunk_crlf{},
result->first,
@ -217,7 +217,7 @@ next(error_code& ec, Visit&& visit)
// do it all in one buffer
v_.template emplace<6>(
boost::in_place_init,
buffer_size(result->first),
buffer_bytes(result->first),
net::const_buffer{nullptr, 0},
chunk_crlf{},
result->first,
@ -229,7 +229,7 @@ next(error_code& ec, Visit&& visit)
}
v_.template emplace<5>(
boost::in_place_init,
buffer_size(result->first),
buffer_bytes(result->first),
net::const_buffer{nullptr, 0},
chunk_crlf{},
result->first,
@ -293,9 +293,9 @@ consume(std::size_t n)
{
case do_header:
BOOST_ASSERT(
n <= buffer_size(v_.template get<2>()));
n <= buffer_bytes(v_.template get<2>()));
v_.template get<2>().consume(n);
if(buffer_size(v_.template get<2>()) > 0)
if(buffer_bytes(v_.template get<2>()) > 0)
break;
header_done_ = true;
v_.reset();
@ -306,9 +306,9 @@ consume(std::size_t n)
case do_header_only:
BOOST_ASSERT(
n <= buffer_size(v_.template get<1>()));
n <= buffer_bytes(v_.template get<1>()));
v_.template get<1>().consume(n);
if(buffer_size(v_.template get<1>()) > 0)
if(buffer_bytes(v_.template get<1>()) > 0)
break;
fwr_ = boost::none;
header_done_ = true;
@ -320,9 +320,9 @@ consume(std::size_t n)
case do_body + 2:
{
BOOST_ASSERT(
n <= buffer_size(v_.template get<3>()));
n <= buffer_bytes(v_.template get<3>()));
v_.template get<3>().consume(n);
if(buffer_size(v_.template get<3>()) > 0)
if(buffer_bytes(v_.template get<3>()) > 0)
break;
v_.reset();
if(! more_)
@ -335,9 +335,9 @@ consume(std::size_t n)
case do_header_c:
BOOST_ASSERT(
n <= buffer_size(v_.template get<4>()));
n <= buffer_bytes(v_.template get<4>()));
v_.template get<4>().consume(n);
if(buffer_size(v_.template get<4>()) > 0)
if(buffer_bytes(v_.template get<4>()) > 0)
break;
header_done_ = true;
v_.reset();
@ -350,9 +350,9 @@ consume(std::size_t n)
case do_header_only_c:
{
BOOST_ASSERT(
n <= buffer_size(v_.template get<1>()));
n <= buffer_bytes(v_.template get<1>()));
v_.template get<1>().consume(n);
if(buffer_size(v_.template get<1>()) > 0)
if(buffer_bytes(v_.template get<1>()) > 0)
break;
fwr_ = boost::none;
header_done_ = true;
@ -367,9 +367,9 @@ consume(std::size_t n)
case do_body_c + 2:
BOOST_ASSERT(
n <= buffer_size(v_.template get<5>()));
n <= buffer_bytes(v_.template get<5>()));
v_.template get<5>().consume(n);
if(buffer_size(v_.template get<5>()) > 0)
if(buffer_bytes(v_.template get<5>()) > 0)
break;
v_.reset();
if(more_)
@ -381,9 +381,9 @@ consume(std::size_t n)
case do_body_final_c:
{
BOOST_ASSERT(
n <= buffer_size(v_.template get<6>()));
n <= buffer_bytes(v_.template get<6>()));
v_.template get<6>().consume(n);
if(buffer_size(v_.template get<6>()) > 0)
if(buffer_bytes(v_.template get<6>()) > 0)
break;
v_.reset();
s_ = do_complete;
@ -393,9 +393,9 @@ consume(std::size_t n)
case do_all_c:
{
BOOST_ASSERT(
n <= buffer_size(v_.template get<7>()));
n <= buffer_bytes(v_.template get<7>()));
v_.template get<7>().consume(n);
if(buffer_size(v_.template get<7>()) > 0)
if(buffer_bytes(v_.template get<7>()) > 0)
break;
header_done_ = true;
v_.reset();
@ -404,9 +404,9 @@ consume(std::size_t n)
}
case do_final_c + 1:
BOOST_ASSERT(buffer_size(v_.template get<8>()));
BOOST_ASSERT(buffer_bytes(v_.template get<8>()));
v_.template get<8>().consume(n);
if(buffer_size(v_.template get<8>()) > 0)
if(buffer_bytes(v_.template get<8>()) > 0)
break;
v_.reset();
goto go_complete;

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

@ -96,7 +96,7 @@ public:
put(ConstBufferSequence const& buffers,
error_code& ec)
{
auto const n = buffer_size(buffers);
auto const n = buffer_bytes(buffers);
auto const len = body_.size();
if(n > len)
{

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

@ -110,7 +110,7 @@ public:
put(ConstBufferSequence const& buffers,
error_code& ec)
{
auto const extra = buffer_size(buffers);
auto const extra = buffer_bytes(buffers);
auto const size = body_.size();
if (extra > body_.max_size() - size)
{

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

@ -104,7 +104,7 @@ public:
put(ConstBufferSequence const& buffers,
error_code& ec)
{
auto const n = buffer_size(buffers);
auto const n = buffer_bytes(buffers);
auto const len = body_.size();
if (n > body_.max_size() - len)
{

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

@ -238,8 +238,8 @@ template<class Buffers>
void
read_ping(ping_data& data, Buffers const& bs)
{
BOOST_ASSERT(buffer_size(bs) <= data.max_size());
data.resize(buffer_size(bs));
BOOST_ASSERT(buffer_bytes(bs) <= data.max_size());
data.resize(buffer_bytes(bs));
net::buffer_copy(net::mutable_buffer{
data.data(), data.size()}, bs);
}
@ -255,7 +255,7 @@ read_close(
error_code& ec)
{
using namespace boost::endian;
auto n = buffer_size(bs);
auto n = buffer_bytes(bs);
BOOST_ASSERT(n <= 125);
if(n == 0)
{

2
include/boost/beast/websocket/detail/impl_base.hpp
View File

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

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

@ -271,7 +271,7 @@ public:
error_code ec;
auto const mb =
beast::detail::dynamic_buffer_prepare(
impl.rd_buf, buffer_size(buffers),
impl.rd_buf, buffer_bytes(buffers),
ec, error::buffer_overflow);
if(! ec)
impl.rd_buf.commit(
@ -433,7 +433,7 @@ do_accept(
impl_->reset();
auto const mb =
beast::detail::dynamic_buffer_prepare(
impl_->rd_buf, buffer_size(buffers), ec,
impl_->rd_buf, buffer_bytes(buffers), ec,
error::buffer_overflow);
if(ec)
return;

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

@ -211,7 +211,7 @@ public:
auto const b = buffers_prefix(
clamp(impl.rd_fh.len),
impl.rd_buf.data());
auto const len = buffer_size(b);
auto const len = buffer_bytes(b);
BOOST_ASSERT(len == impl.rd_fh.len);
ping_data payload;
detail::read_ping(payload, b);
@ -278,7 +278,7 @@ public:
}
auto const cb = buffers_prefix(clamp(
impl.rd_fh.len), impl.rd_buf.data());
auto const len = buffer_size(cb);
auto const len = buffer_bytes(cb);
BOOST_ASSERT(len == impl.rd_fh.len);
ping_data payload;
detail::read_ping(payload, cb);
@ -303,7 +303,7 @@ public:
}
auto const cb = buffers_prefix(clamp(
impl.rd_fh.len), impl.rd_buf.data());
auto const len = buffer_size(cb);
auto const len = buffer_bytes(cb);
BOOST_ASSERT(len == impl.rd_fh.len);
BOOST_ASSERT(! impl.rd_close);
impl.rd_close = true;
@ -350,7 +350,7 @@ public:
{
if(impl.rd_buf.size() == 0 && impl.rd_buf.max_size() >
(std::min)(clamp(impl.rd_remain),
buffer_size(cb_)))
buffer_bytes(cb_)))
{
// Fill the read buffer first, otherwise we
// get fewer bytes at the cost of one I/O.
@ -397,8 +397,8 @@ public:
{
// Read into caller's buffer
BOOST_ASSERT(impl.rd_remain > 0);
BOOST_ASSERT(buffer_size(cb_) > 0);
BOOST_ASSERT(buffer_size(buffers_prefix(
BOOST_ASSERT(buffer_bytes(cb_) > 0);
BOOST_ASSERT(buffer_bytes(buffers_prefix(
clamp(impl.rd_remain), cb_)) > 0);
BOOST_ASIO_CORO_YIELD
impl.stream().async_read_some(buffers_prefix(
@ -435,7 +435,7 @@ public:
// Read compressed message frame payload:
// inflate even if rd_fh_.len == 0, otherwise we
// never emit the end-of-stream deflate block.
while(buffer_size(cb_) > 0)
while(buffer_bytes(cb_) > 0)
{
if( impl.rd_remain > 0 &&
impl.rd_buf.size() == 0 &&
@ -976,7 +976,7 @@ loop:
// Get control frame payload
auto const b = buffers_prefix(
clamp(impl.rd_fh.len), impl.rd_buf.data());
auto const len = buffer_size(b);
auto const len = buffer_bytes(b);
BOOST_ASSERT(len == impl.rd_fh.len);
// Clear this otherwise the next
@ -1059,7 +1059,7 @@ loop:
{
if(impl.rd_buf.size() == 0 && impl.rd_buf.max_size() >
(std::min)(clamp(impl.rd_remain),
buffer_size(buffers)))
buffer_bytes(buffers)))
{
// Fill the read buffer first, otherwise we
// get fewer bytes at the cost of one I/O.
@ -1103,8 +1103,8 @@ loop:
{
// Read into caller's buffer
BOOST_ASSERT(impl.rd_remain > 0);
BOOST_ASSERT(buffer_size(buffers) > 0);
BOOST_ASSERT(buffer_size(buffers_prefix(
BOOST_ASSERT(buffer_bytes(buffers) > 0);
BOOST_ASSERT(buffer_bytes(buffers_prefix(
clamp(impl.rd_remain), buffers)) > 0);
auto const bytes_transferred =
impl.stream().read_some(buffers_prefix(
@ -1144,7 +1144,7 @@ loop:
//
bool did_read = false;
buffers_suffix<MutableBufferSequence> cb(buffers);
while(buffer_size(cb) > 0)
while(buffer_bytes(cb) > 0)
{
zlib::z_params zs;
{

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

@ -279,7 +279,7 @@ secure_prng(bool value)
template<class NextLayer, bool deflateSupported>
void
stream<NextLayer, deflateSupported>::
write_buffer_size(std::size_t amount)
write_buffer_bytes(std::size_t amount)
{
if(amount < 8)
BOOST_THROW_EXCEPTION(std::invalid_argument{
@ -290,7 +290,7 @@ write_buffer_size(std::size_t amount)
template<class NextLayer, bool deflateSupported>
std::size_t
stream<NextLayer, deflateSupported>::
write_buffer_size() const
write_buffer_bytes() const
{
return impl_->wr_buf_opt;
}

14
include/boost/beast/websocket/impl/stream_impl.hpp
View File

@ -645,7 +645,7 @@ parse_fh(
DynamicBuffer& b,
error_code& ec)
{
if(buffer_size(b.data()) < 2)
if(buffer_bytes(b.data()) < 2)
{
// need more bytes
ec = {};
@ -670,7 +670,7 @@ parse_fh(
fh.mask = (tmp[1] & 0x80) != 0;
if(fh.mask)
need += 4;
if(buffer_size(cb) < need)
if(buffer_bytes(cb) < need)
{
// need more bytes
ec = {};
@ -757,7 +757,7 @@ parse_fh(
return false;
}
if(detail::is_control(fh.op) &&
buffer_size(cb) < need + fh.len)
buffer_bytes(cb) < need + fh.len)
{
// Make the entire control frame payload
// get read in before we return `true`
@ -768,7 +768,7 @@ parse_fh(
case 126:
{
std::uint8_t tmp[2];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
BOOST_ASSERT(buffer_bytes(cb) >= sizeof(tmp));
cb.consume(net::buffer_copy(net::buffer(tmp), cb));
fh.len = detail::big_uint16_to_native(&tmp[0]);
if(fh.len < 126)
@ -782,7 +782,7 @@ parse_fh(
case 127:
{
std::uint8_t tmp[8];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
BOOST_ASSERT(buffer_bytes(cb) >= sizeof(tmp));
cb.consume(net::buffer_copy(net::buffer(tmp), cb));
fh.len = detail::big_uint64_to_native(&tmp[0]);
if(fh.len < 65536)
@ -797,7 +797,7 @@ parse_fh(
if(fh.mask)
{
std::uint8_t tmp[4];
BOOST_ASSERT(buffer_size(cb) >= sizeof(tmp));
BOOST_ASSERT(buffer_bytes(cb) >= sizeof(tmp));
cb.consume(net::buffer_copy(net::buffer(tmp), cb));
fh.key = detail::little_uint32_to_native(&tmp[0]);
detail::prepare_key(rd_key, fh.key);
@ -837,7 +837,7 @@ parse_fh(
rd_cont = ! fh.fin;
rd_remain = fh.len;
}
b.consume(b.size() - buffer_size(cb));
b.consume(b.size() - buffer_bytes(cb));
ec = {};
return true;
}

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

@ -114,7 +114,7 @@ public:
else
{
BOOST_ASSERT(impl.wr_buf_size != 0);
remain_ = buffer_size(cb_);
remain_ = buffer_bytes(cb_);
if(remain_ > impl.wr_buf_size)
how_ = do_nomask_frag;
else
@ -130,7 +130,7 @@ public:
else
{
BOOST_ASSERT(impl.wr_buf_size != 0);
remain_ = buffer_size(cb_);
remain_ = buffer_bytes(cb_);
if(remain_ > impl.wr_buf_size)
how_ = do_mask_frag;
else
@ -186,7 +186,7 @@ operator()(
{
// send a single frame
fh_.fin = fin_;
fh_.len = buffer_size(cb_);
fh_.len = buffer_bytes(cb_);
impl.wr_fb.clear();
detail::write<flat_static_buffer_base>(
impl.wr_fb, fh_);
@ -252,7 +252,7 @@ operator()(
if(how_ == do_mask_nofrag)
{
// send a single frame using multiple writes
remain_ = beast::buffer_size(cb_);
remain_ = beast::buffer_bytes(cb_);
fh_.fin = fin_;
fh_.len = remain_;
fh_.key = impl.create_mask();
@ -362,13 +362,13 @@ operator()(
more_ = impl.deflate(b, cb_, fin_, in_, ec);
if(impl.check_stop_now(ec))
goto upcall;
n = buffer_size(b);
n = buffer_bytes(b);
if(n == 0)
{
// The input was consumed, but there is
// no output due to compression latency.
BOOST_ASSERT(! fin_);
BOOST_ASSERT(buffer_size(cb_) == 0);
BOOST_ASSERT(buffer_bytes(cb_) == 0);
goto upcall;
}
if(fh_.mask)
@ -517,7 +517,7 @@ write_some(bool fin,
fh.op = impl.wr_cont ?
detail::opcode::cont : impl.wr_opcode;
fh.mask = impl.role == role_type::client;
auto remain = buffer_size(buffers);
auto remain = buffer_bytes(buffers);
if(impl.wr_compress)
{
@ -531,14 +531,14 @@ write_some(bool fin,
b, cb, fin, bytes_transferred, ec);
if(impl.check_stop_now(ec))
return bytes_transferred;
auto const n = buffer_size(b);
auto const n = buffer_bytes(b);
if(n == 0)
{
// The input was consumed, but there
// is no output due to compression
// latency.
BOOST_ASSERT(! fin);
BOOST_ASSERT(buffer_size(cb) == 0);
BOOST_ASSERT(buffer_bytes(cb) == 0);
fh.fin = false;
break;
}

6
include/boost/beast/websocket/stream.hpp
View File

@ -546,17 +546,17 @@ public:
@par Example
Setting the write buffer size.
@code
ws.write_buffer_size(8192);
ws.write_buffer_bytes(8192);
@endcode
@param amount The size of the write buffer in bytes.
*/
void
write_buffer_size(std::size_t amount);
write_buffer_bytes(std::size_t amount);
/// Returns the size of the write buffer.
std::size_t
write_buffer_size() const;
write_buffer_bytes() const;
/** Set the text message write option.

10
test/beast/core/buffer_traits.cpp
View File

@ -206,26 +206,26 @@ public:
void
testFunction()
{
BEAST_EXPECT(buffer_size(
BEAST_EXPECT(buffer_bytes(
net::const_buffer("Hello, world!", 13)) == 13);
BEAST_EXPECT(buffer_size(
BEAST_EXPECT(buffer_bytes(
net::mutable_buffer{}) == 0);
{
sequence s;
BEAST_EXPECT(buffer_size(s) == 13);
BEAST_EXPECT(buffer_bytes(s) == 13);
}
{
std::array<net::const_buffer, 2> s({{
net::const_buffer("Hello, world!", 13),
net::const_buffer("Hello, world!", 13)}});
BEAST_EXPECT(buffer_size(s) == 26);
BEAST_EXPECT(buffer_bytes(s) == 26);
}
BOOST_STATIC_ASSERT(! detail::is_invocable<
detail::buffer_size_impl,
detail::buffer_bytes_impl,
std::size_t(not_sequence const&)>::value);
}

4
test/beast/core/buffers_adaptor.cpp
View File

@ -45,11 +45,11 @@ public:
{
char s1[13];
buffers_triple tb1(s1, sizeof(s1));
BEAST_EXPECT(buffer_size(tb1) == sizeof(s1));
BEAST_EXPECT(buffer_bytes(tb1) == sizeof(s1));
char s2[15];
buffers_triple tb2(s2, sizeof(s2));
BEAST_EXPECT(buffer_size(tb2) == sizeof(s2));
BEAST_EXPECT(buffer_bytes(tb2) == sizeof(s2));
{
// construction

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

@ -185,12 +185,12 @@ public:
{
auto const b = beast::buffers_cat(b0, b0);
BEAST_EXPECT(buffer_size(b) == 0);
BEAST_EXPECT(buffer_bytes(b) == 0);
BEAST_EXPECT(buffers_length(b) == 0);
}
{
auto const b = beast::buffers_cat(b0, b0, b0, b0);
BEAST_EXPECT(buffer_size(b) == 0);
BEAST_EXPECT(buffer_bytes(b) == 0);
BEAST_EXPECT(buffers_length(b) == 0);
}
{

12
test/beast/core/buffers_prefix.cpp
View File

@ -65,7 +65,7 @@ public:
};
buffers_prefix_view<test_buffers> v(
2, boost::in_place_init, std::true_type{});
BEAST_EXPECT(buffer_size(v) == 0);
BEAST_EXPECT(buffer_bytes(v) == 0);
}
{
@ -74,14 +74,14 @@ public:
c[1] = 0;
buffers_prefix_view<net::const_buffer> v(
2, boost::in_place_init, c, sizeof(c));
BEAST_EXPECT(buffer_size(v) == 2);
BEAST_EXPECT(buffer_bytes(v) == 2);
}
{
char c[2];
buffers_prefix_view<net::mutable_buffer> v(
2, boost::in_place_init, c, sizeof(c));
BEAST_EXPECT(buffer_size(v) == 2);
BEAST_EXPECT(buffer_bytes(v) == 2);
}
}
@ -107,7 +107,7 @@ public:
BEAST_EXPECT(buffers_to_string(pb2) == buffers_to_string(pb));
pb = buffers_prefix(0, bs);
pb2 = pb;
BEAST_EXPECT(buffer_size(pb2) == 0);
BEAST_EXPECT(buffer_bytes(pb2) == 0);
pb2 = buffers_prefix(i, bs);
BEAST_EXPECT(buffers_to_string(pb2) == s.substr(0, i));
}
@ -118,9 +118,9 @@ public:
void testEmpty()
{
auto pb0 = buffers_prefix(0, net::mutable_buffer{});
BEAST_EXPECT(buffer_size(pb0) == 0);
BEAST_EXPECT(buffer_bytes(pb0) == 0);
auto pb1 = buffers_prefix(1, net::mutable_buffer{});
BEAST_EXPECT(buffer_size(pb1) == 0);
BEAST_EXPECT(buffer_bytes(pb1) == 0);
BEAST_EXPECT(net::buffer_copy(pb0, pb1) == 0);
}

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

@ -83,7 +83,7 @@ public:
{
buffers_suffix<net::mutable_buffer> cb(
net::mutable_buffer{});
BEAST_EXPECT(buffer_size(cb) == 0);
BEAST_EXPECT(buffer_bytes(cb) == 0);
buffers_suffix<net::mutable_buffer> cb2(
net::mutable_buffer{});
BEAST_EXPECT(net::buffer_copy(cb2, cb) == 0);
@ -131,11 +131,11 @@ public:
net::const_buffer{&buf[i+j], k}}};
buffers_suffix<decltype(bs)> cb(bs);
BEAST_EXPECT(buffers_to_string(cb) == s);
BEAST_EXPECT(buffer_size(cb) == s.size());
BEAST_EXPECT(buffer_bytes(cb) == s.size());
cb.consume(0);
BEAST_EXPECT(eq(cb, consumed_buffers(bs, 0)));
BEAST_EXPECT(buffers_to_string(cb) == s);
BEAST_EXPECT(buffer_size(cb) == s.size());
BEAST_EXPECT(buffer_bytes(cb) == s.size());
cb.consume(x);
BEAST_EXPECT(buffers_to_string(cb) == s.substr(x));
BEAST_EXPECT(eq(cb, consumed_buffers(bs, x)));

2
test/beast/core/dynamic_buffer_ref.cpp
View File

@ -54,7 +54,7 @@ public:
db.commit(12);
BEAST_EXPECT(db.size() == 12);
BEAST_EXPECT(db.capacity() == 512);
BEAST_EXPECT(buffer_size(db.data()) == 12);
BEAST_EXPECT(buffer_bytes(db.data()) == 12);
db.consume(12);
BEAST_EXPECT(db.size() == 0);
BEAST_EXPECT(db.capacity() == 512);

2
test/beast/core/flat_static_buffer.cpp
View File

@ -51,7 +51,7 @@ public:
BEAST_EXPECT(buffers_to_string(b.data()) == s);
b.clear();
BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.data()) == 0);
BEAST_EXPECT(buffer_bytes(b.data()) == 0);
}
// flat_static_buffer

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

@ -115,7 +115,7 @@ public:
bs[0] = net::const_buffer(b, 100);
bs[1] = net::const_buffer(b + 100, 200);
bs[2] = net::const_buffer(b + 100 + 200, 300);
BEAST_EXPECT(buffer_size(bs) <=
BEAST_EXPECT(buffer_bytes(bs) <=
detail::flat_stream_base::max_stack);
flat_stream<test::stream> s(ioc);
error_code ec;
@ -130,7 +130,7 @@ public:
bs[0] = net::const_buffer(b,
detail::flat_stream_base::max_stack);
bs[1] = net::const_buffer(b + bs[0].size(), 1024);
BEAST_EXPECT(buffer_size(bs) <=
BEAST_EXPECT(buffer_bytes(bs) <=
detail::flat_stream_base::max_size);
flat_stream<test::stream> s(ioc);
error_code ec;
@ -145,7 +145,7 @@ public:
bs[0] = net::const_buffer(b,
detail::flat_stream_base::max_stack);
bs[1] = net::const_buffer(b + bs[0].size(), 1024);
BEAST_EXPECT(buffer_size(bs) <=
BEAST_EXPECT(buffer_bytes(bs) <=
detail::flat_stream_base::max_size);
flat_stream<test::stream> s(ioc);
error_code ec;

2
test/beast/core/make_printable.cpp
View File

@ -28,7 +28,7 @@ public:
print (ConstBufferSequence const& buffers)
{
std::cout <<
"Buffer size: " << buffer_size(buffers) << " bytes\n"
"Buffer size: " << buffer_bytes(buffers) << " bytes\n"
"Buffer data: '" << make_printable(buffers) << "'\n";
}

38
test/beast/core/multi_buffer.cpp
View File

@ -707,11 +707,11 @@ public:
multi_buffer mb2{std::move(b)};
BEAST_EXPECT(buffers_to_string(mb2.data()) == s);
BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.data()) == 0);
BEAST_EXPECT(buffer_bytes(b.data()) == 0);
b = std::move(mb2);
BEAST_EXPECT(buffers_to_string(b.data()) == s);
BEAST_EXPECT(mb2.size() == 0);
BEAST_EXPECT(buffer_size(mb2.data()) == 0);
BEAST_EXPECT(buffer_bytes(mb2.data()) == 0);
}
}
}}}
@ -734,68 +734,68 @@ public:
multi_buffer b;
{
auto d = b.prepare(z);
BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_bytes(d) == z);
}
{
auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_bytes(d) == 0);
}
{
auto d = b.prepare(y);
BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_bytes(d) == y);
}
{
auto d = b.prepare(x);
BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_bytes(d) == x);
b.commit(buffer_copy(d, net::buffer(s.data(), x)));
}
BEAST_EXPECT(b.size() == x);
BEAST_EXPECT(buffer_size(b.data()) == b.size());
BEAST_EXPECT(buffer_bytes(b.data()) == b.size());
{
auto d = b.prepare(x);
BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_bytes(d) == x);
}
{
auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_bytes(d) == 0);
}
{
auto d = b.prepare(z);
BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_bytes(d) == z);
}
{
auto d = b.prepare(y);
BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_bytes(d) == y);
b.commit(buffer_copy(d, net::buffer(s.data()+x, y)));
}
b.commit(1);
BEAST_EXPECT(b.size() == x + y);
BEAST_EXPECT(buffer_size(b.data()) == b.size());
BEAST_EXPECT(buffer_bytes(b.data()) == b.size());
{
auto d = b.prepare(x);
BEAST_EXPECT(buffer_size(d) == x);
BEAST_EXPECT(buffer_bytes(d) == x);
}
{
auto d = b.prepare(y);
BEAST_EXPECT(buffer_size(d) == y);
BEAST_EXPECT(buffer_bytes(d) == y);
}
{
auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_bytes(d) == 0);
}
{
auto d = b.prepare(z);
BEAST_EXPECT(buffer_size(d) == z);
BEAST_EXPECT(buffer_bytes(d) == z);
b.commit(buffer_copy(d, net::buffer(s.data()+x+y, z)));
}
b.commit(2);
BEAST_EXPECT(b.size() == x + y + z);
BEAST_EXPECT(buffer_size(b.data()) == b.size());
BEAST_EXPECT(buffer_bytes(b.data()) == b.size());
BEAST_EXPECT(buffers_to_string(b.data()) == s);
b.consume(t);
{
auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_bytes(d) == 0);
}
BEAST_EXPECT(buffers_to_string(b.data()) ==
s.substr(t, std::string::npos));
@ -807,7 +807,7 @@ public:
b.consume(1);
{
auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0);
BEAST_EXPECT(buffer_bytes(d) == 0);
}
}
}}}}}

2
test/beast/core/static_buffer.cpp
View File

@ -55,7 +55,7 @@ public:
BEAST_EXPECT(buffers_to_string(b.data()) == s);
b.clear();
BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.data()) == 0);
BEAST_EXPECT(buffer_bytes(b.data()) == 0);
}
// static_buffer

36
test/beast/core/test_buffer.hpp
View File

@ -116,9 +116,9 @@ void test_mutable_buffers(
net::mutable_buffer)
{
string_view src = "Hello, world!";
BOOST_ASSERT(buffer_size(b) <= src.size());
if(src.size() > buffer_size(b))
src = {src.data(), buffer_size(b)};
BOOST_ASSERT(buffer_bytes(b) <= src.size());
if(src.size() > buffer_bytes(b))
src = {src.data(), buffer_bytes(b)};
net::buffer_copy(b, net::const_buffer(
src.data(), src.size()));
BEAST_EXPECT(beast::buffers_to_string(b) == src);
@ -141,7 +141,7 @@ test_buffer_sequence(
net::buffer_sequence_begin(buffers));
BEAST_EXPECT(sizeof(iterator) > 0);
auto const size = buffer_size(buffers);
auto const size = buffer_bytes(buffers);
BEAST_EXPECT(size > 0 );
// begin, end
@ -155,12 +155,12 @@ test_buffer_sequence(
// copy construction
ConstBufferSequence b1(buffers);
BEAST_EXPECT(buffer_size(b1) == size);
BEAST_EXPECT(buffer_bytes(b1) == size);
// copy assignment
ConstBufferSequence b2(buffers);
b2 = b1;
BEAST_EXPECT(buffer_size(b2) == size);
BEAST_EXPECT(buffer_bytes(b2) == size);
// iterators
{
@ -190,7 +190,7 @@ test_buffer_sequence(
m = 0;
n = length;
for(it = first; n--; ++it)
m += buffer_size(*it);
m += buffer_bytes(*it);
BEAST_EXPECT(it == last);
BEAST_EXPECT(m == size);
@ -198,7 +198,7 @@ test_buffer_sequence(
m = 0;
n = length;
for(it = first; n--;)
m += buffer_size(*it++);
m += buffer_bytes(*it++);
BEAST_EXPECT(it == last);
BEAST_EXPECT(m == size);
@ -206,7 +206,7 @@ test_buffer_sequence(
m = 0;
n = length;
for(it = last; n--;)
m += buffer_size(*--it);
m += buffer_bytes(*--it);
BEAST_EXPECT(it == first);
BEAST_EXPECT(m == size);
@ -216,7 +216,7 @@ test_buffer_sequence(
for(it = last; n--;)
{
it--;
m += buffer_size(*it);
m += buffer_bytes(*it);
}
BEAST_EXPECT(it == first);
BEAST_EXPECT(m == size);
@ -302,7 +302,7 @@ test_mutable_dynamic_buffer(
{
MutableDynamicBuffer b(b0);
auto const mb = b.prepare(src.size());
BEAST_EXPECT(buffer_size(mb) == src.size());
BEAST_EXPECT(buffer_bytes(mb) == src.size());
buffers_fill(mb, '*');
b.commit(src.size());
BEAST_EXPECT(b.size() == src.size());
@ -377,7 +377,7 @@ test_dynamic_buffer(
DynamicBuffer::mutable_buffers_type>::value);
BEAST_EXPECT(b0.size() == 0);
BEAST_EXPECT(buffer_size(b0.data()) == 0);
BEAST_EXPECT(buffer_bytes(b0.data()) == 0);
// members
{
@ -463,7 +463,7 @@ test_dynamic_buffer(
DynamicBuffer b(b0);
b.commit(1);
BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.prepare(0)) == 0);
BEAST_EXPECT(buffer_bytes(b.prepare(0)) == 0);
b.commit(0);
BEAST_EXPECT(b.size() == 0);
b.commit(1);
@ -508,7 +508,7 @@ test_dynamic_buffer(
src = {src.data(), b0.max_size()};
BEAST_EXPECT(b0.max_size() >= src.size());
BEAST_EXPECT(b0.size() == 0);
BEAST_EXPECT(buffer_size(b0.data()) == 0);
BEAST_EXPECT(buffer_bytes(b0.data()) == 0);
auto const make_new_src =
[&buf, &k0, &src]
{
@ -523,12 +523,12 @@ test_dynamic_buffer(
DynamicBuffer b(b0);
auto const& bc(b);
auto const mb = b.prepare(src.size());
BEAST_EXPECT(buffer_size(mb) == src.size());
BEAST_EXPECT(buffer_bytes(mb) == src.size());
beast::test_buffer_sequence(mb);
b.commit(net::buffer_copy(mb,
net::const_buffer(src.data(), src.size())));
BEAST_EXPECT(
buffer_size(bc.data()) == src.size());
buffer_bytes(bc.data()) == src.size());
beast::test_buffer_sequence(bc.data());
}
@ -561,12 +561,12 @@ test_dynamic_buffer(
}
BEAST_EXPECT(b.size() == in.size());
BEAST_EXPECT(
buffer_size(bc.data()) == in.size());
buffer_bytes(bc.data()) == in.size());
BEAST_EXPECT(beast::buffers_to_string(
bc.data()) == in);
while(b.size() > 0)
b.consume(k);
BEAST_EXPECT(buffer_size(bc.data()) == 0);
BEAST_EXPECT(buffer_bytes(bc.data()) == 0);
}
} } }
}

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

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

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

@ -35,7 +35,7 @@ public:
operator()(error_code&, ConstBufferSequence const& buffers)
{
buffer.commit(net::buffer_copy(
buffer.prepare(buffer_size(buffers)),
buffer.prepare(buffer_bytes(buffers)),
buffers));
}
};

2
test/beast/http/parser.cpp
View File

@ -60,7 +60,7 @@ public:
if(ec)
return;
if(p.need_eof() &&
buffer_size(cb) == 0)
buffer_bytes(cb) == 0)
{
p.put_eof(ec);
if(ec)

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

@ -92,7 +92,7 @@ public:
operator()(error_code&,
ConstBufferSequence const& buffers)
{
size = buffer_size(buffers);
size = buffer_bytes(buffers);
}
};

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

@ -43,7 +43,7 @@ struct span_body_test
BEAST_EXPECTS(! ec, ec.message());
if(! BEAST_EXPECT(buf != boost::none))
return;
BEAST_EXPECT(buffer_size(buf->first) == 3);
BEAST_EXPECT(buffer_bytes(buf->first) == 3);
BEAST_EXPECT(! buf->second);
}
{

4
test/beast/websocket/stream.cpp
View File

@ -72,12 +72,12 @@ public:
stream<test::stream> ws{ioc_};
ws.auto_fragment(true);
ws.write_buffer_size(2048);
ws.write_buffer_bytes(2048);
ws.binary(false);
ws.read_message_max(1 * 1024 * 1024);
try
{
ws.write_buffer_size(7);
ws.write_buffer_bytes(7);
fail();
}
catch(std::exception const&)

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

@ -432,7 +432,7 @@ public:
ConstBufferSequence const& buffers)
{
buffer.commit(net::buffer_copy(
buffer.prepare(buffer_size(buffers)),
buffer.prepare(buffer_bytes(buffers)),
buffers));
}

2
test/beast/websocket/write.cpp
View File

@ -124,7 +124,7 @@ public:
[&](ws_type_t<deflateSupported>& ws)
{
ws.auto_fragment(false);
ws.write_buffer_size(16);
ws.write_buffer_bytes(16);
std::string const s(32, '*');
w.write(ws, net::buffer(s));
flat_buffer b;

2
test/bench/parser/bench_parser.cpp
View File

@ -92,7 +92,7 @@ public:
used += n;
if(parser.is_done())
break;
if(buffer_size(cb) == 0)
if(buffer_bytes(cb) == 0)
break;
}
return used;

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

@ -138,7 +138,7 @@ public:
ws_.set_option(pmd);
ws_.binary(true);
ws_.auto_fragment(false);
ws_.write_buffer_size(64 * 1024);
ws_.write_buffer_bytes(64 * 1024);
}
~connection()
@ -183,7 +183,7 @@ private:
do_write()
{
std::geometric_distribution<std::size_t> dist{
double(4) / beast::buffer_size(tb_)};
double(4) / beast::buffer_bytes(tb_)};
ws_.async_write_some(true,
beast::buffers_prefix(dist(rng_), tb_),
beast::bind_front_handler(

2
test/doc/core_1_refresher.cpp
View File

@ -97,7 +97,7 @@ std::string string_from_buffers (ConstBufferSequence const& buffers)
// optimization: reserve all the space for the string first
std::string result;
result.reserve(beast::buffer_size(buffers)); // beast version of net::buffer_size
result.reserve(beast::buffer_bytes(buffers)); // beast version of net::buffer_size
// iterate over each buffer in the sequence and append it to the string
for(auto it = net::buffer_sequence_begin(buffers); // returns an iterator to beginning of the sequence

2
test/doc/exemplars.cpp
View File

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

14
test/doc/http_snippets.cpp
View File

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

2
test/doc/websocket_4_messages.cpp
View File

@ -97,7 +97,7 @@ snippets()
// This will cause the message to be broken up into multiple frames.
for(;;)
{
if(buffer_size(cb) > 512)
if(buffer_bytes(cb) > 512)
{
// There are more than 512 bytes left to send, just
// send the next 512 bytes. The value `false` informs

2
test/doc/websocket_5_control_frames.cpp
View File

@ -53,7 +53,7 @@ snippets()
//[code_websocket_5_3
ws.auto_fragment(true);
ws.write_buffer_size(16384);
ws.write_buffer_bytes(16384);
//]
}