Struct Task

pub struct Task { /* private fields */ }

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

impl Task

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();

        let status = format!("Phase {}", i / 100);
        task.set_current_status(Some(status));

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

    Ok(())
}

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

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

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(())
}

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

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

pub fn current_progress_count(&self) -> u64

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

pub fn set_current_progress_count(&self, current_progress: u64)

Updates the current progress counter to be the specified value

pub fn max_elements(&self) -> u64

Returns the maximum number of elements of this task

pub fn set_max_elements(&self, max_elements: u64)

pub fn current_progress_frac(&self) -> f64

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

pub fn get_id(&self) -> u64

Returns the ID of this task.

pub fn get_name(&self) -> &str

Returns the name of this task

pub fn get_created(&self) -> UnixTimestamp

Returns the time this task was created

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

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

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();

        let status = format!("Phase {}", i / 100);
        task.set_current_status(Some(status));

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

    Ok(())
}

pub fn mark_all_completed(&self)

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

pub fn mark_some_completed(&self, completed: u64)

Mark some some portion of this task as completed.

pub fn get_remaining_time(&self) -> Duration

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();

        let status = format!("Phase {}", i / 100);
        task.set_current_status(Some(status));

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

    Ok(())
}

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(())
}

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

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

pub fn mark_ended(&self)

Marks this task as ended. If this task has already ended, does nothing.

pub fn num_children(&self) -> usize

Returns the number of child tasks this task has

pub fn each_child<F: FnMut(&Task)>(&self, func: F)

Iterates over each child task, providing a reference of the child task to the input function

pub fn clean_completed_children(&self) -> Vec<Task>

pub fn new_child_task(&self, id: u64, name: String, max_elements: u64) -> Task

Creates a new child task of this task

pub fn push_new_child_task(&self, task: Task)

Appends this task as a tracked child task.

pub fn is_complete(&self) -> bool

Returns true if this task is complete.

pub fn cancel(&self)

Marks this task as “Cancelled”. Users of this task may opt to ignore this flag, it’s really more like a suggestion.

pub fn is_cancelled(&self) -> bool

Returns true if this task has been marked ‘cancelled’. Cancelling a task is a one-way operation.

pub fn current_status(&self) -> Option<Arc<String>>

Gets a copy of the current status

pub fn set_current_status<T: AsRef<str>>(&self, status: Option<T>)

Sets the optional current status of this task

Examples found in repository

examples/progress.rs (line 19)

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();

        let status = format!("Phase {}", i / 100);
        task.set_current_status(Some(status));

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

    Ok(())
}

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Task

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

Formats the value using the given formatter.