Struct Loader 

pub struct Loader { /* private fields */ }

Virtual storage for all available assets.

Implementations

impl Loader

pub fn builder() -> LoaderBuilder

Returns LoaderBuilder instance

Examples found in repository

examples/proc.rs (line 157)

async fn run() -> Result<(), Box<dyn std::error::Error>> {
    // Fill map.
    let source = HashMapSource(
        vec![
            (
                AssetId::new(2).unwrap(),
                b"null".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(3).unwrap(),
                b"{\"field\": {}}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(4).unwrap(),
                b"{\"a\": 3}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(5).unwrap(),
                b"{\"c\": {\"a\": 2}, \"a\": 3}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(6).unwrap(),
                b"{\"wrapped\": 42}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(7).unwrap(),
                b"{\"a\": 6}".to_vec().into_boxed_slice(),
            ),
            (AssetId::new(8).unwrap(), b"{}".to_vec().into_boxed_slice()),
        ]
        .into_iter()
        .collect(),
    );

    let loader = Loader::builder().with(source).build();

    let _: &UnitAsset = loader.load("2").await.build(&mut ())?;
    println!("UnitAsset loaded");

    let _: &SimpleAsset = loader.load("3").await.build(&mut ())?;
    println!("SimpleAsset loaded");

    let _: &TwoLevelAsset = loader.load("4").await.build(&mut ())?;
    println!("TwoLevelAsset loaded");

    let _: &ComplexAsset = loader.load("5").await.build(&mut ())?;
    println!("ComplexAsset loaded");

    let _: &WrapperAsset = loader.load("6").await.build(&mut ())?;
    println!("WrapperAsset loaded");

    let _: &AssetWithWrapper = loader.load("7").await.build(&mut ())?;
    println!("AssetWithWrapper loaded");

    let _: &AssetWithSerdeAttribute = loader.load("8").await.build(&mut ())?;
    println!("AssetWithSerdeAttribute loaded");

    let _: &AssetWithOption = loader.load("8").await.build(&mut ())?;
    println!("AssetWithOption loaded");

    Ok(())
}

pub fn load_typed<A>(&self, id: TypedAssetId<A>) -> AssetHandle<A>

where A: Asset,

Load asset with specified id and returns handle that can be used to access assets once it is loaded.

If asset was previously requested it will not be re-loaded, but handle to shared state will be returned instead, even if first load was not successful or different format was used.

pub fn load<'a, A, K>(&self, key: K) -> AssetHandle<A>

where A: Asset, K: Into<Key<'a>>,

Load asset with specified key (path or id) and returns handle that can be used to access assets once it is loaded.

If asset was previously requested it will not be re-loaded, but handle to shared state will be returned instead, even if first load was not successful or different format was used.

Examples found in repository

examples/proc.rs (line 159)

async fn run() -> Result<(), Box<dyn std::error::Error>> {
    // Fill map.
    let source = HashMapSource(
        vec![
            (
                AssetId::new(2).unwrap(),
                b"null".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(3).unwrap(),
                b"{\"field\": {}}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(4).unwrap(),
                b"{\"a\": 3}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(5).unwrap(),
                b"{\"c\": {\"a\": 2}, \"a\": 3}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(6).unwrap(),
                b"{\"wrapped\": 42}".to_vec().into_boxed_slice(),
            ),
            (
                AssetId::new(7).unwrap(),
                b"{\"a\": 6}".to_vec().into_boxed_slice(),
            ),
            (AssetId::new(8).unwrap(), b"{}".to_vec().into_boxed_slice()),
        ]
        .into_iter()
        .collect(),
    );

    let loader = Loader::builder().with(source).build();

    let _: &UnitAsset = loader.load("2").await.build(&mut ())?;
    println!("UnitAsset loaded");

    let _: &SimpleAsset = loader.load("3").await.build(&mut ())?;
    println!("SimpleAsset loaded");

    let _: &TwoLevelAsset = loader.load("4").await.build(&mut ())?;
    println!("TwoLevelAsset loaded");

    let _: &ComplexAsset = loader.load("5").await.build(&mut ())?;
    println!("ComplexAsset loaded");

    let _: &WrapperAsset = loader.load("6").await.build(&mut ())?;
    println!("WrapperAsset loaded");

    let _: &AssetWithWrapper = loader.load("7").await.build(&mut ())?;
    println!("AssetWithWrapper loaded");

    let _: &AssetWithSerdeAttribute = loader.load("8").await.build(&mut ())?;
    println!("AssetWithSerdeAttribute loaded");

    let _: &AssetWithOption = loader.load("8").await.build(&mut ())?;
    println!("AssetWithOption loaded");

    Ok(())
}

Trait Implementations

impl Clone for Loader

fn clone(&self) -> Loader

Returns a duplicate of the value.

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

Performs copy-assignment from source.