musli_wire/
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::{Buf, Context};
8use musli_storage::en::StorageEncoder;
9use musli_utils::writer::BufWriter;
10use musli_utils::{Options, Writer};
11
12use crate::tag::{Kind, Tag};
13
14/// A very simple encoder.
15pub struct WireEncoder<'a, W, const OPT: Options, C: ?Sized> {
16    cx: &'a C,
17    writer: W,
18}
19
20impl<'a, W, const OPT: Options, C> WireEncoder<'a, W, OPT, C>
21where
22    W: Writer,
23    C: ?Sized + Context,
24{
25    /// Construct a new fixed width message encoder.
26    #[inline]
27    pub(crate) fn new(cx: &'a C, writer: W) -> Self {
28        Self { cx, writer }
29    }
30
31    #[inline]
32    fn encode_map_len(&mut self, len: usize) -> Result<(), C::Error> {
33        let Some(len) = len.checked_mul(2) else {
34            return Err(self.cx.message("Map length overflow"));
35        };
36
37        let (tag, embedded) = Tag::with_len(Kind::Sequence, len);
38        self.writer.write_byte(self.cx, tag.byte())?;
39
40        if !embedded {
41            musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), len)?;
42        }
43
44        Ok(())
45    }
46
47    #[inline]
48    fn encode_sequence_len(&mut self, len: usize) -> Result<(), C::Error> {
49        let (tag, embedded) = Tag::with_len(Kind::Sequence, len);
50        self.writer.write_byte(self.cx, tag.byte())?;
51
52        if !embedded {
53            musli_utils::int::encode_usize::<_, _, OPT>(self.cx, self.writer.borrow_mut(), len)?;
54        }
55
56        Ok(())
57    }
58}
59
60pub struct WireSequenceEncoder<'a, W, B, const OPT: Options, C: ?Sized> {
61    cx: &'a C,
62    writer: W,
63    buffer: BufWriter<B>,
64}
65
66impl<'a, W, B, const OPT: Options, C: ?Sized> WireSequenceEncoder<'a, W, B, OPT, C> {
67    /// Construct a new fixed width message encoder.
68    #[inline]
69    pub(crate) fn new(cx: &'a C, writer: W, buffer: B) -> Self {
70        Self {
71            cx,
72            writer,
73            buffer: BufWriter::new(buffer),
74        }
75    }
76}
77
78#[musli::encoder]
79impl<'a, W, const OPT: Options, C> Encoder for WireEncoder<'a, W, OPT, C>
80where
81    C: ?Sized + Context,
82    W: Writer,
83{
84    type Cx = C;
85    type Error = C::Error;
86    type Ok = ();
87    type Mode = C::Mode;
88    type WithContext<'this, U> = WireEncoder<'this, W, OPT, U> where U: 'this + Context;
89    type EncodePack = WireSequenceEncoder<'a, W, C::Buf<'a>, OPT, C>;
90    type EncodeSome = Self;
91    type EncodeSequence = Self;
92    type EncodeMap = Self;
93    type EncodeMapEntries = Self;
94    type EncodeVariant = Self;
95    type EncodeSequenceVariant = Self;
96    type EncodeMapVariant = Self;
97
98    #[inline]
99    fn cx(&self) -> &Self::Cx {
100        self.cx
101    }
102
103    #[inline]
104    fn with_context<U>(self, cx: &U) -> Result<Self::WithContext<'_, U>, C::Error>
105    where
106        U: Context,
107    {
108        Ok(WireEncoder::new(cx, self.writer))
109    }
110
111    #[inline]
112    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
113        write!(f, "type supported by the wire encoder")
114    }
115
116    #[inline]
117    fn encode<T>(self, value: T) -> Result<Self::Ok, C::Error>
118    where
119        T: Encode<Self::Mode>,
120    {
121        value.encode(self.cx, self)
122    }
123
124    #[inline]
125    fn encode_unit(mut self) -> Result<Self::Ok, C::Error> {
126        self.writer
127            .write_byte(self.cx, Tag::new(Kind::Sequence, 0).byte())?;
128        Ok(())
129    }
130
131    #[inline]
132    fn encode_pack(self) -> Result<Self::EncodePack, C::Error> {
133        let Some(buf) = self.cx.alloc() else {
134            return Err(self.cx.message("Failed to allocate pack buffer"));
135        };
136
137        Ok(WireSequenceEncoder::new(self.cx, self.writer, buf))
138    }
139
140    #[inline]
141    fn encode_array<const N: usize>(self, array: &[u8; N]) -> Result<Self::Ok, C::Error> {
142        self.encode_bytes(array)
143    }
144
145    #[inline]
146    fn encode_bytes(mut self, bytes: &[u8]) -> Result<Self::Ok, C::Error> {
147        encode_prefix::<_, _, OPT>(self.cx, self.writer.borrow_mut(), bytes.len())?;
148        self.writer.write_bytes(self.cx, bytes)?;
149        Ok(())
150    }
151
152    #[inline]
153    fn encode_bytes_vectored<I>(mut self, len: usize, vectors: I) -> Result<Self::Ok, C::Error>
154    where
155        I: IntoIterator,
156        I::Item: AsRef<[u8]>,
157    {
158        encode_prefix::<_, _, OPT>(self.cx, self.writer.borrow_mut(), len)?;
159
160        for bytes in vectors {
161            self.writer.write_bytes(self.cx, bytes.as_ref())?;
162        }
163
164        Ok(())
165    }
166
167    #[inline]
168    fn encode_string(self, string: &str) -> Result<Self::Ok, C::Error> {
169        self.encode_bytes(string.as_bytes())
170    }
171
172    #[inline]
173    fn collect_string<T>(self, value: &T) -> Result<Self::Ok, <Self::Cx as Context>::Error>
174    where
175        T: ?Sized + fmt::Display,
176    {
177        let buf = self.cx.collect_string(value)?;
178        self.encode_string(buf.as_ref())
179    }
180
181    #[inline]
182    fn encode_usize(mut self, value: usize) -> Result<Self::Ok, C::Error> {
183        crate::wire_int::encode_length::<_, _, OPT>(self.cx, self.writer.borrow_mut(), value)
184    }
185
186    #[inline]
187    fn encode_isize(mut self, value: isize) -> Result<Self::Ok, C::Error> {
188        crate::wire_int::encode_length::<_, _, OPT>(
189            self.cx,
190            self.writer.borrow_mut(),
191            value as usize,
192        )
193    }
194
195    #[inline]
196    fn encode_bool(mut self, value: bool) -> Result<Self::Ok, C::Error> {
197        self.writer.write_byte(
198            self.cx,
199            Tag::new(Kind::Continuation, if value { 1 } else { 0 }).byte(),
200        )
201    }
202
203    #[inline]
204    fn encode_char(self, value: char) -> Result<Self::Ok, C::Error> {
205        self.encode_u32(value as u32)
206    }
207
208    #[inline]
209    fn encode_u8(mut self, value: u8) -> Result<Self::Ok, C::Error> {
210        crate::wire_int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
211    }
212
213    #[inline]
214    fn encode_u16(mut self, value: u16) -> Result<Self::Ok, C::Error> {
215        crate::wire_int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
216    }
217
218    #[inline]
219    fn encode_u32(mut self, value: u32) -> Result<Self::Ok, C::Error> {
220        crate::wire_int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
221    }
222
223    #[inline]
224    fn encode_u64(mut self, value: u64) -> Result<Self::Ok, C::Error> {
225        crate::wire_int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
226    }
227
228    #[inline]
229    fn encode_u128(mut self, value: u128) -> Result<Self::Ok, C::Error> {
230        crate::wire_int::encode_unsigned::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
231    }
232
233    #[inline]
234    fn encode_i8(self, value: i8) -> Result<Self::Ok, C::Error> {
235        self.encode_u8(value as u8)
236    }
237
238    #[inline]
239    fn encode_i16(mut self, value: i16) -> Result<Self::Ok, C::Error> {
240        crate::wire_int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
241    }
242
243    #[inline]
244    fn encode_i32(mut self, value: i32) -> Result<Self::Ok, C::Error> {
245        crate::wire_int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
246    }
247
248    #[inline]
249    fn encode_i64(mut self, value: i64) -> Result<Self::Ok, C::Error> {
250        crate::wire_int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
251    }
252
253    #[inline]
254    fn encode_i128(mut self, value: i128) -> Result<Self::Ok, C::Error> {
255        crate::wire_int::encode_signed::<_, _, _, OPT>(self.cx, self.writer.borrow_mut(), value)
256    }
257
258    #[inline]
259    fn encode_f32(self, value: f32) -> Result<Self::Ok, C::Error> {
260        self.encode_u32(value.to_bits())
261    }
262
263    #[inline]
264    fn encode_f64(self, value: f64) -> Result<Self::Ok, C::Error> {
265        self.encode_u64(value.to_bits())
266    }
267
268    #[inline]
269    fn encode_some(mut self) -> Result<Self::EncodeSome, C::Error> {
270        self.writer
271            .write_byte(self.cx, Tag::new(Kind::Sequence, 1).byte())?;
272        Ok(self)
273    }
274
275    #[inline]
276    fn encode_none(mut self) -> Result<Self::Ok, C::Error> {
277        self.writer
278            .write_byte(self.cx, Tag::new(Kind::Sequence, 0).byte())?;
279        Ok(())
280    }
281
282    #[inline]
283    fn encode_sequence(mut self, hint: &SequenceHint) -> Result<Self::EncodeSequence, C::Error> {
284        self.encode_sequence_len(hint.size)?;
285        Ok(self)
286    }
287
288    #[inline]
289    fn encode_map(mut self, hint: &MapHint) -> Result<Self::EncodeMap, C::Error> {
290        self.encode_map_len(hint.size)?;
291        Ok(self)
292    }
293
294    #[inline]
295    fn encode_map_entries(self, hint: &MapHint) -> Result<Self::EncodeMapEntries, C::Error> {
296        self.encode_map(hint)
297    }
298
299    #[inline]
300    fn encode_variant(mut self) -> Result<Self::EncodeVariant, C::Error> {
301        self.writer
302            .write_byte(self.cx, Tag::new(Kind::Sequence, 2).byte())?;
303        Ok(self)
304    }
305
306    #[inline]
307    fn encode_sequence_variant<T>(
308        mut self,
309        tag: &T,
310        hint: &SequenceHint,
311    ) -> Result<Self::EncodeSequenceVariant, C::Error>
312    where
313        T: ?Sized + Encode<C::Mode>,
314    {
315        self.writer
316            .write_byte(self.cx, Tag::new(Kind::Sequence, 2).byte())?;
317        WireEncoder::<_, OPT, _>::new(self.cx, self.writer.borrow_mut()).encode(tag)?;
318        self.encode_sequence(hint)
319    }
320
321    #[inline]
322    fn encode_map_variant<T>(
323        mut self,
324        tag: &T,
325        hint: &MapHint,
326    ) -> Result<Self::EncodeSequenceVariant, C::Error>
327    where
328        T: ?Sized + Encode<C::Mode>,
329    {
330        self.writer
331            .write_byte(self.cx, Tag::new(Kind::Sequence, 2).byte())?;
332        WireEncoder::<_, OPT, _>::new(self.cx, self.writer.borrow_mut()).encode(tag)?;
333        self.encode_map(hint)
334    }
335}
336
337impl<'a, W, B, const OPT: Options, C> SequenceEncoder for WireSequenceEncoder<'a, W, B, OPT, C>
338where
339    C: ?Sized + Context,
340    W: Writer,
341    B: Buf,
342{
343    type Cx = C;
344    type Ok = ();
345    type EncodeNext<'this> = StorageEncoder<'a, &'this mut BufWriter<B>, OPT, C> where Self: 'this, B: Buf;
346
347    #[inline]
348    fn encode_next(&mut self) -> Result<Self::EncodeNext<'_>, C::Error> {
349        Ok(StorageEncoder::new(self.cx, &mut self.buffer))
350    }
351
352    #[inline]
353    fn finish_sequence(mut self) -> Result<Self::Ok, C::Error> {
354        let buffer = self.buffer.into_inner();
355        encode_prefix::<_, _, OPT>(self.cx, self.writer.borrow_mut(), buffer.len())?;
356        self.writer.write_buffer(self.cx, buffer)?;
357        Ok(())
358    }
359}
360
361impl<'a, W, const OPT: Options, C> SequenceEncoder for WireEncoder<'a, W, OPT, C>
362where
363    C: ?Sized + Context,
364    W: Writer,
365{
366    type Cx = C;
367    type Ok = ();
368    type EncodeNext<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
369
370    #[inline]
371    fn encode_next(&mut self) -> Result<Self::EncodeNext<'_>, C::Error> {
372        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
373    }
374
375    #[inline]
376    fn finish_sequence(self) -> Result<Self::Ok, C::Error> {
377        Ok(())
378    }
379}
380
381impl<'a, W, const OPT: Options, C> MapEncoder for WireEncoder<'a, W, OPT, C>
382where
383    C: ?Sized + Context,
384    W: Writer,
385{
386    type Cx = C;
387    type Ok = ();
388    type EncodeEntry<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
389
390    #[inline]
391    fn encode_entry(&mut self) -> Result<Self::EncodeEntry<'_>, C::Error> {
392        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
393    }
394
395    #[inline]
396    fn finish_map(self) -> Result<Self::Ok, C::Error> {
397        Ok(())
398    }
399}
400
401impl<'a, W, const OPT: Options, C> EntriesEncoder for WireEncoder<'a, W, OPT, C>
402where
403    C: ?Sized + Context,
404    W: Writer,
405{
406    type Cx = C;
407    type Ok = ();
408    type EncodeEntryKey<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
409    type EncodeEntryValue<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
410
411    #[inline]
412    fn encode_entry_key(&mut self) -> Result<Self::EncodeEntryKey<'_>, C::Error> {
413        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
414    }
415
416    #[inline]
417    fn encode_entry_value(&mut self) -> Result<Self::EncodeEntryValue<'_>, C::Error> {
418        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
419    }
420
421    #[inline]
422    fn finish_entries(self) -> Result<Self::Ok, C::Error> {
423        Ok(())
424    }
425}
426
427impl<'a, W, const OPT: Options, C> EntryEncoder for WireEncoder<'a, W, OPT, C>
428where
429    C: ?Sized + Context,
430    W: Writer,
431{
432    type Cx = C;
433    type Ok = ();
434    type EncodeKey<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
435    type EncodeValue<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
436
437    #[inline]
438    fn encode_key(&mut self) -> Result<Self::EncodeKey<'_>, C::Error> {
439        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
440    }
441
442    #[inline]
443    fn encode_value(&mut self) -> Result<Self::EncodeValue<'_>, C::Error> {
444        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
445    }
446
447    #[inline]
448    fn finish_entry(self) -> Result<Self::Ok, C::Error> {
449        Ok(())
450    }
451}
452
453impl<'a, W, const OPT: Options, C> VariantEncoder for WireEncoder<'a, W, OPT, C>
454where
455    C: ?Sized + Context,
456    W: Writer,
457{
458    type Cx = C;
459    type Ok = ();
460    type EncodeTag<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
461    type EncodeData<'this> = WireEncoder<'a, W::Mut<'this>, OPT, C> where Self: 'this;
462
463    #[inline]
464    fn encode_tag(&mut self) -> Result<Self::EncodeTag<'_>, C::Error> {
465        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
466    }
467
468    #[inline]
469    fn encode_data(&mut self) -> Result<Self::EncodeData<'_>, C::Error> {
470        Ok(WireEncoder::new(self.cx, self.writer.borrow_mut()))
471    }
472
473    #[inline]
474    fn finish_variant(self) -> Result<Self::Ok, C::Error> {
475        Ok(())
476    }
477}
478
479/// Encode a length prefix.
480#[inline]
481fn encode_prefix<C, W, const OPT: Options>(
482    cx: &C,
483    mut writer: W,
484    len: usize,
485) -> Result<(), C::Error>
486where
487    C: ?Sized + Context,
488    W: Writer,
489{
490    let (tag, embedded) = Tag::with_len(Kind::Prefix, len);
491    writer.write_byte(cx, tag.byte())?;
492
493    if !embedded {
494        musli_utils::int::encode_usize::<_, _, OPT>(cx, writer, len)?;
495    }
496
497    Ok(())
498}
musli_wire/en.rs

musli_wire/
en.rs
