gantz_ca 0.2.0

Content-addressing for gantz
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! A dedicated hash trait for constructing a content address.

/// The [`blake3`] hasher used for gantz' content addressing.
pub type Hasher = blake3::Hasher;

/// Types that can be hashed to produce a content address.
pub trait CaHash {
    /// Hash `self` to produce a stable content address.
    fn hash(&self, hasher: &mut Hasher);
}

impl CaHash for u8 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for u16 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for u32 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for u64 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for usize {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for i8 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for i16 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for i32 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for i64 {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl CaHash for isize {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self.to_be_bytes());
    }
}

impl<const N: usize> CaHash for [u8; N] {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self[..]);
    }
}

impl CaHash for str {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(self.as_bytes());
    }
}

impl CaHash for String {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(self.as_bytes());
    }
}

impl CaHash for [u8] {
    fn hash(&self, hasher: &mut Hasher) {
        hasher.update(&self[..]);
    }
}

impl<T> CaHash for Box<T>
where
    T: ?Sized + CaHash,
{
    fn hash(&self, hasher: &mut Hasher) {
        (**self).hash(hasher);
    }
}

impl<T> CaHash for std::rc::Rc<T>
where
    T: ?Sized + CaHash,
{
    fn hash(&self, hasher: &mut Hasher) {
        (**self).hash(hasher);
    }
}

impl<T> CaHash for std::sync::Arc<T>
where
    T: ?Sized + CaHash,
{
    fn hash(&self, hasher: &mut Hasher) {
        (**self).hash(hasher);
    }
}

impl<T> CaHash for Option<T>
where
    T: CaHash,
{
    fn hash(&self, hasher: &mut Hasher) {
        const NONE: u8 = 0;
        const SOME: u8 = 1;
        match self {
            None => {
                hasher.update(&[NONE]);
            }
            Some(t) => {
                hasher.update(&[SOME]);
                t.hash(hasher);
            }
        }
    }
}

impl CaHash for crate::ContentAddr {
    fn hash(&self, hasher: &mut Hasher) {
        self.0.hash(hasher);
    }
}