Enum Fetch 

pub enum Fetch<T> {
    Ready(T),
    Pending(BoxFuture<'static, T>),
}

An in-progress request to fetch some data.

A Fetch represents the period of uncertainty after some data has been requested, before it is known whether that data exists locally or must be retrieved from an external source (or whether we must wait for the data to be created in the first place).

For data that is already available locally, a request for that data may return Fetch::Ready with the data itself. Otherwise, the request will return Fetch::Pending with a future that will resolve once the data is available.

Depending on the context, Fetch can behave a bit like a Future or a bit like a Result. Therefore, it implements IntoFuture, so it can be awaited (this is the same as calling resolve) and it implements methods context and with_context, which make it easy to convert a Fetch to a Result, mimicking the methods from Snafu traits OptionExt and ResultExt.

Variants

Ready(T)

Pending(BoxFuture<'static, T>)

Implementations

impl<T> Fetch<T>

pub fn try_resolve(self) -> Result<T, Self>

Get the requested data if it is available immediately.

If the requested data is not immediately available, Err(self) is returned so that the Fetch object may be used again.

pub fn context<C, E>(self, context: C) -> Result<T, E>

where C: IntoError<E, Source = NoneError>, E: Error + ErrorCompat,

Convert this Fetch to a Result with the provided error context.

The result indicates whether the requested data is immediately available. If it is, Ok is returned. Otherwise, an error is created from context using Snafu.

pub fn with_context<F, C, E>(self, context: F) -> Result<T, E>

where F: FnOnce() -> C, C: IntoError<E, Source = NoneError>, E: Error + ErrorCompat,

Convert this Fetch to a Result with the provided error context.

The result indicates whether the requested data is immediately available. If it is, Ok is returned. Otherwise, an error is created from context using Snafu.

pub fn is_pending(&self) -> bool

Does this fetch represent an unresolved query?

pub async fn then_fetch<Fut, R>( self, f: impl Send + FnOnce(&T) -> Fut + 'static, ) -> Fetch<(T, R)>

where Fut: Send + Future<Output = Fetch<R>>, T: Send + 'static, R: Send + 'static,

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

pub async fn resolve(self) -> T

Wait for the data to become available, if it is not already.

pub async fn with_timeout(self, timeout_duration: Duration) -> Option<T>

Wait for the requested data to become available, but only for up to timeout.

This function is similar to resolve, but if the future does not resolve within timeout, then with_timeout will resolve with None.

impl<T: 'static> Fetch<T>

pub fn map<F, U>(self, f: F) -> Fetch<U>

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

Transform the result of this fetch.

If the requested data is already available, f will be applied immediately. Otherwise, f will be saved and applied after the pending future resolves.

Trait Implementations

impl<T: Send + 'static> IntoFuture for Fetch<T>

type Output = T

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <Fetch<T> as IntoFuture>::Output> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.