musli/serde/
ser.rs

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

musli/serde/
ser.rs
