forked from boostorg/beast
Rename to buffer_bytes
This commit is contained in:
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
{
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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)));
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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";
|
||||
}
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}}}}}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
} } }
|
||||
}
|
||||
|
||||
@@ -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())
|
||||
{
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
};
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -92,7 +92,7 @@ public:
|
||||
operator()(error_code&,
|
||||
ConstBufferSequence const& buffers)
|
||||
{
|
||||
size = buffer_size(buffers);
|
||||
size = buffer_bytes(buffers);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
{
|
||||
|
||||
@@ -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&)
|
||||
|
||||
@@ -432,7 +432,7 @@ public:
|
||||
ConstBufferSequence const& buffers)
|
||||
{
|
||||
buffer.commit(net::buffer_copy(
|
||||
buffer.prepare(buffer_size(buffers)),
|
||||
buffer.prepare(buffer_bytes(buffers)),
|
||||
buffers));
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -53,7 +53,7 @@ snippets()
|
||||
//[code_websocket_5_3
|
||||
|
||||
ws.auto_fragment(true);
|
||||
ws.write_buffer_size(16384);
|
||||
ws.write_buffer_bytes(16384);
|
||||
|
||||
//]
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user