Struct ProgressBar 

pub struct ProgressBar<T: Write> {
    pub total: u64,
    pub is_finish: bool,
    pub is_multibar: bool,
    pub show_bar: bool,
    pub show_speed: bool,
    pub show_percent: bool,
    pub show_counter: bool,
    pub show_time_left: bool,
    pub show_tick: bool,
    pub show_message: bool,
    /* private fields */
}

Fields

total: u64

is_finish: bool

is_multibar: bool

show_bar: bool

show_speed: bool

show_percent: bool

show_counter: bool

show_time_left: bool

show_tick: bool

show_message: bool

Implementations

impl ProgressBar<Stdout>

pub fn new(total: u64) -> ProgressBar<Stdout>

Create a new ProgressBar with default configuration.

Examples

use std::thread;
use pbr::{ProgressBar, Units};

let count = 1000;
let mut pb = ProgressBar::new(count);
pb.set_units(Units::Bytes);

for _ in 0..count {
   pb.inc();
   thread::sleep_ms(100);
}

impl<T: Write> ProgressBar<T>

pub fn on(handle: T, total: u64) -> ProgressBar<T>

Create a new ProgressBar with default configuration but pass an arbitrary writer.

Examples

use std::thread;
use std::io::stderr;
use pbr::{ProgressBar, Units};

let count = 1000;
let mut pb = ProgressBar::on(stderr(), count);
pb.set_units(Units::Bytes);

for _ in 0..count {
   pb.inc();
   thread::sleep_ms(100);
}

pub fn set_units(&mut self, u: Units)

Set units, default is simple numbers

Examples

use pbr::{ProgressBar, Units};

let n_bytes = 100;
let mut pb = ProgressBar::new(n_bytes);
pb.set_units(Units::Bytes);

pub fn format(&mut self, fmt: &str)

Set custom format to the drawing bar, default is [=>-]

Examples

let mut pb = ProgressBar::new(...);
pb.format("[=>_]");

pub fn message(&mut self, message: &str)

Set message to display in the prefix, call with “” to stop printing a message.

All newlines are replaced with spaces.

Examples

let mut pb = ProgressBar::new(20);

for x in 0..20 {
   match x {
      0 => pb.message("Doing 1st Quarter"),
      5 => pb.message("Doing 2nd Quarter"),
      10 => pb.message("Doing 3rd Quarter"),
      15 => pb.message("Doing 4th Quarter"),
   }
   pb.inc().
}

pub fn tick_format(&mut self, tick_fmt: &str)

Set tick format for the progressBar, default is \|/-

Format is not limited to 4 characters, any string can be used as a tick format (the tick will successively take the value of each char but won’t loop backwards).

Examples

let mut pb = ProgressBar::new(...);
pb.tick_format("▀▐▄▌")

pub fn set_width(&mut self, w: Option<usize>)

Set width, or None for default.

Examples

let mut pb = ProgressBar::new(...);
pb.set_width(Some(80));

pub fn set_max_refresh_rate(&mut self, w: Option<Duration>)

Set max refresh rate, above which the progress bar will not redraw, or None for none.

Examples

let mut pb = ProgressBar::new(...);
pb.set_max_refresh_rate(Some(Duration::from_millis(100)));

pub fn tick(&mut self)

Update progress bar even though no progress are made Useful to see if a program is bricked or just not doing any progress.

tick is not needed with add or inc as performed operation take place in draw function.

Examples

let mut pb = ProgressBar::new(...);
pb.inc();
for _ in ... {
   ...do something
   pb.tick();
}
pb.finish();

pub fn add(&mut self, i: u64) -> u64

Add to current value

Examples

use pbr::ProgressBar;

let mut pb = ProgressBar::new(10);
pb.add(5);
pb.finish();

pub fn set(&mut self, i: u64) -> u64

Manually set the current value of the bar

Examples

use pbr::ProgressBar;

let mut pb = ProgressBar::new(10);
pb.set(8);
pb.finish();

pub fn inc(&mut self) -> u64

Increment current value

pub fn reset_start_time(&mut self)

Resets the start time to now

pub fn finish(&mut self)

Calling finish manually will set current to total and draw the last time

pub fn finish_print(&mut self, s: &str)

Call finish and write string s that will replace the progress bar.

pub fn finish_println(&mut self, s: &str)

Call finish and write string s below the progress bar.

If the ProgressBar is part of MultiBar instance, you should use finish_print to print message.

Trait Implementations

impl<T: Write> Write for ProgressBar<T>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.