Enum LoadingState 

pub enum LoadingState<T> {
    Loading,
    Ready(T),
}

Represents the loading state of an async resource.

Use this as your Query::Output type when the query needs to load data asynchronously (e.g., file I/O, network requests).

Example

struct LoadFile { path: PathBuf }

impl Query for LoadFile {
    type CacheKey = PathBuf;
    type Output = LoadingState<String>;

    fn query(&self, ctx: &mut QueryContext) -> Result<Self::Output, QueryError> {
        // Check if already loaded
        if let Some(content) = ctx.get_loaded(&self.path) {
            return Ok(LoadingState::Ready(content));
        }

        // Spawn background loader
        ctx.spawn_loader(self.cache_key(), async {
            tokio::fs::read_to_string(&self.path).await.unwrap()
        });

        Err(QueryError::Suspend)
    }
}

Variants

Loading

Resource is still loading.

Ready(T)

Resource is ready with the given value.

Implementations

impl<T> LoadingState<T>

pub fn is_loading(&self) -> bool

Check if the resource is still loading.

pub fn is_ready(&self) -> bool

Check if the resource is ready.

pub fn get(&self) -> Option<&T>

Get the value if ready, None if loading.

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

Get the value if ready, None if loading (consuming version).

pub fn suspend(self) -> Result<T, QueryError>

Convert to Result - Loading becomes Err(QueryError::Suspend).

Use this with the ? operator to propagate loading state upward.

Example

fn query(&self, ctx: &mut QueryContext) -> Result<MyOutput, QueryError> {
    let data = ctx.query(LoadData { id: self.id })?.suspend()?;
    // `data` is guaranteed to be ready here
    Ok(process(data))
}

pub fn suspend_ref(&self) -> Result<&T, QueryError>

Reference version of suspend.

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> LoadingState<U>

Map the inner value if ready.

pub fn and_then<U, F: FnOnce(T) -> LoadingState<U>>( self, f: F, ) -> LoadingState<U>

Flat map the inner value if ready.

Trait Implementations

impl<T: Clone> Clone for LoadingState<T>

fn clone(&self) -> LoadingState<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for LoadingState<T>

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

Formats the value using the given formatter.

impl<T> Default for LoadingState<T>

fn default() -> LoadingState<T>

Returns the “default value” for a type.

impl<T> From<Option<T>> for LoadingState<T>

fn from(opt: Option<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for LoadingState<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for LoadingState<T>

fn eq(&self, other: &LoadingState<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for LoadingState<T>

impl<T> StructuralPartialEq for LoadingState<T>