Enum fyrox::asset::state::ResourceState

pub enum ResourceState {
    Pending {
        path: PathBuf,
        wakers: Vec<Waker>,
        type_uuid: Uuid,
    },
    LoadError {
        path: PathBuf,
        error: Option<Arc<dyn ResourceLoadError>>,
        type_uuid: Uuid,
    },
    Ok(Box<dyn ResourceData>),
}

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.

type_uuid: Uuid

Unique type id of the resource.

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<dyn ResourceLoadError>>

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

type_uuid: Uuid

Unique type id of the resource.

An error has occurred during the load.

Ok(Box<dyn ResourceData>)

Actual resource data when it is fully loaded.

Implementations

impl ResourceState

pub fn new_pending(path: PathBuf, type_uuid: Uuid) -> ResourceState

Creates new resource in pending state.

pub fn new_load_error( path: PathBuf, error: Option<Arc<dyn ResourceLoadError>>, type_uuid: Uuid ) -> ResourceState

Creates new resource in error state.

pub fn new_ok<T>(data: T) -> ResourceStatewhere T: ResourceData,

Creates new resource in ok (resource with data) state.

pub fn is_loading(&self) -> bool

Checks whether the resource is still loading or not.

pub fn switch_to_pending_state(&mut self)

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

pub fn type_uuid(&self) -> Uuid

Returns unique type id of the resource.

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

Returns a path to the resource source.

pub fn commit(&mut self, state: ResourceState)

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

pub fn commit_ok<T>(&mut self, data: T)where T: ResourceData,

Changes internal state to ResourceState::Ok

pub fn commit_error<E>(&mut self, path: PathBuf, error: E)where E: ResourceLoadError,

Changes internal state to ResourceState::LoadError.

Trait Implementations

impl Debug for ResourceState

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

Formats the value using the given formatter.

impl Default for ResourceState

fn default() -> ResourceState

Returns the “default value” for a type.

impl Drop for ResourceState

fn drop(&mut self)

Executes the destructor for this type.

impl Visit for ResourceState

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>