Struct std::io::BufStream

pub struct BufStream<S: Write> {
    // some fields omitted
}

Unstable

: unsure about semantics of buffering two directions, leading to issues like #17136

Wraps a Stream and buffers input and output to and from it.

It can be excessively inefficient to work directly with a Read+Write. For example, every call to read or write on TcpStream results in a system call. A BufStream keeps in memory buffers of data, making large, infrequent calls to read and write on the underlying Read+Write.

The output buffer will be written out when this stream is dropped.

Methods

impl<S: Read + Write> BufStream<S>

fn with_capacities(reader_cap: usize, writer_cap: usize, inner: S) -> BufStream<S>

Unstable

: unsure about semantics of buffering two directions, leading to issues like #17136

Creates a new buffered stream with explicitly listed capacities for the reader/writer buffer.

fn new(inner: S) -> BufStream<S>

Unstable

: unsure about semantics of buffering two directions, leading to issues like #17136

Creates a new buffered stream with the default reader/writer buffer capacities.

fn get_ref(&self) -> &S

Unstable

: unsure about semantics of buffering two directions, leading to issues like #17136

Gets a reference to the underlying stream.

fn get_mut(&mut self) -> &mut S

Unstable

: unsure about semantics of buffering two directions, leading to issues like #17136

Gets a mutable reference to the underlying stream.

Warning

It is inadvisable to read directly from or write directly to the underlying stream.

fn into_inner(self) -> Result<S, IntoInnerError<BufStream<S>>>

Unstable

: unsure about semantics of buffering two directions, leading to issues like #17136

Unwraps this BufStream, returning the underlying stream.

The internal write buffer is written out before returning the stream. Any leftover data in the read buffer is lost.

Trait Implementations

impl<S: Read + Write> BufRead for BufStream<S>

fn fill_buf(&mut self) -> Result<&[u8]>

fn consume(&mut self, amt: usize)

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>

fn read_line(&mut self, buf: &mut String) -> Result<usize>

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

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

impl<S: Read + Write> Read for BufStream<S>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

fn by_ref(&mut self) -> &mut Self where Self: Sized

fn bytes(self) -> Bytes<Self> where Self: Sized

fn chars(self) -> Chars<Self> where Self: Sized

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

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

fn tee<W: Write>(self, out: W) -> Tee<Self, W> where Self: Sized

impl<S: Read + Write> Write for BufStream<S>

fn write(&mut self, buf: &[u8]) -> Result<usize>

fn flush(&mut self) -> Result<()>

fn write_all(&mut self, buf: &[u8]) -> Result<()>

fn write_fmt(&mut self, fmt: Arguments) -> Result<()>

fn by_ref(&mut self) -> &mut Self where Self: Sized

fn broadcast<W: Write>(self, other: W) -> Broadcast<Self, W> where Self: Sized

impl<S: Write> Debug for BufStream<S> where S: Debug

fn fmt(&self, fmt: &mut Formatter) -> Result