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

Remove dynamic_buffer_ref:

Browse Source 
* dynamic_buffer_ref is removed, because Asio / Networking
  has introduced the DynamicBuffer_v2 concept which is incompatible
  with Beast's storage types.

The next version of Beast (1.70) will provide changes to
interoperate with Asio / Networking's new concepts.
This commit is contained in:
Vinnie Falco
2019-03-06 16:25:08 -08:00
parent f4e2a327c8
commit fdf64a4550
10 changed files with 1 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -1,6 +1,7 @@
Version 230:
* Don't use dynamic_buffer_ref
* Remove dynamic_buffer_ref
--------------------------------------------------------------------------------

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

@ -133,15 +133,6 @@ set of additional implementations of the dynamic buffer concept:
The basic container is an
[@https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer [*AllocatorAwareContainer]].
]]
[[
[link beast.ref.boost__beast__dynamic_buffer_ref `dynamic_buffer_ref`]
[link beast.ref.boost__beast__dynamic_buffer_ref_wrapper `dynamic_buffer_ref_wrapper`]
][
This function returns a wrapper containing a reference to the passed
dynamic buffer, permitting a Beast dynamic buffer type (which acts
like a true container type) to be used with Networking algorithms
which want to take ownership of the dynamic buffer in their interface.
]]
[[
[link beast.ref.boost__beast__flat_static_buffer `flat_static_buffer`]
[link beast.ref.boost__beast__flat_static_buffer_base `flat_static_buffer_base`]

12
doc/qbk/03_core/7_composed.qbk
View File

@ -89,18 +89,6 @@ composed operations:
handler, whose associated allocator and associated executor will
will be the same as those of the original handler.
]]
[[
[link beast.ref.boost__beast__handler_ptr `handler_ptr`]
][
This is a smart pointer container used to manage the internal state of a
composed operation. It is useful when the state is non trivial. For example
when the state has non-movable or contains expensive to move types. The
container takes ownership of the final completion handler, and provides
boilerplate to invoke the final handler in a way that also deletes the
internal state. The internal state is allocated using the final completion
handler's associated allocator, benefiting from all handler memory
management optimizations transparently.
]]
[[
[link beast.ref.boost__beast__saved_handler `saved_handler`]
][

2
doc/qbk/quickref.xml
View File

@ -132,7 +132,6 @@
<member><link linkend="beast.ref.boost__beast__buffers_cat_view">buffers_cat_view</link></member>
<member><link linkend="beast.ref.boost__beast__buffers_prefix_view">buffers_prefix_view</link></member>
<member><link linkend="beast.ref.boost__beast__buffers_suffix">buffers_suffix</link></member>
<member><link linkend="beast.ref.boost__beast__dynamic_buffer_ref_wrapper">dynamic_buffer_ref_wrapper</link>&nbsp;<emphasis role="green">&#9733;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__flat_buffer">flat_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__flat_static_buffer">flat_static_buffer</link></member>
<member><link linkend="beast.ref.boost__beast__flat_static_buffer_base">flat_static_buffer_base</link></member>
@ -150,7 +149,6 @@
<member><link linkend="beast.ref.boost__beast__buffers_range">buffers_range</link>&nbsp;<emphasis role="green">&#9733;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__buffers_range_ref">buffers_range_ref</link>&nbsp;<emphasis role="green">&#9733;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__buffers_to_string">buffers_to_string</link></member>
<member><link linkend="beast.ref.boost__beast__dynamic_buffer_ref">dynamic_buffer_ref</link>&nbsp;<emphasis role="green">&#9733;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__make_printable">make_printable</link>&nbsp;<emphasis role="green">&#9733;</emphasis></member>
<member><link linkend="beast.ref.boost__beast__ostream">ostream</link></member>
<member><link linkend="beast.ref.boost__beast__read_size">read_size</link></member>

1
doc/qbk/release_notes.qbk
View File

@ -160,7 +160,6 @@
* New:
* `saved_handler`
* `buffers_range_ref`
* `dynamic_buffer_ref`
* `executor_type`
* `get_lowest_layer`,
`lowest_layer_type`

1
include/boost/beast/core.hpp
View File

@ -24,7 +24,6 @@
#include <boost/beast/core/buffers_suffix.hpp>
#include <boost/beast/core/buffers_to_string.hpp>
#include <boost/beast/core/detect_ssl.hpp>
#include <boost/beast/core/dynamic_buffer_ref.hpp>
#include <boost/beast/core/error.hpp>
#include <boost/beast/core/file.hpp>
#include <boost/beast/core/file_base.hpp>

143
include/boost/beast/core/dynamic_buffer_ref.hpp
View File

@ -1,143 +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_CORE_DYNAMIC_BUFFER_REF_HPP
#define BOOST_BEAST_CORE_DYNAMIC_BUFFER_REF_HPP
#include <boost/beast/core/detail/config.hpp>
#include <boost/asio/buffer.hpp>
#include <cstdlib>
#include <type_traits>
namespace boost {
namespace beast {
/** A lightweight reference to a dynamic buffer.
Objects of this type meet the requirements of <em>DynamicBuffer</em>.
This is the wrapper returned by the function @ref dynamic_buffer_ref.
@see dynamic_buffer_ref
*/
template<class DynamicBuffer>
class dynamic_buffer_ref_wrapper
#if ! BOOST_BEAST_DOXYGEN
{
static_assert(net::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer type requirements not met");
DynamicBuffer& b_;
public:
using const_buffers_type = typename
DynamicBuffer::const_buffers_type;
using mutable_buffers_type = typename
DynamicBuffer::mutable_buffers_type;
dynamic_buffer_ref_wrapper(
dynamic_buffer_ref_wrapper&&) = default;
dynamic_buffer_ref_wrapper(
dynamic_buffer_ref_wrapper const&) = default;
explicit
dynamic_buffer_ref_wrapper(
DynamicBuffer& b) noexcept
: b_(b)
{
}
std::size_t
size() const noexcept
{
return b_.size();
}
std::size_t
max_size() const noexcept
{
return b_.max_size();
}
std::size_t
capacity() const noexcept
{
return b_.capacity();
}
const_buffers_type
data() const noexcept
{
return b_.data();
}
mutable_buffers_type
prepare(std::size_t n)
{
return b_.prepare(n);
}
void
commit(std::size_t n)
{
b_.commit(n);
}
void
consume(std::size_t n)
{
b_.consume(n);
}
}
#endif
;
/** Return a non-owning reference to a dynamic buffer.
This function returns a wrapper which holds a reference to the
passed dynamic buffer. The wrapper meets the requirements of
<em>DynamicBuffer</em>, allowing its use in Networking algorithms
which want to take ownership of the dynamic buffer. Since Beast
dynamic buffers are true storage types, they cannot be used directly
with functions that take ownership of the dynamic buffer.
@par Example
This function reads a line of text from a stream into a
@ref beast::basic_flat_buffer, using the net function `async_read_until`.
@code
template <class SyncReadStream>
std::size_t read_line (SyncReadStream& stream, flat_buffer& buffer)
{
return net::read_until(stream, dynamic_buffer_ref(buffer), "\r\n");
}
@endcode
@param buffer The dynamic buffer to wrap. Ownership of the buffer is
not transferred, the caller is still responsible for managing the
lifetime of the original object.
@return A wrapper meeting the requirements of <em>DynamicBuffer</em>
which references the original dynamic buffer.
@see dynamic_buffer_ref_wrapper
*/
template<class DynamicBuffer>
dynamic_buffer_ref_wrapper<DynamicBuffer>
dynamic_buffer_ref(DynamicBuffer& buffer) noexcept
{
static_assert(net::is_dynamic_buffer<DynamicBuffer>::value,
"DynamicBuffer type requirements not met");
return dynamic_buffer_ref_wrapper<DynamicBuffer>(buffer);
}
} // beast
} // boost
#endif

1
test/beast/core/CMakeLists.txt
View File

@ -44,7 +44,6 @@ add_executable (tests-beast-core
buffers_suffix.cpp
buffers_to_string.cpp
detect_ssl.cpp
dynamic_buffer_ref.cpp
error.cpp
file.cpp
file_base.cpp

1
test/beast/core/Jamfile
View File

@ -32,7 +32,6 @@ local SOURCES =
buffers_suffix.cpp
buffers_to_string.cpp
detect_ssl.cpp
dynamic_buffer_ref.cpp
error.cpp
file.cpp
file_base.cpp

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

@ -1,73 +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
//
// Test that header file is self-contained.
#include <boost/beast/core/dynamic_buffer_ref.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <boost/beast/_experimental/test/stream.hpp>
#include <boost/beast/core/flat_buffer.hpp>
#include <boost/asio/read_until.hpp>
namespace boost {
namespace beast {
namespace {
template <class SyncReadStream>
std::size_t read_line (SyncReadStream& stream, flat_buffer& buffer)
{
return net::read_until(stream, dynamic_buffer_ref(buffer), "\r\n");
}
} // (anon)
class dynamic_buffer_ref_test : public beast::unit_test::suite
{
public:
void
testJavadocs()
{
BEAST_EXPECT(static_cast<
std::size_t(*)(test::stream&, flat_buffer&)>(
&read_line<test::stream>));
}
void
testBuffer()
{
flat_buffer b;
b.max_size(1000);
auto db = dynamic_buffer_ref(b);
BEAST_EXPECT(db.max_size() == 1000);
BEAST_EXPECT(db.size() == 0);
BEAST_EXPECT(db.capacity() == 0);
db.prepare(512);
BEAST_EXPECT(db.size() == 0);
BEAST_EXPECT(db.capacity() == 512);
db.commit(12);
BEAST_EXPECT(db.size() == 12);
BEAST_EXPECT(db.capacity() == 512);
BEAST_EXPECT(buffer_bytes(db.data()) == 12);
db.consume(12);
BEAST_EXPECT(db.size() == 0);
BEAST_EXPECT(db.capacity() == 512);
}
void run() override
{
testJavadocs();
testBuffer();
}
};
BEAST_DEFINE_TESTSUITE(beast,core,dynamic_buffer_ref);
} // beast
} // boost