musli_serde/
serializer.rs

1use core::fmt;
2
3use musli::en::{EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder};
4use musli::hint::{MapHint, SequenceHint};
5use musli::{Context, Encoder};
6
7use serde::ser::{self, Serialize};
8
9pub struct Serializer<'a, E>
10where
11    E: Encoder,
12{
13    cx: &'a E::Cx,
14    encoder: E,
15}
16
17impl<'a, E> Serializer<'a, E>
18where
19    E: Encoder,
20{
21    /// Construct a new deserializer out of an encoder.
22    pub fn new(cx: &'a E::Cx, encoder: E) -> Self {
23        Self { cx, encoder }
24    }
25}
26
27impl<'a, E> ser::Serializer for Serializer<'a, E>
28where
29    E: Encoder,
30    <E::Cx as Context>::Error: ser::Error,
31{
32    type Ok = E::Ok;
33    type Error = <E::Cx as Context>::Error;
34
35    type SerializeSeq = SerializeSeq<'a, E::EncodeSequence>;
36    type SerializeTuple = SerializeSeq<'a, E::EncodeSequence>;
37    type SerializeTupleStruct = SerializeSeq<'a, E::EncodeSequence>;
38    type SerializeTupleVariant = SerializeSeq<'a, E::EncodeSequenceVariant>;
39    type SerializeMap = SerializeMap<'a, E::EncodeMapEntries>;
40    type SerializeStruct = SerializeStruct<'a, E::EncodeMap>;
41    type SerializeStructVariant = SerializeStructVariant<'a, E::EncodeMapVariant>;
42
43    #[inline]
44    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
45        self.encoder.encode_bool(v)
46    }
47
48    #[inline]
49    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
50        self.encoder.encode_i8(v)
51    }
52
53    #[inline]
54    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
55        self.encoder.encode_i16(v)
56    }
57
58    #[inline]
59    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
60        self.encoder.encode_i32(v)
61    }
62
63    #[inline]
64    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
65        self.encoder.encode_i64(v)
66    }
67
68    #[inline]
69    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
70        self.encoder.encode_i128(v)
71    }
72
73    #[inline]
74    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
75        self.encoder.encode_u8(v)
76    }
77
78    #[inline]
79    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
80        self.encoder.encode_u16(v)
81    }
82
83    #[inline]
84    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
85        self.encoder.encode_u32(v)
86    }
87
88    #[inline]
89    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
90        self.encoder.encode_u64(v)
91    }
92
93    #[inline]
94    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
95        self.encoder.encode_u128(v)
96    }
97
98    #[inline]
99    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
100        self.encoder.encode_f32(v)
101    }
102
103    #[inline]
104    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
105        self.encoder.encode_f64(v)
106    }
107
108    #[inline]
109    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
110        self.encoder.encode_char(v)
111    }
112
113    #[inline]
114    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
115        self.encoder.encode_string(v)
116    }
117
118    #[inline]
119    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
120        self.encoder.encode_bytes(v)
121    }
122
123    #[inline]
124    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
125        self.encoder.encode_none()
126    }
127
128    #[inline]
129    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
130    where
131        T: ser::Serialize,
132    {
133        let encoder = self.encoder.encode_some()?;
134        value.serialize(Serializer::new(self.cx, encoder))
135    }
136
137    #[inline]
138    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
139        self.encoder.encode_unit()
140    }
141
142    #[inline]
143    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
144        self.encoder.encode_unit()
145    }
146
147    #[inline]
148    fn serialize_unit_variant(
149        self,
150        _: &'static str,
151        _: u32,
152        variant_name: &'static str,
153    ) -> Result<Self::Ok, Self::Error> {
154        encode_variant(self.cx, self.encoder, variant_name, |encoder| {
155            encoder.encode_unit()
156        })
157    }
158
159    #[inline]
160    fn serialize_newtype_struct<T: ?Sized>(
161        self,
162        _: &'static str,
163        value: &T,
164    ) -> Result<Self::Ok, Self::Error>
165    where
166        T: ser::Serialize,
167    {
168        value.serialize(Serializer::new(self.cx, self.encoder))
169    }
170
171    #[inline]
172    fn serialize_newtype_variant<T: ?Sized>(
173        self,
174        _: &'static str,
175        _: u32,
176        variant_name: &'static str,
177        value: &T,
178    ) -> Result<Self::Ok, Self::Error>
179    where
180        T: ser::Serialize,
181    {
182        encode_variant(self.cx, self.encoder, variant_name, move |encoder| {
183            value.serialize(Serializer::new(self.cx, encoder))
184        })
185    }
186
187    #[inline]
188    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
189        let Some(len) = len else {
190            return Err(ser::Error::custom(
191                "Can only encode sequences with known lengths",
192            ));
193        };
194
195        let hint = SequenceHint::with_size(len);
196        let encoder = self.encoder.encode_sequence(&hint)?;
197        Ok(SerializeSeq::new(self.cx, encoder))
198    }
199
200    #[inline]
201    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
202        let hint = SequenceHint::with_size(len);
203        let encoder = self.encoder.encode_sequence(&hint)?;
204        Ok(SerializeSeq::new(self.cx, encoder))
205    }
206
207    #[inline]
208    fn serialize_tuple_struct(
209        self,
210        _: &'static str,
211        len: usize,
212    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
213        let hint = SequenceHint::with_size(len);
214        let encoder = self.encoder.encode_sequence(&hint)?;
215        Ok(SerializeSeq::new(self.cx, encoder))
216    }
217
218    #[inline]
219    fn serialize_tuple_variant(
220        self,
221        _: &'static str,
222        _: u32,
223        variant_name: &'static str,
224        len: usize,
225    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
226        let hint = SequenceHint::with_size(len);
227        let encoder = self.encoder.encode_sequence_variant(variant_name, &hint)?;
228        Ok(SerializeSeq::new(self.cx, encoder))
229    }
230
231    #[inline]
232    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
233        let Some(len) = len else {
234            return Err(self
235                .cx
236                .message("Can only serialize maps with known lengths"));
237        };
238
239        let hint = MapHint::with_size(len);
240        let encoder = self.encoder.encode_map_entries(&hint)?;
241        Ok(SerializeMap::new(self.cx, encoder))
242    }
243
244    #[inline]
245    fn serialize_struct(
246        self,
247        _: &'static str,
248        len: usize,
249    ) -> Result<Self::SerializeStruct, Self::Error> {
250        let hint = MapHint::with_size(len);
251        let encoder = self.encoder.encode_map(&hint)?;
252        Ok(SerializeStruct::new(self.cx, encoder))
253    }
254
255    #[inline]
256    fn serialize_struct_variant(
257        self,
258        _: &'static str,
259        _: u32,
260        variant_name: &'static str,
261        len: usize,
262    ) -> Result<Self::SerializeStructVariant, Self::Error> {
263        let hint = MapHint::with_size(len);
264        let encoder = self.encoder.encode_map_variant(variant_name, &hint)?;
265        Ok(SerializeStructVariant::new(self.cx, encoder))
266    }
267
268    #[inline]
269    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
270    where
271        T: fmt::Display,
272    {
273        let string = self.cx.collect_string(value)?;
274        self.serialize_str(string.as_ref())
275    }
276}
277
278#[inline]
279fn encode_variant<E, T, F, O>(
280    cx: &E::Cx,
281    encoder: E,
282    variant_tag: &T,
283    f: F,
284) -> Result<O, <E::Cx as Context>::Error>
285where
286    <E::Cx as Context>::Error: ser::Error,
287    E: Encoder,
288    T: ?Sized + Serialize,
289    F: FnOnce(
290        <E::EncodeVariant as VariantEncoder>::EncodeData<'_>,
291    ) -> Result<O, <E::Cx as Context>::Error>,
292{
293    let mut variant = encoder.encode_variant()?;
294    variant_tag.serialize(Serializer::new(cx, variant.encode_tag()?))?;
295    let output = f(variant.encode_data()?)?;
296    variant.finish_variant()?;
297    Ok(output)
298}
299
300pub struct SerializeSeq<'a, E>
301where
302    E: SequenceEncoder,
303{
304    cx: &'a E::Cx,
305    encoder: E,
306}
307
308impl<'a, E> SerializeSeq<'a, E>
309where
310    E: SequenceEncoder,
311{
312    fn new(cx: &'a E::Cx, encoder: E) -> Self {
313        Self { cx, encoder }
314    }
315}
316
317impl<'a, E> ser::SerializeSeq for SerializeSeq<'a, E>
318where
319    <E::Cx as Context>::Error: ser::Error,
320    E: SequenceEncoder,
321{
322    type Ok = E::Ok;
323    type Error = <E::Cx as Context>::Error;
324
325    #[inline]
326    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
327    where
328        T: ser::Serialize,
329    {
330        let encoder = self.encoder.encode_next()?;
331        value.serialize(Serializer::new(self.cx, encoder))?;
332        Ok(())
333    }
334
335    #[inline]
336    fn end(self) -> Result<Self::Ok, Self::Error> {
337        self.encoder.finish_sequence()
338    }
339}
340
341impl<'a, E> ser::SerializeTupleStruct for SerializeSeq<'a, E>
342where
343    <E::Cx as Context>::Error: ser::Error,
344    E: SequenceEncoder,
345{
346    type Ok = E::Ok;
347    type Error = <E::Cx as Context>::Error;
348
349    #[inline]
350    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
351    where
352        T: ser::Serialize,
353    {
354        ser::SerializeSeq::serialize_element(self, value)
355    }
356
357    #[inline]
358    fn end(self) -> Result<Self::Ok, Self::Error> {
359        ser::SerializeSeq::end(self)
360    }
361}
362
363impl<'a, E> ser::SerializeTuple for SerializeSeq<'a, E>
364where
365    <E::Cx as Context>::Error: ser::Error,
366    E: SequenceEncoder,
367{
368    type Ok = E::Ok;
369    type Error = <E::Cx as Context>::Error;
370
371    #[inline]
372    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
373    where
374        T: ser::Serialize,
375    {
376        ser::SerializeSeq::serialize_element(self, value)
377    }
378
379    #[inline]
380    fn end(self) -> Result<Self::Ok, Self::Error> {
381        ser::SerializeSeq::end(self)
382    }
383}
384
385impl<'a, E> ser::SerializeTupleVariant for SerializeSeq<'a, E>
386where
387    <E::Cx as Context>::Error: ser::Error,
388    E: SequenceEncoder,
389{
390    type Ok = E::Ok;
391    type Error = <E::Cx as Context>::Error;
392
393    #[inline]
394    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
395    where
396        T: ser::Serialize,
397    {
398        ser::SerializeSeq::serialize_element(self, value)
399    }
400
401    #[inline]
402    fn end(self) -> Result<Self::Ok, Self::Error> {
403        ser::SerializeSeq::end(self)
404    }
405}
406
407pub struct SerializeMap<'a, E>
408where
409    E: EntriesEncoder,
410{
411    cx: &'a E::Cx,
412    encoder: E,
413}
414
415impl<'a, E> SerializeMap<'a, E>
416where
417    E: EntriesEncoder,
418{
419    fn new(cx: &'a E::Cx, encoder: E) -> Self {
420        Self { cx, encoder }
421    }
422}
423
424impl<'a, E> ser::SerializeMap for SerializeMap<'a, E>
425where
426    <E::Cx as Context>::Error: ser::Error,
427    E: EntriesEncoder,
428{
429    type Ok = E::Ok;
430    type Error = <E::Cx as Context>::Error;
431
432    #[inline]
433    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
434    where
435        T: ser::Serialize,
436    {
437        let encoder = self.encoder.encode_entry_key()?;
438        key.serialize(Serializer::new(self.cx, encoder))?;
439        Ok(())
440    }
441
442    #[inline]
443    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
444    where
445        T: ser::Serialize,
446    {
447        let encoder = self.encoder.encode_entry_value()?;
448        value.serialize(Serializer::new(self.cx, encoder))?;
449        Ok(())
450    }
451
452    #[inline]
453    fn end(self) -> Result<Self::Ok, Self::Error> {
454        self.encoder.finish_entries()
455    }
456}
457
458pub struct SerializeStruct<'a, E>
459where
460    E: MapEncoder,
461{
462    cx: &'a E::Cx,
463    encoder: E,
464}
465
466impl<'a, E> SerializeStruct<'a, E>
467where
468    E: MapEncoder,
469{
470    fn new(cx: &'a E::Cx, encoder: E) -> Self {
471        Self { cx, encoder }
472    }
473}
474
475impl<'a, E> ser::SerializeStruct for SerializeStruct<'a, E>
476where
477    <E::Cx as Context>::Error: ser::Error,
478    E: MapEncoder,
479{
480    type Ok = E::Ok;
481    type Error = <E::Cx as Context>::Error;
482
483    #[inline]
484    fn serialize_field<T: ?Sized>(
485        &mut self,
486        key: &'static str,
487        value: &T,
488    ) -> Result<(), Self::Error>
489    where
490        T: ser::Serialize,
491    {
492        let mut field = self.encoder.encode_entry()?;
493        field.encode_key()?.encode(key)?;
494        value.serialize(Serializer::new(self.cx, field.encode_value()?))?;
495        field.finish_entry()?;
496        Ok(())
497    }
498
499    #[inline]
500    fn end(self) -> Result<Self::Ok, Self::Error> {
501        self.encoder.finish_map()
502    }
503}
504
505pub struct SerializeStructVariant<'a, E>
506where
507    E: MapEncoder,
508{
509    cx: &'a E::Cx,
510    encoder: E,
511}
512
513impl<'a, E> SerializeStructVariant<'a, E>
514where
515    E: MapEncoder,
516{
517    fn new(cx: &'a E::Cx, encoder: E) -> Self {
518        Self { cx, encoder }
519    }
520}
521
522impl<'a, E> ser::SerializeStructVariant for SerializeStructVariant<'a, E>
523where
524    <E::Cx as Context>::Error: ser::Error,
525    E: MapEncoder,
526{
527    type Ok = E::Ok;
528    type Error = <E::Cx as Context>::Error;
529
530    #[inline]
531    fn serialize_field<T: ?Sized>(
532        &mut self,
533        key: &'static str,
534        value: &T,
535    ) -> Result<(), Self::Error>
536    where
537        T: ser::Serialize,
538    {
539        self.encoder.encode_entry_fn(|field| {
540            field.encode_key()?.encode(key)?;
541            value.serialize(Serializer::new(self.cx, field.encode_value()?))?;
542            Ok(())
543        })?;
544
545        Ok(())
546    }
547
548    #[inline]
549    fn end(self) -> Result<Self::Ok, Self::Error> {
550        self.encoder.finish_map()
551    }
552}
musli_serde/serializer.rs

musli_serde/
serializer.rs
