Enum fyrox_resource::ResourceState

pub enum ResourceState<T, E> where
    T: ResourceData,
    E: ResourceLoadError,  {
    Pending {
        path: PathBuf,
        wakers: Vec<Waker>,
    },
    LoadError {
        path: PathBuf,
        error: Option<Arc<E>>,
    },
    Ok(T),
}

Resource could be in three possible states:

1. Pending - it is loading.
2. LoadError - an error has occurred during the load.
3. Ok - resource is fully loaded and ready to use.

Why it is so complex? Short answer: asynchronous loading. Long answer: when you loading a scene you expect it to be loaded as fast as possible, use all available power of the CPU. To achieve that each resource ideally should be loaded on separate core of the CPU, but since this is asynchronous, we must have the ability to track the state of the resource.

Variants

Pending

Fields

path: PathBuf

A path to load resource from.

wakers: Vec<Waker>

List of wakers to wake future when resource is fully loaded.

Resource is loading from external resource or in the queue to load.

LoadError

Fields

path: PathBuf

A path at which it was impossible to load the resource.

error: Option<Arc<E>>

An error. This wrapped in Option only to be Default_ed.

An error has occurred during the load.

Ok(T)

Actual resource data when it is fully loaded.

Implementations

impl<T: ResourceData, E: ResourceLoadError> ResourceState<T, E>

pub fn new_pending(path: PathBuf) -> Self

Creates new resource in pending state.

pub fn switch_to_pending_state(&mut self)

Switches the internal state of the resource to ResourceState::Pending.

pub fn path(&self) -> Cow<'_, Path>

Returns a path to the resource source.

pub fn commit(&mut self, state: ResourceState<T, E>)

Changes ResourceState::Pending state to ResourceState::Ok(data) with given data. Additionally it wakes all futures.

pub fn commit_ok(&mut self, data: T)

Changes internal state to ResourceState::Ok

pub fn commit_error(&mut self, path: PathBuf, error: E)

Changes internal state to ResourceState::LoadError.

Trait Implementations

impl<T: Debug, E: Debug> Debug for ResourceState<T, E> where
    T: ResourceData,
    E: ResourceLoadError, 

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

Formats the value using the given formatter.

impl<T: ResourceData, E: ResourceLoadError> Default for ResourceState<T, E>

fn default() -> Self

Returns the “default value” for a type.

impl<T, E> Visit for ResourceState<T, E> where
    T: ResourceData,
    E: ResourceLoadError, 

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult