Struct nix_compat::nar::reader::FileReader

pub struct FileReader<'a, 'r> {
    reader: ArchiveReader<'a, 'r>,
    len: u64,
    pad: u8,
}

File contents, readable through the Read trait.

It comes with some caveats:

• You must always read the entire file, unless you intend to abandon the entire archive reader.
• You must abandon the entire archive reader upon the first error.

It’s fine to read exactly reader.len() bytes without ever seeing an explicit EOF.

Fields

reader: ArchiveReader<'a, 'r>

len: u64

pad: u8

Truncated original file length for padding computation. We only care about the 3 least significant bits; semantically, this is a u3.

Implementations

impl<'a, 'r> FileReader<'a, 'r>

fn new(reader: ArchiveReader<'a, 'r>, len: u64) -> Result<Self>

Instantiate a new reader, starting after wire::TOK_REG or wire::TOK_EXE. We handle the terminating wire::TOK_PAR on semantic EOF.

pub fn is_empty(&self) -> bool

pub fn len(&self) -> u64

impl FileReader<'_, '_>

pub fn fill_buf(&mut self) -> Result<&[u8]>

Equivalent to BufRead::fill_buf

We can’t directly implement BufRead, because FileReader::consume needs to perform fallible I/O.

pub fn consume(&mut self, n: usize) -> Result<()>

Analogous to BufRead::consume, differing only in that it needs to perform I/O in order to read padding and terminators.

pub fn copy(&mut self, dst: impl Write) -> Result<()>

Copy the (remaining) contents of the file into dst.

impl FileReader<'_, '_>

fn finish(&mut self) -> Result<()>

We’ve reached semantic EOF, consume and verify the padding and terminating TOK_PAR. Files are padded to 64 bits (8 bytes), just like any other byte string in the wire format.

Trait Implementations

impl Read for FileReader<'_, '_>

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

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<'_>) -> 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<'_>) -> 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” adaptor 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.