Struct employer::Employer

pub struct Employer<K, V, D> { /* fields omitted */ }

An interface for spawning worker threads and storing their results

The description passed to Employer::new must implement the JobDescription trait.

Methods

impl<K, V, D> Employer<K, V, D>

pub fn new(description: D) -> Self

Create a new Employer with the given job description

impl<K, V, S, F> Employer<K, V, (S, F)> where
    (S, F): JobDescription<K, Output = V>, 

pub fn with_state(state: S, f: F) -> Self

Create a new Employer wither the given shared state and job function

impl<K, V, D> Employer<K, V, D>

pub fn get<'a, Q>(&'a self, input: &Q) -> Job<'a, K, V> where
    Q: Hash + Ord,
    K: Borrow<Q>, 

Get the job with the given input

pub fn wait_for<'a, Q>(&'a self, input: &Q) -> Option<OutputGuard<'a, K, V>> where
    Q: Hash + Ord,
    K: Borrow<Q>, 

Block the thread, wait for a job to finish, and get its result

Returns None if a job with the given input does not exist

pub fn finished<Q>(&self, input: &Q) -> bool where
    Q: Hash + Ord,
    K: Borrow<Q>, 

Check if the job with the given input has finished

pub fn in_progress_len(&self) -> usize

Check the number of jobs that are in progress

pub fn finished_len(&self) -> usize

Check the number of jobs that are in progress

pub fn finished_iter(&self) -> JobIter<K, V>

Iterate over finished job input/output pairs

pub fn in_progress_inputs(&self) -> impl Iterator<Item = InputGuard<K, V>>

Iterate over in_progress job inputs

pub fn finished_inputs(&self) -> impl Iterator<Item = InputGuard<K, V>>

Iterate over finished job inputs

pub fn inputs(&self) -> impl Iterator<Item = InputGuard<K, V>>

Iterate over all job inputs

pub fn outputs(&self) -> impl Iterator<Item = OutputGuard<K, V>>

Iterate over finished job outputs

impl<K, V, D> Employer<K, V, D> where
    K: Ord + Hash + Clone + Send + Sync + 'static,
    V: Send + Sync + 'static,
    D: JobDescription<K, Output = V> + 'static, 

pub fn start(&self, input: K)

Start a new job with the the given input if one with the same input is not in progress or finished

If you want to start the job even if one with the same input is already finished, use Employer::restart or Employer::restart_if.

pub fn restart(&self, input: K)

Start a new job with the given input if one with the same input is not in progress

If you want to avoid starting a new job if one with the same input has already finished, use Employer::start.

pub fn restart_if<G>(&self, input: K, condition: G) where
    G: FnOnce(&V) -> bool, 

Start a new job with the given input if one with the same input is not in progress, and if it exists and is finished, the result satisfies the supplied condition

An example use case is if your job involves IO. In this case, your work function could return a Result, and the condition supplied to this function would be Result::is_err.

If you want to avoid starting a new job if one with the same input has already finished, use Employer::start.

pub fn remove<Q>(&self, input: &Q) where
    Q: Hash + Ord,
    K: Borrow<Q>, 

Remove a finished job with the given input

Trait Implementations

impl<K, V, D> Debug for Employer<K, V, D>

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

Formats the value using the given formatter.

impl<K, V, D> Default for Employer<K, V, D> where
    D: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<K, V, D> From<D> for Employer<K, V, D>

fn from(desc: D) -> Self

Performs the conversion.

impl<K, V, D> From<Employer<K, V, D>> for Arc<D>

fn from(employer: Employer<K, V, D>) -> Self

Performs the conversion.

impl<'a, K, V, H> IntoIterator for &'a Employer<K, V, H>

type Item = JobGuard<'a, K, V>

The type of the elements being iterated over.

type IntoIter = JobIter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.