Struct ChunkReader

pub struct ChunkReader {
    chunks: ChunkSet,
    position: u64,
    total_size: u64,
    chunk_size: u64,
    current_chunk_cache: usize,
}

Chunk reader for streaming ISO data

Fields

chunks: ChunkSet

Chunk information

position: u64

Current read position (for sequential reads)

total_size: u64

Total ISO size

chunk_size: u64

Chunk size used during write

current_chunk_cache: usize

Cached current chunk index (optimization)

Implementations

impl ChunkReader

pub fn from_manifest(manifest: &IsoManifest) -> Result<Self, IsoError>

Create a reader from a manifest

pub fn from_chunks(chunks: ChunkSet, chunk_size: u64) -> Self

Create a reader from a chunk set

pub fn total_size(&self) -> u64

Get total ISO size

pub fn position(&self) -> u64

Get current read position

pub fn num_chunks(&self) -> usize

Get number of chunks

pub fn seek(&mut self, position: u64) -> Result<(), IsoError>

Seek to a position

pub fn remaining(&self) -> u64

Get remaining bytes from current position

pub fn is_eof(&self) -> bool

Check if at end of ISO

fn chunk_index_for_offset(&self, offset: u64) -> Option<usize>

Find chunk containing a given byte offset

fn chunk_start_offset(&self, chunk_index: usize) -> u64

Get the starting byte offset of a chunk

pub fn read_at<F>( &self, offset: u64, buffer: &mut [u8], read_sector_fn: F, ) -> Result<usize, IsoError>

where F: FnMut(u64, u64, &mut [u8]) -> Result<usize, IsoError>,

Read data at a specific offset

The read_sector_fn callback performs the actual block I/O: fn(partition_start_lba: u64, sector_offset: u64, buffer: &mut [u8]) -> Result<usize, IsoError>

Returns number of bytes read (may be less than buffer size at EOF or chunk boundary)

pub fn read_next<F>( &mut self, buffer: &mut [u8], read_sector_fn: F, ) -> Result<usize, IsoError>

where F: FnMut(u64, u64, &mut [u8]) -> Result<usize, IsoError>,

Read at current position and advance

This is the main method for sequential reading.

pub fn read_range<F>( &mut self, offset: u64, buffer: &mut [u8], read_sector_fn: F, ) -> Result<usize, IsoError>

where F: FnMut(u64, u64, &mut [u8]) -> Result<usize, IsoError>,

Read a range spanning multiple chunks

This handles reading across chunk boundaries transparently.

pub fn get_chunk(&self, index: usize) -> Option<&ChunkInfo>

Get chunk info by index

pub fn chunks(&self) -> impl Iterator<Item = &ChunkInfo>

Iterate over all chunks