[−][src]Struct df_st_core::bufreader::BufReader
Implementations
impl<R: Read, T> BufReader<R, T>
[src]
pub fn new(inner: R, progress: Progress<T>) -> BufReader<R, T>ⓘNotable traits for BufReader<R, T>
impl<R: Read, T: ProgressUpdater> Read for BufReader<R, T>
[src]
Notable traits for BufReader<R, T>
impl<R: Read, T: ProgressUpdater> Read for BufReader<R, T>
Creates a new BufReader<R>
with a default buffer capacity. The default is currently 8 KB,
but may change in the future.
Examples
use std::io::BufReader; use std::fs::File; fn main() -> std::io::Result<()> { let f = File::open("log.txt")?; let reader = BufReader::new(f); Ok(()) }
pub fn with_capacity(
capacity: usize,
inner: R,
progress: Progress<T>
) -> BufReader<R, T>ⓘNotable traits for BufReader<R, T>
impl<R: Read, T: ProgressUpdater> Read for BufReader<R, T>
[src]
capacity: usize,
inner: R,
progress: Progress<T>
) -> BufReader<R, T>ⓘ
Notable traits for BufReader<R, T>
impl<R: Read, T: ProgressUpdater> Read for BufReader<R, T>
impl<R, T> BufReader<R, T>
[src]
pub fn get_ref(&self) -> &R
[src]
Gets a reference to the underlying reader.
It is inadvisable to directly read from the underlying reader.
Examples
use std::io::BufReader; use std::fs::File; fn main() -> std::io::Result<()> { let f1 = File::open("log.txt")?; let reader = BufReader::new(f1); let f2 = reader.get_ref(); Ok(()) }
pub fn get_mut(&mut self) -> &mut R
[src]
Gets a mutable reference to the underlying reader.
It is inadvisable to directly read from the underlying reader.
Examples
use std::io::BufReader; use std::fs::File; fn main() -> std::io::Result<()> { let f1 = File::open("log.txt")?; let mut reader = BufReader::new(f1); let f2 = reader.get_mut(); Ok(()) }
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.
Examples
use std::io::{BufReader, BufRead}; use std::fs::File; fn main() -> std::io::Result<()> { let f = File::open("log.txt")?; let mut reader = BufReader::new(f); assert!(reader.buffer().is_empty()); if reader.fill_buf()?.len() > 0 { assert!(!reader.buffer().is_empty()); } Ok(()) }
pub fn capacity(&self) -> usize
[src]
Returns the number of bytes the internal buffer can hold at once.
Examples
#![feature(buffered_io_capacity)] use std::io::{BufReader, BufRead}; use std::fs::File; fn main() -> std::io::Result<()> { let f = File::open("log.txt")?; let mut reader = BufReader::new(f); let capacity = reader.capacity(); let buffer = reader.fill_buf()?; assert!(buffer.len() <= capacity); Ok(()) }
pub fn into_inner(self) -> R
[src]
Unwraps this BufReader<R>
, returning the underlying reader.
Note that any leftover data in the internal buffer is lost. Therefore, a following read from the underlying reader may lead to data loss.
Examples
use std::io::BufReader; use std::fs::File; fn main() -> std::io::Result<()> { let f1 = File::open("log.txt")?; let reader = BufReader::new(f1); let f2 = reader.into_inner(); Ok(()) }
Trait Implementations
impl<R: Read, T: ProgressUpdater> BufRead for BufReader<R, T>
[src]
fn fill_buf(&mut self) -> Result<&[u8]>
[src]
fn consume(&mut self, amt: usize)
[src]
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>
1.0.0[src]
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
fn split(self, byte: u8) -> Split<Self>
1.0.0[src]
fn lines(self) -> Lines<Self>
1.0.0[src]
impl<R, T> Debug for BufReader<R, T> where
R: Debug,
[src]
R: Debug,
impl<R: Read, T: ProgressUpdater> Read for BufReader<R, T>
[src]
fn read(&mut self, buf: &mut [u8]) -> Result<usize>
[src]
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>
[src]
fn is_read_vectored(&self) -> bool
[src]
unsafe fn initializer(&self) -> Initializer
[src]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
1.0.0[src]
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]
fn by_ref(&mut self) -> &mut Self
1.0.0[src]
fn bytes(self) -> Bytes<Self>
1.0.0[src]
fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read,
1.0.0[src]
R: Read,
fn take(self, limit: u64) -> Take<Self>
1.0.0[src]
impl<R: Seek, T> Seek for BufReader<R, T>
[src]
fn seek(&mut self, pos: SeekFrom) -> Result<u64>
[src]
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<R>
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.
To seek without discarding the internal buffer, use BufReader::seek_relative
.
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 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)
.
fn stream_len(&mut self) -> Result<u64, Error>
[src]
fn stream_position(&mut self) -> Result<u64, Error>
[src]
Auto Trait Implementations
impl<R, T> RefUnwindSafe for BufReader<R, T> where
R: RefUnwindSafe,
T: RefUnwindSafe,
R: RefUnwindSafe,
T: RefUnwindSafe,
impl<R, T> Send for BufReader<R, T> where
R: Send,
T: Send,
R: Send,
T: Send,
impl<R, T> Sync for BufReader<R, T> where
R: Sync,
T: Sync,
R: Sync,
T: Sync,
impl<R, T> Unpin for BufReader<R, T> where
R: Unpin,
T: Unpin,
R: Unpin,
T: Unpin,
impl<R, T> UnwindSafe for BufReader<R, T> where
R: UnwindSafe,
T: UnwindSafe,
R: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?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>,