[−][src]Struct futures_util::io::BufReader
The BufReader
struct adds buffering to any reader.
It can be excessively inefficient to work directly with a AsyncRead
instance. A BufReader
performs large, infrequent reads on the underlying
AsyncRead
and maintains an in-memory buffer of the results.
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.
Implementations
impl<R: AsyncRead> BufReader<R>
[src]
pub fn new(inner: R) -> Self
[src]
Creates a new BufReader
with a default buffer capacity. The default is currently 8 KB,
but may change in the future.
pub fn with_capacity(capacity: usize, inner: R) -> Self
[src]
Creates a new BufReader
with the specified buffer capacity.
pub fn get_ref(&self) -> &Rⓘ
[src]
Acquires a reference to the underlying sink or stream that this combinator is pulling from.
pub fn get_mut(&mut self) -> &mut Rⓘ
[src]
Acquires a mutable reference to the underlying sink or stream that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.
pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R>ⓘ
[src]
Acquires a pinned mutable reference to the underlying sink or stream that this combinator is pulling from.
Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.
pub fn into_inner(self) -> R
[src]
Consumes this combinator, returning the underlying sink or stream.
Note that this may discard intermediate state of this combinator, so care should be taken to avoid losing resources when this is called.
pub fn buffer(&self) -> &[u8]ⓘ
[src]
Returns a reference to the internally buffered data.
Unlike fill_buf
, this will not attempt to fill the buffer if it is empty.
Trait Implementations
impl<R: AsyncRead> AsyncBufRead for BufReader<R>
[src]
fn poll_fill_buf(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<&[u8]>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<&[u8]>>
fn consume(self: Pin<&mut Self>, amt: usize)
[src]
impl<R: AsyncRead> AsyncRead for BufReader<R>
[src]
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
fn poll_read_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize>>
impl<R: AsyncRead + AsyncSeek> AsyncSeek for BufReader<R>
[src]
fn poll_seek(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
pos: SeekFrom
) -> Poll<Result<u64>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
pos: SeekFrom
) -> Poll<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
.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)
.
impl<R: AsyncWrite> AsyncWrite for BufReader<R>
[src]
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
fn poll_write_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize>>
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>
[src]
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>
[src]
impl<R: Debug> Debug for BufReader<R>
[src]
impl<R> PinnedDrop for BufReader<R>
[src]
impl<'pin, R> Unpin for BufReader<R> where
__BufReader<'pin, R>: Unpin,
[src]
__BufReader<'pin, R>: Unpin,
impl<R> UnsafeUnpin for BufReader<R>
[src]
Auto Trait Implementations
impl<R> RefUnwindSafe for BufReader<R> where
R: RefUnwindSafe,
R: RefUnwindSafe,
impl<R> Send for BufReader<R> where
R: Send,
R: Send,
impl<R> Sync for BufReader<R> where
R: Sync,
R: Sync,
impl<R> UnwindSafe for BufReader<R> where
R: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<R> AsyncBufReadExt for R where
R: AsyncBufRead + ?Sized,
[src]
R: AsyncBufRead + ?Sized,
fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntil<'a, Self>ⓘ where
Self: Unpin,
[src]
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntil<'a, Self>ⓘ where
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn lines(self) -> Lines<Self> where
Self: Sized,
[src]
Self: Sized,
impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized,
[src]
R: AsyncRead + ?Sized,
fn chain<R>(self, next: R) -> Chain<Self, R> where
Self: Sized,
R: AsyncRead,
[src]
Self: Sized,
R: AsyncRead,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectored<'a, Self>ⓘNotable traits for ReadVectored<'_, R>
impl<R: AsyncRead + ?Sized + Unpin, '_> Future for ReadVectored<'_, R> type Output = Result<usize>;
where
Self: Unpin,
[src]
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectored<'a, Self>ⓘ
Notable traits for ReadVectored<'_, R>
impl<R: AsyncRead + ?Sized + Unpin, '_> Future for ReadVectored<'_, R> type Output = Result<usize>;
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String
) -> ReadToString<'a, Self>ⓘNotable traits for ReadToString<'_, A>
impl<A: ?Sized, '_> Future for ReadToString<'_, A> where
A: AsyncRead + Unpin, type Output = Result<usize>;
where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut String
) -> ReadToString<'a, Self>ⓘ
Notable traits for ReadToString<'_, A>
impl<A: ?Sized, '_> Future for ReadToString<'_, A> where
A: AsyncRead + Unpin, type Output = Result<usize>;
Self: Unpin,
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite + Sized,
[src]
Self: AsyncWrite + Sized,
fn take(self, limit: u64) -> Take<Self> where
Self: Sized,
[src]
Self: Sized,
impl<S> AsyncSeekExt for S where
S: AsyncSeek + ?Sized,
[src]
S: AsyncSeek + ?Sized,
impl<W> AsyncWriteExt for W where
W: AsyncWrite + ?Sized,
[src]
W: AsyncWrite + ?Sized,
fn flush(&mut self) -> Flush<'_, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn close(&mut self) -> Close<'_, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectored<'a, Self>ⓘNotable traits for WriteVectored<'_, W>
impl<W: AsyncWrite + ?Sized + Unpin, '_> Future for WriteVectored<'_, W> type Output = Result<usize>;
where
Self: Unpin,
[src]
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectored<'a, Self>ⓘ
Notable traits for WriteVectored<'_, W>
impl<W: AsyncWrite + ?Sized + Unpin, '_> Future for WriteVectored<'_, W> type Output = Result<usize>;
Self: Unpin,
fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self>ⓘ where
Self: Unpin,
[src]
Self: Unpin,
fn into_sink<Item: AsRef<[u8]>>(self) -> IntoSink<Self, Item> where
Self: Sized,
[src]
Self: Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,