Struct SplitStreamReader 

pub struct SplitStreamReader<R: Read, ObjectID: FsVerityHashValue> {
    decoder: Decoder<'static, BufReader<R>>,
    pub refs: DigestMap<ObjectID>,
    inline_bytes: usize,
}

Reader for parsing split stream format files with inline content and external object references.

Fields

decoder: Decoder<'static, BufReader<R>>

refs: DigestMap<ObjectID>

Digest map containing content hash to object ID mappings

inline_bytes: usize

Implementations

impl<R: Read, ObjectID: FsVerityHashValue> SplitStreamReader<R, ObjectID>

pub fn new(reader: R) -> Result<Self>

Creates a new split stream reader from the provided reader.

Reads the digest map header from the stream during initialization.

fn ensure_chunk( &mut self, eof_ok: bool, ext_ok: bool, expected_bytes: usize, ) -> Result<ChunkType<ObjectID>>

pub fn read_inline_exact(&mut self, buffer: &mut [u8]) -> Result<bool>

Reads the exact number of inline bytes Assumes that the data cannot be split across chunks

fn discard_padding(&mut self, size: usize) -> Result<()>

pub fn read_exact( &mut self, actual_size: usize, stored_size: usize, ) -> Result<SplitStreamData<ObjectID>>

Reads an exact amount of data, which may be inline or external.

The stored_size is the size as recorded in the stream (including any padding), while actual_size is the actual content size without padding. Returns either inline content or an external object reference.

pub fn cat( &mut self, output: &mut impl Write, load_data: impl FnMut(&ObjectID) -> Result<Vec<u8>>, ) -> Result<()>

Concatenates the entire split stream content to the output writer.

Inline content is written directly, while external references are resolved using the provided load_data callback function.

pub fn get_object_refs(&mut self, callback: impl FnMut(&ObjectID)) -> Result<()>

Traverses the split stream and calls the callback for each object reference.

This includes both references from the digest map and external references in the stream.

pub fn get_stream_refs(&mut self, callback: impl FnMut(&Sha256Digest))

Calls the callback for each content hash in the digest map.

pub fn lookup(&self, body: &Sha256Digest) -> Result<&ObjectID>

Looks up an object ID by content hash in the digest map.

Returns an error if the reference is not found.

Trait Implementations

impl<R: Read, ObjectID: FsVerityHashValue> Debug for SplitStreamReader<R, ObjectID>

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

Formats the value using the given formatter.

impl<F: Read, ObjectID: FsVerityHashValue> Read for SplitStreamReader<F, ObjectID>

fn read(&mut self, data: &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” 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.