Struct obnam::engine::Engine

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

Do heavy work in the background.

An engine takes items of work from a work queue, and does the work in the background, using tokio blocking tasks. The background work can be CPU intensive or block on I/O. The number of active concurrent tasks is limited to the size of the queue.

The actual work is done in a function or closure passed in as a parameter to the engine. The worker function is called with a work item as an argument, in a thread dedicated for that worker function.

The need to move work items between threads puts some restrictions on the types used as work items.

Implementations

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

pub fn new<S, F>(queue: WorkQueue<S>, func: F) -> Self where
    F: Send + Copy + 'static + Fn(S) -> T,
    S: Send + 'static, 

Create a new engine.

Each engine gets work from a queue, and calls the same worker function for each item of work. The results are put into another, internal queue.

pub async fn next(&mut self) -> Option<T>

Get the oldest result of the worker function, if any.

This will block until there is a result, or it’s known that no more results will be forthcoming.