Struct indicatif::ProgressBar

pub struct ProgressBar { /* private fields */ }

A progress bar or spinner.

Implementations

impl ProgressBar

pub fn new(len: u64) -> ProgressBar

Creates a new progress bar with a given length.

This progress bar by default draws directly to stderr, and refreshes a maximum of 15 times a second

pub fn hidden() -> ProgressBar

Creates a completely hidden progress bar.

This progress bar still responds to API changes but it does not have a length or render in any way.

pub fn with_draw_target(len: u64, target: ProgressDrawTarget) -> ProgressBar

Creates a new progress bar with a given length and draw target.

pub fn new_spinner() -> ProgressBar

Creates a new spinner.

This spinner by default draws directly to stderr This adds the default spinner style to it.

pub fn set_style(&self, style: ProgressStyle)

Overrides the stored style.

This does not redraw the bar. Call tick to force it.

pub fn enable_steady_tick(&self, ms: u64)

Spawns a background thread to tick the progress bar.

When this is enabled a background thread will regularly tick the progress back in the given interval (milliseconds). This is useful to advance progress bars that are very slow by themselves.

When steady ticks are enabled calling .tick() on a progress bar does not do anything.

pub fn disable_steady_tick(&self)

Undoes enable_steady_tick.

pub fn set_draw_delta(&self, n: u64)

Limit redrawing of progress bar to every n steps. Defaults to 0.

By default, the progress bar will redraw whenever its state advances. This setting is helpful in situations where the overhead of redrawing the progress bar dominates the computation whose progress is being reported.

If n is greater than 0, operations that change the progress bar such as .tick(), .set_message() and .set_length() will no longer cause the progress bar to be redrawn, and will only be shown once the position advances by n steps.

let n = 1_000_000;
let pb = ProgressBar::new(n);
pb.set_draw_delta(n / 100); // redraw every 1% of additional progress

pub fn tick(&self)

Manually ticks the spinner or progress bar.

This automatically happens on any other change to a progress bar.

pub fn inc(&self, delta: u64)

Advances the position of a progress bar by delta.

pub fn println<I: Into<String>>(&self, msg: I)

Print a log line above the progress bar.

pub fn set_position(&self, pos: u64)

Sets the position of the progress bar.

pub fn set_length(&self, len: u64)

Sets the length of the progress bar.

pub fn set_prefix(&self, prefix: &str)

Sets the current prefix of the progress bar.

pub fn set_message(&self, msg: &str)

Sets the current message of the progress bar.

pub fn reset_eta(&self)

Resets the ETA calculation.

This can be useful if progress bars make a huge jump or were paused for a prolonged time.

pub fn finish(&self)

Finishes the progress bar and leaves the current message.

pub fn finish_with_message(&self, msg: &str)

Finishes the progress bar and sets a message.

pub fn finish_and_clear(&self)

Finishes the progress bar and completely clears it.

pub fn set_draw_target(&self, target: ProgressDrawTarget)

Sets a different draw target for the progress bar.

This can be used to draw the progress bar to stderr for instance:

let pb = ProgressBar::new(100);
pb.set_draw_target(ProgressDrawTarget::stderr());

pub fn wrap_iter<It: Iterator>(&self, it: It) -> ProgressBarIter<'_, It>

Wraps an iterator with the progress bar.

let v = vec![1, 2, 3];
let pb = ProgressBar::new(3);
for item in pb.wrap_iter(v.iter()) {
    // ...
}

pub fn wrap_read<R: Read>(&self, read: R) -> ProgressBarRead<'_, R>

Wraps a Reader with the progress bar.

let source = File::open("work.txt")?;
let mut target = File::create("done.txt")?;
let pb = ProgressBar::new(source.metadata()?.len());
io::copy(&mut pb.wrap_read(source), &mut target);

Trait Implementations

impl Debug for ProgressBar

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

Formats the value using the given formatter.

impl Drop for ProgressBar

fn drop(&mut self)

Executes the destructor for this type.