Struct AssetResult 

pub struct AssetResult<A> { /* private fields */ }

Implementations

impl<A> AssetResult<A>

where A: Asset,

pub fn build_optional<B>( &mut self, builder: &mut B, ) -> Result<Option<&A>, Error>

where A: AssetBuild<B>,

Builds and returns asset. Returns Err if asset decoding or build errors. Returns Ok(None) if asset is not found.

pub fn build<B>(&mut self, builder: &mut B) -> Result<&A, Error>

where A: AssetBuild<B>,

Builds and returns asset. Returns Err if asset decoding or build errors or if asset is not found.

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(())
}

pub fn get_optional(&mut self) -> Result<Option<&A>, Error>

where A: TrivialAssetBuild,

Returns asset. Returns Err if asset decoding or build errors. This function is only usable for TrivialAssetBuild implementors. All TrivialAssets implement TrivialAssetBuild.

pub fn get(&mut self) -> Result<&A, Error>

where A: TrivialAssetBuild,

Returns asset. Returns Err if asset decoding or build errors or if asset is not found. This function is only usable for TrivialAssetBuild implementors. All TrivialAssets implement TrivialAssetBuild.