1use crate::{
2 Mappable,
3 MerkleRoot,
4 MerkleRootStorage,
5 StorageInspect,
6 StorageMut,
7 StorageMutate,
8 StorageRead,
9 StorageReadError,
10 StorageRef,
11 StorageSize,
12 StorageWrite,
13};
14use alloc::{
15 borrow::Cow,
16 vec::Vec,
17};
18
19impl<T: StorageInspect<Type> + ?Sized, Type: Mappable> StorageInspect<Type> for &'_ T {
20 type Error = T::Error;
21
22 fn get(
23 &self,
24 key: &Type::Key,
25 ) -> Result<Option<Cow<'_, Type::OwnedValue>>, Self::Error> {
26 <T as StorageInspect<Type>>::get(self, key)
27 }
28
29 fn contains_key(&self, key: &Type::Key) -> Result<bool, Self::Error> {
30 <T as StorageInspect<Type>>::contains_key(self, key)
31 }
32}
33
34impl<T: StorageInspect<Type> + ?Sized, Type: Mappable> StorageInspect<Type>
35 for &'_ mut T
36{
37 type Error = T::Error;
38
39 fn get(
40 &self,
41 key: &Type::Key,
42 ) -> Result<Option<Cow<'_, Type::OwnedValue>>, Self::Error> {
43 <T as StorageInspect<Type>>::get(self, key)
44 }
45
46 fn contains_key(&self, key: &Type::Key) -> Result<bool, Self::Error> {
47 <T as StorageInspect<Type>>::contains_key(self, key)
48 }
49}
50
51impl<T: StorageMutate<Type> + ?Sized, Type: Mappable> StorageMutate<Type> for &'_ mut T {
52 fn insert(
53 &mut self,
54 key: &Type::Key,
55 value: &Type::Value,
56 ) -> Result<(), Self::Error> {
57 <T as StorageMutate<Type>>::insert(self, key, value)
58 }
59
60 fn replace(
61 &mut self,
62 key: &Type::Key,
63 value: &Type::Value,
64 ) -> Result<Option<Type::OwnedValue>, Self::Error> {
65 <T as StorageMutate<Type>>::replace(self, key, value)
66 }
67
68 fn remove(&mut self, key: &Type::Key) -> Result<(), Self::Error> {
69 <T as StorageMutate<Type>>::remove(self, key)
70 }
71
72 fn take(&mut self, key: &Type::Key) -> Result<Option<Type::OwnedValue>, Self::Error> {
73 <T as StorageMutate<Type>>::take(self, key)
74 }
75}
76
77impl<T: StorageSize<Type> + ?Sized, Type: Mappable> StorageSize<Type> for &'_ T {
78 fn size_of_value(
79 &self,
80 key: &<Type as Mappable>::Key,
81 ) -> Result<Option<usize>, Self::Error> {
82 <T as StorageSize<Type>>::size_of_value(self, key)
83 }
84}
85
86impl<T: StorageSize<Type> + ?Sized, Type: Mappable> StorageSize<Type> for &'_ mut T {
87 fn size_of_value(
88 &self,
89 key: &<Type as Mappable>::Key,
90 ) -> Result<Option<usize>, Self::Error> {
91 <T as StorageSize<Type>>::size_of_value(self, key)
92 }
93}
94
95impl<T: StorageRead<Type> + StorageSize<Type> + ?Sized, Type: Mappable> StorageRead<Type>
96 for &'_ T
97{
98 fn read_exact(
99 &self,
100 key: &<Type as Mappable>::Key,
101 offset: usize,
102 buf: &mut [u8],
103 ) -> Result<Result<usize, StorageReadError>, Self::Error> {
104 <T as StorageRead<Type>>::read_exact(self, key, offset, buf)
105 }
106
107 fn read_zerofill(
108 &self,
109 key: &<Type as Mappable>::Key,
110 offset: usize,
111 buf: &mut [u8],
112 ) -> Result<Result<usize, StorageReadError>, Self::Error> {
113 <T as StorageRead<Type>>::read_zerofill(self, key, offset, buf)
114 }
115
116 fn read_alloc(
117 &self,
118 key: &<Type as Mappable>::Key,
119 ) -> Result<Option<alloc::vec::Vec<u8>>, Self::Error> {
120 <T as StorageRead<Type>>::read_alloc(self, key)
121 }
122}
123
124impl<T: StorageRead<Type> + StorageSize<Type> + ?Sized, Type: Mappable> StorageRead<Type>
125 for &'_ mut T
126{
127 fn read_exact(
128 &self,
129 key: &<Type as Mappable>::Key,
130 offset: usize,
131 buf: &mut [u8],
132 ) -> Result<Result<usize, StorageReadError>, Self::Error> {
133 <T as StorageRead<Type>>::read_exact(self, key, offset, buf)
134 }
135
136 fn read_zerofill(
137 &self,
138 key: &<Type as Mappable>::Key,
139 offset: usize,
140 buf: &mut [u8],
141 ) -> Result<Result<usize, StorageReadError>, Self::Error> {
142 <T as StorageRead<Type>>::read_zerofill(self, key, offset, buf)
143 }
144
145 fn read_alloc(
146 &self,
147 key: &<Type as Mappable>::Key,
148 ) -> Result<Option<alloc::vec::Vec<u8>>, Self::Error> {
149 <T as StorageRead<Type>>::read_alloc(self, key)
150 }
151}
152
153impl<T: StorageWrite<Type> + ?Sized, Type: Mappable> StorageWrite<Type> for &'_ mut T {
154 fn write_bytes(&mut self, key: &Type::Key, buf: &[u8]) -> Result<(), Self::Error> {
155 <T as StorageWrite<Type>>::write_bytes(self, key, buf)
156 }
157
158 fn replace_bytes(
159 &mut self,
160 key: &Type::Key,
161 buf: &[u8],
162 ) -> Result<Option<Vec<u8>>, Self::Error> {
163 <T as StorageWrite<Type>>::replace_bytes(self, key, buf)
164 }
165
166 fn take_bytes(&mut self, key: &Type::Key) -> Result<Option<Vec<u8>>, Self::Error> {
167 <T as StorageWrite<Type>>::take_bytes(self, key)
168 }
169}
170
171impl<T: MerkleRootStorage<Key, Type> + ?Sized, Key, Type: Mappable>
172 MerkleRootStorage<Key, Type> for &'_ T
173{
174 fn root(&self, key: &Key) -> Result<MerkleRoot, Self::Error> {
175 <T as MerkleRootStorage<Key, Type>>::root(self, key)
176 }
177}
178
179impl<T: MerkleRootStorage<Key, Type> + ?Sized, Key, Type: Mappable>
180 MerkleRootStorage<Key, Type> for &'_ mut T
181{
182 fn root(&self, key: &Key) -> Result<MerkleRoot, Self::Error> {
183 <T as MerkleRootStorage<Key, Type>>::root(self, key)
184 }
185}
186
187impl<'a, T: StorageInspect<Type>, Type: Mappable> StorageRef<'a, T, Type> {
188 #[inline(always)]
189 pub fn get(
190 self,
191 key: &Type::Key,
192 ) -> Result<Option<Cow<'a, Type::OwnedValue>>, T::Error> {
193 self.0.get(key)
194 }
195
196 #[inline(always)]
197 pub fn contains_key(self, key: &Type::Key) -> Result<bool, T::Error> {
198 self.0.contains_key(key)
199 }
200}
201
202impl<T, Type: Mappable> StorageRef<'_, T, Type> {
203 #[inline(always)]
204 pub fn root<Key>(self, key: &Key) -> Result<MerkleRoot, T::Error>
205 where
206 T: MerkleRootStorage<Key, Type>,
207 {
208 self.0.root(key)
209 }
210}
211
212impl<T: StorageRead<Type>, Type: Mappable> StorageRef<'_, T, Type> {
213 #[inline(always)]
214 pub fn read_exact(
215 &self,
216 key: &<Type as Mappable>::Key,
217 offset: usize,
218 buf: &mut [u8],
219 ) -> Result<Result<usize, StorageReadError>, T::Error> {
220 self.0.read_exact(key, offset, buf)
221 }
222
223 #[inline(always)]
224 pub fn read_zerofill(
225 &self,
226 key: &<Type as Mappable>::Key,
227 offset: usize,
228 buf: &mut [u8],
229 ) -> Result<Result<usize, StorageReadError>, T::Error> {
230 self.0.read_zerofill(key, offset, buf)
231 }
232
233 #[inline(always)]
234 pub fn read_alloc(
235 &self,
236 key: &<Type as Mappable>::Key,
237 ) -> Result<Option<alloc::vec::Vec<u8>>, T::Error> {
238 self.0.read_alloc(key)
239 }
240}
241
242impl<'a, T: StorageInspect<Type>, Type: Mappable> StorageMut<'a, T, Type> {
243 #[inline(always)]
244 pub fn get(
245 self,
246 key: &Type::Key,
247 ) -> Result<Option<Cow<'a, Type::OwnedValue>>, T::Error> {
248 let self_: &'a T = self.0;
250 self_.get(key)
251 }
252
253 #[inline(always)]
254 pub fn contains_key(self, key: &Type::Key) -> Result<bool, T::Error> {
255 self.0.contains_key(key)
256 }
257}
258
259impl<T, Type> StorageMut<'_, T, Type>
260where
261 T: StorageMutate<Type>,
262 Type: Mappable,
263{
264 #[inline(always)]
265 pub fn insert(self, key: &Type::Key, value: &Type::Value) -> Result<(), T::Error> {
266 StorageMutate::insert(self.0, key, value)
267 }
268
269 #[inline(always)]
270 pub fn replace(
271 self,
272 key: &Type::Key,
273 value: &Type::Value,
274 ) -> Result<Option<Type::OwnedValue>, T::Error> {
275 StorageMutate::replace(self.0, key, value)
276 }
277
278 #[inline(always)]
279 pub fn remove(self, key: &Type::Key) -> Result<(), T::Error> {
280 StorageMutate::remove(self.0, key)
281 }
282
283 #[inline(always)]
284 pub fn take(self, key: &Type::Key) -> Result<Option<Type::OwnedValue>, T::Error> {
285 StorageMutate::take(self.0, key)
286 }
287}
288
289impl<T, Type: Mappable> StorageMut<'_, T, Type> {
290 #[inline(always)]
291 pub fn root<Key>(self, key: &Key) -> Result<MerkleRoot, T::Error>
292 where
293 T: MerkleRootStorage<Key, Type>,
294 {
295 self.0.root(key)
296 }
297}
298
299impl<T, Type> StorageMut<'_, T, Type>
300where
301 Type: Mappable,
302 T: StorageWrite<Type>,
303{
304 #[inline(always)]
305 pub fn write_bytes(&mut self, key: &Type::Key, buf: &[u8]) -> Result<(), T::Error> {
306 StorageWrite::write_bytes(self.0, key, buf)
307 }
308
309 #[inline(always)]
310 pub fn replace_bytes(
311 &mut self,
312 key: &Type::Key,
313 buf: &[u8],
314 ) -> Result<Option<Vec<u8>>, T::Error>
315 where
316 T: StorageSize<Type>,
317 {
318 StorageWrite::replace_bytes(self.0, key, buf)
319 }
320
321 #[inline(always)]
322 pub fn take_bytes(&mut self, key: &Type::Key) -> Result<Option<Vec<u8>>, T::Error> {
323 StorageWrite::take_bytes(self.0, key)
324 }
325}