Struct async_std::io::BufReader [−][src]
pub struct BufReader<R> { /* fields omitted */ }
Expand description
Adds buffering to any reader.
It can be excessively inefficient to work directly with a Read
instance. A BufReader
performs large, infrequent reads on the underlying Read
and maintains an in-memory buffer
of the incoming byte stream.
BufReader
can improve the speed of programs that make small and repeated read calls to
the same file or network socket. It does not help when reading very large amounts at once, or
reading just one or a few times. It also provides no advantage when reading from a source that
is already in memory, like a Vec<u8>
.
When the BufReader
is dropped, the contents of its buffer will be discarded. Creating
multiple instances of a BufReader
on the same stream can cause data loss.
This type is an async version of std::io::BufReader
.
Examples
use async_std::fs::File;
use async_std::io::BufReader;
use async_std::prelude::*;
let mut file = BufReader::new(File::open("a.txt").await?);
let mut line = String::new();
file.read_line(&mut line).await?;
Implementations
Creates a buffered reader with default buffer capacity.
The default capacity is currently 8 KB, but may change in the future.
Examples
use async_std::fs::File;
use async_std::io::BufReader;
let f = BufReader::new(File::open("a.txt").await?);
Creates a new buffered reader with the specified capacity.
Examples
use async_std::fs::File;
use async_std::io::BufReader;
let f = BufReader::with_capacity(1024, File::open("a.txt").await?);
Gets a reference to the underlying reader.
It is inadvisable to directly read from the underlying reader.
Examples
use async_std::fs::File;
use async_std::io::BufReader;
let f = BufReader::new(File::open("a.txt").await?);
let inner = f.get_ref();
Gets a mutable reference to the underlying reader.
It is inadvisable to directly read from the underlying reader.
Examples
use async_std::fs::File;
use async_std::io::BufReader;
let mut file = BufReader::new(File::open("a.txt").await?);
let inner = file.get_mut();
Returns a reference to the internal buffer.
This function will not attempt to fill the buffer if it is empty.
Examples
use async_std::fs::File;
use async_std::io::BufReader;
let f = BufReader::new(File::open("a.txt").await?);
let buffer = f.buffer();
Unwraps the buffered reader, returning the underlying reader.
Note that any leftover data in the internal buffer is lost.
Examples
use async_std::fs::File;
use async_std::io::BufReader;
let f = BufReader::new(File::open("a.txt").await?);
let inner = f.into_inner();
Trait Implementations
Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
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
Reads all bytes into buf
until the delimiter byte
or EOF is reached. Read more
Reads all bytes and appends them into buf
until a newline (the 0xA byte) is
reached. Read more
Returns a stream over the lines of this byte stream. Read more
Attempt to read from the AsyncRead
into buf
.
Attempt to read from the AsyncRead
into bufs
using vectored IO operations.
Reads some bytes from the byte stream. Read more
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
Reads all bytes from the byte stream. Read more
Reads all bytes from the byte stream and appends them into a string. Read more
Reads the exact number of bytes required to fill buf
. Read more
Creates an adaptor which will read at most limit
bytes from it. Read more
Creates a “by reference” adaptor for this instance of Read
. Read more
Transforms this Read
instance to a Stream
over its bytes. Read more
Seeks 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 .into_inner()
immediately after a seek yields the
underlying reader at the same position.
See Seek
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)
.