Struct Fetcher 

pub struct Fetcher<I: Send + 'static, O> { /* private fields */ }

A value factory that uses the result of an asynchronous task to compute an output value.

The fetcher takes a task and a factory function. It produces an output value O by taking an Option of an input value I.

If the inner Task is not ready yet, the factory will be called with None. Once the inner Task is ready, the factory will be called with Some(I).

This is similar to the FutureBuilder from Flutter.

Implementations

impl<I: Send + 'static, O> Fetcher<I, O>

pub const fn new( task: Box<dyn Task<I>>, factory: Box<dyn Fn(Option<I>) -> O + 'static>, ) -> Self

Create a new task fetcher with the given task and factory function.

pub fn spawn( future: impl Future<Output = I> + Send + 'static, factory: impl Fn(Option<I>) -> O + 'static, ) -> Self

Spawn a future using the TaskRunner and create a new Fetcher with the resulting task and the given factory function.

If you want to spawn a blocking task, use Fetcher::spawn_blocking instead.

pub fn spawn_blocking( func: impl Fn() -> I + Send + 'static, factory: impl Fn(Option<I>) -> O + 'static, ) -> Self

Spawn a blocking function using the TaskRunner and create a new Fetcher with the resulting task and the given factory function.

If your task is non-blocking (a simple future), use Fetcher::spawn instead.

pub const fn value_mut(&mut self) -> Option<&mut O>

Returns a mutable reference to the possible output value.

This is mostly used internally and will return the cached output value.

pub const fn value_ref(&self) -> Option<&O>

Returns a reference to the possible output value.

This is mostly used internally and will return the cached output value.

pub fn is_ready(&self) -> bool

Returns whether the inner task is ready.

NOTE: This will only return true, if the inner task has finished, but the value has not been consumed yet.

pub const fn is_fetched(&self) -> bool

Returns whether the inner task has finished and the value has been computed.

pub fn compute(&mut self)

Computes the output value from the inner task.

If the inner task is not ready, the factory function will be called with None. Otherwise, it will be called with Some(I).

pub fn fetch(&mut self) -> &mut O

Fetches the output value and returns a mutable reference.

This will only actually compute the value, if the task is not fully finished yet, so it’s safe to call, even if the task is already done.