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.

This will never block the current thread. If the task is currently running and thus not able to process this update request, nothing will be done and this method returns immediately.

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, nothing will be done and this method returns immediately.

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

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.