Struct ProgressLogger

pub struct ProgressLogger { /* private fields */ }

An implementation of ProgressLog with output generated using the log crate at the info level.

Instances can be created by using fluent setters, or by using the progress_logger macro.

You can clone a logger to create a new one with the same setup but with all the counters reset. This behavior is useful when you want to configure a logger and then use its configuration for other loggers.

Examples

A typical call sequence to a progress logger is as follows:

use dsi_progress_logger::prelude::*;

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = ProgressLogger::default();
pl.item_name("pumpkin");
pl.start("Smashing pumpkins...");
for _ in 0..100 {
   // do something on each pumpkin
   pl.update();
}
pl.done();

The progress_logger macro will create the progress logger for you and set its log_target to std::module_path!(), which is usually what you want. You can also call any setter with a key-value syntax:

use dsi_progress_logger::prelude::*;

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = progress_logger![item_name="pumpkin"];
pl.start("Smashing pumpkins...");
for _ in 0..100 {
   // do something on each pumpkin
   pl.update();
}
pl.done();

A progress logger can also be used as a handy timer:

use dsi_progress_logger::prelude::*;

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = progress_logger![item_name="pumpkin"];
pl.start("Smashing pumpkins...");
for _ in 0..100 {
   // do something on each pumpkin
}
pl.done_with_count(100);

This progress logger will display information about memory usage:

use dsi_progress_logger::prelude::*;

env_logger::builder().filter_level(log::LevelFilter::Info).try_init()?;

let mut pl = progress_logger![display_memory=true];

Implementations

impl ProgressLogger

pub const LIGHT_UPDATE_MASK: usize = 1_048_575usize

Calls to light_update will cause a call to Instant::now only if the current count is a multiple of this mask plus one.

Trait Implementations

impl Clone for ProgressLogger

fn clone(&self) -> Self

Clone the logger, returning a logger with the same setup but with all the counters reset.

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

Performs copy-assignment from source.

impl Default for ProgressLogger

fn default() -> Self

Create a default ProgressLogger with a log interval of 10 seconds and item name set to “item”.

impl Display for ProgressLogger

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

Formats the value using the given formatter.

impl ProgressLog for ProgressLogger

fn light_update(&mut self)

Increases the count and, once every LIGHT_UPDATE_MASK + 1 calls, check whether it is time to log.

type Concurrent = ConcurrentWrapper

The type returned by concurrent.

fn log(&mut self, now: Instant)

Force a log of self assuming now is the current time.

fn log_if(&mut self, now: Instant)

Log self if it is time to log.

fn add_to_count(&mut self, count: usize)

Add a value to the counter.

fn display_memory(&mut self, display_memory: bool) -> &mut Self

Set the display of memory information.

fn item_name(&mut self, item_name: impl AsRef<str>) -> &mut Self

Set the name of an item.

fn log_interval(&mut self, log_interval: Duration) -> &mut Self

Set the log interval.

fn expected_updates(&mut self, expected_updates: Option<usize>) -> &mut Self

Set the expected number of updates.

fn time_unit(&mut self, time_unit: Option<TimeUnit>) -> &mut Self

Set the time unit to use for speed.

fn local_speed(&mut self, local_speed: bool) -> &mut Self

Set whether to display additionally the speed achieved during the last log interval.

fn log_target(&mut self, target: impl AsRef<str>) -> &mut Self

Set the log target.

fn start(&mut self, msg: impl AsRef<str>)

Start the logger, displaying the given message.

fn refresh(&mut self)

Refreshe memory information, if previously requested with display_memory. You do not need to call this method unless you display the logger manually.

fn update(&mut self)

Increase the count and check whether it is time to log.

fn update_with_count_and_time(&mut self, count: usize, now: Instant)

Set the count and check whether it is time to log, given the current time.

fn update_and_display(&mut self)

Increase the count and forces a log.

fn stop(&mut self)

Stop the logger, fixing the final time.

fn done(&mut self)

Stop the logger, print Completed., and display the final stats. The number of expected updates will be cleared.

fn done_with_count(&mut self, count: usize)

Stop the logger, sets the count, prints Completed., and displays the final stats. The number of expected updates will be cleared.

fn elapsed(&self) -> Option<Duration>

Return the elapsed time since the logger was started, or None if the logger has not been started.

fn trace(&self, args: Arguments<'_>)

Output the given message at the trace level.

fn debug(&self, args: Arguments<'_>)

Output the given message at the debug level.

fn info(&self, args: Arguments<'_>)

Output the given message at the info level.

fn warn(&self, args: Arguments<'_>)

Output the given message at the warn level.

fn error(&self, args: Arguments<'_>)

Output the given message at the error level.

fn concurrent(&self) -> Self::Concurrent

Return a concurrent copy of the logger.

fn update_with_count(&mut self, count: usize)

Set the count and check whether it is time to log.