Struct ProgressState 

pub struct ProgressState<'a, F>
where
    F: ProgressCallback + ?Sized,
{ /* private fields */ }

Helper wrapper for throttling progress callback frequency.

Some operations progress very quickly (e.g., processing thousands of items), and reporting progress on every item would overwhelm the callback and impact performance. This wrapper enforces a minimum time between updates.

Example

use sqlitegraph::progress::{ProgressCallback, ProgressState, NoProgress};
use std::time::Duration;

let inner = NoProgress;
let mut progress = ProgressState::new(&inner, Duration::from_millis(100));

// Only reports if at least 100ms has passed since last report
progress.update(5, Some(10), "Processing")?;
progress.update(6, Some(10), "Processing")?; // May be skipped

Implementations

impl<'a, F> ProgressState<'a, F>

where F: ProgressCallback + ?Sized,

pub fn new(callback: &'a F, interval: Duration) -> Self

Creates a new progress state wrapper.

Parameters

• callback: The underlying progress callback to wrap
• interval: Minimum time between progress updates

Example

use sqlitegraph::progress::{ProgressCallback, ProgressState, NoProgress};
use std::time::Duration;

let callback = NoProgress;
let progress = ProgressState::new(&callback, Duration::from_millis(100));

pub fn update(&mut self, current: usize, total: Option<usize>, message: &str)

Updates progress, but only if the minimum interval has elapsed.

Parameters

• current: Current step or item being processed
• total: Total number of steps (if known)
• message: Human-readable progress message

Example

// Returns immediately if interval hasn't elapsed
progress.update(50, Some(100), "Processing");

pub fn force_update( &mut self, current: usize, total: Option<usize>, message: &str, )

Forces an immediate progress update, bypassing the throttling logic.

Use this for important milestones (e.g., completion) that should always be reported regardless of timing.

Example

// Always report the final update, even if interval hasn't elapsed
progress.force_update(100, Some(100), "Complete");

pub fn update_interval(&self) -> Duration

Returns the configured update interval.

Example

let interval = progress.update_interval();
assert_eq!(interval, Duration::from_millis(100));

Trait Implementations

impl<'a, F> Debug for ProgressState<'a, F>

where F: ProgressCallback + ?Sized + Debug,

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

Formats the value using the given formatter.