Enum ResourceState 

pub enum ResourceState {
    Unloaded,
    Pending {
        wakers: WakersList,
    },
    LoadError {
        path: PathBuf,
        error: LoadError,
    },
    Ok {
        data: ResourceDataWrapper,
    },
}

Resource could be in three possible states (a small state machine):

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

Why is it so complex?

Short answer: asynchronous loading. Long answer: when you’re 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 be able to track the state of the resource.

Path

Resources do not store their paths to respective files in the file system, instead resource only stores their unique identifiers (UUID). Use crate::registry::ResourceRegistry to get a path associated with the resource uuid.

UUID

Resource UUID is available only if the resource is fully loaded. This is because there’s no way to get the UUID earlier: the UUID is stored in a metadata file which exists only if the resource is present. It is somewhat possible to get a UUID when a resource is failed to load, but not in 100% cases.

Variants

Unloaded

Resource is not loaded. In some situations, having a handle to a resource can be sufficient even without the resource’s data.

Pending

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

Fields

wakers: WakersList

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

LoadError

An error has occurred during the load.

Fields

path: PathBuf

A resource path, it is stored only to be able to reload the resources that failed to load previously.

error: LoadError

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

Ok

Actual resource data when it is fully loaded.

Fields

data: ResourceDataWrapper

Actual data of the resource.

Implementations

impl ResourceState

pub const PENDING_WAKERS: &'static str = "Pending@wakers"

pub const LOAD_ERROR_PATH: &'static str = "LoadError@path"

pub const LOAD_ERROR_ERROR: &'static str = "LoadError@error"

pub const OK_DATA: &'static str = "Ok@data"

impl ResourceState

pub fn new_pending() -> ResourceState

Creates new resource in pending state.

pub fn new_load_error(path: PathBuf, error: LoadError) -> ResourceState

Creates new resource in error state.

pub fn new_ok<T>(data: T) -> ResourceState

where T: ResourceData,

Creates new resource in ResourceState::Ok state.

pub fn new_ok_untyped(data: Box<dyn ResourceData>) -> ResourceState

Creates a new resource in ResourceState::Ok state using arbitrary data.

pub fn is_loading(&self) -> bool

Checks whether the resource is still loading or not.

pub fn is_ok(&self) -> bool

Checks whether the resource is loaded without errors.

pub fn switch_to_pending_state(&mut self)

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

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.

pub fn data_ref(&self) -> Option<&ResourceDataWrapper>

Tries to get the resource data. Will fail if the resource is not in ResourceState::Ok.

pub fn data_mut(&mut self) -> Option<&mut ResourceDataWrapper>

Tries to get the resource data. Will fail if the resource is not in ResourceState::Ok.

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

where T: TypedResourceData,

Tries to get the resource data of the given type. Will fail if the resource is not in ResourceState::Ok.

pub fn data_mut_of_type<T>(&mut self) -> Option<&mut T>

where T: TypedResourceData,

Tries to get the resource data of the given type. Will fail if the resource is not in ResourceState::Ok.

Trait Implementations

impl Clone for ResourceState

fn clone(&self) -> ResourceState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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 Display for ResourceState

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

Formats the value using the given formatter.

impl Drop for ResourceState

fn drop(&mut self)

Executes the destructor for this type.

impl Reflect for ResourceState

where ResourceState: 'static,

fn source_path() -> &'static str

fn try_clone_box(&self) -> Option<Box<dyn Reflect>>

fn type_name(&self) -> &'static str

fn derived_types() -> &'static [TypeId]

fn query_derived_types(&self) -> &'static [TypeId]

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_ref(&self, func: &mut dyn FnMut(&[FieldRef<'_, '_>]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [FieldMut<'_, '_>]))

fn into_any(self: Box<ResourceState>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn set_field( &mut self, field_name: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, SetFieldError>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

fn as_handle( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHandle + 'static)>), )

fn as_handle_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHandle + 'static)>), )