Struct BackgroundRunner 

pub struct BackgroundRunner<T> { /* private fields */ }

Runner for a background task to be invoked periodically.

Implementations

impl<T: 'static + Send> BackgroundRunner<T>

pub fn new(task: impl 'static + Send + FnMut(&T)) -> Self

where T: Default,

Create a new background runner with the given task

This spawns a new thread to execute the task periodically, triggered by the Self::update() method.

Examples found in repository

examples/iter.rs (lines 10-15)

fn main() {
    let mut runner_iter = 0;

    // Set up the runner, giving it the task to run
    let runner = BackgroundRunner::new(move |iter| {
        // Simulate some heavy work
        sleep(Duration::from_millis(10));
        println!("runner_iter = {runner_iter}, iter = {iter}");
        runner_iter += 1;
    });

    let start = Instant::now();
    let mut iter = 0;
    while start.elapsed().as_millis() < 100 {
        // Update the runner with the current loop iteration
        runner.update(&iter);
        iter += 1;
    }
}

pub fn with_init_data( init_data: T, task: impl 'static + Send + FnMut(&T), ) -> Self

Create a new background runner with the given initial data and task

This spawns a new thread to execute the task periodically, triggered by the Self::update() method.

pub fn update(&self, new_data: &T)

where T: Clone,

Trigger the runner’s task if it’s not currently running.

Also see Self::update_with() for details.

T::clone_from() is invoked to update the data that is passed to the task.

Examples found in repository

examples/iter.rs (line 21)

fn main() {
    let mut runner_iter = 0;

    // Set up the runner, giving it the task to run
    let runner = BackgroundRunner::new(move |iter| {
        // Simulate some heavy work
        sleep(Duration::from_millis(10));
        println!("runner_iter = {runner_iter}, iter = {iter}");
        runner_iter += 1;
    });

    let start = Instant::now();
    let mut iter = 0;
    while start.elapsed().as_millis() < 100 {
        // Update the runner with the current loop iteration
        runner.update(&iter);
        iter += 1;
    }
}

pub fn update_with(&self, f: impl FnOnce(&mut T))

Trigger the runner’s task if it’s not currently running.

This will never block the current thread. If the task is currently running and thus not able to process this update request, this update is dicarded and this method returns immediately without any effect (also f is not invoked in this case).

The given closure is invoked with a mutable reference to the currently stored data to allow for its modification (e.g. via clone_from).

pub fn wait_and_update(&self, new_data: &T)

where T: Clone,

Trigger the runner’s task, blocking until it can be executed.

Also see Self::wait_and_update_with() for details.

T::clone_from() is invoked to update the data that is passed to the task.

pub fn wait_and_update_with(&self, f: impl FnOnce(&mut T))

Trigger the runner’s task, blocking until it can be executed.

Unlike Self::update_with(), this method will block the current thread until the new_data can be handed over to the background task. Thus, it is ensured that the task will see this or a later submitted datum, given that is does not panic and the program is not terminated.

This function is particularly useful in conjunction with Self::join() to ensure that the last update is processed completely.

The given closure is invoked with a mutable reference to the currently stored data to allow for its modification.

pub fn join(self)

Wait for the background thread to finish.

This function will wait until the background thread has finished executing it’s last task and exited. This is useful to ensure that the last task has completed, in particular, before terminating the program.

Notice, if the program is terminating, without calling this method, the background thread might be terminated abruptly, possibly in the middle of executing the task.

Trait Implementations

impl<T: Debug> Debug for BackgroundRunner<T>

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

Formats the value using the given formatter.

impl<T> Drop for BackgroundRunner<T>

fn drop(&mut self)

Executes the destructor for this type.