Popularity
5.7
Stable
Activity
0.0
Declining
468
13
47

Programming language: Rust
License: MIT License
Tags: CLI     Terminal     Command-line     Progress     Pb    
Latest version: v1.0.3

pb alternatives and similar packages

Based on the "Progress" category.
Alternatively, view pb alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of pb or a related project?

Add another 'Progress' Package

README

Terminal progress bar for Rust

Latest version License Docs Build Status Gitter

Console progress bar for Rust Inspired from pb, support and tested on MacOS, Linux and Windows

Screenshot

Documentation

Examples

  1. simple example
extern crate pbr;

use pbr::ProgressBar;
use std::thread;

fn main() {
    let count = 1000;
    let mut pb = ProgressBar::new(count);
    pb.format("╢▌▌░╟");
    for _ in 0..count {
        pb.inc();
        thread::sleep_ms(200);
    }
    pb.finish_print("done");
}
  1. MultiBar example. see full example here ```rust extern crate pbr;

use std::thread; use pbr::MultiBar; use std::time::Duration;

fn main() { let mut mb = MultiBar::new(); let count = 100; mb.println("Application header:");

let mut p1 = mb.create_bar(count);
let _ = thread::spawn(move || {
    for _ in 0..count {
        p1.inc();
        thread::sleep(Duration::from_millis(100));
    }
    // notify the multibar that this bar finished.
    p1.finish();
});

mb.println("add a separator between the two bars");

let mut p2 = mb.create_bar(count * 2);
let _ = thread::spawn(move || {
    for _ in 0..count * 2 {
        p2.inc();
        thread::sleep(Duration::from_millis(100));
    }
    // notify the multibar that this bar finished.
    p2.finish();
});

// start listen to all bars changes.
// this is a blocking operation, until all bars will finish.
// to ignore blocking, you can run it in a different thread.
mb.listen();

}


3. Broadcast writing (simple file copying)

```rust
#![feature(io)]
extern crate pbr;

use std::io::copy;
use std::io::prelude::*;
use std::fs::File;
use pbr::{ProgressBar, Units};

fn main() {
    let mut file = File::open("/usr/share/dict/words").unwrap();
    let n_bytes = file.metadata().unwrap().len() as usize;
    let mut pb = ProgressBar::new(n_bytes);
    pb.set_units(Units::Bytes);
    let mut handle = File::create("copy-words").unwrap().broadcast(&mut pb);
    copy(&mut file, &mut handle).unwrap();
    pb.finish_print("done");
}

License

MIT


*Note that all licence references and agreements mentioned in the pb README section above are relevant to that project's source code only.