goods 0.12.1

Async assets system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use std::{
    convert::Infallible,
    future::{ready, Ready},
};

use {
    crate::loader::Loader,
    std::{error::Error, future::Future},
};

/// An asset type that can be built from decoded representation.
pub trait Asset: Clone + Sized + Send + Sync + 'static {
    /// Decoded representation of this asset.
    type Decoded: Send + Sync;

    /// Decoding error.
    type DecodeError: Error + Send + Sync + 'static;

    /// Building error.
    type BuildError: Error + Send + Sync + 'static;

    /// Future that will resolve into decoded asset when ready.
    type Fut: Future<Output = Result<Self::Decoded, Self::DecodeError>> + Send;

    /// Asset name.
    fn name() -> &'static str;

    /// Decode asset from bytes loaded from asset source.
    fn decode(bytes: Box<[u8]>, loader: &Loader) -> Self::Fut;
}

/// Asset building trait.
/// Users should implement this trait for at least single choice of `B`.
/// But it is highly recommended to implement this trait for wide choices of `B` for improved composability.
/// Because composite asset will implement `AssetBuild<B>` only for such types `B` for which all components implement `AssetBuild<B>`.
///
/// For example, if a reference of type `T` is necessary to build the asset,
/// implementing `AssetBuild<B> where B: Borrow<T>` (or `BorrowMut<T>` if mutable reference is needed)
/// would be recommended.
pub trait AssetBuild<B>: Asset {
    /// Build asset instance using decoded representation and `Resources`.
    fn build(decoded: Self::Decoded, builder: &mut B) -> Result<Self, Self::BuildError>;
}

/// Simple assets have no dependencies.
/// For this reason their `decode` function is always sync and do not take `Loader` argument.
pub trait SimpleAsset: Asset {
    /// Decode asset synchronously.
    fn decode(bytes: Box<[u8]>) -> Result<Self::Decoded, Self::DecodeError>;
}

/// Trivial assets have no dependencies and do not require building.
/// They are decoded directly from bytes.
/// And thus they implement `AssetBuild<B>` for any `B`.
pub trait TrivialAsset: Clone + Sized + Send + Sync + 'static {
    type Error: Error + Send + Sync + 'static;

    /// Asset name.
    fn name() -> &'static str;

    /// Decode asset directly.
    fn decode(bytes: Box<[u8]>) -> Result<Self, Self::Error>;
}

impl<A> Asset for A
where
    A: TrivialAsset,
{
    type Decoded = A;
    type DecodeError = A::Error;
    type BuildError = Infallible;
    type Fut = Ready<Result<A, A::Error>>;

    /// Asset name.
    fn name() -> &'static str {
        <A as TrivialAsset>::name()
    }

    fn decode(bytes: Box<[u8]>, _: &Loader) -> Ready<Result<A, A::Error>> {
        ready(<A as SimpleAsset>::decode(bytes))
    }
}

impl<A> SimpleAsset for A
where
    A: TrivialAsset,
{
    fn decode(bytes: Box<[u8]>) -> Result<A, A::Error> {
        TrivialAsset::decode(bytes)
    }
}

impl<A, B> AssetBuild<B> for A
where
    A: TrivialAsset,
{
    fn build(decoded: A, _: &mut B) -> Result<A, Infallible> {
        Ok(decoded)
    }
}