sonic_rs/value/
de.rs

1use std::{mem::MaybeUninit, result::Result as StdResult, slice};
2
3use ::serde::{
4    de::{
5        self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
6        SeqAccess, Unexpected, VariantAccess, Visitor,
7    },
8    forward_to_deserialize_any,
9};
10
11use super::node::ValueRef;
12use crate::{
13    error::{Error, ErrorCode},
14    reader::Reader,
15    serde::{number::N, tri},
16    value::{node::Value, Object},
17};
18
19/// Interpret a `sonic_rs::Value` as an instance of type `T`.
20///
21/// # Example
22///
23/// ```
24/// use serde::Deserialize;
25/// use sonic_rs::json;
26///
27/// #[derive(Deserialize, Debug)]
28/// struct User {
29///     string: String,
30///     number: i32,
31///     array: Vec<String>,
32/// }
33///
34///  // The type of `j` is `sonic_rs::Value`
35///  let j = json!({
36///      "string": "hello",
37///      "number": 123,
38///      "array": ["a", "b", "c"],
39///  });
40///  let u: User = sonic_rs::from_value(&j).unwrap();
41///  assert_eq!(u.string, "hello");
42///  assert_eq!(u.number, 123);
43///  assert_eq!(u.array, vec!["a", "b", "c"]);
44/// ```
45///
46/// # Errors
47///
48/// This conversion can fail if the structure of the Value does not match the
49/// structure expected by `T`, for example if `T` is a struct type but the Value
50/// contains something other than a JSON map. It can also fail if the structure
51/// is correct but `T`'s implementation of `Deserialize` decides that something
52/// is wrong with the data, for example required struct fields are missing from
53/// the JSON map or some number is too big to fit in the expected primitive
54/// type.
55pub fn from_value<'de, T>(value: &'de Value) -> Result<T, Error>
56where
57    T: Deserialize<'de>,
58{
59    T::deserialize(value)
60}
61
62impl<'de> Deserialize<'de> for Value {
63    /// Deserialize this value from a `Deserializer`.
64    ///
65    /// # Examples
66    ///
67    /// ```
68    /// use sonic_rs::Value;
69    ///
70    /// let v: Value = sonic_rs::from_str(r#"{"a": 1, "b": 2}"#).unwrap();
71    /// assert_eq!(v["a"], 1);
72    /// assert_eq!(v["b"], 2);
73    /// ```
74    fn deserialize<D>(deserializer: D) -> StdResult<Self, D::Error>
75    where
76        D: ::serde::Deserializer<'de>,
77    {
78        deserializer.deserialize_newtype_struct(TOKEN, ValueVisitor)
79    }
80}
81
82pub(crate) const TOKEN: &str = "$sonic_rs::private::Value";
83
84pub(crate) struct ValueVisitor;
85
86impl<'de> Visitor<'de> for ValueVisitor {
87    type Value = Value;
88
89    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
90        formatter.write_str("a valid json")
91    }
92
93    fn visit_bytes<E>(self, value_binary: &[u8]) -> StdResult<Value, E>
94    where
95        E: de::Error,
96    {
97        // we pass the value from value_binary
98        unsafe {
99            assert!(
100                value_binary.len() == std::mem::size_of::<Value>(),
101                "invalid value size {}",
102                value_binary.len()
103            );
104            let mut dom: MaybeUninit<Value> = MaybeUninit::zeroed();
105            std::ptr::copy_nonoverlapping(
106                value_binary.as_ptr() as *const Value,
107                dom.as_mut_ptr(),
108                1,
109            );
110            Ok(dom.assume_init())
111        }
112    }
113}
114
115struct SeqRefDeserializer<'de> {
116    iter: slice::Iter<'de, Value>,
117}
118
119impl<'de> SeqRefDeserializer<'de> {
120    fn new(slice: &'de [Value]) -> Self {
121        SeqRefDeserializer { iter: slice.iter() }
122    }
123}
124
125impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
126    type Error = Error;
127
128    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
129    where
130        T: DeserializeSeed<'de>,
131    {
132        match self.iter.next() {
133            Some(value) => seed.deserialize(value).map(Some),
134            None => Ok(None),
135        }
136    }
137
138    fn size_hint(&self) -> Option<usize> {
139        match self.iter.size_hint() {
140            (lower, Some(upper)) if lower == upper => Some(upper),
141            _ => None,
142        }
143    }
144}
145
146struct MapRefDeserializer<'de> {
147    iter: <&'de Object as IntoIterator>::IntoIter,
148    value: Option<&'de Value>,
149}
150
151impl<'de> MapRefDeserializer<'de> {
152    fn new(map: &'de Object) -> Self {
153        MapRefDeserializer {
154            iter: map.into_iter(),
155            value: None,
156        }
157    }
158}
159
160impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
161    type Error = Error;
162
163    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
164    where
165        T: DeserializeSeed<'de>,
166    {
167        match self.iter.next() {
168            Some((key, value)) => {
169                self.value = Some(value);
170                let key_de = MapKeyDeserializer { key };
171                seed.deserialize(key_de).map(Some)
172            }
173            None => Ok(None),
174        }
175    }
176
177    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
178    where
179        T: DeserializeSeed<'de>,
180    {
181        match self.value.take() {
182            Some(value) => seed.deserialize(value),
183            None => Err(serde::de::Error::custom("value is missing")),
184        }
185    }
186
187    fn size_hint(&self) -> Option<usize> {
188        match self.iter.size_hint() {
189            (lower, Some(upper)) if lower == upper => Some(upper),
190            _ => None,
191        }
192    }
193}
194
195struct MapKeyDeserializer<'de> {
196    key: &'de str,
197}
198
199macro_rules! deserialize_numeric_key {
200    ($method:ident) => {
201        deserialize_numeric_key!($method, deserialize_number);
202    };
203
204    ($method:ident, $using:ident) => {
205        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
206        where
207            V: Visitor<'de>,
208        {
209            let mut de =
210                crate::Deserializer::new(crate::reader::Read::new(self.key.as_bytes(), false));
211            match de.parser.read.peek() {
212                Some(b'0'..=b'9' | b'-') => {}
213                _ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, b"", 0)),
214            }
215            let number = tri!(de.$using(visitor));
216            Ok(number)
217        }
218    };
219}
220
221impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
222    type Error = Error;
223
224    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
225    where
226        V: Visitor<'de>,
227    {
228        visitor.visit_borrowed_str(self.key)
229    }
230
231    deserialize_numeric_key!(deserialize_i8);
232    deserialize_numeric_key!(deserialize_i16);
233    deserialize_numeric_key!(deserialize_i32);
234    deserialize_numeric_key!(deserialize_i64);
235    deserialize_numeric_key!(deserialize_u8);
236    deserialize_numeric_key!(deserialize_u16);
237    deserialize_numeric_key!(deserialize_u32);
238    deserialize_numeric_key!(deserialize_u64);
239    // TODO: impl parsing f32
240    deserialize_numeric_key!(deserialize_f32);
241    deserialize_numeric_key!(deserialize_f64);
242    deserialize_numeric_key!(deserialize_i128, deserialize_i128);
243    deserialize_numeric_key!(deserialize_u128, deserialize_u128);
244
245    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
246    where
247        V: Visitor<'de>,
248    {
249        if self.key == "true" {
250            visitor.visit_bool(true)
251        } else if self.key == "false" {
252            visitor.visit_bool(false)
253        } else {
254            Err(serde::de::Error::invalid_type(
255                Unexpected::Str(self.key),
256                &visitor,
257            ))
258        }
259    }
260
261    #[inline]
262    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
263    where
264        V: Visitor<'de>,
265    {
266        // Map keys cannot be null.
267        visitor.visit_some(self)
268    }
269
270    #[inline]
271    fn deserialize_newtype_struct<V>(
272        self,
273        _name: &'static str,
274        visitor: V,
275    ) -> Result<V::Value, Error>
276    where
277        V: Visitor<'de>,
278    {
279        visitor.visit_newtype_struct(self)
280    }
281
282    fn deserialize_enum<V>(
283        self,
284        name: &'static str,
285        variants: &'static [&'static str],
286        visitor: V,
287    ) -> Result<V::Value, Error>
288    where
289        V: Visitor<'de>,
290    {
291        self.key
292            .into_deserializer()
293            .deserialize_enum(name, variants, visitor)
294    }
295
296    forward_to_deserialize_any! {
297        char str string bytes byte_buf unit unit_struct seq tuple tuple_struct
298        map struct identifier ignored_any
299    }
300}
301
302fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
303where
304    V: Visitor<'de>,
305{
306    let len = array.len();
307    let mut deserializer = SeqRefDeserializer::new(array);
308    let seq = tri!(visitor.visit_seq(&mut deserializer));
309    let remaining = deserializer.iter.len();
310    if remaining == 0 {
311        Ok(seq)
312    } else {
313        Err(serde::de::Error::invalid_length(
314            len,
315            &"fewer elements in array",
316        ))
317    }
318}
319
320fn visit_object_ref<'de, V>(object: &'de Object, visitor: V) -> Result<V::Value, Error>
321where
322    V: Visitor<'de>,
323{
324    let len = object.len();
325    let mut deserializer = MapRefDeserializer::new(object);
326    let map = tri!(visitor.visit_map(&mut deserializer));
327    let remaining = deserializer.iter.len();
328    if remaining == 0 {
329        Ok(map)
330    } else {
331        Err(serde::de::Error::invalid_length(
332            len,
333            &"fewer elements in map",
334        ))
335    }
336}
337
338macro_rules! deserialize_number {
339    ($method:ident) => {
340        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
341        where
342            V: Visitor<'de>,
343        {
344            match self.as_ref() {
345                ValueRef::Number(n) => n.deserialize_any(visitor),
346                _ => Err(self.invalid_type(&visitor)),
347            }
348        }
349    };
350}
351
352impl Value {
353    #[cold]
354    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
355    where
356        E: serde::de::Error,
357    {
358        serde::de::Error::invalid_type(self.unexpected(), exp)
359    }
360
361    #[cold]
362    fn unexpected(&self) -> Unexpected<'_> {
363        self.as_ref().unexpected()
364    }
365}
366
367impl<'a> ValueRef<'a> {
368    #[cold]
369    fn unexpected(&self) -> Unexpected<'a> {
370        match self {
371            ValueRef::Null => Unexpected::Unit,
372            ValueRef::Bool(b) => Unexpected::Bool(*b),
373            ValueRef::Number(n) => match n.n {
374                N::PosInt(u) => Unexpected::Unsigned(u),
375                N::NegInt(i) => Unexpected::Signed(i),
376                N::Float(f) => Unexpected::Float(f),
377            },
378            ValueRef::String(s) => Unexpected::Str(s),
379            ValueRef::Array(_) => Unexpected::Seq,
380            ValueRef::Object(_) => Unexpected::Map,
381        }
382    }
383}
384
385struct EnumRefDeserializer<'de> {
386    variant: &'de str,
387    value: Option<&'de Value>,
388}
389
390impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
391    type Error = Error;
392    type Variant = VariantRefDeserializer<'de>;
393
394    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
395    where
396        V: DeserializeSeed<'de>,
397    {
398        let variant = self.variant.into_deserializer();
399        let visitor = VariantRefDeserializer { value: self.value };
400        seed.deserialize(variant).map(|v| (v, visitor))
401    }
402}
403
404struct VariantRefDeserializer<'de> {
405    value: Option<&'de Value>,
406}
407
408impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
409    type Error = Error;
410
411    fn unit_variant(self) -> Result<(), Error> {
412        match self.value {
413            Some(value) => Deserialize::deserialize(value),
414            None => Ok(()),
415        }
416    }
417
418    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
419    where
420        T: DeserializeSeed<'de>,
421    {
422        match self.value {
423            Some(value) => seed.deserialize(value),
424            None => Err(serde::de::Error::invalid_type(
425                Unexpected::UnitVariant,
426                &"newtype variant",
427            )),
428        }
429    }
430
431    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
432    where
433        V: Visitor<'de>,
434    {
435        match self.value.map(|v| v.as_ref()) {
436            Some(ValueRef::Array(v)) => {
437                if v.is_empty() {
438                    visitor.visit_unit()
439                } else {
440                    visit_array_ref(v, visitor)
441                }
442            }
443            Some(other) => Err(serde::de::Error::invalid_type(
444                other.unexpected(),
445                &"tuple variant",
446            )),
447            None => Err(serde::de::Error::invalid_type(
448                Unexpected::UnitVariant,
449                &"tuple variant",
450            )),
451        }
452    }
453
454    fn struct_variant<V>(
455        self,
456        _fields: &'static [&'static str],
457        visitor: V,
458    ) -> Result<V::Value, Error>
459    where
460        V: Visitor<'de>,
461    {
462        match self.value.map(|v| v.as_ref()) {
463            Some(ValueRef::Object(v)) => visit_object_ref(v, visitor),
464            Some(other) => Err(serde::de::Error::invalid_type(
465                other.unexpected(),
466                &"struct variant",
467            )),
468            None => Err(serde::de::Error::invalid_type(
469                Unexpected::UnitVariant,
470                &"struct variant",
471            )),
472        }
473    }
474}
475
476impl<'de> IntoDeserializer<'de, Error> for &'de Value {
477    type Deserializer = Self;
478
479    fn into_deserializer(self) -> Self::Deserializer {
480        self
481    }
482}
483
484impl<'de> serde::Deserializer<'de> for &'de Value {
485    type Error = Error;
486
487    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
488    where
489        V: Visitor<'de>,
490    {
491        match self.as_ref() {
492            ValueRef::Null => visitor.visit_unit(),
493            ValueRef::Bool(v) => visitor.visit_bool(v),
494            ValueRef::Number(n) => n.deserialize_any(visitor),
495            ValueRef::String(v) => visitor.visit_borrowed_str(v),
496            ValueRef::Array(v) => visit_array_ref(v, visitor),
497            ValueRef::Object(v) => visit_object_ref(v, visitor),
498        }
499    }
500
501    deserialize_number!(deserialize_i8);
502    deserialize_number!(deserialize_i16);
503    deserialize_number!(deserialize_i32);
504    deserialize_number!(deserialize_i64);
505    deserialize_number!(deserialize_i128);
506    deserialize_number!(deserialize_u8);
507    deserialize_number!(deserialize_u16);
508    deserialize_number!(deserialize_u32);
509    deserialize_number!(deserialize_u64);
510    deserialize_number!(deserialize_u128);
511    deserialize_number!(deserialize_f32);
512    deserialize_number!(deserialize_f64);
513
514    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
515    where
516        V: Visitor<'de>,
517    {
518        match self.as_ref() {
519            ValueRef::Null => visitor.visit_none(),
520            _ => visitor.visit_some(self),
521        }
522    }
523
524    fn deserialize_enum<V>(
525        self,
526        _name: &str,
527        _variants: &'static [&'static str],
528        visitor: V,
529    ) -> Result<V::Value, Error>
530    where
531        V: Visitor<'de>,
532    {
533        let (variant, value) = match self.as_ref() {
534            ValueRef::Object(value) => {
535                let mut iter = value.into_iter();
536                let (variant, value) = match iter.next() {
537                    Some(v) => v,
538                    None => {
539                        return Err(serde::de::Error::invalid_value(
540                            Unexpected::Map,
541                            &"map with a single key",
542                        ));
543                    }
544                };
545                // enums are encoded in json as maps with a single key:value pair
546                if iter.next().is_some() {
547                    return Err(serde::de::Error::invalid_value(
548                        Unexpected::Map,
549                        &"map with a single key",
550                    ));
551                }
552                (variant, Some(value))
553            }
554            ValueRef::String(variant) => (variant, None),
555            other => {
556                return Err(serde::de::Error::invalid_type(
557                    other.unexpected(),
558                    &"string or map",
559                ));
560            }
561        };
562
563        visitor.visit_enum(EnumRefDeserializer { variant, value })
564    }
565
566    #[inline]
567    fn deserialize_newtype_struct<V>(
568        self,
569        _name: &'static str,
570        visitor: V,
571    ) -> Result<V::Value, Error>
572    where
573        V: Visitor<'de>,
574    {
575        visitor.visit_newtype_struct(self)
576    }
577
578    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
579    where
580        V: Visitor<'de>,
581    {
582        match self.as_ref() {
583            ValueRef::Bool(v) => visitor.visit_bool(v),
584            _ => Err(self.invalid_type(&visitor)),
585        }
586    }
587
588    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
589    where
590        V: Visitor<'de>,
591    {
592        self.deserialize_str(visitor)
593    }
594
595    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
596    where
597        V: Visitor<'de>,
598    {
599        match self.as_ref() {
600            ValueRef::String(v) => visitor.visit_borrowed_str(v),
601            _ => Err(self.invalid_type(&visitor)),
602        }
603    }
604
605    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
606    where
607        V: Visitor<'de>,
608    {
609        self.deserialize_str(visitor)
610    }
611
612    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
613    where
614        V: Visitor<'de>,
615    {
616        match self.as_ref() {
617            ValueRef::String(v) => visitor.visit_borrowed_str(v),
618            ValueRef::Array(v) => visit_array_ref(v, visitor),
619            _ => Err(self.invalid_type(&visitor)),
620        }
621    }
622
623    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
624    where
625        V: Visitor<'de>,
626    {
627        self.deserialize_bytes(visitor)
628    }
629
630    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
631    where
632        V: Visitor<'de>,
633    {
634        match self.as_ref() {
635            ValueRef::Null => visitor.visit_unit(),
636            _ => Err(self.invalid_type(&visitor)),
637        }
638    }
639
640    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
641    where
642        V: Visitor<'de>,
643    {
644        self.deserialize_unit(visitor)
645    }
646
647    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
648    where
649        V: Visitor<'de>,
650    {
651        match self.as_ref() {
652            ValueRef::Array(v) => visit_array_ref(v, visitor),
653            _ => Err(self.invalid_type(&visitor)),
654        }
655    }
656
657    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
658    where
659        V: Visitor<'de>,
660    {
661        self.deserialize_seq(visitor)
662    }
663
664    fn deserialize_tuple_struct<V>(
665        self,
666        _name: &'static str,
667        _len: usize,
668        visitor: V,
669    ) -> Result<V::Value, Error>
670    where
671        V: Visitor<'de>,
672    {
673        self.deserialize_seq(visitor)
674    }
675
676    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
677    where
678        V: Visitor<'de>,
679    {
680        match self.as_ref() {
681            ValueRef::Object(v) => visit_object_ref(v, visitor),
682            _ => Err(self.invalid_type(&visitor)),
683        }
684    }
685
686    fn deserialize_struct<V>(
687        self,
688        _name: &'static str,
689        _fields: &'static [&'static str],
690        visitor: V,
691    ) -> Result<V::Value, Error>
692    where
693        V: Visitor<'de>,
694    {
695        match self.as_ref() {
696            ValueRef::Array(v) => visit_array_ref(v, visitor),
697            ValueRef::Object(v) => visit_object_ref(v, visitor),
698            _ => Err(self.invalid_type(&visitor)),
699        }
700    }
701
702    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
703    where
704        V: Visitor<'de>,
705    {
706        self.deserialize_str(visitor)
707    }
708
709    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
710    where
711        V: Visitor<'de>,
712    {
713        visitor.visit_unit()
714    }
715}
716
717#[cfg(test)]
718mod test {
719
720    #[test]
721    fn test_value_as_deserializer() {
722        // unimplemented!()
723    }
724}
sonic_rs/value/de.rs

sonic_rs/value/
de.rs
