Struct Meter 

pub struct Meter { /* private fields */ }

A lock-free progress meter shared across threads behind an Arc.

Every method takes &self and uses Ordering::Relaxed — the counters are advisory progress, never a synchronization primitive, so relaxed ordering is both correct and cheap (a couple of atomic ops per file). Meter is Send + Sync because all of its fields are atomics.

Implementations

impl Meter

pub fn new() -> Self

Creates a fresh meter with all counters at zero and Phase::Idle.

pub fn add_in(&self, n: u64)

Adds n to the bytes-in counter (content read/hashed).

pub fn add_out(&self, n: u64)

Adds n to the bytes-out counter (content written/sent).

pub fn object_started(&self)

Records that an object started: bumps the in-flight gauge by one.

pub fn object_finished(&self)

Records that an object finished: drops the in-flight gauge by one and bumps the done counter by one. Saturates the gauge at zero so a stray finish never underflows.

pub fn set_total(&self, n: u64)

Sets the expected total object count.

pub fn add_skipped(&self, n: u64)

Adds n to the skipped-objects counter.

pub fn set_phase(&self, p: Phase)

Sets the current coarse Phase.

pub fn phase(&self) -> Phase

Reads the current coarse Phase.

pub fn snapshot(&self) -> MeterSnapshot

Takes a point-in-time MeterSnapshot of every counter.

The loads are independently relaxed, so the snapshot is eventually consistent rather than a single atomic view — that is fine for an advisory progress display.

Trait Implementations

impl Debug for Meter

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

Formats the value using the given formatter.

impl Default for Meter

fn default() -> Meter

Returns the “default value” for a type.