EIC code displayed by LXR master/​include/​boost/​beast/​core/​buffer_ref.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:29:27

 //
 // Copyright (c) 2022 Klemens D. Morgenstern (klemens dot morgenstern at gmx dot net)
 //
 // 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)
 #ifndef BOOST_BEAST_BUFFER_REF_HPP
 #define BOOST_BEAST_BUFFER_REF_HPP
 
 #include <cstddef>
 
 namespace boost {
 namespace beast {
 
 #if !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 
 /** The buffer ref provides a wrapper around beast buffers
  * to make them usable with asio dynamic_buffer v1.
  *
  * v2 is current not supported, so that
  * `BOOST_ASIO_NO_DYNAMIC_BUFFER_V1` mustn't be defined.
  *
  * @par Example
  *
  * @code
  *
  * asio::tcp::socket sock;
  * beast::flat_buffer fb;
  * asio::read_until(sock, ref(fb) '\n');
  *
  * @endcode
  *
  * @tparam Buffer The underlying buffer
  */
 template<typename Buffer>
 struct buffer_ref
 {
     /// The ConstBufferSequence used to represent the readable bytes.
     using const_buffers_type = typename Buffer::const_buffers_type;
 
     /// The MutableBufferSequence used to represent the writable bytes.
     using mutable_buffers_type = typename Buffer::mutable_buffers_type;
 
     /// Returns the number of readable bytes.
     std::size_t
     size() const noexcept
     {
         return buffer_.size();
     }
 
     /// Return the maximum number of bytes, both readable and writable, that can ever be held.
     std::size_t
     max_size() const noexcept
     {
         return buffer_.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 buffer_.capacity();
     }
 
     /// Returns a constant buffer sequence representing the readable bytes
     const_buffers_type
     data() const noexcept
     {
         return buffer_.data();
     }
 
     /// Get a list of buffers that represents the output
     /// sequence, with the given size.
     /**
      * Ensures that the output sequence can accommodate @c n bytes, resizing the
      * vector object as necessary.
      *
      * @returns An object of type @c mutable_buffers_type that satisfies
      * MutableBufferSequence requirements, representing vector memory at the
      * start of the output sequence of size @c n.
      *
      * @throws std::length_error If <tt>size() + n > max_size()</tt>.
      *
      * @note The returned object is invalidated by any @c dynamic_vector_buffer
      * or @c vector member function that modifies the input sequence or output
      * sequence.
      */
     mutable_buffers_type prepare(std::size_t n)
     {
         return buffer_.prepare(n);
     }
 
     /// Move bytes from the output sequence to the input
     /// sequence.
     /**
      * @param n The number of bytes to append from the start of the output
      * sequence to the end of the input sequence. The remainder of the output
      * sequence is discarded.
      *
      * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
      * no intervening operations that modify the input or output sequence.
      *
      * @note If @c n is greater than the size of the output sequence, the entire
      * output sequence is moved to the input sequence and no error is issued.
      */
     void commit(std::size_t n)
     {
         return buffer_.commit(n);
     }
 
     /// Remove `n` bytes from the readable byte sequence.
     /**
      * @b DynamicBuffer_v1: Removes @c n characters from the beginning of the
      * input sequence. @note If @c n is greater than the size of the input
      * sequence, the entire input sequence is consumed and no error is issued.
      */
     void consume(std::size_t n)
     {
         return buffer_.consume(n);
     }
 
     /// The type of the underlying buffer.
     using buffer_type = Buffer;
 
     /// Create a buffer reference around @c buffer.
     buffer_ref(Buffer & buffer) : buffer_(buffer) {}
 
     /// Copy the reference.
     buffer_ref(const buffer_ref& buffer) = default;
 
 private:
     Buffer &buffer_;
 };
 
 
 template<class Allocator>
 class basic_flat_buffer;
 template<std::size_t N>
 class flat_static_buffer;
 template<class Allocator>
 class basic_multi_buffer;
 template<std::size_t N>
 class static_buffer;
 
 /// Create a buffer_ref for basic_flat_buffer.
 template<class Allocator>
 inline buffer_ref<basic_flat_buffer<Allocator>> ref(basic_flat_buffer<Allocator> & buf)
 {
     return buffer_ref<basic_flat_buffer<Allocator>>(buf);
 }
 
 /// Create a buffer_ref for flat_static_buffer.
 template<std::size_t N>
 inline buffer_ref<flat_static_buffer<N>> ref(flat_static_buffer<N> & buf)
 {
     return buffer_ref<flat_static_buffer<N>>(buf);
 }
 
 /// Create a buffer_ref for basic_multi_buffer.
 template<class Allocator>
 inline buffer_ref<basic_multi_buffer<Allocator>> ref(basic_multi_buffer<Allocator> & buf)
 {
     return buffer_ref<basic_multi_buffer<Allocator>>(buf);
 }
 
 /// Create a buffer_ref for static_buffer.
 template<std::size_t N>
 inline buffer_ref<static_buffer<N>> ref(static_buffer<N> & buf)
 {
     return buffer_ref<static_buffer<N>>(buf);
 }
 
 #endif // !defined(BOOST_ASIO_NO_DYNAMIC_BUFFER_V1)
 
 }
 }
 
 #endif //BOOST_BEAST_BUFFER_REF_HPP

This page was automatically generated by the 2.3.7 LXR engine. The LXR team