serde_intermediate/ser/
object.rs

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

serde_intermediate/ser/
object.rs
