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

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

 //
 // buffered_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff 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)
 //
 
 #ifndef BOOST_ASIO_BUFFERED_STREAM_HPP
 #define BOOST_ASIO_BUFFERED_STREAM_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <boost/asio/async_result.hpp>
 #include <boost/asio/buffered_read_stream.hpp>
 #include <boost/asio/buffered_write_stream.hpp>
 #include <boost/asio/buffered_stream_fwd.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Adds buffering to the read- and write-related operations of a stream.
 /**
  * The buffered_stream class template can be used to add buffering to the
  * synchronous and asynchronous read and write operations of a stream.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
 template <typename Stream>
 class buffered_stream
   : private noncopyable
 {
 public:
   /// The type of the next layer.
   typedef remove_reference_t<Stream> next_layer_type;
 
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
   /// The type of the executor associated with the object.
   typedef typename lowest_layer_type::executor_type executor_type;
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_stream(Arg&& a)
     : inner_stream_impl_(static_cast<Arg&&>(a)),
       stream_impl_(inner_stream_impl_)
   {
   }
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_stream(Arg&& a,
       std::size_t read_buffer_size, std::size_t write_buffer_size)
     : inner_stream_impl_(static_cast<Arg&&>(a), write_buffer_size),
       stream_impl_(inner_stream_impl_, read_buffer_size)
   {
   }
 
   /// Get a reference to the next layer.
   next_layer_type& next_layer()
   {
     return stream_impl_.next_layer().next_layer();
   }
 
   /// Get a reference to the lowest layer.
   lowest_layer_type& lowest_layer()
   {
     return stream_impl_.lowest_layer();
   }
 
   /// Get a const reference to the lowest layer.
   const lowest_layer_type& lowest_layer() const
   {
     return stream_impl_.lowest_layer();
   }
 
   /// Get the executor associated with the object.
   executor_type get_executor() noexcept
   {
     return stream_impl_.lowest_layer().get_executor();
   }
 
   /// Close the stream.
   void close()
   {
     stream_impl_.close();
   }
 
   /// Close the stream.
   BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec)
   {
     stream_impl_.close(ec);
     BOOST_ASIO_SYNC_OP_VOID_RETURN(ec);
   }
 
   /// Flush all data from the buffer to the next layer. Returns the number of
   /// bytes written to the next layer on the last write operation. Throws an
   /// exception on failure.
   std::size_t flush()
   {
     return stream_impl_.next_layer().flush();
   }
 
   /// Flush all data from the buffer to the next layer. Returns the number of
   /// bytes written to the next layer on the last write operation, or 0 if an
   /// error occurred.
   std::size_t flush(boost::system::error_code& ec)
   {
     return stream_impl_.next_layer().flush(ec);
   }
 
   /// Start an asynchronous flush.
   /**
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) WriteHandler = default_completion_token_t<executor_type>>
   auto async_flush(
       WriteHandler&& handler = default_completion_token_t<executor_type>())
     -> decltype(
       declval<buffered_write_stream<Stream>&>().async_flush(
         static_cast<WriteHandler&&>(handler)))
   {
     return stream_impl_.next_layer().async_flush(
         static_cast<WriteHandler&&>(handler));
   }
 
   /// Write the given data to the stream. Returns the number of bytes written.
   /// Throws an exception on failure.
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers)
   {
     return stream_impl_.write_some(buffers);
   }
 
   /// Write the given data to the stream. Returns the number of bytes written,
   /// or 0 if an error occurred.
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
     return stream_impl_.write_some(buffers, ec);
   }
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
   /**
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
    */
   template <typename ConstBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) WriteHandler = default_completion_token_t<executor_type>>
   auto async_write_some(const ConstBufferSequence& buffers,
       WriteHandler&& handler = default_completion_token_t<executor_type>())
     -> decltype(
       declval<Stream&>().async_write_some(buffers,
         static_cast<WriteHandler&&>(handler)))
   {
     return stream_impl_.async_write_some(buffers,
         static_cast<WriteHandler&&>(handler));
   }
 
   /// Fill the buffer with some data. Returns the number of bytes placed in the
   /// buffer as a result of the operation. Throws an exception on failure.
   std::size_t fill()
   {
     return stream_impl_.fill();
   }
 
   /// Fill the buffer with some data. Returns the number of bytes placed in the
   /// buffer as a result of the operation, or 0 if an error occurred.
   std::size_t fill(boost::system::error_code& ec)
   {
     return stream_impl_.fill(ec);
   }
 
   /// Start an asynchronous fill.
   /**
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
    */
   template <
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) ReadHandler = default_completion_token_t<executor_type>>
   auto async_fill(
       ReadHandler&& handler = default_completion_token_t<executor_type>())
     -> decltype(
       declval<buffered_read_stream<
         buffered_write_stream<Stream>>&>().async_fill(
           static_cast<ReadHandler&&>(handler)))
   {
     return stream_impl_.async_fill(static_cast<ReadHandler&&>(handler));
   }
 
   /// Read some data from the stream. Returns the number of bytes read. Throws
   /// an exception on failure.
   template <typename MutableBufferSequence>
   std::size_t read_some(const MutableBufferSequence& buffers)
   {
     return stream_impl_.read_some(buffers);
   }
 
   /// Read some data from the stream. Returns the number of bytes read or 0 if
   /// an error occurred.
   template <typename MutableBufferSequence>
   std::size_t read_some(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
     return stream_impl_.read_some(buffers, ec);
   }
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
   /**
    * @par Completion Signature
    * @code void(boost::system::error_code, std::size_t) @endcode
    */
   template <typename MutableBufferSequence,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
         std::size_t)) ReadHandler = default_completion_token_t<executor_type>>
   auto async_read_some(const MutableBufferSequence& buffers,
       ReadHandler&& handler = default_completion_token_t<executor_type>())
     -> decltype(
       declval<Stream&>().async_read_some(buffers,
         static_cast<ReadHandler&&>(handler)))
   {
     return stream_impl_.async_read_some(buffers,
         static_cast<ReadHandler&&>(handler));
   }
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read.
   /// Throws an exception on failure.
   template <typename MutableBufferSequence>
   std::size_t peek(const MutableBufferSequence& buffers)
   {
     return stream_impl_.peek(buffers);
   }
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read,
   /// or 0 if an error occurred.
   template <typename MutableBufferSequence>
   std::size_t peek(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
     return stream_impl_.peek(buffers, ec);
   }
 
   /// Determine the amount of data that may be read without blocking.
   std::size_t in_avail()
   {
     return stream_impl_.in_avail();
   }
 
   /// Determine the amount of data that may be read without blocking.
   std::size_t in_avail(boost::system::error_code& ec)
   {
     return stream_impl_.in_avail(ec);
   }
 
 private:
   // The buffered write stream.
   typedef buffered_write_stream<Stream> write_stream_type;
   write_stream_type inner_stream_impl_;
 
   // The buffered read stream.
   typedef buffered_read_stream<write_stream_type&> read_stream_type;
   read_stream_type stream_impl_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_BUFFERED_STREAM_HPP

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