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

Rename to flat_buffer, basic_flat_buffer (API Change):

Browse Source 
These classes are renamed:

* flat_streambuf to flat_buffer
* basic_flat_streambuf to basic_flat_buffer
This commit is contained in:
Vinnie Falco
2017-05-04 16:00:20 -07:00
parent 24fd254690
commit 6e47e9a0ac
14 changed files with 167 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -11,6 +11,7 @@ API Changes:
* New ostream() returns dynamic buffer output stream * New ostream() returns dynamic buffer output stream
* New buffers() replaces to_string() * New buffers() replaces to_string()
* Rename to multi_buffer, basic_multi_buffer * Rename to multi_buffer, basic_multi_buffer
* Rename to flat_buffer, basic_flat_buffer
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------

3
doc/examples.qbk
View File

@ -17,6 +17,7 @@ in the examples directory.
Use HTTP to request the root page from a website and print the response: Use HTTP to request the root page from a website and print the response:
``` ```
#include <beast/core.hpp>
#include <beast/http.hpp> #include <beast/http.hpp>
#include <boost/asio.hpp> #include <boost/asio.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
@ -45,7 +46,7 @@ int main()
beast::http::write(sock, req); beast::http::write(sock, req);
// Receive and print HTTP response using beast // Receive and print HTTP response using beast
beast::multi_buffer b; beast::flat_buffer b;
beast::http::response<beast::http::dynamic_body> res; beast::http::response<beast::http::dynamic_body> res;
beast::http::read(sock, b, res); beast::http::read(sock, b, res);
std::cout << res; std::cout << res;

4
doc/quickref.xml
View File

@ -152,7 +152,7 @@
<bridgehead renderas="sect3">Classes</bridgehead> <bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1"> <simplelist type="vert" columns="1">
<member><link linkend="beast.ref.async_completion">async_completion</link></member> <member><link linkend="beast.ref.async_completion">async_completion</link></member>
<member><link linkend="beast.ref.basic_flat_streambuf">basic_flat_streambuf</link></member> <member><link linkend="beast.ref.basic_flat_buffer">basic_flat_buffer</link></member>
<member><link linkend="beast.ref.basic_multi_buffer">basic_multi_buffer</link></member> <member><link linkend="beast.ref.basic_multi_buffer">basic_multi_buffer</link></member>
<member><link linkend="beast.ref.buffers_adapter">buffers_adapter</link></member> <member><link linkend="beast.ref.buffers_adapter">buffers_adapter</link></member>
<member><link linkend="beast.ref.consuming_buffers">consuming_buffers</link></member> <member><link linkend="beast.ref.consuming_buffers">consuming_buffers</link></member>
@ -161,7 +161,7 @@
<member><link linkend="beast.ref.error_category">error_category</link></member> <member><link linkend="beast.ref.error_category">error_category</link></member>
<member><link linkend="beast.ref.error_code">error_code</link></member> <member><link linkend="beast.ref.error_code">error_code</link></member>
<member><link linkend="beast.ref.error_condition">error_condition</link></member> <member><link linkend="beast.ref.error_condition">error_condition</link></member>
<member><link linkend="beast.ref.flat_streambuf">flat_streambuf</link></member> <member><link linkend="beast.ref.flat_buffer">flat_buffer</link></member>
<member><link linkend="beast.ref.handler_alloc">handler_alloc</link></member> <member><link linkend="beast.ref.handler_alloc">handler_alloc</link></member>
<member><link linkend="beast.ref.handler_ptr">handler_ptr</link></member> <member><link linkend="beast.ref.handler_ptr">handler_ptr</link></member>
<member><link linkend="beast.ref.multi_buffer">multi_buffer</link></member> <member><link linkend="beast.ref.multi_buffer">multi_buffer</link></member>

2
examples/http_example.cpp
View File

@ -34,7 +34,7 @@ int main()
beast::http::write(sock, req); beast::http::write(sock, req);
// Receive and print HTTP response using beast // Receive and print HTTP response using beast
beast::multi_buffer b; beast::flat_buffer b;
beast::http::response<beast::http::dynamic_body> res; beast::http::response<beast::http::dynamic_body> res;
beast::http::read(sock, b, res); beast::http::read(sock, b, res);
std::cout << res; std::cout << res;

2
include/beast/core.hpp
View File

@ -18,7 +18,7 @@
#include <beast/core/consuming_buffers.hpp> #include <beast/core/consuming_buffers.hpp>
#include <beast/core/dynabuf_readstream.hpp> #include <beast/core/dynabuf_readstream.hpp>
#include <beast/core/error.hpp> #include <beast/core/error.hpp>
#include <beast/core/flat_streambuf.hpp> #include <beast/core/flat_buffer.hpp>
#include <beast/core/handler_alloc.hpp> #include <beast/core/handler_alloc.hpp>
#include <beast/core/handler_concepts.hpp> #include <beast/core/handler_concepts.hpp>
#include <beast/core/handler_helpers.hpp> #include <beast/core/handler_helpers.hpp>

46
include/beast/core/flat_streambuf.hpp → include/beast/core/flat_buffer.hpp
View File

@ -5,8 +5,8 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
#ifndef BEAST_FLAT_STREAMBUF_HPP #ifndef BEAST_FLAT_BUFFER_HPP
#define BEAST_FLAT_STREAMBUF_HPP #define BEAST_FLAT_BUFFER_HPP
#include <beast/config.hpp> #include <beast/config.hpp>
#include <beast/core/detail/empty_base_optimization.hpp> #include <beast/core/detail/empty_base_optimization.hpp>
@ -34,7 +34,7 @@ namespace beast {
is stored in a single contiguous buffer. is stored in a single contiguous buffer.
*/ */
template<class Allocator> template<class Allocator>
class basic_flat_streambuf class basic_flat_buffer
#if ! BEAST_DOXYGEN #if ! BEAST_DOXYGEN
: private detail::empty_base_optimization< : private detail::empty_base_optimization<
typename std::allocator_traits<Allocator>:: typename std::allocator_traits<Allocator>::
@ -58,7 +58,7 @@ private:
}; };
template<class OtherAlloc> template<class OtherAlloc>
friend class basic_flat_streambuf; friend class basic_flat_buffer;
using alloc_traits = using alloc_traits =
std::allocator_traits<allocator_type>; std::allocator_traits<allocator_type>;
@ -86,11 +86,11 @@ public:
using mutable_buffers_type = boost::asio::mutable_buffers_1; using mutable_buffers_type = boost::asio::mutable_buffers_1;
/// Copy assignment (disallowed). /// Copy assignment (disallowed).
basic_flat_streambuf& basic_flat_buffer&
operator=(basic_flat_streambuf const&) = delete; operator=(basic_flat_buffer const&) = delete;
/// Destructor. /// Destructor.
~basic_flat_streambuf(); ~basic_flat_buffer();
/** Move constructor. /** Move constructor.
@ -101,7 +101,7 @@ public:
have a capacity of zero, an empty input sequence, have a capacity of zero, an empty input sequence,
and an empty output sequence. and an empty output sequence.
*/ */
basic_flat_streambuf(basic_flat_streambuf&&); basic_flat_buffer(basic_flat_buffer&&);
/** Move constructor. /** Move constructor.
@ -115,7 +115,7 @@ public:
@param alloc The allocator to associate with the @param alloc The allocator to associate with the
stream buffer. stream buffer.
*/ */
basic_flat_streambuf(basic_flat_streambuf&&, basic_flat_buffer(basic_flat_buffer&&,
Allocator const& alloc); Allocator const& alloc);
/** Copy constructor. /** Copy constructor.
@ -123,7 +123,7 @@ public:
The new object will have a copy of the input sequence The new object will have a copy of the input sequence
and an empty output sequence. and an empty output sequence.
*/ */
basic_flat_streambuf(basic_flat_streambuf const&); basic_flat_buffer(basic_flat_buffer const&);
/** Copy constructor. /** Copy constructor.
@ -133,7 +133,7 @@ public:
@param alloc The allocator to associate with the @param alloc The allocator to associate with the
stream buffer. stream buffer.
*/ */
basic_flat_streambuf(basic_flat_streambuf const&, basic_flat_buffer(basic_flat_buffer const&,
Allocator const& alloc); Allocator const& alloc);
/** Copy constructor. /** Copy constructor.
@ -142,8 +142,8 @@ public:
and an empty output sequence. and an empty output sequence.
*/ */
template<class OtherAlloc> template<class OtherAlloc>
basic_flat_streambuf( basic_flat_buffer(
basic_flat_streambuf<OtherAlloc> const&); basic_flat_buffer<OtherAlloc> const&);
/** Copy constructor. /** Copy constructor.
@ -154,8 +154,8 @@ public:
stream buffer. stream buffer.
*/ */
template<class OtherAlloc> template<class OtherAlloc>
basic_flat_streambuf( basic_flat_buffer(
basic_flat_streambuf<OtherAlloc> const&, basic_flat_buffer<OtherAlloc> const&,
Allocator const& alloc); Allocator const& alloc);
/** Construct a flat stream buffer. /** Construct a flat stream buffer.
@ -169,7 +169,7 @@ public:
possible value of `std::size_t` is used. possible value of `std::size_t` is used.
*/ */
explicit explicit
basic_flat_streambuf(std::size_t limit = ( basic_flat_buffer(std::size_t limit = (
std::numeric_limits<std::size_t>::max)()); std::numeric_limits<std::size_t>::max)());
/** Construct a flat stream buffer. /** Construct a flat stream buffer.
@ -185,7 +185,7 @@ public:
that can be allocated. If unspecified, the largest that can be allocated. If unspecified, the largest
possible value of `std::size_t` is used. possible value of `std::size_t` is used.
*/ */
basic_flat_streambuf(Allocator const& alloc, basic_flat_buffer(Allocator const& alloc,
std::size_t limit = ( std::size_t limit = (
std::numeric_limits<std::size_t>::max)()); std::numeric_limits<std::size_t>::max)());
@ -287,24 +287,24 @@ public:
template<class OtherAlloc> template<class OtherAlloc>
friend friend
std::size_t std::size_t
read_size_helper(basic_flat_streambuf< read_size_helper(basic_flat_buffer<
OtherAlloc> const&, std::size_t); OtherAlloc> const&, std::size_t);
private: private:
void void
move_from(basic_flat_streambuf& other); move_from(basic_flat_buffer& other);
template<class OtherAlloc> template<class OtherAlloc>
void void
copy_from(basic_flat_streambuf< copy_from(basic_flat_buffer<
OtherAlloc> const& other); OtherAlloc> const& other);
}; };
using flat_streambuf = using flat_buffer =
basic_flat_streambuf<std::allocator<char>>; basic_flat_buffer<std::allocator<char>>;
} // beast } // beast
#include <beast/core/impl/flat_streambuf.ipp> #include <beast/core/impl/flat_buffer.ipp>
#endif #endif

70
include/beast/core/impl/flat_streambuf.ipp → include/beast/core/impl/flat_buffer.ipp
View File

@ -5,8 +5,8 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
#ifndef BEAST_IMPL_FLAT_STREAMBUF_HPP #ifndef BEAST_IMPL_FLAT_BUFFER_HPP
#define BEAST_IMPL_FLAT_STREAMBUF_HPP #define BEAST_IMPL_FLAT_BUFFER_HPP
#include <boost/assert.hpp> #include <boost/assert.hpp>
#include <stdexcept> #include <stdexcept>
@ -37,8 +37,8 @@ next_pow2(std::size_t x)
template<class Allocator> template<class Allocator>
void void
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
move_from(basic_flat_streambuf& other) move_from(basic_flat_buffer& other)
{ {
p_ = other.p_; p_ = other.p_;
in_ = other.in_; in_ = other.in_;
@ -56,8 +56,8 @@ move_from(basic_flat_streambuf& other)
template<class Allocator> template<class Allocator>
template<class OtherAlloc> template<class OtherAlloc>
void void
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
copy_from(basic_flat_streambuf< copy_from(basic_flat_buffer<
OtherAlloc> const& other) OtherAlloc> const& other)
{ {
max_ = other.max_; max_ = other.max_;
@ -81,8 +81,8 @@ copy_from(basic_flat_streambuf<
} }
template<class Allocator> template<class Allocator>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
~basic_flat_streambuf() ~basic_flat_buffer()
{ {
if(p_) if(p_)
alloc_traits::deallocate( alloc_traits::deallocate(
@ -90,8 +90,8 @@ basic_flat_streambuf<Allocator>::
} }
template<class Allocator> template<class Allocator>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf(basic_flat_streambuf&& other) basic_flat_buffer(basic_flat_buffer&& other)
: detail::empty_base_optimization< : detail::empty_base_optimization<
allocator_type>(std::move(other.member())) allocator_type>(std::move(other.member()))
{ {
@ -99,8 +99,8 @@ basic_flat_streambuf(basic_flat_streambuf&& other)
} }
template<class Allocator> template<class Allocator>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf(basic_flat_streambuf&& other, basic_flat_buffer(basic_flat_buffer&& other,
Allocator const& alloc) Allocator const& alloc)
: detail::empty_base_optimization< : detail::empty_base_optimization<
allocator_type>(alloc) allocator_type>(alloc)
@ -114,9 +114,9 @@ basic_flat_streambuf(basic_flat_streambuf&& other,
} }
template<class Allocator> template<class Allocator>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf( basic_flat_buffer(
basic_flat_streambuf const& other) basic_flat_buffer const& other)
: detail::empty_base_optimization<allocator_type>( : detail::empty_base_optimization<allocator_type>(
alloc_traits::select_on_container_copy_construction( alloc_traits::select_on_container_copy_construction(
other.member())) other.member()))
@ -125,9 +125,9 @@ basic_flat_streambuf(
} }
template<class Allocator> template<class Allocator>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf( basic_flat_buffer(
basic_flat_streambuf const& other, basic_flat_buffer const& other,
Allocator const& alloc) Allocator const& alloc)
: detail::empty_base_optimization< : detail::empty_base_optimization<
allocator_type>(alloc) allocator_type>(alloc)
@ -137,18 +137,18 @@ basic_flat_streambuf(
template<class Allocator> template<class Allocator>
template<class OtherAlloc> template<class OtherAlloc>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf( basic_flat_buffer(
basic_flat_streambuf<OtherAlloc> const& other) basic_flat_buffer<OtherAlloc> const& other)
{ {
copy_from(other); copy_from(other);
} }
template<class Allocator> template<class Allocator>
template<class OtherAlloc> template<class OtherAlloc>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf( basic_flat_buffer(
basic_flat_streambuf<OtherAlloc> const& other, basic_flat_buffer<OtherAlloc> const& other,
Allocator const& alloc) Allocator const& alloc)
: detail::empty_base_optimization< : detail::empty_base_optimization<
allocator_type>(alloc) allocator_type>(alloc)
@ -157,8 +157,8 @@ basic_flat_streambuf(
} }
template<class Allocator> template<class Allocator>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf(std::size_t limit) basic_flat_buffer(std::size_t limit)
: p_(nullptr) : p_(nullptr)
, in_(nullptr) , in_(nullptr)
, out_(nullptr) , out_(nullptr)
@ -170,8 +170,8 @@ basic_flat_streambuf(std::size_t limit)
} }
template<class Allocator> template<class Allocator>
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
basic_flat_streambuf(Allocator const& alloc, basic_flat_buffer(Allocator const& alloc,
std::size_t limit) std::size_t limit)
: detail::empty_base_optimization< : detail::empty_base_optimization<
allocator_type>(alloc) allocator_type>(alloc)
@ -187,7 +187,7 @@ basic_flat_streambuf(Allocator const& alloc,
template<class Allocator> template<class Allocator>
auto auto
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
prepare(std::size_t n) -> prepare(std::size_t n) ->
mutable_buffers_type mutable_buffers_type
{ {
@ -212,7 +212,7 @@ prepare(std::size_t n) ->
// enforce maximum capacity // enforce maximum capacity
if(n > max_ - len) if(n > max_ - len)
throw std::length_error{ throw std::length_error{
"flat_streambuf overflow"}; "basic_flat_buffer overflow"};
// allocate a new buffer // allocate a new buffer
auto const new_size = (std::min)(max_, auto const new_size = (std::min)(max_,
std::max<std::size_t>( std::max<std::size_t>(
@ -237,7 +237,7 @@ prepare(std::size_t n) ->
template<class Allocator> template<class Allocator>
void void
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
consume(std::size_t n) consume(std::size_t n)
{ {
if(n >= dist(in_, out_)) if(n >= dist(in_, out_))
@ -251,14 +251,14 @@ consume(std::size_t n)
template<class Allocator> template<class Allocator>
void void
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
reserve(std::size_t n) reserve(std::size_t n)
{ {
if(n <= capacity()) if(n <= capacity())
return; return;
if(n > max_) if(n > max_)
throw std::length_error{ throw std::length_error{
"flat_streambuf overflow"}; "basic_flat_buffer overflow"};
auto const new_size = (std::min)(max_, auto const new_size = (std::min)(max_,
std::max<std::size_t>( std::max<std::size_t>(
detail::next_pow2(n), min_size)); detail::next_pow2(n), min_size));
@ -282,7 +282,7 @@ reserve(std::size_t n)
template<class Allocator> template<class Allocator>
void void
basic_flat_streambuf<Allocator>:: basic_flat_buffer<Allocator>::
shrink_to_fit() shrink_to_fit()
{ {
auto const len = size(); auto const len = size();
@ -312,7 +312,7 @@ shrink_to_fit()
template<class Allocator> template<class Allocator>
std::size_t std::size_t
read_size_helper(basic_flat_streambuf< read_size_helper(basic_flat_buffer<
Allocator> const& fb, std::size_t max_size) Allocator> const& fb, std::size_t max_size)
{ {
BOOST_ASSERT(max_size >= 1); BOOST_ASSERT(max_size >= 1);

4
include/beast/http/basic_parser.hpp
View File

@ -190,10 +190,10 @@ enum class parse_state
The parser is optimized for the case where the input buffer The parser is optimized for the case where the input buffer
sequence consists of a single contiguous buffer. The sequence consists of a single contiguous buffer. The
@ref beast::flat_streambuf class is provided, which guarantees @ref beast::flat_buffer class is provided, which guarantees
that the input sequence of the stream buffer will be represented that the input sequence of the stream buffer will be represented
by exactly one contiguous buffer. To ensure the optimum performance by exactly one contiguous buffer. To ensure the optimum performance
of the parser, use @ref beast::flat_streambuf with HTTP algorithms of the parser, use @ref beast::flat_buffer with HTTP algorithms
such as @ref beast::http::read, @ref beast::http::read_some, such as @ref beast::http::read, @ref beast::http::read_some,
@ref beast::http::async_read, and @ref beast::http::async_read_some. @ref beast::http::async_read, and @ref beast::http::async_read_some.
Alternatively, the caller may use custom techniques to ensure that Alternatively, the caller may use custom techniques to ensure that

2
test/Jamfile
View File

@ -25,7 +25,7 @@ unit-test core-tests :
core/consuming_buffers.cpp core/consuming_buffers.cpp
core/dynabuf_readstream.cpp core/dynabuf_readstream.cpp
core/error.cpp core/error.cpp
core/flat_streambuf.cpp core/flat_buffer.cpp
core/handler_alloc.cpp core/handler_alloc.cpp
core/handler_concepts.cpp core/handler_concepts.cpp
core/handler_ptr.cpp core/handler_ptr.cpp

2
test/core/CMakeLists.txt
View File

@ -18,7 +18,7 @@ add_executable (core-tests
consuming_buffers.cpp consuming_buffers.cpp
dynabuf_readstream.cpp dynabuf_readstream.cpp
error.cpp error.cpp
flat_streambuf.cpp flat_buffer.cpp
handler_alloc.cpp handler_alloc.cpp
handler_concepts.cpp handler_concepts.cpp
handler_ptr.cpp handler_ptr.cpp

154
test/core/flat_streambuf.cpp → test/core/flat_buffer.cpp
View File

@ -6,7 +6,7 @@
// //
// Test that header file is self-contained. // Test that header file is self-contained.
#include <beast/core/flat_streambuf.hpp> #include <beast/core/flat_buffer.hpp>
#include "buffer_test.hpp" #include "buffer_test.hpp"
#include <beast/core/ostream.hpp> #include <beast/core/ostream.hpp>
@ -17,10 +17,10 @@
namespace beast { namespace beast {
static_assert(is_DynamicBuffer<flat_streambuf>::value, static_assert(is_DynamicBuffer<flat_buffer>::value,
"DynamicBuffer requirements not met"); "DynamicBuffer requirements not met");
class flat_streambuf_test : public beast::unit_test::suite class flat_buffer_test : public beast::unit_test::suite
{ {
public: public:
template<class ConstBufferSequence> template<class ConstBufferSequence>
@ -35,8 +35,8 @@ public:
template<class Alloc1, class Alloc2> template<class Alloc1, class Alloc2>
static static
bool bool
eq(basic_flat_streambuf<Alloc1> const& sb1, eq(basic_flat_buffer<Alloc1> const& sb1,
basic_flat_streambuf<Alloc2> const& sb2) basic_flat_buffer<Alloc2> const& sb2)
{ {
return to_string(sb1.data()) == to_string(sb2.data()); return to_string(sb1.data()) == to_string(sb2.data());
} }
@ -50,13 +50,13 @@ public:
Equal, Assign, Move, Swap, Select>; Equal, Assign, Move, Swap, Select>;
{ {
using boost::asio::buffer_size; using boost::asio::buffer_size;
basic_flat_streambuf<allocator> b1{10}; basic_flat_buffer<allocator> b1{10};
BEAST_EXPECT(b1.size() == 0); BEAST_EXPECT(b1.size() == 0);
BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BEAST_EXPECT(b1.max_size() == 10); BEAST_EXPECT(b1.max_size() == 10);
b1.prepare(1); b1.prepare(1);
b1.commit(1); b1.commit(1);
basic_flat_streambuf<allocator> b2{std::move(b1)}; basic_flat_buffer<allocator> b2{std::move(b1)};
BEAST_EXPECT(b1.capacity() == 0); BEAST_EXPECT(b1.capacity() == 0);
BEAST_EXPECT(b1.max_size() == 10); BEAST_EXPECT(b1.max_size() == 10);
BEAST_EXPECT(b2.size() == 1); BEAST_EXPECT(b2.size() == 1);
@ -65,29 +65,29 @@ public:
BEAST_EXPECT(buffer_size(b1.prepare(1)) == 1); BEAST_EXPECT(buffer_size(b1.prepare(1)) == 1);
} }
{ {
basic_flat_streambuf<allocator> b1{10}; basic_flat_buffer<allocator> b1{10};
basic_flat_streambuf<allocator> b2{std::move(b1), allocator{}}; basic_flat_buffer<allocator> b2{std::move(b1), allocator{}};
} }
{ {
basic_flat_streambuf<allocator> b1{10}; basic_flat_buffer<allocator> b1{10};
basic_flat_streambuf<allocator> b2{b1}; basic_flat_buffer<allocator> b2{b1};
} }
{ {
basic_flat_streambuf<allocator> b1{10}; basic_flat_buffer<allocator> b1{10};
basic_flat_streambuf<allocator> b2{b1, allocator{}}; basic_flat_buffer<allocator> b2{b1, allocator{}};
} }
{ {
flat_streambuf b1{10}; flat_buffer b1{10};
b1.prepare(1); b1.prepare(1);
b1.commit(1); b1.commit(1);
basic_flat_streambuf<allocator> b2{b1}; basic_flat_buffer<allocator> b2{b1};
BEAST_EXPECT(b2.size() == 1); BEAST_EXPECT(b2.size() == 1);
} }
{ {
basic_flat_streambuf<allocator> b1{10}; basic_flat_buffer<allocator> b1{10};
} }
{ {
basic_flat_streambuf<allocator> b1{allocator{}, 10}; basic_flat_buffer<allocator> b1{allocator{}, 10};
} }
} }
@ -136,14 +136,14 @@ public:
// //
{ {
flat_streambuf b{10}; flat_buffer b{10};
b.prepare(1); b.prepare(1);
b.commit(1); b.commit(1);
b.reserve(2); b.reserve(2);
BEAST_EXPECT(b.size() == 1); BEAST_EXPECT(b.size() == 1);
} }
{ {
flat_streambuf b{10}; flat_buffer b{10};
try try
{ {
b.reserve(11); b.reserve(11);
@ -162,35 +162,35 @@ public:
using boost::asio::buffer; using boost::asio::buffer;
using boost::asio::buffer_copy; using boost::asio::buffer_copy;
{ {
flat_streambuf fb{10}; flat_buffer b{10};
BEAST_EXPECT(fb.max_size() == 10); BEAST_EXPECT(b.max_size() == 10);
} }
{ {
flat_streambuf fb{1024}; flat_buffer b{1024};
BEAST_EXPECT(fb.max_size() == 1024); BEAST_EXPECT(b.max_size() == 1024);
} }
std::string const s = "Hello, world!"; std::string const s = "Hello, world!";
for(std::size_t i = 1; i < s.size() - 1; ++i) for(std::size_t i = 1; i < s.size() - 1; ++i)
{ {
flat_streambuf fb{1024}; flat_buffer b{1024};
fb.commit(buffer_copy( b.commit(buffer_copy(
fb.prepare(i), buffer(s))); b.prepare(i), buffer(s)));
fb.commit(buffer_copy( b.commit(buffer_copy(
fb.prepare(s.size() - i), b.prepare(s.size() - i),
buffer(s.data() + i, s.size() - i))); buffer(s.data() + i, s.size() - i)));
BEAST_EXPECT(to_string(fb.data()) == s); BEAST_EXPECT(to_string(b.data()) == s);
{ {
flat_streambuf fb2{fb}; flat_buffer b2{b};
BEAST_EXPECT(eq(fb2, fb)); BEAST_EXPECT(eq(b2, b));
flat_streambuf fb3{std::move(fb2)}; flat_buffer b3{std::move(b2)};
BEAST_EXPECT(eq(fb3, fb)); BEAST_EXPECT(eq(b3, b));
BEAST_EXPECT(! eq(fb2, fb3)); BEAST_EXPECT(! eq(b2, b3));
BEAST_EXPECT(fb2.size() == 0); BEAST_EXPECT(b2.size() == 0);
} }
using alloc_type = std::allocator<double>; using alloc_type = std::allocator<double>;
using type = using type =
basic_flat_streambuf<alloc_type>; basic_flat_buffer<alloc_type>;
alloc_type alloc; alloc_type alloc;
{ {
type fba{alloc, 1}; type fba{alloc, 1};
@ -201,18 +201,18 @@ public:
BEAST_EXPECT(fba.max_size() == 1024); BEAST_EXPECT(fba.max_size() == 1024);
} }
{ {
type fb2{fb}; type fb2{b};
BEAST_EXPECT(eq(fb2, fb)); BEAST_EXPECT(eq(fb2, b));
type fb3{std::move(fb2)}; type fb3{std::move(fb2)};
BEAST_EXPECT(eq(fb3, fb)); BEAST_EXPECT(eq(fb3, b));
BEAST_EXPECT(! eq(fb2, fb3)); BEAST_EXPECT(! eq(fb2, fb3));
BEAST_EXPECT(fb2.size() == 0); BEAST_EXPECT(fb2.size() == 0);
} }
{ {
type fb2{fb, alloc}; type fb2{b, alloc};
BEAST_EXPECT(eq(fb2, fb)); BEAST_EXPECT(eq(fb2, b));
type fb3{std::move(fb2), alloc}; type fb3{std::move(fb2), alloc};
BEAST_EXPECT(eq(fb3, fb)); BEAST_EXPECT(eq(fb3, b));
BEAST_EXPECT(! eq(fb2, fb3)); BEAST_EXPECT(! eq(fb2, fb3));
BEAST_EXPECT(fb2.size() == 0); BEAST_EXPECT(fb2.size() == 0);
} }
@ -224,57 +224,57 @@ public:
{ {
using boost::asio::buffer_size; using boost::asio::buffer_size;
flat_streambuf fb{100}; flat_buffer b{100};
BEAST_EXPECT(fb.size() == 0); BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(fb.capacity() == 0); BEAST_EXPECT(b.capacity() == 0);
BEAST_EXPECT(buffer_size(fb.prepare(100)) == 100); BEAST_EXPECT(buffer_size(b.prepare(100)) == 100);
BEAST_EXPECT(fb.size() == 0); BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(fb.capacity() > 0); BEAST_EXPECT(b.capacity() > 0);
fb.commit(20); b.commit(20);
BEAST_EXPECT(fb.size() == 20); BEAST_EXPECT(b.size() == 20);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
fb.consume(5); b.consume(5);
BEAST_EXPECT(fb.size() == 15); BEAST_EXPECT(b.size() == 15);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
fb.prepare(80); b.prepare(80);
fb.commit(80); b.commit(80);
BEAST_EXPECT(fb.size() == 95); BEAST_EXPECT(b.size() == 95);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
fb.shrink_to_fit(); b.shrink_to_fit();
BEAST_EXPECT(fb.size() == 95); BEAST_EXPECT(b.size() == 95);
BEAST_EXPECT(fb.capacity() == 95); BEAST_EXPECT(b.capacity() == 95);
} }
void void
testPrepare() testPrepare()
{ {
flat_streambuf fb{100}; flat_buffer b{100};
fb.prepare(20); b.prepare(20);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
fb.commit(10); b.commit(10);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
fb.consume(4); b.consume(4);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
fb.prepare(14); b.prepare(14);
BEAST_EXPECT(fb.size() == 6); BEAST_EXPECT(b.size() == 6);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
fb.consume(10); b.consume(10);
BEAST_EXPECT(fb.size() == 0); BEAST_EXPECT(b.size() == 0);
BEAST_EXPECT(fb.capacity() == 100); BEAST_EXPECT(b.capacity() == 100);
} }
void void
testMax() testMax()
{ {
flat_streambuf fb{1}; flat_buffer b{1};
try try
{ {
fb.prepare(2); b.prepare(2);
fail("", __FILE__, __LINE__); fail("", __FILE__, __LINE__);
} }
catch(std::length_error const&) catch(std::length_error const&)
@ -296,6 +296,6 @@ public:
} }
}; };
BEAST_DEFINE_TESTSUITE(flat_streambuf,core,beast); BEAST_DEFINE_TESTSUITE(flat_buffer,core,beast);
} // beast } // beast

30
test/http/design.cpp
View File

@ -5,7 +5,7 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
#include <beast/core/flat_streambuf.hpp> #include <beast/core/flat_buffer.hpp>
#include <beast/core/prepare_buffers.hpp> #include <beast/core/prepare_buffers.hpp>
#include <beast/http/chunk_encode.hpp> #include <beast/http/chunk_encode.hpp>
#include <beast/http/read.hpp> #include <beast/http/read.hpp>
@ -104,7 +104,7 @@ public:
"*" "*"
}; };
message<true, direct_body, fields> m; message<true, direct_body, fields> m;
flat_streambuf b{1024}; flat_buffer b{1024};
read(is, b, m); read(is, b, m);
BEAST_EXPECT(m.body == "*"); BEAST_EXPECT(m.body == "*");
} }
@ -117,7 +117,7 @@ public:
"*" "*"
}; };
message<false, direct_body, fields> m; message<false, direct_body, fields> m;
flat_streambuf b{20}; flat_buffer b{20};
read(is, b, m); read(is, b, m);
BEAST_EXPECT(m.body == "*"); BEAST_EXPECT(m.body == "*");
} }
@ -133,7 +133,7 @@ public:
"0\r\n\r\n" "0\r\n\r\n"
}; };
message<true, direct_body, fields> m; message<true, direct_body, fields> m;
flat_streambuf b{100}; flat_buffer b{100};
read(is, b, m); read(is, b, m);
BEAST_EXPECT(m.body == "*"); BEAST_EXPECT(m.body == "*");
} }
@ -201,7 +201,7 @@ public:
"*" "*"
}; };
message<true, indirect_body, fields> m; message<true, indirect_body, fields> m;
flat_streambuf b{1024}; flat_buffer b{1024};
read(is, b, m); read(is, b, m);
BEAST_EXPECT(m.body == "*"); BEAST_EXPECT(m.body == "*");
} }
@ -214,7 +214,7 @@ public:
"*" "*"
}; };
message<false, indirect_body, fields> m; message<false, indirect_body, fields> m;
flat_streambuf b{20}; flat_buffer b{20};
read(is, b, m); read(is, b, m);
BEAST_EXPECT(m.body == "*"); BEAST_EXPECT(m.body == "*");
} }
@ -231,7 +231,7 @@ public:
"0\r\n\r\n" "0\r\n\r\n"
}; };
message<true, indirect_body, fields> m; message<true, indirect_body, fields> m;
flat_streambuf b{1024}; flat_buffer b{1024};
read(is, b, m); read(is, b, m);
BEAST_EXPECT(m.body == "*"); BEAST_EXPECT(m.body == "*");
} }
@ -253,7 +253,7 @@ public:
"*****" "*****"
}; };
header_parser<true, fields> p; header_parser<true, fields> p;
flat_streambuf b{38}; flat_buffer b{38};
auto const bytes_used = auto const bytes_used =
read_some(is, b, p); read_some(is, b, p);
b.consume(bytes_used); b.consume(bytes_used);
@ -272,7 +272,7 @@ public:
"*****" "*****"
}; };
header_parser<false, fields> p; header_parser<false, fields> p;
flat_streambuf b{20}; flat_buffer b{20};
auto const bytes_used = auto const bytes_used =
read_some(is, b, p); read_some(is, b, p);
b.consume(bytes_used); b.consume(bytes_used);
@ -303,7 +303,7 @@ public:
}; };
header_parser<true, fields> p; header_parser<true, fields> p;
flat_streambuf b{128}; flat_buffer b{128};
auto const bytes_used = auto const bytes_used =
read_some(is, b, p); read_some(is, b, p);
b.consume(bytes_used); b.consume(bytes_used);
@ -335,7 +335,7 @@ public:
DynamicBuffer& b, DynamicBuffer& b,
SyncReadStream& in) SyncReadStream& in)
{ {
flat_streambuf buffer{4096}; // 4K limit flat_buffer buffer{4096}; // 4K limit
header_parser<isRequest, fields> parser; header_parser<isRequest, fields> parser;
error_code ec; error_code ec;
do do
@ -397,7 +397,7 @@ public:
3 // max_read 3 // max_read
}; };
test::string_ostream os{ios_}; test::string_ostream os{ios_};
flat_streambuf b{16}; flat_buffer b{16};
relay<true>(os, b, is); relay<true>(os, b, is);
} }
@ -410,7 +410,7 @@ public:
3 // max_read 3 // max_read
}; };
test::string_ostream os{ios_}; test::string_ostream os{ios_};
flat_streambuf b{16}; flat_buffer b{16};
relay<false>(os, b, is); relay<false>(os, b, is);
} }
@ -427,7 +427,7 @@ public:
2 // max_read 2 // max_read
}; };
test::string_ostream os{ios_}; test::string_ostream os{ios_};
flat_streambuf b{16}; flat_buffer b{16};
relay<true>(os, b, is); relay<true>(os, b, is);
} }
} }
@ -444,7 +444,7 @@ public:
void void
doFixedRead(SyncReadStream& stream, BodyCallback const& cb) doFixedRead(SyncReadStream& stream, BodyCallback const& cb)
{ {
flat_streambuf buffer{4096}; // 4K limit flat_buffer buffer{4096}; // 4K limit
header_parser<isRequest, fields> parser; header_parser<isRequest, fields> parser;
std::size_t bytes_used; std::size_t bytes_used;
bytes_used = read_some(stream, buffer, parser); bytes_used = read_some(stream, buffer, parser);

6
test/http/header_parser.cpp
View File

@ -8,7 +8,7 @@
// Test that header file is self-contained. // Test that header file is self-contained.
#include <beast/http/header_parser.hpp> #include <beast/http/header_parser.hpp>
#include <beast/core/flat_streambuf.hpp> #include <beast/core/flat_buffer.hpp>
#include <beast/http/read.hpp> #include <beast/http/read.hpp>
#include <beast/unit_test/suite.hpp> #include <beast/unit_test/suite.hpp>
#include <beast/test/string_istream.hpp> #include <beast/test/string_istream.hpp>
@ -31,7 +31,7 @@ public:
"User-Agent: test\r\n" "User-Agent: test\r\n"
"\r\n" "\r\n"
}; };
flat_streambuf db{1024}; flat_buffer db{1024};
header_parser<true, fields> p; header_parser<true, fields> p;
read_some(is, db, p); read_some(is, db, p);
BEAST_EXPECT(p.is_complete()); BEAST_EXPECT(p.is_complete());
@ -44,7 +44,7 @@ public:
"\r\n" "\r\n"
"*" "*"
}; };
flat_streambuf db{1024}; flat_buffer db{1024};
header_parser<true, fields> p; header_parser<true, fields> p;
read_some(is, db, p); read_some(is, db, p);
BEAST_EXPECT(! p.is_complete()); BEAST_EXPECT(! p.is_complete());

6
test/http/message_parser.cpp
View File

@ -14,7 +14,7 @@
#include <beast/test/string_istream.hpp> #include <beast/test/string_istream.hpp>
#include <beast/test/string_ostream.hpp> #include <beast/test/string_ostream.hpp>
#include <beast/test/yield_to.hpp> #include <beast/test/yield_to.hpp>
#include <beast/core/flat_streambuf.hpp> #include <beast/core/flat_buffer.hpp>
#include <beast/core/multi_buffer.hpp> #include <beast/core/multi_buffer.hpp>
#include <beast/http/header_parser.hpp> #include <beast/http/header_parser.hpp>
#include <beast/http/read.hpp> #include <beast/http/read.hpp>
@ -39,7 +39,7 @@ public:
#if 0 #if 0
multi_buffer dynabuf; multi_buffer dynabuf;
#else #else
flat_streambuf dynabuf{1024}; flat_buffer dynabuf{1024};
#endif #endif
message<isRequest, string_body, fields> m; message<isRequest, string_body, fields> m;
read(ss, dynabuf, m, ec); read(ss, dynabuf, m, ec);
@ -124,7 +124,7 @@ public:
"Content-Length: 1\r\n" "Content-Length: 1\r\n"
"\r\n" "\r\n"
"*"}; "*"};
flat_streambuf b{1024}; flat_buffer b{1024};
message_parser<true, string_body, fields> p; message_parser<true, string_body, fields> p;
read(is, b, p, ec); read(is, b, p, ec);
auto const& m = p.get(); auto const& m = p.get();