Struct indicatif::ProgressBar

pub struct ProgressBar { /* fields omitted */ }

A progress bar or spinner

The progress bar is an Arc around its internal state. When the progress bar is cloned it just increments the refcount (so the original and its clone share the same state).

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. To change the refresh rate, set the draw target to one with a different refresh rate.

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 with_style(self, style: ProgressStyle) -> ProgressBar

A convenience builder-like function for a progress bar with a given style

pub fn with_prefix(self, prefix: impl Into<Cow<'static, str>>) -> ProgressBar

A convenience builder-like function for a progress bar with a given prefix

pub fn with_message(self, message: impl Into<Cow<'static, str>>) -> ProgressBar

A convenience builder-like function for a progress bar with a given message

pub fn with_position(self, pos: u64) -> ProgressBar

A convenience builder-like function for a progress bar with a given position

pub fn with_elapsed(self, elapsed: Duration) -> ProgressBar

A convenience builder-like function for a progress bar with a given elapsed time

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 ProgressBar::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 bar in the given interval (in milliseconds). This is useful to advance progress bars that are very slow by themselves.

When steady ticks are enabled, calling ProgressBar::tick() on a progress bar does not have any effect.

pub fn disable_steady_tick(&self)

Undoes ProgressBar::enable_steady_tick()

pub fn set_draw_delta(&self, n: u64)

Limit redrawing of progress bar to every n steps

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 ProgressBar::tick(), ProgressBar::set_message() and ProgressBar::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

Note that ProgressDrawTarget may impose additional buffering of redraws.

pub fn set_draw_rate(&self, n: u64)

Sets the refresh rate of progress bar to n updates per seconds

This is similar to set_draw_delta but automatically adapts to a constant refresh rate regardless of how consistent the progress is.

This parameter takes precedence on set_draw_delta if different from 0.

let n = 1_000_000;
let pb = ProgressBar::new(n);
pb.set_draw_rate(25); // aims at redrawing at most 25 times per seconds.

Note that the ProgressDrawTarget may impose additional buffering of redraws.

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 the progress bar by delta

pub fn is_hidden(&self) -> bool

A quick convenience check if the progress bar is hidden

pub fn is_finished(&self) -> bool

Indicates that the progress bar finished

pub fn println<I: AsRef<str>>(&self, msg: I)

Print a log line above the progress bar

If the progress bar is hidden (e.g. when standard output is not a terminal), println() will not do anything. If you want to write to the standard output in such cases as well, use suspend instead.

If the progress bar was added to a MultiProgress, the log line will be printed above all other progress bars.

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 inc_length(&self, delta: u64)

Increase the length of the progress bar

pub fn set_prefix(&self, prefix: impl Into<Cow<'static, str>>)

Sets the current prefix of the progress bar

For the prefix to be visible, the {prefix} placeholder must be present in the template (see ProgressStyle).

pub fn set_message(&self, msg: impl Into<Cow<'static, str>>)

Sets the current message of the progress bar

For the message to be visible, the {msg} placeholder must be present in the template (see ProgressStyle).

pub fn downgrade(&self) -> WeakProgressBar

Creates a new weak reference to this ProgressBar

pub fn reset_eta(&self)

Resets the ETA calculation

This can be useful if the progress bars made a large jump or was paused for a prolonged time.

pub fn reset_elapsed(&self)

Resets elapsed time

pub fn reset(&self)

Resets all of the progress bar state

pub fn finish(&self)

Finishes the progress bar and leaves the current message

pub fn finish_at_current_pos(&self)

Finishes the progress bar at current position and leaves the current message

pub fn finish_with_message(&self, msg: impl Into<Cow<'static, str>>)

Finishes the progress bar and sets a message

For the message to be visible, the {msg} placeholder must be present in the template (see ProgressStyle).

pub fn finish_and_clear(&self)

Finishes the progress bar and completely clears it

pub fn abandon(&self)

Finishes the progress bar and leaves the current message and progress

pub fn abandon_with_message(&self, msg: impl Into<Cow<'static, str>>)

Finishes the progress bar and sets a message, and leaves the current progress

For the message to be visible, the {msg} placeholder must be present in the template (see ProgressStyle).

pub fn finish_using_style(&self)

Finishes the progress bar using the behavior stored in the ProgressStyle

See ProgressStyle::on_finish().

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 (this is the default):

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

Note: Calling this method on a ProgressBar linked with a MultiProgress (after running MultiProgress::add) will unlink this progress bar. If you don’t want this behavior, call MultiProgress::set_draw_target instead.

pub fn suspend<F: FnOnce() -> R, R>(&self, f: F) -> R

Hide the progress bar temporarily, execute f, then redraw the progress bar

Useful for external code that writes to the standard output.

Note: The internal lock is held while f is executed. Other threads trying to print anything on the progress bar will be blocked until f finishes. Therefore, it is recommended to avoid long-running operations in f.

let mut pb = ProgressBar::new(3);
pb.suspend(|| {
    println!("Log message");
})

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) -> ProgressBarIter<R>

Wraps an io::Read 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);

pub fn wrap_write<W: Write>(&self, write: W) -> ProgressBarIter<W>

Wraps an io::Write with the progress bar

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

pub fn position(&self) -> u64

Returns the current position

pub fn length(&self) -> u64

Returns the current length

pub fn eta(&self) -> Duration

Returns the current ETA

pub fn per_sec(&self) -> f64

Returns the current rate of progress

pub fn duration(&self) -> Duration

Returns the current expected duration

pub fn elapsed(&self) -> Duration

Returns the current elapsed time

Trait Implementations

impl Clone for ProgressBar

fn clone(&self) -> ProgressBar

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProgressBar

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

Formats the value using the given formatter.