Struct File 

pub struct File<'a, C>(/* private fields */)
where
    C: Debug + Sync + Send;

Wraps files using mmap().

This implementation tries to mmap the file, falling back to just using a generic reader.

Implementations

impl<'a> File<'a, ()>

pub fn new<P>(file: File, path: P) -> Result<File<'a, ()>, Error>

where P: AsRef<Path>,

Wraps a fs::File.

The given path should be the path that has been used to obtain file from. It is used in error messages to provide context to the user.

While this is slightly less convenient than Self::open, it allows one to inspect or manipulate the fs::File object before handing it off. For example, one can inspect the metadata.

pub fn open<P>(path: P) -> Result<File<'a, ()>, Error>

where P: AsRef<Path>,

Opens the given file.

impl<'a, C> File<'a, C>

where C: Debug + Sync + Send,

pub fn new_with_cookie<P>( file: File, path: P, cookie: C, ) -> Result<File<'a, C>, Error>

where P: AsRef<Path>,

Like Self::new, but sets a cookie.

The given path should be the path that has been used to obtain file from. It is used in error messages to provide context to the user.

While this is slightly less convenient than Self::with_cookie, it allows one to inspect or manipulate the fs::File object before handing it off. For example, one can inspect the metadata.

pub fn with_cookie<P>(path: P, cookie: C) -> Result<File<'a, C>, Error>

where P: AsRef<Path>,

Like Self::open, but sets a cookie.

Trait Implementations

impl<'a, C> BufferedReader<C> for File<'a, C>

where C: Debug + Sync + Send,

fn buffer(&self) -> &[u8]

Returns a reference to the internal buffer.

fn data(&mut self, amount: usize) -> Result<&[u8], Error>

Ensures that the internal buffer has at least amount bytes of data, and returns it.

fn data_hard(&mut self, amount: usize) -> Result<&[u8], Error>

Like BufferedReader::data, but returns an error if there is not at least amount bytes available.

fn consume(&mut self, amount: usize) -> &[u8]

Consumes some of the data.

fn data_consume(&mut self, amount: usize) -> Result<&[u8], Error>

A convenience function that combines BufferedReader::data and BufferedReader::consume.

fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], Error>

A convenience function that effectively combines BufferedReader::data_hard and BufferedReader::consume.

fn get_mut(&mut self) -> Option<&mut dyn BufferedReader<C>>

Returns a mutable reference to the inner BufferedReader, if any.

fn get_ref(&self) -> Option<&dyn BufferedReader<C>>

Returns a reference to the inner BufferedReader, if any.

fn into_inner<'b>( self: Box<File<'a, C>>, ) -> Option<Box<dyn BufferedReader<C> + 'b>>

where File<'a, C>: 'b,

Returns the underlying reader, if any.

fn cookie_set(&mut self, cookie: C) -> C

Sets the BufferedReader’s cookie and returns the old value.

fn cookie_ref(&self) -> &C

Returns a reference to the BufferedReader’s cookie.

fn cookie_mut(&mut self) -> &mut C

Returns a mutable reference to the BufferedReader’s cookie.

fn data_eof(&mut self) -> Result<&[u8], Error>

Returns all of the data until EOF. Like BufferedReader::data, this does not actually consume the data that is read.

fn eof(&mut self) -> bool

Checks whether the end of the stream is reached.

fn consummated(&mut self) -> bool

Checks whether this reader is consummated.

fn read_be_u16(&mut self) -> Result<u16, Error>

A convenience function for reading a 16-bit unsigned integer in big endian format.

fn read_be_u32(&mut self) -> Result<u32, Error>

A convenience function for reading a 32-bit unsigned integer in big endian format.

fn read_to(&mut self, terminal: u8) -> Result<&[u8], Error>

Reads until either terminal is encountered or EOF.

fn drop_until(&mut self, terminals: &[u8]) -> Result<usize, Error>

Discards the input until one of the bytes in terminals is encountered.

fn drop_through( &mut self, terminals: &[u8], match_eof: bool, ) -> Result<(Option<u8>, usize), Error>

Discards the input until one of the bytes in terminals is encountered.

fn steal(&mut self, amount: usize) -> Result<Vec<u8>, Error>

Like BufferedReader::data_consume_hard, but returns the data in a caller-owned buffer.

fn steal_eof(&mut self) -> Result<Vec<u8>, Error>

Like BufferedReader::steal, but instead of stealing a fixed number of bytes, steals all of the data until the end of file.

fn drop_eof(&mut self) -> Result<bool, Error>

Like BufferedReader::steal_eof, but instead of returning the data, the data is discarded.

fn copy(&mut self, sink: &mut dyn Write) -> Result<u64, Error>

Copies data to the given writer returning the copied amount.

fn dump(&self, sink: &mut dyn Write) -> Result<(), Error>

where Self: Sized,

A helpful debugging aid to pretty print a Buffered Reader stack.

fn into_boxed<'a>(self) -> Box<dyn BufferedReader<C> + 'a>

where Self: Sized + 'a,

Boxes the reader.

fn as_boxed<'a>(self) -> Box<dyn BufferedReader<C> + 'a>

where Self: Sized + 'a,

👎Deprecated:

Use into_boxed

Boxes the reader.

impl<'a, C> Debug for File<'a, C>

where C: Debug + Sync + Send,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a, C> Display for File<'a, C>

where C: Debug + Sync + Send,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a, C> Read for File<'a, C>

where C: Debug + Sync + Send,

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

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

Reads all bytes until EOF in this source, placing them into buf.

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

Reads all bytes until EOF in this source, appending them to buf.

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_, u8>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact( &mut self, cursor: BorrowedCursor<'_, u8>, ) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source.

fn read_le<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in little-endian order.

fn read_be<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in big-endian order.