Struct iter_progress::ProgressRecord

pub struct ProgressRecord { /* fields omitted */ }

Every step of the underlying iterator, one of these is generated. It contains all the information of how this iterator is progresing. Use the methods to access data on it.

Methods

impl ProgressRecord

fn duration_since_start(&self) -> Duration

Duration since iteration started

fn num_done(&self) -> usize

Number of items we've generated so far. Will be 0 for the first element

``

use iter_progress::ProgressableIter;

let mut progressor = (0..1_000).progress(); let (state, num) = progressor.next().unwrap(); assert_eq!(state.num_done(), 0); ```

let mut progressor = (0..1_000).progress().skip(120);
let (state, num) = progressor.next().unwrap();
assert_eq!(state.num_done(), 121);

fn previous_record_tm(&self) -> Option<Instant>

Instant for when the previous record was generated. None if there was no previous record.

This can be useful for calculating fine grained rates

fn started_iterating(&self) -> Instant

When the iteration started

fn print_message(&self)

Prints a basic message

fn message(&self) -> String

Returns a basic log message of where we are now. You can construct this yourself, but this is a helpful convience method. Currently looks likt "{time_since_start} - Seen {num_see} Rate {rate}/sec", but the library might change it later. Construct your own message.

fn rate(&self) -> f32

Number of items per second, calcualted from the start

fn fraction(&self) -> Option<f32>

How far through the iterator as a fraction, if known

use iter_progress::ProgressableIter;
let mut progressor = (0..1_000).progress().skip(120);
let (state, num) = progressor.next().unwrap();
assert_eq!(num, 120);
assert_eq!(state.fraction(), Some(0.121));

Returns None if we cannot know, e.g. for an infinite iterator ```

use iter_progress::ProgressableIter;

let mut progressor = (0..).progress().skip(120); let (state, num) = progressor.next().unwrap(); assert_eq!(state.fraction(), None); ```

fn percent(&self) -> Option<f32>

Percentage progress through the iterator, if known.

use iter_progress::ProgressableIter;
let mut progressor = (0..1_000).progress().skip(120);
let (state, num) = progressor.next().unwrap();
assert_eq!(state.percent(), Some(12.1));

Returns None if we cannot know, e.g. for an infinite iterator ```

use iter_progress::ProgressableIter;

let mut progressor = (0..).progress().skip(120); let (state, num) = progressor.next().unwrap(); assert_eq!(state.percent(), None); ```

fn print_every_n_sec<T: Display>(&self, n: f32, msg: T)

Print out msg, but only if there has been n seconds since last printout

fn do_every_n_sec<F: Fn(&Self)>(&self, n: f32, f: F)

Do thing but only every n sec (as far as possible). Could be a print statement.

fn should_do_every_n_sec(&self, n: f32) -> bool

If we want to print every n sec, should we print now?

fn should_do_every_n_items(&self, n: usize) -> bool

If we want to print every n items, should we print now?

fn print_every_n_items<T: Display>(&self, n: usize, msg: T)

Print out msg, but only if there has been n items. Often you want to print out a debug message every 1,000 items or so. This function does that.

fn do_every_n_items<F: Fn(&Self)>(&self, n: usize, f: F)

Do thing but only every n items. Could be a print statement.

takes 2 arguments, n and the function (f) which takes a &ProgressState. f will only be called every n items that pass through the iterator.

for (state, _) in (0..150).progress() {
   state.do_every_n_items(5, |state| {
       println!("Current progress: {}%", state.percent().unwrap());
   });
}

fn recent_rate(&self) -> f32

The rate of the last few items.