assets 0.3.0

asynchronous asset management
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

use std::fmt;
use std::sync::Arc;

use super::{Asset, Export, Exporter, Handle, Import, Importer};

pub enum Event<A, L, S>
where
    A: Asset,
    L: Importer<Output = <A as Import>::Input>,
    S: Exporter<Input = <A as Export>::Output>,
{
    Load(Handle<A>),
    Save(Handle<A>),
    Reimport(Handle<A>),
    Remove(Handle<A>, Arc<A>),
    ExportError(Handle<A>, <A as Export>::Error),
    ImportError(Handle<A>, <A as Import>::Error),
    LoadError(Handle<A>, L::Error),
    SaveError(Handle<A>, S::Error),
}

unsafe impl<A, L, S> Send for Event<A, L, S>
where
    A: Asset,
    L: Importer<Output = <A as Import>::Input>,
    S: Exporter<Input = <A as Export>::Output>,
{}
unsafe impl<A, L, S> Sync for Event<A, L, S>
where
    A: Asset,
    L: Importer<Output = <A as Import>::Input>,
    S: Exporter<Input = <A as Export>::Output>,
{}

impl<A, L, S> fmt::Debug for Event<A, L, S>
where
    A: fmt::Debug + Asset,
    <A as Export>::Error: fmt::Debug,
    <A as Import>::Error: fmt::Debug,
    L: Importer<Output = <A as Import>::Input>,
    L::Error: fmt::Debug,
    S: Exporter<Input = <A as Export>::Output>,
    S::Error: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            &Event::Load(ref handle) => f.debug_tuple("Load").field(handle).finish(),
            &Event::Save(ref handle) => f.debug_tuple("Save").field(handle).finish(),
            &Event::Reimport(ref handle) => f.debug_tuple("Reimport").field(handle).finish(),
            &Event::Remove(ref handle, ref asset) => {
                f.debug_tuple("Remove").field(handle).field(asset).finish()
            }
            &Event::ExportError(ref handle, ref export_error) => f
                .debug_tuple("ExportError")
                .field(&handle)
                .field(export_error)
                .finish(),
            &Event::ImportError(ref handle, ref import_error) => f
                .debug_tuple("ImportError")
                .field(&handle)
                .field(import_error)
                .finish(),
            &Event::LoadError(ref handle, ref load_error) => f
                .debug_tuple("LoadError")
                .field(&handle)
                .field(load_error)
                .finish(),
            &Event::SaveError(ref handle, ref save_error) => f
                .debug_tuple("SaveError")
                .field(&handle)
                .field(save_error)
                .finish(),
        }
    }
}