Struct SplitStreamReader 

pub struct SplitStreamReader<ObjectID: FsVerityHashValue> {
    decoder: Decoder<'static, BufReader<Take<File>>>,
    inline_bytes: usize,
    pub content_type: u64,
    pub total_size: u64,
    object_refs: Vec<ObjectID>,
    named_refs: HashMap<Box<str>, ObjectID>,
}

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

Fields

decoder: Decoder<'static, BufReader<Take<File>>>

inline_bytes: usize

content_type: u64

The content_type ID given when the splitstream was constructed

total_size: u64

The total size of the original/merged stream, in bytes

object_refs: Vec<ObjectID>

named_refs: HashMap<Box<str>, ObjectID>

Implementations

impl<ObjectID: FsVerityHashValue> SplitStreamReader<ObjectID>

pub fn new(file: File, expected_content_type: Option<u64>) -> Result<Self>

Creates a new split stream reader from the provided reader.

Reads the digest map header from the stream during initialization.

fn read_named_references<ObjectId: FsVerityHashValue>( section: &[u8], references: &[ObjectId], ) -> Result<HashMap<Box<str>, ObjectId>>

pub fn iter_named_refs(&self) -> impl Iterator<Item = (&str, &ObjectID)>

Iterate the list of named references defined on this split stream.

pub fn into_named_refs(self) -> HashMap<Box<str>, ObjectID>

Steal the “named refs” table from this splitstream, destructing it in the process.

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, repo: &Repository<ObjectID>, output: &mut impl Write, ) -> 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 lookup_named_ref(&self, name: &str) -> Option<&ObjectID>

Looks up a named reference

Returns None if no such reference exists

Trait Implementations

impl<ObjectID: FsVerityHashValue> Debug for SplitStreamReader<ObjectID>

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

Formats the value using the given formatter.

impl<ObjectID: FsVerityHashValue> Read for SplitStreamReader<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.

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.