Struct ProgressTracker 

pub struct ProgressTracker { /* private fields */ }

Thread-safe progress tracker for logging progress at regular intervals.

Maintains an internal count and logs progress messages when the count crosses interval boundaries. Safe to use from multiple threads.

Example

use fgumi_lib::progress::ProgressTracker;

let tracker = ProgressTracker::new("Processed records")
    .with_interval(100);

// Add items and log at interval boundaries
for _ in 0..250 {
    tracker.log_if_needed(1);  // Logs at 100, 200
}
tracker.log_final();  // Logs "Processed records 250 (complete)"

Multi-threaded Example

use fgumi_lib::progress::ProgressTracker;
use std::sync::Arc;

let tracker = Arc::new(ProgressTracker::new("Processed records").with_interval(1000));

// Multiple threads can safely add to the same tracker
let tracker_clone = Arc::clone(&tracker);
std::thread::spawn(move || {
    tracker_clone.log_if_needed(500);
});

Implementations

impl ProgressTracker

pub fn new(message: impl Into<String>) -> Self

Create a new progress tracker with the specified message.

The tracker starts with a count of 0 and a default interval of 10,000.

Arguments

• message - Message prefix for progress logs (e.g., “Processed records”)

pub fn with_interval(self, interval: u64) -> Self

Set the logging interval.

Progress will be logged each time the count crosses a multiple of this interval. For example, with interval=1000, logs will occur at 1000, 2000, 3000, etc.

Arguments

• interval - The interval between progress logs

pub fn log_if_needed(&self, additional: u64) -> bool

Add to the count and log if an interval boundary was crossed.

This method is thread-safe and can be called from multiple threads. It atomically adds additional to the internal count and logs progress for each interval boundary crossed.

The behavior is equivalent to incrementing the counter one-by-one and checking at each step, but implemented efficiently with a single atomic operation.

Arguments

• additional - Number of items to add to the count

Returns

true if the final count is exactly a multiple of the interval, false otherwise. This is useful for log_final() to know if a final message is needed.

Example

use fgumi_lib::progress::ProgressTracker;

let tracker = ProgressTracker::new("Items").with_interval(100);
tracker.log_if_needed(50);   // count=50, returns false, no log
tracker.log_if_needed(60);   // count=110, returns false, logs "Items 100"
tracker.log_if_needed(90);   // count=200, returns true, logs "Items 200"

pub fn log_final(&self)

Log final progress.

If the current count is not exactly on an interval boundary (i.e., if log_if_needed(0) returns false), logs a final message with “(complete)”. If the count is exactly on an interval, the last log_if_needed call already logged it, so no additional message is needed.

Example

use fgumi_lib::progress::ProgressTracker;

let tracker = ProgressTracker::new("Items").with_interval(100);
tracker.log_if_needed(250);  // Logs "Items 100", "Items 200"
tracker.log_final();          // Logs "Items 250 (complete)"

let tracker2 = ProgressTracker::new("Items").with_interval(100);
tracker2.log_if_needed(200);  // Logs "Items 100", "Items 200"
tracker2.log_final();          // No log (200 is exactly on interval)

pub fn count(&self) -> u64

Get the current count.

Returns

The current count of items processed.