Struct BufStream

pub struct BufStream<RW> { /* private fields */ }

Available on crate features dep_tokio and std only.

Wraps a type that is AsyncWrite and AsyncRead, and buffers its input and output.

It can be excessively inefficient to work directly with something that implements AsyncWrite and AsyncRead. For example, every write, however small, has to traverse the syscall interface, and similarly, every read has to do the same. The BufWriter and BufReader types aid with these problems respectively, but do so in only one direction. BufStream wraps one in the other so that both directions are buffered. See their documentation for details.

Implementations

impl<RW> BufStream<RW>

where RW: AsyncRead + AsyncWrite,

pub fn new(stream: RW) -> BufStream<RW>

Wraps a type in both BufWriter and BufReader.

See the documentation for those types and BufStream for details.

pub fn with_capacity( reader_capacity: usize, writer_capacity: usize, stream: RW, ) -> BufStream<RW>

Creates a BufStream with the specified BufReader capacity and BufWriter capacity.

See the documentation for those types and BufStream for details.

pub fn get_ref(&self) -> &RW

Gets a reference to the underlying I/O object.

It is inadvisable to directly read from the underlying I/O object.

pub fn get_mut(&mut self) -> &mut RW

Gets a mutable reference to the underlying I/O object.

It is inadvisable to directly read from the underlying I/O object.

pub fn get_pin_mut(self: Pin<&mut BufStream<RW>>) -> Pin<&mut RW>

Gets a pinned mutable reference to the underlying I/O object.

It is inadvisable to directly read from the underlying I/O object.

pub fn into_inner(self) -> RW

Consumes this BufStream, returning the underlying I/O object.

Note that any leftover data in the internal buffer is lost.

Trait Implementations

impl<RW> AsyncBufRead for BufStream<RW>

where RW: AsyncRead + AsyncWrite,

fn poll_fill_buf( self: Pin<&mut BufStream<RW>>, cx: &mut Context<'_>, ) -> Poll<Result<&[u8], Error>>

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut BufStream<RW>>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<RW> AsyncRead for BufStream<RW>

where RW: AsyncRead + AsyncWrite,

fn poll_read( self: Pin<&mut BufStream<RW>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

Attempts to read from the AsyncRead into buf.

impl<RW> AsyncSeek for BufStream<RW>

where RW: AsyncRead + AsyncWrite + AsyncSeek,

Seek to an offset, in bytes, in the underlying stream.

The position used for seeking with SeekFrom::Current(_) is the position the underlying stream would be at if the BufStream had no internal buffer.

Seeking always discards the internal buffer, even if the seek position would otherwise fall within it. This guarantees that calling .into_inner() immediately after a seek yields the underlying reader at the same position.

See AsyncSeek for more details.

Note: In the edge case where you’re seeking with SeekFrom::Current(n) where n minus the internal buffer length overflows an i64, two seeks will be performed instead of one. If the second seek returns Err, the underlying reader will be left at the same position it would have if you called seek with SeekFrom::Current(0).

fn start_seek( self: Pin<&mut BufStream<RW>>, position: SeekFrom, ) -> Result<(), Error>

Attempts to seek to an offset, in bytes, in a stream.

fn poll_complete( self: Pin<&mut BufStream<RW>>, cx: &mut Context<'_>, ) -> Poll<Result<u64, Error>>

Waits for a seek operation to complete.

impl<RW> AsyncWrite for BufStream<RW>

where RW: AsyncRead + AsyncWrite,

fn poll_write( self: Pin<&mut BufStream<RW>>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

fn poll_write_vectored( self: Pin<&mut BufStream<RW>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

fn poll_flush( self: Pin<&mut BufStream<RW>>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown( self: Pin<&mut BufStream<RW>>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

impl<RW> Debug for BufStream<RW>

where RW: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<RW> From<BufReader<BufWriter<RW>>> for BufStream<RW>

fn from(b: BufReader<BufWriter<RW>>) -> BufStream<RW>

Converts to this type from the input type.

impl<RW> From<BufWriter<BufReader<RW>>> for BufStream<RW>

fn from(b: BufWriter<BufReader<RW>>) -> BufStream<RW>

Converts to this type from the input type.

impl<'__pin, RW> Unpin for BufStream<RW>

where <PinnedFieldsOfHelperStruct<__Origin<'__pin, RW>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,