Struct irox_progress::Task

source ·

pub struct Task { /* private fields */ }

Expand description

A task is a specific tracked operation. It has:

A Name
A unique ID
A creation time
The current progress of the task (in “elements”), the ‘counter’.
An (optional) maximum number of elements.
A time the task was “started”
The estimated amount of time the task has remaining
A time the task has “ended”
A list of any “Child Tasks” that this task can spawn.

Implementations§

source §

impl Task

source

pub fn new(id: u64, name: String, max_elements: u64) -> Task

Creates a new finite, named task with the specified ID.

Examples found in repository ?

examples/progress.rs (line 12)

pub fn main() -> Result<(), std::io::Error> {
    let elements = 1000;

    let prog = ConsoleProgressPrinter::new_update_rate(Duration::from_millis(100));
    let task = Task::new(0, "Test Task".to_string(), u64::MAX);
    prog.track_task_progress(&task);
    task.mark_started();
    for _i in 0..elements {
        task.mark_one_completed();

        std::thread::sleep(std::time::Duration::from_millis(5));
    }

    Ok(())
}

source

pub fn new_infinite(id: u64, name: String) -> Task

Creates a new infinite, named task with a specific ID.

source

pub fn new_infinite_named(name: String) -> Task

Creates a new infinite, named task with a random ID

Examples found in repository ?

examples/progress_random_write.rs (line 19)

pub fn main() -> Result<(), Error> {
    let mut rand = Random::default();

    let cons = ConsoleProgressPrinter::new_update_rate(Duration::from_millis(100));
    let task = Task::new_infinite_named("Writer".to_string());
    cons.track_task_progress(&task);
    task.mark_started();

    let out = OpenOptions::new()
        .write(true)
        .truncate(true)
        .create(true)
        .open("test")?;
    let out = BufWriter::new(out);
    let mut out = WriterTask::new(out, task);

    let gb = 1_000_000_000 / 8;
    for _i in 0..gb {
        out.write_be_u64(rand.next_u64())?;
    }

    Ok(())
}

source

pub fn new_named(name: String, max_elements: u64) -> Task

Creates a new finite, named task with a random ID.

source

pub fn current_progress_count(&self) -> u64

Returns the number of elements completed in the range 0..=max_elements

source

pub fn max_elements(&self) -> u64

Returns the maximum number of elements of this task

source

pub fn current_progress_frac(&self) -> f64

Returns the current progress as a fraction in the range 0..=1

source

pub fn get_id(&self) -> u64

Returns the ID of this task.

source

pub fn get_name(&self) -> &str

Returns the name of this task

source

pub fn get_created(&self) -> UnixTimestamp

Returns the time this task was created

source

pub fn get_started(&self) -> Option<&UnixTimestamp>

Returns the time at which this task started, or None if the task hasn’t started yet.

source

pub fn mark_one_completed(&self)

Increments the ‘completed’ counter.

Examples found in repository ?

examples/progress.rs (line 16)

pub fn main() -> Result<(), std::io::Error> {
    let elements = 1000;

    let prog = ConsoleProgressPrinter::new_update_rate(Duration::from_millis(100));
    let task = Task::new(0, "Test Task".to_string(), u64::MAX);
    prog.track_task_progress(&task);
    task.mark_started();
    for _i in 0..elements {
        task.mark_one_completed();

        std::thread::sleep(std::time::Duration::from_millis(5));
    }

    Ok(())
}

source

pub fn mark_all_completed(&self)

Mark this task complete. Does not affect sub-tasks.

source

pub fn mark_some_completed(&self, completed: u64)

Mark some some portion of this task as completed.

source

pub fn get_remaining_time(&self) -> Duration

source

pub fn mark_started(&self)

Marks this task as started. If the task has already started, does nothing.

Examples found in repository ?

examples/progress.rs (line 14)

pub fn main() -> Result<(), std::io::Error> {
    let elements = 1000;

    let prog = ConsoleProgressPrinter::new_update_rate(Duration::from_millis(100));
    let task = Task::new(0, "Test Task".to_string(), u64::MAX);
    prog.track_task_progress(&task);
    task.mark_started();
    for _i in 0..elements {
        task.mark_one_completed();

        std::thread::sleep(std::time::Duration::from_millis(5));
    }

    Ok(())
}

More examples

Hide additional examples

examples/progress_random_write.rs (line 21)

pub fn main() -> Result<(), Error> {
    let mut rand = Random::default();

    let cons = ConsoleProgressPrinter::new_update_rate(Duration::from_millis(100));
    let task = Task::new_infinite_named("Writer".to_string());
    cons.track_task_progress(&task);
    task.mark_started();

    let out = OpenOptions::new()
        .write(true)
        .truncate(true)
        .create(true)
        .open("test")?;
    let out = BufWriter::new(out);
    let mut out = WriterTask::new(out, task);

    let gb = 1_000_000_000 / 8;
    for _i in 0..gb {
        out.write_be_u64(rand.next_u64())?;
    }

    Ok(())
}