Struct tokio::io::BufStream

source ·
pub struct BufStream<RW> { /* private fields */ }
Expand description

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§

source§

impl<RW: AsyncRead + AsyncWrite> BufStream<RW>

source

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.

source

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.

source

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.

source

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.

source

pub fn get_pin_mut(self: Pin<&mut Self>) -> 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.

source

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§

source§

impl<RW: AsyncRead + AsyncWrite> AsyncBufRead for BufStream<RW>

source§

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

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

fn consume(self: Pin<&mut Self>, 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. Read more
source§

impl<RW: AsyncRead + AsyncWrite> AsyncRead for BufStream<RW>

source§

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

Attempts to read from the AsyncRead into buf. Read more
source§

impl<RW: AsyncRead + AsyncWrite + AsyncSeek> AsyncSeek for BufStream<RW>

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).

source§

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

Attempts to seek to an offset, in bytes, in a stream. Read more
source§

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

Waits for a seek operation to complete. Read more
source§

impl<RW: AsyncRead + AsyncWrite> AsyncWrite for BufStream<RW>

source§

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

Attempt to write bytes from buf into the object. Read more
source§

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

Like poll_write, except that it writes from a slice of buffers. Read more
source§

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation. Read more
source§

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

Attempts to flush the object, ensuring that any buffered data reach their destination. Read more
source§

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

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

impl<RW: Debug> Debug for BufStream<RW>

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

impl<'__pin, RW> Unpin for BufStream<RW>where __Origin<'__pin, RW>: Unpin,

Auto Trait Implementations§

§

impl<RW> RefUnwindSafe for BufStream<RW>where RW: RefUnwindSafe,

§

impl<RW> Send for BufStream<RW>where RW: Send,

§

impl<RW> Sync for BufStream<RW>where RW: Sync,

§

impl<RW> UnwindSafe for BufStream<RW>where RW: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<R> AsyncBufReadExt for Rwhere R: AsyncBufRead + ?Sized,

source§

fn read_until<'a>( &'a mut self, byte: u8, buf: &'a mut Vec<u8> ) -> ReadUntil<'a, Self>where Self: Unpin,

Reads all bytes into buf until the delimiter byte or EOF is reached. Read more
source§

fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self>where Self: Unpin,

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided buffer. Read more
source§

fn split(self, byte: u8) -> Split<Self>where Self: Sized + Unpin,

Returns a stream of the contents of this reader split on the byte byte. Read more
source§

fn fill_buf(&mut self) -> FillBuf<'_, Self>where Self: Unpin,

Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
source§

fn consume(&mut self, amt: usize)where Self: Unpin,

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to read. Read more
source§

fn lines(self) -> Lines<Self>where Self: Sized,

Returns a stream over the lines of this reader. This method is the async equivalent to BufRead::lines. Read more
source§

impl<R> AsyncReadExt for Rwhere R: AsyncRead + ?Sized,

source§

fn chain<R>(self, next: R) -> Chain<Self, R>where Self: Sized, R: AsyncRead,

Creates a new AsyncRead instance that chains this stream with next. Read more
source§

fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>where Self: Unpin,

Pulls some bytes from this source into the specified buffer, returning how many bytes were read. Read more
source§

fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B>where Self: Sized + Unpin, B: BufMut,

Pulls some bytes from this source into the specified buffer, advancing the buffer’s internal cursor. Read more
source§

fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>where Self: Unpin,

Reads the exact number of bytes required to fill buf. Read more
source§

fn read_u8<'a>(&'a mut self) -> ReadU8<&'a mut Self>where Self: Unpin,

Reads an unsigned 8 bit integer from the underlying reader. Read more
source§

fn read_i8<'a>(&'a mut self) -> ReadI8<&'a mut Self>where Self: Unpin,

Reads a signed 8 bit integer from the underlying reader. Read more
source§

fn read_u16<'a>(&'a mut self) -> ReadU16<&'a mut Self>where Self: Unpin,

Reads an unsigned 16-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_i16<'a>(&'a mut self) -> ReadI16<&'a mut Self>where Self: Unpin,

Reads a signed 16-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_u32<'a>(&'a mut self) -> ReadU32<&'a mut Self>where Self: Unpin,

Reads an unsigned 32-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_i32<'a>(&'a mut self) -> ReadI32<&'a mut Self>where Self: Unpin,

Reads a signed 32-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_u64<'a>(&'a mut self) -> ReadU64<&'a mut Self>where Self: Unpin,

Reads an unsigned 64-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_i64<'a>(&'a mut self) -> ReadI64<&'a mut Self>where Self: Unpin,

Reads an signed 64-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_u128<'a>(&'a mut self) -> ReadU128<&'a mut Self>where Self: Unpin,

Reads an unsigned 128-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_i128<'a>(&'a mut self) -> ReadI128<&'a mut Self>where Self: Unpin,

Reads an signed 128-bit integer in big-endian order from the underlying reader. Read more
source§

fn read_f32<'a>(&'a mut self) -> ReadF32<&'a mut Self>where Self: Unpin,

Reads an 32-bit floating point type in big-endian order from the underlying reader. Read more
source§

fn read_f64<'a>(&'a mut self) -> ReadF64<&'a mut Self>where Self: Unpin,

Reads an 64-bit floating point type in big-endian order from the underlying reader. Read more
source§

fn read_u16_le<'a>(&'a mut self) -> ReadU16Le<&'a mut Self>where Self: Unpin,

Reads an unsigned 16-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_i16_le<'a>(&'a mut self) -> ReadI16Le<&'a mut Self>where Self: Unpin,

Reads a signed 16-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_u32_le<'a>(&'a mut self) -> ReadU32Le<&'a mut Self>where Self: Unpin,

Reads an unsigned 32-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_i32_le<'a>(&'a mut self) -> ReadI32Le<&'a mut Self>where Self: Unpin,

Reads a signed 32-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_u64_le<'a>(&'a mut self) -> ReadU64Le<&'a mut Self>where Self: Unpin,

Reads an unsigned 64-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_i64_le<'a>(&'a mut self) -> ReadI64Le<&'a mut Self>where Self: Unpin,

Reads an signed 64-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_u128_le<'a>(&'a mut self) -> ReadU128Le<&'a mut Self>where Self: Unpin,

Reads an unsigned 128-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_i128_le<'a>(&'a mut self) -> ReadI128Le<&'a mut Self>where Self: Unpin,

Reads an signed 128-bit integer in little-endian order from the underlying reader. Read more
source§

fn read_f32_le<'a>(&'a mut self) -> ReadF32Le<&'a mut Self>where Self: Unpin,

Reads an 32-bit floating point type in little-endian order from the underlying reader. Read more
source§

fn read_f64_le<'a>(&'a mut self) -> ReadF64Le<&'a mut Self>where Self: Unpin,

Reads an 64-bit floating point type in little-endian order from the underlying reader. Read more
source§

fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self>where Self: Unpin,

Reads all bytes until EOF in this source, placing them into buf. Read more
source§

fn read_to_string<'a>( &'a mut self, dst: &'a mut String ) -> ReadToString<'a, Self>where Self: Unpin,

Reads all bytes until EOF in this source, appending them to buf. Read more
source§

fn take(self, limit: u64) -> Take<Self>where Self: Sized,

Creates an adaptor which reads at most limit bytes from it. Read more
source§

impl<S> AsyncSeekExt for Swhere S: AsyncSeek + ?Sized,

source§

fn seek(&mut self, pos: SeekFrom) -> Seek<'_, Self>where Self: Unpin,

Creates a future which will seek an IO object, and then yield the new position in the object and the object itself. Read more
source§

fn rewind(&mut self) -> Seek<'_, Self>where Self: Unpin,

Creates a future which will rewind to the beginning of the stream. Read more
source§

fn stream_position(&mut self) -> Seek<'_, Self>where Self: Unpin,

Creates a future which will return the current seek position from the start of the stream. Read more
source§

impl<W> AsyncWriteExt for Wwhere W: AsyncWrite + ?Sized,

source§

fn write<'a>(&'a mut self, src: &'a [u8]) -> Write<'a, Self>where Self: Unpin,

Writes a buffer into this writer, returning how many bytes were written. Read more
source§

fn write_vectored<'a, 'b>( &'a mut self, bufs: &'a [IoSlice<'b>] ) -> WriteVectored<'a, 'b, Self>where Self: Unpin,

Like write, except that it writes from a slice of buffers. Read more
source§

fn write_buf<'a, B>(&'a mut self, src: &'a mut B) -> WriteBuf<'a, Self, B>where Self: Sized + Unpin, B: Buf,

Writes a buffer into this writer, advancing the buffer’s internal cursor. Read more
source§

fn write_all_buf<'a, B>( &'a mut self, src: &'a mut B ) -> WriteAllBuf<'a, Self, B>where Self: Sized + Unpin, B: Buf,

Attempts to write an entire buffer into this writer. Read more
source§

fn write_all<'a>(&'a mut self, src: &'a [u8]) -> WriteAll<'a, Self>where Self: Unpin,

Attempts to write an entire buffer into this writer. Read more
source§

fn write_u8<'a>(&'a mut self, n: u8) -> WriteU8<&'a mut Self>where Self: Unpin,

Writes an unsigned 8-bit integer to the underlying writer. Read more
source§

fn write_i8<'a>(&'a mut self, n: i8) -> WriteI8<&'a mut Self>where Self: Unpin,

Writes a signed 8-bit integer to the underlying writer. Read more
source§

fn write_u16<'a>(&'a mut self, n: u16) -> WriteU16<&'a mut Self>where Self: Unpin,

Writes an unsigned 16-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_i16<'a>(&'a mut self, n: i16) -> WriteI16<&'a mut Self>where Self: Unpin,

Writes a signed 16-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_u32<'a>(&'a mut self, n: u32) -> WriteU32<&'a mut Self>where Self: Unpin,

Writes an unsigned 32-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_i32<'a>(&'a mut self, n: i32) -> WriteI32<&'a mut Self>where Self: Unpin,

Writes a signed 32-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_u64<'a>(&'a mut self, n: u64) -> WriteU64<&'a mut Self>where Self: Unpin,

Writes an unsigned 64-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_i64<'a>(&'a mut self, n: i64) -> WriteI64<&'a mut Self>where Self: Unpin,

Writes an signed 64-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_u128<'a>(&'a mut self, n: u128) -> WriteU128<&'a mut Self>where Self: Unpin,

Writes an unsigned 128-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_i128<'a>(&'a mut self, n: i128) -> WriteI128<&'a mut Self>where Self: Unpin,

Writes an signed 128-bit integer in big-endian order to the underlying writer. Read more
source§

fn write_f32<'a>(&'a mut self, n: f32) -> WriteF32<&'a mut Self>where Self: Unpin,

Writes an 32-bit floating point type in big-endian order to the underlying writer. Read more
source§

fn write_f64<'a>(&'a mut self, n: f64) -> WriteF64<&'a mut Self>where Self: Unpin,

Writes an 64-bit floating point type in big-endian order to the underlying writer. Read more
source§

fn write_u16_le<'a>(&'a mut self, n: u16) -> WriteU16Le<&'a mut Self>where Self: Unpin,

Writes an unsigned 16-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_i16_le<'a>(&'a mut self, n: i16) -> WriteI16Le<&'a mut Self>where Self: Unpin,

Writes a signed 16-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_u32_le<'a>(&'a mut self, n: u32) -> WriteU32Le<&'a mut Self>where Self: Unpin,

Writes an unsigned 32-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_i32_le<'a>(&'a mut self, n: i32) -> WriteI32Le<&'a mut Self>where Self: Unpin,

Writes a signed 32-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_u64_le<'a>(&'a mut self, n: u64) -> WriteU64Le<&'a mut Self>where Self: Unpin,

Writes an unsigned 64-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_i64_le<'a>(&'a mut self, n: i64) -> WriteI64Le<&'a mut Self>where Self: Unpin,

Writes an signed 64-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_u128_le<'a>(&'a mut self, n: u128) -> WriteU128Le<&'a mut Self>where Self: Unpin,

Writes an unsigned 128-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_i128_le<'a>(&'a mut self, n: i128) -> WriteI128Le<&'a mut Self>where Self: Unpin,

Writes an signed 128-bit integer in little-endian order to the underlying writer. Read more
source§

fn write_f32_le<'a>(&'a mut self, n: f32) -> WriteF32Le<&'a mut Self>where Self: Unpin,

Writes an 32-bit floating point type in little-endian order to the underlying writer. Read more
source§

fn write_f64_le<'a>(&'a mut self, n: f64) -> WriteF64Le<&'a mut Self>where Self: Unpin,

Writes an 64-bit floating point type in little-endian order to the underlying writer. Read more
source§

fn flush(&mut self) -> Flush<'_, Self>where Self: Unpin,

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination. Read more
source§

fn shutdown(&mut self) -> Shutdown<'_, Self>where Self: Unpin,

Shuts down the output stream, ensuring that the value can be dropped cleanly. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.