serde_intermediate/ser/
intermediate.rs

1use crate::{error::*, value::intermediate::*};
2use serde::Serialize;
3
4pub fn serialize<T>(value: &T) -> Result<Intermediate>
5where
6    T: Serialize + ?Sized,
7{
8    value.serialize(Serializer)
9}
10
11pub struct Serializer;
12
13macro_rules! impl_serialize {
14    ($name:ident, $variant:ident, $type:ident) => {
15        fn $name(self, v: $type) -> Result<Self::Ok> {
16            Ok(Intermediate::$variant(v))
17        }
18    };
19}
20
21impl serde::ser::Serializer for Serializer {
22    type Ok = Intermediate;
23    type Error = Error;
24    type SerializeSeq = SeqSerializer;
25    type SerializeTuple = TupleSerializer;
26    type SerializeTupleStruct = TupleStructSerializer;
27    type SerializeTupleVariant = TupleVariantSerializer;
28    type SerializeMap = MapSerializer;
29    type SerializeStruct = StructSerializer;
30    type SerializeStructVariant = StructVariantSerializer;
31
32    impl_serialize!(serialize_bool, Bool, bool);
33    impl_serialize!(serialize_i8, I8, i8);
34    impl_serialize!(serialize_i16, I16, i16);
35    impl_serialize!(serialize_i32, I32, i32);
36    impl_serialize!(serialize_i64, I64, i64);
37    impl_serialize!(serialize_i128, I128, i128);
38    impl_serialize!(serialize_u8, U8, u8);
39    impl_serialize!(serialize_u16, U16, u16);
40    impl_serialize!(serialize_u32, U32, u32);
41    impl_serialize!(serialize_u64, U64, u64);
42    impl_serialize!(serialize_u128, U128, u128);
43    impl_serialize!(serialize_f32, F32, f32);
44    impl_serialize!(serialize_f64, F64, f64);
45    impl_serialize!(serialize_char, Char, char);
46
47    fn serialize_str(self, v: &str) -> Result<Self::Ok> {
48        Ok(Intermediate::String(v.to_owned()))
49    }
50
51    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
52        Ok(Intermediate::Bytes(v.to_owned()))
53    }
54
55    fn serialize_none(self) -> Result<Self::Ok> {
56        Ok(Intermediate::Option(None))
57    }
58
59    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
60    where
61        T: ?Sized + Serialize,
62    {
63        Ok(Intermediate::Option(Some(Box::new(value.serialize(self)?))))
64    }
65
66    fn serialize_unit(self) -> Result<Self::Ok> {
67        Ok(Intermediate::Unit)
68    }
69
70    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok> {
71        Ok(Intermediate::UnitStruct)
72    }
73
74    fn serialize_unit_variant(
75        self,
76        _: &'static str,
77        _: u32,
78        variant: &'static str,
79    ) -> Result<Self::Ok> {
80        Ok(Intermediate::UnitVariant(variant.to_owned()))
81    }
82
83    fn serialize_newtype_struct<T>(self, _: &'static str, value: &T) -> Result<Self::Ok>
84    where
85        T: ?Sized + Serialize,
86    {
87        Ok(Intermediate::NewTypeStruct(Box::new(
88            value.serialize(self)?,
89        )))
90    }
91
92    fn serialize_newtype_variant<T>(
93        self,
94        _: &'static str,
95        _: u32,
96        variant: &'static str,
97        value: &T,
98    ) -> Result<Self::Ok>
99    where
100        T: ?Sized + Serialize,
101    {
102        Ok(Intermediate::NewTypeVariant(
103            variant.to_owned(),
104            Box::new(value.serialize(self)?),
105        ))
106    }
107
108    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
109        Ok(SeqSerializer {
110            values: match len {
111                Some(len) => Vec::with_capacity(len),
112                None => vec![],
113            },
114        })
115    }
116
117    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
118        Ok(TupleSerializer {
119            values: Vec::with_capacity(len),
120        })
121    }
122
123    fn serialize_tuple_struct(
124        self,
125        _: &'static str,
126        len: usize,
127    ) -> Result<Self::SerializeTupleStruct> {
128        Ok(TupleStructSerializer {
129            values: Vec::with_capacity(len),
130        })
131    }
132
133    fn serialize_tuple_variant(
134        self,
135        _: &'static str,
136        _: u32,
137        variant: &'static str,
138        len: usize,
139    ) -> Result<Self::SerializeTupleVariant> {
140        Ok(TupleVariantSerializer {
141            variant: variant.to_owned(),
142            values: Vec::with_capacity(len),
143        })
144    }
145
146    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
147        Ok(MapSerializer {
148            values: match len {
149                Some(len) => Vec::with_capacity(len),
150                None => vec![],
151            },
152        })
153    }
154
155    fn serialize_struct(self, _: &'static str, len: usize) -> Result<Self::SerializeStruct> {
156        Ok(StructSerializer {
157            values: Vec::with_capacity(len),
158        })
159    }
160
161    fn serialize_struct_variant(
162        self,
163        _: &'static str,
164        _: u32,
165        variant: &'static str,
166        len: usize,
167    ) -> Result<Self::SerializeStructVariant> {
168        Ok(StructVariantSerializer {
169            variant: variant.to_owned(),
170            values: Vec::with_capacity(len),
171        })
172    }
173}
174
175pub struct SeqSerializer {
176    values: Vec<Intermediate>,
177}
178
179impl serde::ser::SerializeSeq for SeqSerializer {
180    type Ok = Intermediate;
181    type Error = Error;
182
183    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
184    where
185        T: ?Sized + Serialize,
186    {
187        self.values.push(value.serialize(Serializer)?);
188        Ok(())
189    }
190
191    fn end(self) -> Result<Self::Ok> {
192        Ok(Intermediate::Seq(self.values))
193    }
194}
195
196pub struct TupleSerializer {
197    values: Vec<Intermediate>,
198}
199
200impl serde::ser::SerializeTuple for TupleSerializer {
201    type Ok = Intermediate;
202    type Error = Error;
203
204    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
205    where
206        T: ?Sized + Serialize,
207    {
208        self.values.push(value.serialize(Serializer)?);
209        Ok(())
210    }
211
212    fn end(self) -> Result<Self::Ok> {
213        Ok(Intermediate::Tuple(self.values))
214    }
215}
216
217pub struct TupleStructSerializer {
218    values: Vec<Intermediate>,
219}
220
221impl serde::ser::SerializeTupleStruct for TupleStructSerializer {
222    type Ok = Intermediate;
223    type Error = Error;
224
225    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
226    where
227        T: ?Sized + Serialize,
228    {
229        self.values.push(value.serialize(Serializer)?);
230        Ok(())
231    }
232
233    fn end(self) -> Result<Self::Ok> {
234        Ok(Intermediate::TupleStruct(self.values))
235    }
236}
237
238pub struct TupleVariantSerializer {
239    variant: String,
240    values: Vec<Intermediate>,
241}
242
243impl serde::ser::SerializeTupleVariant for TupleVariantSerializer {
244    type Ok = Intermediate;
245    type Error = Error;
246
247    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
248    where
249        T: ?Sized + Serialize,
250    {
251        self.values.push(value.serialize(Serializer)?);
252        Ok(())
253    }
254
255    fn end(self) -> Result<Self::Ok> {
256        Ok(Intermediate::TupleVariant(self.variant, self.values))
257    }
258}
259
260pub struct MapSerializer {
261    values: Vec<(Intermediate, Intermediate)>,
262}
263
264impl serde::ser::SerializeMap for MapSerializer {
265    type Ok = Intermediate;
266    type Error = Error;
267
268    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
269    where
270        T: ?Sized + Serialize,
271    {
272        self.values
273            .push((key.serialize(Serializer)?, Intermediate::Unit));
274        Ok(())
275    }
276
277    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
278    where
279        T: ?Sized + Serialize,
280    {
281        self.values.last_mut().unwrap().1 = value.serialize(Serializer)?;
282        Ok(())
283    }
284
285    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
286    where
287        K: ?Sized + Serialize,
288        V: ?Sized + Serialize,
289    {
290        self.values
291            .push((key.serialize(Serializer)?, value.serialize(Serializer)?));
292        Ok(())
293    }
294
295    fn end(self) -> Result<Self::Ok> {
296        Ok(Intermediate::Map(self.values))
297    }
298}
299
300pub struct StructSerializer {
301    values: Vec<(String, Intermediate)>,
302}
303
304impl serde::ser::SerializeStruct for StructSerializer {
305    type Ok = Intermediate;
306    type Error = Error;
307
308    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
309    where
310        T: ?Sized + Serialize,
311    {
312        self.values
313            .push((key.to_owned(), value.serialize(Serializer)?));
314        Ok(())
315    }
316
317    fn end(self) -> Result<Intermediate> {
318        Ok(Intermediate::Struct(self.values))
319    }
320}
321
322pub struct StructVariantSerializer {
323    variant: String,
324    values: Vec<(String, Intermediate)>,
325}
326
327impl serde::ser::SerializeStructVariant for StructVariantSerializer {
328    type Ok = Intermediate;
329    type Error = Error;
330
331    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
332    where
333        T: ?Sized + Serialize,
334    {
335        self.values
336            .push((key.to_owned(), value.serialize(Serializer)?));
337        Ok(())
338    }
339
340    fn end(self) -> Result<Intermediate> {
341        Ok(Intermediate::StructVariant(self.variant, self.values))
342    }
343}
serde_intermediate/ser/intermediate.rs

serde_intermediate/ser/
intermediate.rs
