boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2025-07-31 05:17:26 +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: Version 228:
* Fix UB in decorator: * Fix UB in decorator:

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

@ -21,7 +21,7 @@ transferred.
[table Buffer Algorithms and Types [table Buffer Algorithms and Types
[[Name][Description]] [[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 This is a more reliable version of
[@boost:/doc/html/boost_asio/reference/buffer_size.html `net::buffer_size`] [@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"> </entry><entry valign="top">
<bridgehead renderas="sect3">Functions</bridgehead> <bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1"> <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_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_front">buffers_front</link></member>
<member><link linkend="beast.ref.boost__beast__buffers_prefix">buffers_prefix</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` is preferred over `handler_ptr`
* New * New
`buffer_size` `buffer_bytes`
replacement for `net::buffer_size` replacement for `net::buffer_size`
* New: * 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 out_pos = net::buffer_sequence_end(out);
auto const in_begin = net::buffer_sequence_begin(in); auto const in_begin = net::buffer_sequence_begin(in);
auto const out_begin = net::buffer_sequence_begin(out); 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) if(in_pos == in_begin || out_pos == out_begin)
return; return;
net::const_buffer cb{*--in_pos}; 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); b_, sp->b.data(), sp->read_max);
sp->b.consume(bytes_transferred); sp->b.consume(bytes_transferred);
} }
else if (buffer_size(b_) > 0) else if (buffer_bytes(b_) > 0)
{ {
ec = net::error::eof; ec = net::error::eof;
} }
@ -177,7 +177,7 @@ struct stream::run_read_op
std::move(h), std::move(h),
in, in,
buffers)}, buffers)},
buffer_size(buffers)); buffer_bytes(buffers));
} }
}; };
@ -217,7 +217,7 @@ struct stream::run_write_op
return upcall(ec, n); return upcall(ec, n);
// A request to write 0 bytes to a stream is a no-op. // 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); return upcall(ec, n);
// connection closed // connection closed
@ -227,7 +227,7 @@ struct stream::run_write_op
// copy buffers // copy buffers
n = std::min<std::size_t>( 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); std::lock_guard<std::mutex> lock(out->m);
n = net::buffer_copy(out->b.prepare(n), buffers); n = net::buffer_copy(out->b.prepare(n), buffers);
@ -273,7 +273,7 @@ read_some(MutableBufferSequence const& buffers,
return 0; return 0;
// A request to read 0 bytes from a stream is a no-op. // A request to read 0 bytes from a stream is a no-op.
if(buffer_size(buffers) == 0) if(buffer_bytes(buffers) == 0)
{ {
ec = {}; ec = {};
return 0; return 0;
@ -357,7 +357,7 @@ write_some(
return 0; return 0;
// A request to write 0 bytes to a stream is a no-op. // A request to write 0 bytes to a stream is a no-op.
if(buffer_size(buffers) == 0) if(buffer_bytes(buffers) == 0)
{ {
ec = {}; ec = {};
return 0; return 0;
@ -373,7 +373,7 @@ write_some(
// copy buffers // copy buffers
auto n = std::min<std::size_t>( 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); std::lock_guard<std::mutex> lock(out->m);
n = net::buffer_copy(out->b.prepare(n), buffers); 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. // 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(); lock.unlock();
(*op)(ec); (*op)(ec);
@ -273,7 +273,7 @@ stream::
str() const str() const
{ {
auto const bs = in_->b.data(); auto const bs = in_->b.data();
if(buffer_size(bs) == 0) if(buffer_bytes(bs) == 0)
return {}; return {};
auto const b = beast::buffers_front(bs); auto const b = beast::buffers_front(bs);
return {static_cast<char const*>(b.data()), b.size()}; 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 This function is designed as an easier-to-use replacement for
`net::buffer_size`. It recognizes customization points found through `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: equivalent to performing:
@code @code
using namespace net; using namespace net;
buffer_size(b); buffer_bytes(b);
@endcode @endcode
In addition this handles types which are convertible to In addition this handles types which are convertible to
`net::const_buffer`; these are not handled by `net::buffer_size`. `net::const_buffer`; these are not handled by `net::buffer_size`.
@ -162,9 +162,9 @@ using buffers_iterator_type =
#if BOOST_BEAST_DOXYGEN #if BOOST_BEAST_DOXYGEN
template<class Buffers> template<class Buffers>
void void
buffer_size(Buffers const& buffers); buffer_bytes(Buffers const& buffers);
#else #else
BOOST_BEAST_INLINE_VARIABLE(buffer_size, detail::buffer_size_impl) BOOST_BEAST_INLINE_VARIABLE(buffer_bytes, detail::buffer_bytes_impl)
#endif #endif
} // beast } // beast

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

@ -129,7 +129,7 @@ public:
#if ! BOOST_BEAST_DOXYGEN #if ! BOOST_BEAST_DOXYGEN
std::size_t std::size_t
buffer_size_impl() const noexcept buffer_bytes_impl() const noexcept
{ {
return size_; 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) void send(SyncWriteStream& stream, ConstBufferSequence const& buffers)
{ {
buffers_suffix<ConstBufferSequence> bs{buffers}; buffers_suffix<ConstBufferSequence> bs{buffers};
while(buffer_size(bs) > 0) while(buffer_bytes(bs) > 0)
bs.consume(stream.write_some(bs)); bs.consume(stream.write_some(bs));
} }
@endcode @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, net::is_const_buffer_sequence<ConstBufferSequence>::value,
"ConstBufferSequence type requirements not met"); "ConstBufferSequence type requirements not met");
std::string result; std::string result;
result.reserve(buffer_size(buffers)); result.reserve(buffer_bytes(buffers));
for(auto const buffer : buffers_range_ref(buffers)) for(auto const buffer : buffers_range_ref(buffers))
result.append(static_cast<char const*>( result.append(static_cast<char const*>(
buffer.data()), buffer.size()); 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 #endif
template<class T, class = void> struct buffer_bytes_impl
struct has_buffer_size_impl : std::false_type
{ {
};
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 std::size_t
operator()(B const& b) const operator()(net::const_buffer b) const noexcept
{ {
return net::const_buffer(b).size(); 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 std::size_t
operator()(B const& b) const operator()(net::mutable_buffer b) const noexcept
{ {
using net::buffer_size; return net::mutable_buffer(b).size();
return buffer_size(b);
} }
template< template<
class B, class B,
class = typename std::enable_if< class = typename std::enable_if<
! std::is_convertible<B, net::const_buffer>::value>::type, net::is_const_buffer_sequence<B>::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>
std::size_t 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 /** 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> template<class ConstBufferSequence>
bool bool

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

@ -46,14 +46,14 @@ public:
auto last = net::buffer_sequence_end(buffers); auto last = net::buffer_sequence_end(buffers);
if(first != last) if(first != last)
{ {
result.size = buffer_size(*first); result.size = buffer_bytes(*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 = buffer_size(*it); auto const n = buffer_bytes(*it);
if(result.size + n > limit) if(result.size + n > limit)
break; break;
result.size += n; 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_( , max_size_(
[&bs] [&bs]
{ {
return buffer_size(bs); return buffer_bytes(bs);
}()) }())
{ {
} }
@ -418,7 +418,7 @@ buffers_adaptor(
, max_size_( , max_size_(
[&] [&]
{ {
return buffer_size(bs_); return buffer_bytes(bs_);
}()) }())
{ {
} }
@ -501,14 +501,14 @@ 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 = buffer_size(*end_) - out_pos_; auto size = buffer_bytes(*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 = buffer_size(*end_); size = buffer_bytes(*end_);
if(n < size) if(n < size)
{ {
out_end_ = n; out_end_ = n;
@ -544,7 +544,7 @@ commit(std::size_t n) noexcept
while(out_ != last) while(out_ != last)
{ {
auto const avail = auto const avail =
buffer_size(*out_) - out_pos_; buffer_bytes(*out_) - out_pos_;
if(n < avail) if(n < avail)
{ {
out_pos_ += n; out_pos_ += n;
@ -561,7 +561,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_ == buffer_size(*out_)) if(out_pos_ == buffer_bytes(*out_))
{ {
++out_; ++out_;
out_pos_ = 0; out_pos_ = 0;
@ -577,7 +577,7 @@ consume(std::size_t n) noexcept
while(begin_ != out_) while(begin_ != out_)
{ {
auto const avail = auto const avail =
buffer_size(*begin_) - in_pos_; buffer_bytes(*begin_) - in_pos_;
if(n < avail) if(n < avail)
{ {
in_size_ -= n; 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(); auto const last = bs_.end();
while(end_ != last) while(end_ != last)
{ {
auto const len = buffer_size(*end_++); auto const len = buffer_bytes(*end_++);
if(len >= size) if(len >= size)
{ {
size_ += size; size_ += size;
@ -282,12 +282,6 @@ public:
std::forward<Args>(args)...)) 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::forward<Args>(args)...))
{ {
} }
std::size_t
buffer_size_impl() const noexcept
{
return this->size();
}
}; };
} // beast } // 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_) for(;amount > 0 && begin_ != end; ++begin_)
{ {
auto const len = auto const len =
buffer_size(*begin_) - skip_; buffer_bytes(*begin_) - skip_;
if(amount < len) if(amount < len)
{ {
skip_ += amount; skip_ += amount;

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

@ -196,7 +196,7 @@ public:
const_iterator end() const noexcept; const_iterator end() const noexcept;
std::size_t std::size_t
buffer_size() const noexcept buffer_bytes() const noexcept
{ {
return b_->size(); return b_->size();
} }
@ -1242,7 +1242,7 @@ basic_multi_buffer<Allocator>::
debug_check() const debug_check() const
{ {
#ifndef NDEBUG #ifndef NDEBUG
BOOST_ASSERT(buffer_size(data()) == in_size_); BOOST_ASSERT(buffer_bytes(data()) == in_size_);
if(list_.empty()) if(list_.empty())
{ {
BOOST_ASSERT(in_pos_ == 0); 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) print (ConstBufferSequence const& buffers)
{ {
std::cout << std::cout <<
"Buffer size: " << buffer_size(buffers) << " bytes\n" "Buffer size: " << buffer_bytes(buffers) << " bytes\n"
"Buffer data: '" << make_printable(buffers) << "'\n"; "Buffer data: '" << make_printable(buffers) << "'\n";
} }
@endcode @endcode

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

@ -88,7 +88,7 @@ struct basic_dynamic_body
put(ConstBufferSequence const& buffers, put(ConstBufferSequence const& buffers,
error_code& ec) error_code& ec)
{ {
auto const n = buffer_size(buffers); auto const n = buffer_bytes(buffers);
if(body_.size() > body_.max_size() - n) if(body_.size() > body_.max_size() - n)
{ {
ec = error::buffer_overflow; 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 = static_cast<char*>(
body_.data) + bytes_transferred; body_.data) + bytes_transferred;
body_.size -= bytes_transferred; body_.size -= bytes_transferred;
if(bytes_transferred == buffer_size(buffers)) if(bytes_transferred == buffer_bytes(buffers))
ec = {}; ec = {};
else else
ec = error::need_buffer; 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 // single buffer
return put(net::const_buffer(*p), ec); return put(net::const_buffer(*p), ec);
} }
auto const size = buffer_size(buffers); auto const size = buffer_bytes(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);
if(size > buf_len_) 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>::
chunk_body(ConstBufferSequence const& buffers) chunk_body(ConstBufferSequence const& buffers)
: view_( : view_(
buffer_size(buffers), buffer_bytes(buffers),
net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0},
chunk_crlf{}, chunk_crlf{},
buffers, buffers,
@ -104,7 +104,7 @@ chunk_body(
ConstBufferSequence const& buffers, ConstBufferSequence const& buffers,
string_view extensions) string_view extensions)
: view_( : view_(
buffer_size(buffers), buffer_bytes(buffers),
net::const_buffer{ net::const_buffer{
extensions.data(), extensions.size()}, extensions.data(), extensions.size()},
chunk_crlf{}, chunk_crlf{},
@ -123,7 +123,7 @@ chunk_body(
typename std::decay<ChunkExtensions>::type>>( typename std::decay<ChunkExtensions>::type>>(
std::forward<ChunkExtensions>(extensions))) std::forward<ChunkExtensions>(extensions)))
, view_( , view_(
buffer_size(buffers), buffer_bytes(buffers),
exts_->str(), exts_->str(),
chunk_crlf{}, chunk_crlf{},
buffers, buffers,
@ -142,7 +142,7 @@ chunk_body(
typename std::decay<ChunkExtensions>::type>>(allocator, typename std::decay<ChunkExtensions>::type>>(allocator,
std::forward<ChunkExtensions>(extensions))) std::forward<ChunkExtensions>(extensions)))
, view_( , view_(
buffer_size(buffers), buffer_bytes(buffers),
exts_->str(), exts_->str(),
chunk_crlf{}, chunk_crlf{},
buffers, 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>( v_.template emplace<7>(
boost::in_place_init, boost::in_place_init,
fwr_->get(), fwr_->get(),
buffer_size(result->first), buffer_bytes(result->first),
net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0},
chunk_crlf{}, chunk_crlf{},
result->first, result->first,
@ -178,7 +178,7 @@ next(error_code& ec, Visit&& visit)
v_.template emplace<4>( v_.template emplace<4>(
boost::in_place_init, boost::in_place_init,
fwr_->get(), fwr_->get(),
buffer_size(result->first), buffer_bytes(result->first),
net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0},
chunk_crlf{}, chunk_crlf{},
result->first, result->first,
@ -217,7 +217,7 @@ next(error_code& ec, Visit&& visit)
// do it all in one buffer // do it all in one buffer
v_.template emplace<6>( v_.template emplace<6>(
boost::in_place_init, boost::in_place_init,
buffer_size(result->first), buffer_bytes(result->first),
net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0},
chunk_crlf{}, chunk_crlf{},
result->first, result->first,
@ -229,7 +229,7 @@ next(error_code& ec, Visit&& visit)
} }
v_.template emplace<5>( v_.template emplace<5>(
boost::in_place_init, boost::in_place_init,
buffer_size(result->first), buffer_bytes(result->first),
net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0},
chunk_crlf{}, chunk_crlf{},
result->first, result->first,
@ -293,9 +293,9 @@ consume(std::size_t n)
{ {
case do_header: case do_header:
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<2>())); n <= buffer_bytes(v_.template get<2>()));
v_.template get<2>().consume(n); v_.template get<2>().consume(n);
if(buffer_size(v_.template get<2>()) > 0) if(buffer_bytes(v_.template get<2>()) > 0)
break; break;
header_done_ = true; header_done_ = true;
v_.reset(); v_.reset();
@ -306,9 +306,9 @@ consume(std::size_t n)
case do_header_only: case do_header_only:
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<1>())); n <= buffer_bytes(v_.template get<1>()));
v_.template get<1>().consume(n); v_.template get<1>().consume(n);
if(buffer_size(v_.template get<1>()) > 0) if(buffer_bytes(v_.template get<1>()) > 0)
break; break;
fwr_ = boost::none; fwr_ = boost::none;
header_done_ = true; header_done_ = true;
@ -320,9 +320,9 @@ consume(std::size_t n)
case do_body + 2: case do_body + 2:
{ {
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<3>())); n <= buffer_bytes(v_.template get<3>()));
v_.template get<3>().consume(n); v_.template get<3>().consume(n);
if(buffer_size(v_.template get<3>()) > 0) if(buffer_bytes(v_.template get<3>()) > 0)
break; break;
v_.reset(); v_.reset();
if(! more_) if(! more_)
@ -335,9 +335,9 @@ consume(std::size_t n)
case do_header_c: case do_header_c:
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<4>())); n <= buffer_bytes(v_.template get<4>()));
v_.template get<4>().consume(n); v_.template get<4>().consume(n);
if(buffer_size(v_.template get<4>()) > 0) if(buffer_bytes(v_.template get<4>()) > 0)
break; break;
header_done_ = true; header_done_ = true;
v_.reset(); v_.reset();
@ -350,9 +350,9 @@ consume(std::size_t n)
case do_header_only_c: case do_header_only_c:
{ {
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<1>())); n <= buffer_bytes(v_.template get<1>()));
v_.template get<1>().consume(n); v_.template get<1>().consume(n);
if(buffer_size(v_.template get<1>()) > 0) if(buffer_bytes(v_.template get<1>()) > 0)
break; break;
fwr_ = boost::none; fwr_ = boost::none;
header_done_ = true; header_done_ = true;
@ -367,9 +367,9 @@ consume(std::size_t n)
case do_body_c + 2: case do_body_c + 2:
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<5>())); n <= buffer_bytes(v_.template get<5>()));
v_.template get<5>().consume(n); v_.template get<5>().consume(n);
if(buffer_size(v_.template get<5>()) > 0) if(buffer_bytes(v_.template get<5>()) > 0)
break; break;
v_.reset(); v_.reset();
if(more_) if(more_)
@ -381,9 +381,9 @@ consume(std::size_t n)
case do_body_final_c: case do_body_final_c:
{ {
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<6>())); n <= buffer_bytes(v_.template get<6>()));
v_.template get<6>().consume(n); v_.template get<6>().consume(n);
if(buffer_size(v_.template get<6>()) > 0) if(buffer_bytes(v_.template get<6>()) > 0)
break; break;
v_.reset(); v_.reset();
s_ = do_complete; s_ = do_complete;
@ -393,9 +393,9 @@ consume(std::size_t n)
case do_all_c: case do_all_c:
{ {
BOOST_ASSERT( BOOST_ASSERT(
n <= buffer_size(v_.template get<7>())); n <= buffer_bytes(v_.template get<7>()));
v_.template get<7>().consume(n); v_.template get<7>().consume(n);
if(buffer_size(v_.template get<7>()) > 0) if(buffer_bytes(v_.template get<7>()) > 0)
break; break;
header_done_ = true; header_done_ = true;
v_.reset(); v_.reset();
@ -404,9 +404,9 @@ consume(std::size_t n)
} }
case do_final_c + 1: 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); v_.template get<8>().consume(n);
if(buffer_size(v_.template get<8>()) > 0) if(buffer_bytes(v_.template get<8>()) > 0)
break; break;
v_.reset(); v_.reset();
goto go_complete; goto go_complete;

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

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

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

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

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

@ -238,8 +238,8 @@ template<class Buffers>
void void
read_ping(ping_data& data, Buffers const& bs) read_ping(ping_data& data, Buffers const& bs)
{ {
BOOST_ASSERT(buffer_size(bs) <= data.max_size()); BOOST_ASSERT(buffer_bytes(bs) <= data.max_size());
data.resize(buffer_size(bs)); data.resize(buffer_bytes(bs));
net::buffer_copy(net::mutable_buffer{ net::buffer_copy(net::mutable_buffer{
data.data(), data.size()}, bs); data.data(), data.size()}, bs);
} }
@ -255,7 +255,7 @@ read_close(
error_code& ec) error_code& ec)
{ {
using namespace boost::endian; using namespace boost::endian;
auto n = buffer_size(bs); auto n = buffer_bytes(bs);
BOOST_ASSERT(n <= 125); BOOST_ASSERT(n <= 125);
if(n == 0) 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); cb.consume(zs.total_in);
if(zs.avail_out > 0 && fin) if(zs.avail_out > 0 && fin)
{ {
auto const remain = buffer_size(cb); auto const remain = buffer_bytes(cb);
if(remain == 0) if(remain == 0)
{ {
// Inspired by Mark Adler // Inspired by Mark Adler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -185,12 +185,12 @@ public:
{ {
auto const b = beast::buffers_cat(b0, b0); 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); BEAST_EXPECT(buffers_length(b) == 0);
} }
{ {
auto const b = beast::buffers_cat(b0, b0, b0, b0); 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); 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( buffers_prefix_view<test_buffers> v(
2, boost::in_place_init, std::true_type{}); 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; c[1] = 0;
buffers_prefix_view<net::const_buffer> v( buffers_prefix_view<net::const_buffer> v(
2, boost::in_place_init, c, sizeof(c)); 2, boost::in_place_init, c, sizeof(c));
BEAST_EXPECT(buffer_size(v) == 2); BEAST_EXPECT(buffer_bytes(v) == 2);
} }
{ {
char c[2]; char c[2];
buffers_prefix_view<net::mutable_buffer> v( buffers_prefix_view<net::mutable_buffer> v(
2, boost::in_place_init, c, sizeof(c)); 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)); BEAST_EXPECT(buffers_to_string(pb2) == buffers_to_string(pb));
pb = buffers_prefix(0, bs); pb = buffers_prefix(0, bs);
pb2 = pb; pb2 = pb;
BEAST_EXPECT(buffer_size(pb2) == 0); BEAST_EXPECT(buffer_bytes(pb2) == 0);
pb2 = buffers_prefix(i, bs); pb2 = buffers_prefix(i, bs);
BEAST_EXPECT(buffers_to_string(pb2) == s.substr(0, i)); BEAST_EXPECT(buffers_to_string(pb2) == s.substr(0, i));
} }
@ -118,9 +118,9 @@ public:
void testEmpty() void testEmpty()
{ {
auto pb0 = buffers_prefix(0, net::mutable_buffer{}); 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{}); 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); 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( buffers_suffix<net::mutable_buffer> cb(
net::mutable_buffer{}); net::mutable_buffer{});
BEAST_EXPECT(buffer_size(cb) == 0); BEAST_EXPECT(buffer_bytes(cb) == 0);
buffers_suffix<net::mutable_buffer> cb2( buffers_suffix<net::mutable_buffer> cb2(
net::mutable_buffer{}); net::mutable_buffer{});
BEAST_EXPECT(net::buffer_copy(cb2, cb) == 0); BEAST_EXPECT(net::buffer_copy(cb2, cb) == 0);
@ -131,11 +131,11 @@ public:
net::const_buffer{&buf[i+j], k}}}; net::const_buffer{&buf[i+j], k}}};
buffers_suffix<decltype(bs)> cb(bs); buffers_suffix<decltype(bs)> cb(bs);
BEAST_EXPECT(buffers_to_string(cb) == s); BEAST_EXPECT(buffers_to_string(cb) == s);
BEAST_EXPECT(buffer_size(cb) == s.size()); BEAST_EXPECT(buffer_bytes(cb) == s.size());
cb.consume(0); cb.consume(0);
BEAST_EXPECT(eq(cb, consumed_buffers(bs, 0))); BEAST_EXPECT(eq(cb, consumed_buffers(bs, 0)));
BEAST_EXPECT(buffers_to_string(cb) == s); BEAST_EXPECT(buffers_to_string(cb) == s);
BEAST_EXPECT(buffer_size(cb) == s.size()); BEAST_EXPECT(buffer_bytes(cb) == s.size());
cb.consume(x); cb.consume(x);
BEAST_EXPECT(buffers_to_string(cb) == s.substr(x)); BEAST_EXPECT(buffers_to_string(cb) == s.substr(x));
BEAST_EXPECT(eq(cb, consumed_buffers(bs, 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); db.commit(12);
BEAST_EXPECT(db.size() == 12); BEAST_EXPECT(db.size() == 12);
BEAST_EXPECT(db.capacity() == 512); BEAST_EXPECT(db.capacity() == 512);
BEAST_EXPECT(buffer_size(db.data()) == 12); BEAST_EXPECT(buffer_bytes(db.data()) == 12);
db.consume(12); db.consume(12);
BEAST_EXPECT(db.size() == 0); BEAST_EXPECT(db.size() == 0);
BEAST_EXPECT(db.capacity() == 512); 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); BEAST_EXPECT(buffers_to_string(b.data()) == s);
b.clear(); b.clear();
BEAST_EXPECT(b.size() == 0); BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.data()) == 0); BEAST_EXPECT(buffer_bytes(b.data()) == 0);
} }
// flat_static_buffer // 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[0] = net::const_buffer(b, 100);
bs[1] = net::const_buffer(b + 100, 200); bs[1] = net::const_buffer(b + 100, 200);
bs[2] = net::const_buffer(b + 100 + 200, 300); 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); detail::flat_stream_base::max_stack);
flat_stream<test::stream> s(ioc); flat_stream<test::stream> s(ioc);
error_code ec; error_code ec;
@ -130,7 +130,7 @@ public:
bs[0] = net::const_buffer(b, bs[0] = net::const_buffer(b,
detail::flat_stream_base::max_stack); detail::flat_stream_base::max_stack);
bs[1] = net::const_buffer(b + bs[0].size(), 1024); 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); detail::flat_stream_base::max_size);
flat_stream<test::stream> s(ioc); flat_stream<test::stream> s(ioc);
error_code ec; error_code ec;
@ -145,7 +145,7 @@ public:
bs[0] = net::const_buffer(b, bs[0] = net::const_buffer(b,
detail::flat_stream_base::max_stack); detail::flat_stream_base::max_stack);
bs[1] = net::const_buffer(b + bs[0].size(), 1024); 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); detail::flat_stream_base::max_size);
flat_stream<test::stream> s(ioc); flat_stream<test::stream> s(ioc);
error_code ec; error_code ec;

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

@ -28,7 +28,7 @@ public:
print (ConstBufferSequence const& buffers) print (ConstBufferSequence const& buffers)
{ {
std::cout << std::cout <<
"Buffer size: " << buffer_size(buffers) << " bytes\n" "Buffer size: " << buffer_bytes(buffers) << " bytes\n"
"Buffer data: '" << make_printable(buffers) << "'\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)}; multi_buffer mb2{std::move(b)};
BEAST_EXPECT(buffers_to_string(mb2.data()) == s); BEAST_EXPECT(buffers_to_string(mb2.data()) == s);
BEAST_EXPECT(b.size() == 0); BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.data()) == 0); BEAST_EXPECT(buffer_bytes(b.data()) == 0);
b = std::move(mb2); b = std::move(mb2);
BEAST_EXPECT(buffers_to_string(b.data()) == s); BEAST_EXPECT(buffers_to_string(b.data()) == s);
BEAST_EXPECT(mb2.size() == 0); 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; multi_buffer b;
{ {
auto d = b.prepare(z); auto d = b.prepare(z);
BEAST_EXPECT(buffer_size(d) == z); BEAST_EXPECT(buffer_bytes(d) == z);
} }
{ {
auto d = b.prepare(0); auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_bytes(d) == 0);
} }
{ {
auto d = b.prepare(y); auto d = b.prepare(y);
BEAST_EXPECT(buffer_size(d) == y); BEAST_EXPECT(buffer_bytes(d) == y);
} }
{ {
auto d = b.prepare(x); 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))); b.commit(buffer_copy(d, net::buffer(s.data(), x)));
} }
BEAST_EXPECT(b.size() == 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); auto d = b.prepare(x);
BEAST_EXPECT(buffer_size(d) == x); BEAST_EXPECT(buffer_bytes(d) == x);
} }
{ {
auto d = b.prepare(0); auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_bytes(d) == 0);
} }
{ {
auto d = b.prepare(z); auto d = b.prepare(z);
BEAST_EXPECT(buffer_size(d) == z); BEAST_EXPECT(buffer_bytes(d) == z);
} }
{ {
auto d = b.prepare(y); 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(buffer_copy(d, net::buffer(s.data()+x, y)));
} }
b.commit(1); b.commit(1);
BEAST_EXPECT(b.size() == x + y); 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); auto d = b.prepare(x);
BEAST_EXPECT(buffer_size(d) == x); BEAST_EXPECT(buffer_bytes(d) == x);
} }
{ {
auto d = b.prepare(y); auto d = b.prepare(y);
BEAST_EXPECT(buffer_size(d) == y); BEAST_EXPECT(buffer_bytes(d) == y);
} }
{ {
auto d = b.prepare(0); auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_bytes(d) == 0);
} }
{ {
auto d = b.prepare(z); 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(buffer_copy(d, net::buffer(s.data()+x+y, z)));
} }
b.commit(2); b.commit(2);
BEAST_EXPECT(b.size() == x + y + z); 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); BEAST_EXPECT(buffers_to_string(b.data()) == s);
b.consume(t); b.consume(t);
{ {
auto d = b.prepare(0); auto d = b.prepare(0);
BEAST_EXPECT(buffer_size(d) == 0); BEAST_EXPECT(buffer_bytes(d) == 0);
} }
BEAST_EXPECT(buffers_to_string(b.data()) == BEAST_EXPECT(buffers_to_string(b.data()) ==
s.substr(t, std::string::npos)); s.substr(t, std::string::npos));
@ -807,7 +807,7 @@ public:
b.consume(1); b.consume(1);
{ {
auto d = b.prepare(0); 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); BEAST_EXPECT(buffers_to_string(b.data()) == s);
b.clear(); b.clear();
BEAST_EXPECT(b.size() == 0); BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(buffer_size(b.data()) == 0); BEAST_EXPECT(buffer_bytes(b.data()) == 0);
} }
// static_buffer // static_buffer

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

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

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

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

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

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

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

@ -92,7 +92,7 @@ public:
operator()(error_code&, operator()(error_code&,
ConstBufferSequence const& buffers) 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()); BEAST_EXPECTS(! ec, ec.message());
if(! BEAST_EXPECT(buf != boost::none)) if(! BEAST_EXPECT(buf != boost::none))
return; return;
BEAST_EXPECT(buffer_size(buf->first) == 3); BEAST_EXPECT(buffer_bytes(buf->first) == 3);
BEAST_EXPECT(! buf->second); BEAST_EXPECT(! buf->second);
} }
{ {

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

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

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

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

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

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

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

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

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

@ -138,7 +138,7 @@ public:
ws_.set_option(pmd); ws_.set_option(pmd);
ws_.binary(true); ws_.binary(true);
ws_.auto_fragment(false); ws_.auto_fragment(false);
ws_.write_buffer_size(64 * 1024); ws_.write_buffer_bytes(64 * 1024);
} }
~connection() ~connection()
@ -183,7 +183,7 @@ private:
do_write() do_write()
{ {
std::geometric_distribution<std::size_t> dist{ std::geometric_distribution<std::size_t> dist{
double(4) / beast::buffer_size(tb_)}; double(4) / beast::buffer_bytes(tb_)};
ws_.async_write_some(true, ws_.async_write_some(true,
beast::buffers_prefix(dist(rng_), tb_), beast::buffers_prefix(dist(rng_), tb_),
beast::bind_front_handler( 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 // optimization: reserve all the space for the string first
std::string result; 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 // 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 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" // The specification requires this to indicate "no error"
ec = {}; ec = {};
return buffer_size(buffers); return buffer_bytes(buffers);
} }
/** Called when the body is complete. /** 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 // Manually emit a chunk by first writing the chunk-size header with the correct size
net::write(sock, chunk_header{ net::write(sock, chunk_header{
buffer_size(cb1) + buffer_bytes(cb1) +
buffer_size(cb2) + buffer_bytes(cb2) +
buffer_size(cb3)}); buffer_bytes(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 +367,7 @@ print_cxx14(message<isRequest, Body, Fields> const& m)
{ {
ec = {}; ec = {};
std::cout << buffers(buffer); std::cout << buffers(buffer);
sr.consume(buffer_size(buffer)); sr.consume(buffer_bytes(buffer));
}); });
} }
while(! ec && ! sr.is_done()); while(! ec && ! sr.is_done());
@ -394,7 +394,7 @@ struct lambda
{ {
ec = {}; ec = {};
std::cout << buffers(buffer); 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 = {}; ec = {};
std::cout << buffers(buffer); std::cout << buffers(buffer);
sr.consume(buffer_size(buffer)); sr.consume(buffer_bytes(buffer));
}); });
} }
while(! sr.is_header_done()); while(! sr.is_header_done());
@ -449,7 +449,7 @@ split_print_cxx14(message<isRequest, Body, Fields> const& m)
{ {
ec = {}; ec = {};
std::cout << buffers(buffer); std::cout << buffers(buffer);
sr.consume(buffer_size(buffer)); sr.consume(buffer_bytes(buffer));
}); });
} }
while(! ec && ! sr.is_done()); 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. // This will cause the message to be broken up into multiple frames.
for(;;) for(;;)
{ {
if(buffer_size(cb) > 512) if(buffer_bytes(cb) > 512)
{ {
// There are more than 512 bytes left to send, just // There are more than 512 bytes left to send, just
// send the next 512 bytes. The value `false` informs // 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 //[code_websocket_5_3
ws.auto_fragment(true); ws.auto_fragment(true);
ws.write_buffer_size(16384); ws.write_buffer_bytes(16384);
//] //]
} }