boost/beast/core/buffers_adaptor.hpp
// // 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_BUFFERS_ADAPTOR_HPP #define BOOST_BEAST_BUFFERS_ADAPTOR_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/optional.hpp> #include <type_traits> namespace boost { namespace beast { /** Adapts a <em>MutableBufferSequence</em> into a <em>DynamicBuffer</em>. This class wraps a <em>MutableBufferSequence</em> to meet the requirements of <em>DynamicBuffer</em>. Upon construction the input and output sequences are empty. A copy of the mutable buffer sequence object is stored; however, ownership of the underlying memory is not transferred. The caller is responsible for making sure that referenced memory remains valid for the duration of any operations. The size of the mutable buffer sequence determines the maximum number of bytes which may be prepared and committed. @tparam MutableBufferSequence The type of mutable buffer sequence to adapt. */ template<class MutableBufferSequence> class buffers_adaptor { static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); using iter_type = buffers_iterator_type<MutableBufferSequence>; template<bool> class subrange; MutableBufferSequence bs_; iter_type begin_; iter_type out_; iter_type end_; std::size_t max_size_; std::size_t in_pos_ = 0; // offset in *begin_ std::size_t in_size_ = 0; // size of input sequence std::size_t out_pos_ = 0; // offset in *out_ std::size_t out_end_ = 0; // output end offset iter_type end_impl() const; buffers_adaptor( buffers_adaptor const& other, std::size_t nbegin, std::size_t nout, std::size_t nend); public: /// The type of the underlying mutable buffer sequence using value_type = MutableBufferSequence; /** Construct a buffers adaptor. @param buffers The mutable buffer sequence to wrap. A copy of the object will be made, but ownership of the memory is not transferred. */ explicit buffers_adaptor(MutableBufferSequence const& buffers); /** Constructor This constructs the buffer adaptor in-place from a list of arguments. @param args Arguments forwarded to the buffers constructor. */ template<class... Args> explicit buffers_adaptor(boost::in_place_init_t, Args&&... args); /// Copy Constructor buffers_adaptor(buffers_adaptor const& other); /// Copy Assignment buffers_adaptor& operator=(buffers_adaptor const&); /// Returns the original mutable buffer sequence value_type const& value() const { return bs_; } //-------------------------------------------------------------------------- #if BOOST_BEAST_DOXYGEN /// The ConstBufferSequence used to represent the readable bytes. using const_buffers_type = __implementation_defined__; /// The MutableBufferSequence used to represent the writable bytes. using mutable_buffers_type = __implementation_defined__; #else using const_buffers_type = subrange<false>; using mutable_buffers_type = subrange<true>; #endif /// Returns the number of readable bytes. std::size_t size() const noexcept { return in_size_; } /// Return the maximum number of bytes, both readable and writable, that can ever be held. std::size_t max_size() const noexcept { return max_size_; } /// Return the maximum number of bytes, both readable and writable, that can be held without requiring an allocation. std::size_t capacity() const noexcept { return max_size_; } /// Returns a constant buffer sequence representing the readable bytes const_buffers_type data() const noexcept; /// Returns a constant buffer sequence representing the readable bytes const_buffers_type cdata() const noexcept { return data(); } /// Returns a mutable buffer sequence representing the readable bytes. mutable_buffers_type data() noexcept; /** Returns a mutable buffer sequence representing writable bytes. Returns a mutable buffer sequence representing the writable bytes containing exactly `n` bytes of storage. This function does not allocate memory. Instead, the storage comes from the underlying mutable buffer sequence. All buffer sequences previously obtained using @ref prepare are invalidated. Buffer sequences previously obtained using @ref data remain valid. @param n The desired number of bytes in the returned buffer sequence. @throws std::length_error if `size() + n` exceeds `max_size()`. @esafe Strong guarantee. */ mutable_buffers_type prepare(std::size_t n); /** Append writable bytes to the readable bytes. Appends n bytes from the start of the writable bytes to the end of the readable bytes. The remainder of the writable bytes are discarded. If n is greater than the number of writable bytes, all writable bytes are appended to the readable bytes. All buffer sequences previously obtained using @ref prepare are invalidated. Buffer sequences previously obtained using @ref data remain valid. @param n The number of bytes to append. If this number is greater than the number of writable bytes, all writable bytes are appended. @esafe No-throw guarantee. */ void commit(std::size_t n) noexcept; /** Remove bytes from beginning of the readable bytes. Removes n bytes from the beginning of the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The number of bytes to remove. If this number is greater than the number of readable bytes, all readable bytes are removed. @esafe No-throw guarantee. */ void consume(std::size_t n) noexcept; private: subrange<true> make_subrange(std::size_t pos, std::size_t n); subrange<false> make_subrange(std::size_t pos, std::size_t n) const; friend struct buffers_adaptor_test_hook; }; } // beast } // boost #include <boost/beast/core/impl/buffers_adaptor.hpp> #endif