hash_value/
ser.rs

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

hash_value/
ser.rs
