Struct WriterProgressReporter 

pub struct WriterProgressReporter<W> { /* private fields */ }

Progress reporter that writes human-readable events to a writer.

Type Parameters

• W - Writer receiving formatted progress events.

Examples

use std::io::Cursor;
use std::sync::{
    Arc,
    Mutex,
};
use std::time::Duration;

use qubit_progress::{
    ProgressCounters,
    ProgressEvent,
    ProgressReporter,
    WriterProgressReporter,
};

let output = Arc::new(Mutex::new(Cursor::new(Vec::new())));
let reporter = WriterProgressReporter::new(output.clone());
reporter.report(&ProgressEvent::running(
    ProgressCounters::new(Some(4)).with_completed_count(2),
    Duration::from_secs(1),
));

let bytes = output.lock().expect("output should lock").get_ref().clone();
let text = String::from_utf8(bytes).expect("progress output should be UTF-8");
assert!(text.contains("running"));
assert!(text.contains("2/4"));

Implementations

impl<W> WriterProgressReporter<W>

pub fn new(writer: Arc<Mutex<W>>) -> Self

Creates a reporter from a shared writer.

Parameters

• writer - Shared writer receiving progress output.

Returns

A writer-backed progress reporter.

pub fn from_writer(writer: W) -> Self

Creates a reporter from an owned writer.

Parameters

• writer - Owned writer receiving progress output.

Returns

A writer-backed progress reporter.

pub const fn writer(&self) -> &Arc<Mutex<W>>

Returns the shared writer used by this reporter.

Returns

A shared reference to the writer mutex.

Trait Implementations

impl<W: Debug> Debug for WriterProgressReporter<W>

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

Formats the value using the given formatter.

impl<W> ProgressReporter for WriterProgressReporter<W>

where W: Write + Send,

fn report(&self, event: &ProgressEvent)

Writes one progress event as a single human-readable line.

Parameters

• event - Progress event to format and write.

Panics

Recovers the inner writer when the writer mutex is poisoned, and panics only when writing to the configured writer fails.