musli_storage/
en.rs

1use core::fmt;
2
3use musli::en::{
4    Encode, Encoder, EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder,
5};
6use musli::hint::{MapHint, SequenceHint};
7use musli::Context;
8use musli_utils::{Options, Writer};
9
10/// A vaery simple encoder suitable for storage encoding.
11pub struct StorageEncoder<'a, W, const OPT: Options, C: ?Sized> {
12    cx: &'a C,
13    writer: W,
14}
15
16impl<'a, W, const OPT: Options, C: ?Sized> StorageEncoder<'a, W, OPT, C> {
17    /// Construct a new fixed width message encoder.
18    #[inline]
19    pub fn new(cx: &'a C, writer: W) -> Self {
20        Self { cx, writer }
21    }
22}
23
24#[musli::encoder]
25impl<'a, W, const OPT: Options, C> Encoder for StorageEncoder<'a, W, OPT, C>
26where
27    C: ?Sized + Context,
28    W: Writer,
29{
30    type Cx = C;
31    type Error = C::Error;
32    type Ok = ();
33    type Mode = C::Mode;
34    type WithContext<'this, U> = StorageEncoder<'this, W, OPT, U> where U: 'this + Context;
35    type EncodePack = StorageEncoder<'a, W, OPT, C>;
36    type EncodeSome = Self;
37    type EncodeSequence = Self;
38    type EncodeMap = Self;
39    type EncodeMapEntries = Self;
40    type EncodeVariant = Self;
41    type EncodeSequenceVariant = Self;
42    type EncodeMapVariant = Self;
43
44    #[inline]
45    fn cx(&self) -> &Self::Cx {
46        self.cx
47    }
48
49    #[inline]
50    fn with_context<U>(self, cx: &U) -> Result<Self::WithContext<'_, U>, C::Error>
51    where
52        U: Context,
53    {
54        Ok(StorageEncoder::new(cx, self.writer))
55    }
56
57    #[inline]
58    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
59        write!(f, "type supported by the storage encoder")
60    }
61
62    #[inline]
63    fn encode<T>(self, value: T) -> Result<Self::Ok, Self::Error>
64    where
65        T: Encode<Self::Mode>,
66    {
67        value.encode(self.cx, self)
68    }
69
70    #[inline]
71    fn encode_unit(self) -> Result<Self::Ok, C::Error> {
72        static HINT: SequenceHint = SequenceHint::with_size(0);
73        self.encode_sequence_fn(&HINT, |_| Ok(()))
74    }
75
76    #[inline]
77    fn encode_pack(self) -> Result<Self::EncodePack, C::Error> {
78        Ok(self)
79    }
80
81    #[inline]
82    fn encode_array<const N: usize>(mut self, array: &[u8; N]) -> Result<Self::Ok, C::Error> {
83        self.writer.write_bytes(self.cx, array)
84    }
85
86    #[inline]
87    fn encode_bytes(mut self, bytes: &[u8]) -> Result<Self::Ok, C::Error> {
88        musli_utils::int::encode_usize::<_, _, OPT>(
89            self.cx,
90            self.writer.borrow_mut(),
91            bytes.len(),
92        )?;
93        self.writer.write_bytes(self.cx, bytes)?;
94        Ok(())
95    }
96
97    #[inline]
98    fn encode_bytes_vectored<I>(mut self, len: usize, vectors: I) -> Result<Self::Ok, C::Error>
99    where
100        I: IntoIterator,
101        I::Item: AsRef<[u8]>,
102    {
103        musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), len)?;
104
105        for bytes in vectors {
106            self.writer.write_bytes(self.cx, bytes.as_ref())?;
107        }
108
109        Ok(())
110    }
111
112    #[inline]
113    fn encode_string(mut self, string: &str) -> Result<Self::Ok, C::Error> {
114        musli_utils::int::encode_usize::<_, _, OPT>(
115            self.cx,
116            self.writer.borrow_mut(),
117            string.len(),
118        )?;
119        self.writer.write_bytes(self.cx, string.as_bytes())?;
120        Ok(())
121    }
122
123    #[inline]
124    fn collect_string<T>(self, value: &T) -> Result<Self::Ok, <Self::Cx as Context>::Error>
125    where
126        T: ?Sized + fmt::Display,
127    {
128        let buf = self.cx.collect_string(value)?;
129        self.encode_string(buf.as_ref())
130    }
131
132    #[inline]
133    fn encode_usize(mut self, value: usize) -> Result<Self::Ok, C::Error> {
134        musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), value)
135    }
136
137    #[inline]
138    fn encode_isize(self, value: isize) -> Result<Self::Ok, C::Error> {
139        self.encode_usize(value as usize)
140    }
141
142    #[inline]
143    fn encode_bool(mut self, value: bool) -> Result<Self::Ok, C::Error> {
144        self.writer.write_byte(self.cx, if value { 1 } else { 0 })
145    }
146
147    #[inline]
148    fn encode_char(self, value: char) -> Result<Self::Ok, C::Error> {
149        self.encode_u32(value as u32)
150    }
151
152    #[inline]
153    fn encode_u8(mut self, value: u8) -> Result<Self::Ok, C::Error> {
154        self.writer.write_byte(self.cx, value)
155    }
156
157    #[inline]
158    fn encode_u16(mut self, value: u16) -> Result<Self::Ok, C::Error> {
159        musli_utils::int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
160    }
161
162    #[inline]
163    fn encode_u32(mut self, value: u32) -> Result<Self::Ok, C::Error> {
164        musli_utils::int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
165    }
166
167    #[inline]
168    fn encode_u64(mut self, value: u64) -> Result<Self::Ok, C::Error> {
169        musli_utils::int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
170    }
171
172    #[inline]
173    fn encode_u128(mut self, value: u128) -> Result<Self::Ok, C::Error> {
174        musli_utils::int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
175    }
176
177    #[inline]
178    fn encode_i8(self, value: i8) -> Result<Self::Ok, C::Error> {
179        self.encode_u8(value as u8)
180    }
181
182    #[inline]
183    fn encode_i16(mut self, value: i16) -> Result<Self::Ok, C::Error> {
184        musli_utils::int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
185    }
186
187    #[inline]
188    fn encode_i32(mut self, value: i32) -> Result<Self::Ok, C::Error> {
189        musli_utils::int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
190    }
191
192    #[inline]
193    fn encode_i64(mut self, value: i64) -> Result<Self::Ok, C::Error> {
194        musli_utils::int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
195    }
196
197    #[inline]
198    fn encode_i128(mut self, value: i128) -> Result<Self::Ok, C::Error> {
199        musli_utils::int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
200    }
201
202    #[inline]
203    fn encode_f32(self, value: f32) -> Result<Self::Ok, C::Error> {
204        self.encode_u32(value.to_bits())
205    }
206
207    #[inline]
208    fn encode_f64(self, value: f64) -> Result<Self::Ok, C::Error> {
209        self.encode_u64(value.to_bits())
210    }
211
212    #[inline]
213    fn encode_some(mut self) -> Result<Self::EncodeSome, C::Error> {
214        self.writer.write_byte(self.cx, 1)?;
215        Ok(self)
216    }
217
218    #[inline]
219    fn encode_none(mut self) -> Result<Self::Ok, C::Error> {
220        self.writer.write_byte(self.cx, 0)?;
221        Ok(())
222    }
223
224    #[inline]
225    fn encode_sequence(mut self, hint: &SequenceHint) -> Result<Self::EncodeSequence, C::Error> {
226        musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), hint.size)?;
227        Ok(self)
228    }
229
230    #[inline]
231    fn encode_map(mut self, hint: &MapHint) -> Result<Self::EncodeMap, C::Error> {
232        musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), hint.size)?;
233        Ok(self)
234    }
235
236    #[inline]
237    fn encode_map_entries(mut self, hint: &MapHint) -> Result<Self::EncodeMapEntries, C::Error> {
238        musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), hint.size)?;
239        Ok(self)
240    }
241
242    #[inline]
243    fn encode_variant(self) -> Result<Self::EncodeVariant, C::Error> {
244        Ok(self)
245    }
246
247    #[inline]
248    fn encode_sequence_variant<T>(
249        mut self,
250        tag: &T,
251        hint: &SequenceHint,
252    ) -> Result<Self::EncodeSequenceVariant, C::Error>
253    where
254        T: ?Sized + Encode<C::Mode>,
255    {
256        StorageEncoder::<_, OPT, _>::new(self.cx, self.writer.borrow_mut()).encode(tag)?;
257        musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), hint.size)?;
258        Ok(self)
259    }
260
261    #[inline]
262    fn encode_map_variant<T>(
263        mut self,
264        tag: &T,
265        hint: &MapHint,
266    ) -> Result<Self::EncodeMapVariant, C::Error>
267    where
268        T: ?Sized + Encode<C::Mode>,
269    {
270        StorageEncoder::<_, OPT, _>::new(self.cx, self.writer.borrow_mut()).encode(tag)?;
271        musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), hint.size)?;
272        Ok(self)
273    }
274}
275
276impl<'a, W, const OPT: Options, C> SequenceEncoder for StorageEncoder<'a, W, OPT, C>
277where
278    C: ?Sized + Context,
279    W: Writer,
280{
281    type Cx = C;
282    type Ok = ();
283    type EncodeNext<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
284
285    #[inline]
286    fn encode_next(&mut self) -> Result<Self::EncodeNext<'_>, C::Error> {
287        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
288    }
289
290    #[inline]
291    fn finish_sequence(self) -> Result<Self::Ok, C::Error> {
292        Ok(())
293    }
294}
295
296impl<'a, W, const OPT: Options, C> MapEncoder for StorageEncoder<'a, W, OPT, C>
297where
298    C: ?Sized + Context,
299    W: Writer,
300{
301    type Cx = C;
302    type Ok = ();
303    type EncodeEntry<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
304
305    #[inline]
306    fn encode_entry(&mut self) -> Result<Self::EncodeEntry<'_>, C::Error> {
307        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
308    }
309
310    #[inline]
311    fn finish_map(self) -> Result<Self::Ok, C::Error> {
312        Ok(())
313    }
314}
315
316impl<'a, W, const OPT: Options, C> EntryEncoder for StorageEncoder<'a, W, OPT, C>
317where
318    C: ?Sized + Context,
319    W: Writer,
320{
321    type Cx = C;
322    type Ok = ();
323    type EncodeKey<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
324    type EncodeValue<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
325
326    #[inline]
327    fn encode_key(&mut self) -> Result<Self::EncodeKey<'_>, C::Error> {
328        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
329    }
330
331    #[inline]
332    fn encode_value(&mut self) -> Result<Self::EncodeValue<'_>, C::Error> {
333        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
334    }
335
336    #[inline]
337    fn finish_entry(self) -> Result<Self::Ok, C::Error> {
338        Ok(())
339    }
340}
341
342impl<'a, W, const OPT: Options, C> EntriesEncoder for StorageEncoder<'a, W, OPT, C>
343where
344    C: ?Sized + Context,
345    W: Writer,
346{
347    type Cx = C;
348    type Ok = ();
349    type EncodeEntryKey<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
350    type EncodeEntryValue<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
351
352    #[inline]
353    fn encode_entry_key(&mut self) -> Result<Self::EncodeEntryKey<'_>, C::Error> {
354        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
355    }
356
357    #[inline]
358    fn encode_entry_value(&mut self) -> Result<Self::EncodeEntryValue<'_>, C::Error> {
359        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
360    }
361
362    #[inline]
363    fn finish_entries(self) -> Result<Self::Ok, C::Error> {
364        Ok(())
365    }
366}
367
368impl<'a, W, const OPT: Options, C> VariantEncoder for StorageEncoder<'a, W, OPT, C>
369where
370    C: ?Sized + Context,
371    W: Writer,
372{
373    type Cx = C;
374    type Ok = ();
375    type EncodeTag<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
376    type EncodeData<'this> = StorageEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
377
378    #[inline]
379    fn encode_tag(&mut self) -> Result<Self::EncodeTag<'_>, C::Error> {
380        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
381    }
382
383    #[inline]
384    fn encode_data(&mut self) -> Result<Self::EncodeData<'_>, C::Error> {
385        Ok(StorageEncoder::new(self.cx, self.writer.borrow_mut()))
386    }
387
388    #[inline]
389    fn finish_variant(self) -> Result<Self::Ok, C::Error> {
390        Ok(())
391    }
392}
musli_storage/en.rs

musli_storage/
en.rs
