rimu_value/serde/
ser.rs

1// https://github.com/serde-rs/json/blob/master/src/value/ser.rs
2
3use indexmap::IndexMap;
4use serde::{ser::Impossible, Serialize};
5use std::fmt::Display;
6
7use super::{to_serde_value, SerdeValue, SerdeValueError, SerdeValueObject};
8
9impl Serialize for SerdeValue {
10    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
11    where
12        S: serde::Serializer,
13    {
14        match self {
15            SerdeValue::Null => serializer.serialize_unit(),
16            SerdeValue::Boolean(boolean) => serializer.serialize_bool(*boolean),
17            SerdeValue::Number(number) => number.serialize(serializer),
18            SerdeValue::String(string) => serializer.serialize_str(string),
19            SerdeValue::List(list) => list.serialize(serializer),
20            SerdeValue::Object(object) => object.serialize(serializer),
21            // TODO
22            SerdeValue::Function(_) => serializer.serialize_unit(),
23        }
24    }
25}
26
27pub struct Serializer;
28
29impl serde::Serializer for Serializer {
30    type Ok = SerdeValue;
31    type Error = SerdeValueError;
32
33    type SerializeSeq = SerializeVec;
34    type SerializeTuple = SerializeVec;
35    type SerializeTupleStruct = SerializeVec;
36    type SerializeTupleVariant = SerializeTupleVariant;
37    type SerializeMap = SerializeMap;
38    type SerializeStruct = SerializeMap;
39    type SerializeStructVariant = SerializeStructVariant;
40
41    #[inline]
42    fn serialize_bool(self, value: bool) -> Result<SerdeValue, SerdeValueError> {
43        Ok(SerdeValue::Boolean(value))
44    }
45
46    #[inline]
47    fn serialize_i8(self, value: i8) -> Result<SerdeValue, SerdeValueError> {
48        self.serialize_i64(value as i64)
49    }
50
51    #[inline]
52    fn serialize_i16(self, value: i16) -> Result<SerdeValue, SerdeValueError> {
53        self.serialize_i64(value as i64)
54    }
55
56    #[inline]
57    fn serialize_i32(self, value: i32) -> Result<SerdeValue, SerdeValueError> {
58        self.serialize_i64(value as i64)
59    }
60
61    fn serialize_i64(self, value: i64) -> Result<SerdeValue, SerdeValueError> {
62        Ok(SerdeValue::Number(value.into()))
63    }
64
65    fn serialize_i128(self, value: i128) -> Result<SerdeValue, SerdeValueError> {
66        if let Ok(value) = u64::try_from(value) {
67            Ok(SerdeValue::Number(value.into()))
68        } else if let Ok(value) = i64::try_from(value) {
69            Ok(SerdeValue::Number(value.into()))
70        } else {
71            Err(SerdeValueError::NumberOutOfRange)
72        }
73    }
74
75    #[inline]
76    fn serialize_u8(self, value: u8) -> Result<SerdeValue, SerdeValueError> {
77        self.serialize_u64(value as u64)
78    }
79
80    #[inline]
81    fn serialize_u16(self, value: u16) -> Result<SerdeValue, SerdeValueError> {
82        self.serialize_u64(value as u64)
83    }
84
85    #[inline]
86    fn serialize_u32(self, value: u32) -> Result<SerdeValue, SerdeValueError> {
87        self.serialize_u64(value as u64)
88    }
89
90    #[inline]
91    fn serialize_u64(self, value: u64) -> Result<SerdeValue, SerdeValueError> {
92        Ok(SerdeValue::Number(value.into()))
93    }
94
95    fn serialize_u128(self, value: u128) -> Result<SerdeValue, SerdeValueError> {
96        if let Ok(value) = u64::try_from(value) {
97            Ok(SerdeValue::Number(value.into()))
98        } else {
99            Err(SerdeValueError::NumberOutOfRange)
100        }
101    }
102
103    #[inline]
104    fn serialize_f32(self, float: f32) -> Result<SerdeValue, SerdeValueError> {
105        Ok(SerdeValue::from(float))
106    }
107
108    #[inline]
109    fn serialize_f64(self, float: f64) -> Result<SerdeValue, SerdeValueError> {
110        Ok(SerdeValue::from(float))
111    }
112
113    #[inline]
114    fn serialize_char(self, value: char) -> Result<SerdeValue, SerdeValueError> {
115        let mut s = String::new();
116        s.push(value);
117        Ok(SerdeValue::String(s))
118    }
119
120    #[inline]
121    fn serialize_str(self, value: &str) -> Result<SerdeValue, SerdeValueError> {
122        Ok(SerdeValue::String(value.to_owned()))
123    }
124
125    fn serialize_bytes(self, value: &[u8]) -> Result<SerdeValue, SerdeValueError> {
126        let vec = value
127            .iter()
128            .map(|&b| SerdeValue::Number(b.into()))
129            .collect();
130        Ok(SerdeValue::List(vec))
131    }
132
133    #[inline]
134    fn serialize_unit(self) -> Result<SerdeValue, SerdeValueError> {
135        Ok(SerdeValue::Null)
136    }
137
138    #[inline]
139    fn serialize_unit_struct(self, _name: &'static str) -> Result<SerdeValue, SerdeValueError> {
140        self.serialize_unit()
141    }
142
143    #[inline]
144    fn serialize_unit_variant(
145        self,
146        _name: &'static str,
147        _variant_index: u32,
148        variant: &'static str,
149    ) -> Result<SerdeValue, SerdeValueError> {
150        self.serialize_str(variant)
151    }
152
153    #[inline]
154    fn serialize_newtype_struct<T>(
155        self,
156        _name: &'static str,
157        value: &T,
158    ) -> Result<SerdeValue, SerdeValueError>
159    where
160        T: ?Sized + Serialize,
161    {
162        value.serialize(self)
163    }
164
165    fn serialize_newtype_variant<T>(
166        self,
167        _name: &'static str,
168        _variant_index: u32,
169        variant: &'static str,
170        value: &T,
171    ) -> Result<SerdeValue, SerdeValueError>
172    where
173        T: ?Sized + Serialize,
174    {
175        let mut values = SerdeValueObject::new();
176        values.insert(String::from(variant), to_serde_value(value)?);
177        Ok(SerdeValue::Object(values))
178    }
179
180    #[inline]
181    fn serialize_none(self) -> Result<SerdeValue, SerdeValueError> {
182        self.serialize_unit()
183    }
184
185    #[inline]
186    fn serialize_some<T>(self, value: &T) -> Result<SerdeValue, SerdeValueError>
187    where
188        T: ?Sized + Serialize,
189    {
190        value.serialize(self)
191    }
192
193    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, SerdeValueError> {
194        Ok(SerializeVec {
195            vec: Vec::with_capacity(len.unwrap_or(0)),
196        })
197    }
198
199    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, SerdeValueError> {
200        self.serialize_seq(Some(len))
201    }
202
203    fn serialize_tuple_struct(
204        self,
205        _name: &'static str,
206        len: usize,
207    ) -> Result<Self::SerializeTupleStruct, SerdeValueError> {
208        self.serialize_seq(Some(len))
209    }
210
211    fn serialize_tuple_variant(
212        self,
213        _name: &'static str,
214        _variant_index: u32,
215        variant: &'static str,
216        len: usize,
217    ) -> Result<Self::SerializeTupleVariant, SerdeValueError> {
218        Ok(SerializeTupleVariant {
219            name: String::from(variant),
220            vec: Vec::with_capacity(len),
221        })
222    }
223
224    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerdeValueError> {
225        Ok(SerializeMap::Map {
226            map: SerdeValueObject::new(),
227            next_key: None,
228        })
229    }
230
231    fn serialize_struct(
232        self,
233        _name: &'static str,
234        len: usize,
235    ) -> Result<Self::SerializeStruct, SerdeValueError> {
236        self.serialize_map(Some(len))
237    }
238
239    fn serialize_struct_variant(
240        self,
241        _name: &'static str,
242        _variant_index: u32,
243        variant: &'static str,
244        _len: usize,
245    ) -> Result<Self::SerializeStructVariant, SerdeValueError> {
246        Ok(SerializeStructVariant {
247            name: String::from(variant),
248            map: SerdeValueObject::new(),
249        })
250    }
251
252    fn collect_str<T>(self, value: &T) -> Result<SerdeValue, SerdeValueError>
253    where
254        T: ?Sized + Display,
255    {
256        Ok(SerdeValue::String(value.to_string()))
257    }
258}
259
260pub struct SerializeVec {
261    vec: Vec<SerdeValue>,
262}
263
264pub struct SerializeTupleVariant {
265    name: String,
266    vec: Vec<SerdeValue>,
267}
268
269pub enum SerializeMap {
270    Map {
271        map: IndexMap<String, SerdeValue>,
272        next_key: Option<String>,
273    },
274}
275
276pub struct SerializeStructVariant {
277    name: String,
278    map: IndexMap<String, SerdeValue>,
279}
280
281impl serde::ser::SerializeSeq for SerializeVec {
282    type Ok = SerdeValue;
283    type Error = SerdeValueError;
284
285    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
286    where
287        T: ?Sized + Serialize,
288    {
289        self.vec.push(to_serde_value(value)?);
290        Ok(())
291    }
292
293    fn end(self) -> Result<SerdeValue, SerdeValueError> {
294        Ok(SerdeValue::List(self.vec))
295    }
296}
297
298impl serde::ser::SerializeTuple for SerializeVec {
299    type Ok = SerdeValue;
300    type Error = SerdeValueError;
301
302    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
303    where
304        T: ?Sized + Serialize,
305    {
306        serde::ser::SerializeSeq::serialize_element(self, value)
307    }
308
309    fn end(self) -> Result<SerdeValue, Self::Error> {
310        serde::ser::SerializeSeq::end(self)
311    }
312}
313
314impl serde::ser::SerializeTupleStruct for SerializeVec {
315    type Ok = SerdeValue;
316    type Error = SerdeValueError;
317
318    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
319    where
320        T: ?Sized + Serialize,
321    {
322        serde::ser::SerializeSeq::serialize_element(self, value)
323    }
324
325    fn end(self) -> Result<Self::Ok, Self::Error> {
326        serde::ser::SerializeSeq::end(self)
327    }
328}
329
330impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
331    type Ok = SerdeValue;
332    type Error = SerdeValueError;
333
334    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
335    where
336        T: ?Sized + Serialize,
337    {
338        self.vec.push(to_serde_value(value)?);
339        Ok(())
340    }
341
342    fn end(self) -> Result<Self::Ok, Self::Error> {
343        let mut object = SerdeValueObject::new();
344
345        object.insert(self.name, SerdeValue::List(self.vec));
346
347        Ok(SerdeValue::Object(object))
348    }
349}
350
351impl serde::ser::SerializeMap for SerializeMap {
352    type Ok = SerdeValue;
353    type Error = SerdeValueError;
354
355    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
356    where
357        T: ?Sized + Serialize,
358    {
359        match self {
360            SerializeMap::Map { next_key, .. } => {
361                *next_key = Some(key.serialize(MapKeySerializer)?);
362                Ok(())
363            }
364        }
365    }
366
367    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
368    where
369        T: ?Sized + Serialize,
370    {
371        match self {
372            SerializeMap::Map { map, next_key } => {
373                let key = next_key.take();
374                // Panic because this indicates a bug in the program rather than an
375                // expected failure.
376                let key = key.expect("serialize_value called before serialize_key");
377                map.insert(key, to_serde_value(value)?);
378                Ok(())
379            }
380        }
381    }
382
383    fn end(self) -> Result<Self::Ok, Self::Error> {
384        match self {
385            SerializeMap::Map { map, .. } => Ok(SerdeValue::Object(map)),
386        }
387    }
388}
389
390struct MapKeySerializer;
391
392fn key_must_be_a_string() -> SerdeValueError {
393    SerdeValueError::KeyMustBeAString
394}
395
396fn float_key_must_be_finite() -> SerdeValueError {
397    SerdeValueError::FloatKeyMustBeFinite
398}
399
400impl serde::Serializer for MapKeySerializer {
401    type Ok = String;
402    type Error = SerdeValueError;
403
404    type SerializeSeq = Impossible<String, SerdeValueError>;
405    type SerializeTuple = Impossible<String, SerdeValueError>;
406    type SerializeTupleStruct = Impossible<String, SerdeValueError>;
407    type SerializeTupleVariant = Impossible<String, SerdeValueError>;
408    type SerializeMap = Impossible<String, SerdeValueError>;
409    type SerializeStruct = Impossible<String, SerdeValueError>;
410    type SerializeStructVariant = Impossible<String, SerdeValueError>;
411
412    #[inline]
413    fn serialize_unit_variant(
414        self,
415        _name: &'static str,
416        _variant_index: u32,
417        variant: &'static str,
418    ) -> Result<String, Self::Error> {
419        Ok(variant.to_owned())
420    }
421
422    #[inline]
423    fn serialize_newtype_struct<T>(
424        self,
425        _name: &'static str,
426        value: &T,
427    ) -> Result<String, Self::Error>
428    where
429        T: ?Sized + Serialize,
430    {
431        value.serialize(self)
432    }
433
434    fn serialize_bool(self, _value: bool) -> Result<String, Self::Error> {
435        Err(key_must_be_a_string())
436    }
437
438    fn serialize_i8(self, value: i8) -> Result<String, Self::Error> {
439        Ok(value.to_string())
440    }
441
442    fn serialize_i16(self, value: i16) -> Result<String, SerdeValueError> {
443        Ok(value.to_string())
444    }
445
446    fn serialize_i32(self, value: i32) -> Result<String, SerdeValueError> {
447        Ok(value.to_string())
448    }
449
450    fn serialize_i64(self, value: i64) -> Result<String, SerdeValueError> {
451        Ok(value.to_string())
452    }
453
454    fn serialize_u8(self, value: u8) -> Result<String, SerdeValueError> {
455        Ok(value.to_string())
456    }
457
458    fn serialize_u16(self, value: u16) -> Result<String, SerdeValueError> {
459        Ok(value.to_string())
460    }
461
462    fn serialize_u32(self, value: u32) -> Result<String, SerdeValueError> {
463        Ok(value.to_string())
464    }
465
466    fn serialize_u64(self, value: u64) -> Result<String, SerdeValueError> {
467        Ok(value.to_string())
468    }
469
470    fn serialize_f32(self, value: f32) -> Result<String, SerdeValueError> {
471        if value.is_finite() {
472            Ok(ryu::Buffer::new().format_finite(value).to_owned())
473        } else {
474            Err(float_key_must_be_finite())
475        }
476    }
477
478    fn serialize_f64(self, value: f64) -> Result<String, SerdeValueError> {
479        if value.is_finite() {
480            Ok(ryu::Buffer::new().format_finite(value).to_owned())
481        } else {
482            Err(float_key_must_be_finite())
483        }
484    }
485
486    #[inline]
487    fn serialize_char(self, value: char) -> Result<String, SerdeValueError> {
488        Ok({
489            let mut s = String::new();
490            s.push(value);
491            s
492        })
493    }
494
495    #[inline]
496    fn serialize_str(self, value: &str) -> Result<String, SerdeValueError> {
497        Ok(value.to_owned())
498    }
499
500    fn serialize_bytes(self, _value: &[u8]) -> Result<String, SerdeValueError> {
501        Err(key_must_be_a_string())
502    }
503
504    fn serialize_unit(self) -> Result<String, SerdeValueError> {
505        Err(key_must_be_a_string())
506    }
507
508    fn serialize_unit_struct(self, _name: &'static str) -> Result<String, SerdeValueError> {
509        Err(key_must_be_a_string())
510    }
511
512    fn serialize_newtype_variant<T>(
513        self,
514        _name: &'static str,
515        _variant_index: u32,
516        _variant: &'static str,
517        _value: &T,
518    ) -> Result<String, SerdeValueError>
519    where
520        T: ?Sized + Serialize,
521    {
522        Err(key_must_be_a_string())
523    }
524
525    fn serialize_none(self) -> Result<String, SerdeValueError> {
526        Err(key_must_be_a_string())
527    }
528
529    fn serialize_some<T>(self, _value: &T) -> Result<String, SerdeValueError>
530    where
531        T: ?Sized + Serialize,
532    {
533        Err(key_must_be_a_string())
534    }
535
536    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
537        Err(key_must_be_a_string())
538    }
539
540    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
541        Err(key_must_be_a_string())
542    }
543
544    fn serialize_tuple_struct(
545        self,
546        _name: &'static str,
547        _len: usize,
548    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
549        Err(key_must_be_a_string())
550    }
551
552    fn serialize_tuple_variant(
553        self,
554        _name: &'static str,
555        _variant_index: u32,
556        _variant: &'static str,
557        _len: usize,
558    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
559        Err(key_must_be_a_string())
560    }
561
562    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
563        Err(key_must_be_a_string())
564    }
565
566    fn serialize_struct(
567        self,
568        _name: &'static str,
569        _len: usize,
570    ) -> Result<Self::SerializeStruct, Self::Error> {
571        Err(key_must_be_a_string())
572    }
573
574    fn serialize_struct_variant(
575        self,
576        _name: &'static str,
577        _variant_index: u32,
578        _variant: &'static str,
579        _len: usize,
580    ) -> Result<Self::SerializeStructVariant, SerdeValueError> {
581        Err(key_must_be_a_string())
582    }
583
584    fn collect_str<T>(self, value: &T) -> Result<String, SerdeValueError>
585    where
586        T: ?Sized + Display,
587    {
588        Ok(value.to_string())
589    }
590}
591
592impl serde::ser::SerializeStruct for SerializeMap {
593    type Ok = SerdeValue;
594    type Error = SerdeValueError;
595
596    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
597    where
598        T: ?Sized + Serialize,
599    {
600        match self {
601            SerializeMap::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value),
602        }
603    }
604
605    fn end(self) -> Result<Self::Ok, Self::Error> {
606        match self {
607            SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
608        }
609    }
610}
611
612impl serde::ser::SerializeStructVariant for SerializeStructVariant {
613    type Ok = SerdeValue;
614    type Error = SerdeValueError;
615
616    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), SerdeValueError>
617    where
618        T: ?Sized + Serialize,
619    {
620        self.map.insert(String::from(key), to_serde_value(value)?);
621        Ok(())
622    }
623
624    fn end(self) -> Result<Self::Ok, SerdeValueError> {
625        let mut object = SerdeValueObject::new();
626
627        object.insert(self.name, SerdeValue::Object(self.map));
628
629        Ok(SerdeValue::Object(object))
630    }
631}
rimu_value/serde/ser.rs

rimu_value/serde/
ser.rs
