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

use std::sync::Arc;

use crate::AssetId;

use {
    super::asset::Asset,
    std::{
        any::TypeId,
        hash::{Hash, Hasher},
    },
};

#[derive(Clone, PartialEq, Eq, Hash)]
pub struct IdKey {
    pub type_id: TypeId,
    pub id: AssetId,
}

impl IdKey {
    pub fn new<A: Asset>(asset: AssetId) -> Self {
        IdKey {
            type_id: TypeId::of::<A>(),
            id: asset,
        }
    }

    pub fn eq_key<A: Asset>(&self, asset: AssetId) -> bool {
        self.type_id == TypeId::of::<A>() && self.id == asset
    }
}

pub fn hash_id_key<A, H>(id: AssetId, state: &mut H)
where
    A: Asset,
    H: Hasher,
{
    TypeId::of::<A>().hash(state);
    id.hash(state);
}

#[derive(Clone, PartialEq, Eq, Hash)]
pub struct PathKey {
    pub type_id: TypeId,
    pub path: Arc<str>,
}

impl PathKey {
    pub fn new<A: Asset>(asset: Arc<str>) -> Self {
        PathKey {
            type_id: TypeId::of::<A>(),
            path: asset,
        }
    }

    pub fn eq_key<A: Asset>(&self, asset: &str) -> bool {
        self.type_id == TypeId::of::<A>() && *self.path == *asset
    }
}

pub fn hash_path_key<A, H>(path: &str, state: &mut H)
where
    A: Asset,
    H: Hasher,
{
    TypeId::of::<A>().hash(state);
    path.hash(state);
}