Struct Executor

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

An Executor runs a function in some Context (this will usually be a thread)

This is similar to std::thread::JoinHandle, though it always will yield an Arc<T> instead This allows the Executor to be stored itself, and accesses via Executor::result() are a cheap arc clone instead of requiring moves. Of course, using Executor::take(), you can still grab the inner data if its available.

Implementations

impl<T> Executor<T>

where T: Send + Sync + 'static,

pub fn new<E, F>(e: E, f: F) -> Self

where F: FnOnce() -> T + Send + 'static, E: Context,

Run f in the Execution context _e, creating an Executor

Arguments

• e: The context to run on. For StdContext or RayonGlobalContext you can just use ::default(), they are stateless.
• f: The function to run. f must be FnOnce + Send + 'static - as if you would pass it to std::thread::spawn

pub fn is_done(&self) -> bool

Returns true if the function passed into Executor::new() has completed

pub fn result(&self) -> Option<Arc<T>>

Returns Some(Arc<T>) if the function passed into Execute::new() has completed, or None otherwise

pub fn take_result(self) -> Option<T>

Consumes this Executor, returning either Some(T) if the executor has completed, or None if it has not.

There is no way for the work function if you you unsuccessfully tried to take the data. It will run to its end. There is no way to retrieve this data as well. So you probably only want to only `Executor::take()` if `Executor::is_done()` returnd true before.