Struct std::io::BufReaderStable [-] [+] [src]

pub struct BufReader<R> {
    // some fields omitted
}

Wraps a Read and buffers input from it

It can be excessively inefficient to work directly with a Read instance. For example, every call to read on TcpStream results in a system call. A BufReader performs large, infrequent reads on the underlying Read and maintains an in-memory buffer of the results.

Methods

impl<R: Read> BufReader<R>

fn new(inner: R) -> BufReader<R>

Creates a new BufReader with a default buffer capacity

fn with_capacity(cap: usize, inner: R) -> BufReader<R>

Creates a new BufReader with the specified buffer capacity

fn get_ref(&self) -> &R

Gets a reference to the underlying reader.

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

Gets a mutable reference to the underlying reader.

Warning

It is inadvisable to directly read from the underlying reader.

fn into_inner(self) -> R

Unwraps this BufReader, returning the underlying reader.

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

Trait Implementations

impl<R: Read> Read for BufReader<R>

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<R: Read> BufRead for BufReader<R>

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<R> Debug for BufReader<R> where R: Debug

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

impl<R: Seek> Seek for BufReader<R>

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

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

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

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

See std::io::Seek for more details.

Note: In the edge case where you're seeking with SeekFrom::Current(n) where n minus the internal buffer length underflows 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 seeked to SeekFrom::Current(0).