Struct ProgressReader 

pub struct ProgressReader<'a, R> { /* private fields */ }

Wrapper reader that tracks bytes read and reports progress.

This reader wraps any Read implementation and reports bytes read to a progress callback. To reduce callback overhead, it uses batching with a configurable threshold (default: 1 MB).

Batching Behavior

The reader accumulates bytes read and only invokes the progress callback when:

1. The accumulated bytes reach the batch threshold (default: 1 MB)
2. The reader is dropped (flushes remaining bytes)

This reduces callback overhead for large files while still providing responsive progress updates.

Examples

use exarch_core::ProgressCallback;
use exarch_core::creation::progress::ProgressReader;
use std::fs::File;
use std::io::Read;
use std::path::Path;

let file = File::open("large_file.bin")?;
let mut progress = DummyProgress;
let mut reader = ProgressReader::new(file, &mut progress);

let mut buffer = vec![0u8; 8192];
loop {
    let bytes_read = reader.read(&mut buffer)?;
    if bytes_read == 0 {
        break;
    }
    // Progress is automatically reported
}

Implementations

impl<'a, R> ProgressReader<'a, R>

pub fn new(inner: R, progress: &'a mut dyn ProgressCallback) -> Self

Creates a new progress-tracking reader with default batch threshold.

The default batch threshold is 1 MB (1,048,576 bytes).

Parameters

• inner: The reader to wrap
• progress: Mutable reference to the progress callback

Examples

use exarch_core::ProgressCallback;
use exarch_core::creation::progress::ProgressReader;
use std::fs::File;
use std::path::Path;

let file = File::open("data.bin")?;
let mut progress = DummyProgress;
let reader = ProgressReader::new(file, &mut progress);

pub fn with_batch_threshold( inner: R, progress: &'a mut dyn ProgressCallback, batch_threshold: u64, ) -> Self

Creates a new progress-tracking reader with custom batch threshold.

Parameters

• inner: The reader to wrap
• progress: Mutable reference to the progress callback
• batch_threshold: Number of bytes to accumulate before reporting

Examples

use exarch_core::ProgressCallback;
use exarch_core::creation::progress::ProgressReader;
use std::fs::File;
use std::path::Path;

let file = File::open("data.bin")?;
let mut progress = DummyProgress;
// Report progress every 64 KB
let reader = ProgressReader::with_batch_threshold(file, &mut progress, 64 * 1024);

pub fn flush_progress(&mut self)

Flushes any accumulated bytes to the progress callback.

This is called automatically when the reader is dropped, but can be called manually if needed.

Trait Implementations

impl<R> Drop for ProgressReader<'_, R>

fn drop(&mut self)

Executes the destructor for this type.

impl<R: Read> Read for ProgressReader<'_, R>

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.