Struct assets_manager::Handle

pub struct Handle<'a, T> { /* private fields */ }

A handle on an asset.

Such a handle can be used to get access to an asset of type A. It is generally obtained by call AssetCache::load and its variants.

If feature hot-reloading is used, this structure wraps a RwLock, so assets can be written to be reloaded. As such, any number of read guard can exist at the same time, but none can exist while reloading an asset (when calling AssetCache::hot_reload).

This is the structure you want to use to store a reference to an asset. However it is generally easier to work with 'static data. For more information, see top-level documentation.

Implementations

impl<'a, T> Handle<'a, T>

pub fn read(&self) -> AssetGuard<'a, T>

Locks the pointed asset for reading.

If T implements NotHotReloaded or if hot-reloading is disabled, no reloading can occur so there is no actual lock. In these cases, calling this function is cheap and do not involve synchronisation.

Returns a RAII guard which will release the lock once dropped.

pub fn id(&self) -> &'a SharedString

Returns the id of the asset.

Note that the lifetime of the returned &str is tied to that of the AssetCache, so it can outlive the handle.

pub fn reload_watcher(&self) -> ReloadWatcher<'a>

Returns a ReloadWatcher that can be used to check whether this asset was reloaded.

Example

use assets_manager::{Asset, AssetCache, ReloadWatcher};

let cache = AssetCache::new("assets")?;
let asset = cache.load::<String>("common.some_text")?;
let mut watcher = asset.reload_watcher();

// The handle has just been created, so `reloaded` returns false
assert!(!watcher.reloaded());

loop {
    cache.hot_reload();

    if watcher.reloaded() {
        println!("The asset was reloaded !")
    }

    // Calling `reloaded` once more returns false: the asset has not
    // been reloaded since last call to `reloaded`
    assert!(!watcher.reloaded());
}

pub fn last_reload_id(&self) -> ReloadId

Returns the last ReloadId associated with this asset.

It is only meaningful when compared to other ReloadIds returned by the same handle.

pub fn reloaded_global(&self) -> bool

Returns true if the asset has been reloaded since last call to this method with any handle on this asset.

Note that this method and reload_watcher are totally independant, and the result of the two functions do not depend on whether the other was called.

pub fn same_handle(&self, other: &Self) -> bool

Checks if the two handles refer to the same asset.

impl<'a, A> Handle<'a, A>where
    A: NotHotReloaded,

pub fn get(&self) -> &'a A

Returns a reference to the underlying asset.

This method only works if hot-reloading is disabled for the given type.

impl<A> Handle<'_, A>where
    A: Copy,

pub fn copied(self) -> A

Returns a copy of the inner asset.

This is functionnally equivalent to cloned, but it ensures that no expensive operation is used (eg if a type is refactored).

impl<A> Handle<'_, A>where
    A: Clone,

pub fn cloned(self) -> A

Returns a clone of the inner asset.

Trait Implementations

impl<A> Clone for Handle<'_, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Debug for Handle<'_, A>where
    A: Debug,

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

Formats the value using the given formatter.

impl<T, U> PartialEq<Handle<'_, U>> for Handle<'_, T>where
    T: PartialEq<U>,

fn eq(&self, other: &Handle<'_, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<A> Serialize for Handle<'_, A>where
    A: Serialize,

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<A> Copy for Handle<'_, A>

impl<A> Eq for Handle<'_, A>where
    A: Eq,