Struct RangeReader 

pub struct RangeReader<R> { /* private fields */ }

A reader that reads a specific range of data from a ReaderAt source.

RangeReader implements std::io::Read and provides bounded reading within a specified range of offsets. It maintains its current position and ensures reads don’t exceed the defined end boundary.

Useful when working with APIs that operate on std::io::Read instead of ReaderAt. For instance, incrementally reading large prelude and trailing data of a ZIP file.

Examples

Reading prelude data from a zip file:

use std::io::Read;
use rawzip::{ZipArchive, RangeReader, RECOMMENDED_BUFFER_SIZE};
use std::fs::File;

let file = File::open("assets/test-prefix.zip")?;
let mut buffer = vec![0u8; RECOMMENDED_BUFFER_SIZE];
let archive = ZipArchive::from_file(file, &mut buffer)?;

// Typically you only need the first entry to find where the zip data starts
// but this is the longer form that examines every entry in case they are
// out of order
let mut zip_start_offset = archive.directory_offset();
let mut entries = archive.entries(&mut buffer);
while let Some(entry) = entries.next_entry()? {
    zip_start_offset = zip_start_offset.min(entry.local_header_offset());
}

// For example purposes, just slurp up all the prelude data
let mut prelude_reader = RangeReader::new(archive.get_ref(), 0..zip_start_offset);
prelude_reader.read_exact(&mut buffer[..zip_start_offset as usize])?;
assert_eq!(
    &buffer[..zip_start_offset as usize],
    b"prefix that could be an executable jar file"
);

Implementations

impl<R> RangeReader<R>

pub fn new(archive: R, range: Range<u64>) -> Self

Creates a new RangeReader that will read data from the specified range.

pub fn position(&self) -> u64

Returns the current read position within the range.

pub fn remaining(&self) -> u64

Returns the remaining bytes that are expected to be read from the current position.

When a range reader is constructed with a range that exceeds the underlying reader, remaining will be non-zero when read() returns zero signalling the end of the stream.

pub fn end_offset(&self) -> u64

Returns the end offset of the range.

pub fn get_ref(&self) -> &R

Returns a reference to the underlying reader.

pub fn into_inner(self) -> R

Consumes the self and returns the underlying reader.

Trait Implementations

impl<R: Clone> Clone for RangeReader<R>

fn clone(&self) -> RangeReader<R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug> Debug for RangeReader<R>

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

Formats the value using the given formatter.

impl<R> Read for RangeReader<R>

where R: ReaderAt,

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” 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.