Struct InflateReader 

pub struct InflateReader<'a> { /* private fields */ }

Streaming zlib reader: decompresses input incrementally into a small accumulation buffer, so a caller can parse length-delimited records as they become available and discard consumed bytes — peak memory stays ~the largest single record being buffered, not the whole decompressed blob.

Usage: ensure(n) to make ≥ n bytes available, read from available(), then consume(k). The buffer is compacted (consumed prefix dropped) as it grows.

Implementations

impl<'a> InflateReader<'a>

pub fn new(input: &'a [u8], max: u64) -> Self

pub fn available(&self) -> &[u8]

Unparsed decompressed bytes currently buffered.

pub fn consume(&mut self, n: usize)

Mark n already-read bytes as consumed.

pub fn ensure(&mut self, need: usize) -> Result<bool>

Ensure at least need unparsed bytes are buffered, decompressing more as required. Returns Ok(false) if the stream ends before reaching need.

pub fn is_done(&self) -> bool

True once the stream is fully decompressed and all bytes consumed.

pub fn total_out(&self) -> u64

Total decompressed bytes produced so far. After the stream ends this is the blob’s exact inflated size.

pub fn compressed_progress(&self) -> (usize, usize)

Compressed input consumed so far plus the input’s full length. The ratio lets callers extrapolate totals (e.g. record counts) from a prefix without a second pass over the blob.

pub fn stream_ended(&self) -> bool

Whether zlib reported a proper stream end (terminator + adler32 checksum). An EOF (ensure returning false) without this means the input was truncated, not finished.

Trait Implementations

impl Drop for InflateReader<'_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.