serde_bridge/
de.rs

1use std::fmt::Formatter;
2use std::vec::IntoIter;
3
4use anyhow::anyhow;
5use indexmap::IndexMap;
6use serde::de::{DeserializeOwned, DeserializeSeed, MapAccess, SeqAccess, Visitor};
7use serde::{de, Deserialize};
8
9use crate::{Error, Value};
10
11/// Convert [`Value`] into `T: DeserializeOwned`.
12///
13/// # Examples
14///
15/// ```
16/// use serde_bridge::{from_value, Value};
17/// # use anyhow::Result;
18/// # fn main() -> Result<()> {
19/// let v: bool = from_value(Value::Bool(true))?;
20/// # assert!(v);
21/// # Ok(())
22/// # }
23/// ```
24pub fn from_value<T: DeserializeOwned>(v: Value) -> Result<T, Error> {
25    T::deserialize(Deserializer(v))
26}
27
28/// Convert [`Value`] into `T: DeserializeOwned`.
29///
30/// # Examples
31///
32/// ```
33/// use serde_bridge::{FromValue, Value};
34/// # use anyhow::Result;
35/// # fn main() -> Result<()>{
36/// let v = bool::from_value(Value::Bool(true))?;
37/// # assert!(v);
38/// # Ok(())
39/// # }
40/// ```
41pub trait FromValue {
42    fn from_value(v: Value) -> Result<Self, Error>
43    where
44        Self: Sized;
45}
46
47impl<T> FromValue for T
48where
49    T: DeserializeOwned,
50{
51    fn from_value(v: Value) -> Result<Self, Error> {
52        from_value(v)
53    }
54}
55
56struct ValueVisitor;
57
58impl<'de> Visitor<'de> for ValueVisitor {
59    type Value = Value;
60
61    fn expecting(&self, f: &mut Formatter) -> std::fmt::Result {
62        write!(f, "expecting visitor")
63    }
64
65    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
66    where
67        E: de::Error,
68    {
69        Ok(Value::Bool(v))
70    }
71
72    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
73    where
74        E: de::Error,
75    {
76        Ok(Value::I8(v))
77    }
78
79    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
80    where
81        E: de::Error,
82    {
83        Ok(Value::I16(v))
84    }
85
86    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
87    where
88        E: de::Error,
89    {
90        Ok(Value::I32(v))
91    }
92
93    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
94    where
95        E: de::Error,
96    {
97        Ok(Value::I64(v))
98    }
99
100    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
101    where
102        E: de::Error,
103    {
104        Ok(Value::U8(v))
105    }
106
107    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
108    where
109        E: de::Error,
110    {
111        Ok(Value::U16(v))
112    }
113
114    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
115    where
116        E: de::Error,
117    {
118        Ok(Value::U32(v))
119    }
120
121    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
122    where
123        E: de::Error,
124    {
125        Ok(Value::U64(v))
126    }
127
128    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
129    where
130        E: de::Error,
131    {
132        Ok(Value::F32(v))
133    }
134
135    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
136    where
137        E: de::Error,
138    {
139        Ok(Value::F64(v))
140    }
141
142    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
143    where
144        E: de::Error,
145    {
146        Ok(Value::Char(v))
147    }
148
149    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
150    where
151        E: de::Error,
152    {
153        Ok(Value::Str(v.to_string()))
154    }
155
156    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
157    where
158        E: de::Error,
159    {
160        Ok(Value::Str(v.to_string()))
161    }
162
163    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
164    where
165        E: de::Error,
166    {
167        Ok(Value::Str(v))
168    }
169
170    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
171    where
172        E: de::Error,
173    {
174        Ok(Value::Bytes(v.to_vec()))
175    }
176
177    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
178    where
179        E: de::Error,
180    {
181        Ok(Value::Bytes(v.to_vec()))
182    }
183
184    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
185    where
186        E: de::Error,
187    {
188        Ok(Value::Bytes(v))
189    }
190
191    fn visit_none<E>(self) -> Result<Self::Value, E>
192    where
193        E: de::Error,
194    {
195        Ok(Value::None)
196    }
197
198    fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
199    where
200        D: serde::Deserializer<'de>,
201    {
202        Ok(Value::Some(Box::new(d.deserialize_any(ValueVisitor)?)))
203    }
204
205    fn visit_unit<E>(self) -> Result<Self::Value, E>
206    where
207        E: de::Error,
208    {
209        Ok(Value::Unit)
210    }
211
212    fn visit_newtype_struct<D>(self, d: D) -> Result<Self::Value, D::Error>
213    where
214        D: serde::Deserializer<'de>,
215    {
216        Ok(Value::NewtypeStruct(
217            "",
218            Box::new(d.deserialize_any(ValueVisitor)?),
219        ))
220    }
221
222    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
223    where
224        A: SeqAccess<'de>,
225    {
226        let mut vec = Vec::new();
227        while let Some(v) = seq.next_element()? {
228            vec.push(v);
229        }
230        Ok(Value::Seq(vec))
231    }
232
233    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
234    where
235        A: MapAccess<'de>,
236    {
237        let mut im = IndexMap::new();
238        while let Some((k, v)) = map.next_entry()? {
239            im.insert(k, v);
240        }
241        Ok(Value::Map(im))
242    }
243}
244
245impl<'de> Deserialize<'de> for Value {
246    fn deserialize<D>(d: D) -> Result<Self, D::Error>
247    where
248        D: serde::Deserializer<'de>,
249    {
250        d.deserialize_any(ValueVisitor)
251    }
252}
253
254pub struct Deserializer(Value);
255
256impl<'de> serde::Deserializer<'de> for Deserializer {
257    type Error = Error;
258
259    fn deserialize_any<V>(self, vis: V) -> Result<V::Value, Self::Error>
260    where
261        V: Visitor<'de>,
262    {
263        match &self.0 {
264            Value::Bool(_) => self.deserialize_bool(vis),
265            Value::I8(_) => self.deserialize_i8(vis),
266            Value::I16(_) => self.deserialize_i16(vis),
267            Value::I32(_) => self.deserialize_i32(vis),
268            Value::I64(_) => self.deserialize_i64(vis),
269            Value::I128(_) => self.deserialize_i128(vis),
270            Value::U8(_) => self.deserialize_u8(vis),
271            Value::U16(_) => self.deserialize_u16(vis),
272            Value::U32(_) => self.deserialize_u32(vis),
273            Value::U64(_) => self.deserialize_u64(vis),
274            Value::U128(_) => self.deserialize_u128(vis),
275            Value::F32(_) => self.deserialize_f32(vis),
276            Value::F64(_) => self.deserialize_f64(vis),
277            Value::Char(_) => self.deserialize_char(vis),
278            Value::Str(_) => self.deserialize_string(vis),
279            Value::Bytes(_) => self.deserialize_byte_buf(vis),
280            Value::None => self.deserialize_option(vis),
281            Value::Some(_) => self.deserialize_option(vis),
282            Value::Unit => self.deserialize_unit(vis),
283            Value::Map(_) => self.deserialize_map(vis),
284            Value::Seq(_) => self.deserialize_seq(vis),
285            Value::Struct(_, _) => self.deserialize_map(vis),
286            v => unimplemented!("deserialize_any for {:?}", v),
287        }
288    }
289
290    fn deserialize_bool<V>(self, vis: V) -> Result<V::Value, Self::Error>
291    where
292        V: Visitor<'de>,
293    {
294        match self.0 {
295            Value::Bool(v) => vis.visit_bool(v),
296            v => Err(Error(anyhow!("invalid type: {:?}", v))),
297        }
298    }
299
300    fn deserialize_i8<V>(self, vis: V) -> Result<V::Value, Self::Error>
301    where
302        V: Visitor<'de>,
303    {
304        match self.0 {
305            Value::I8(v) => vis.visit_i8(v),
306            Value::I16(v) => vis.visit_i8(i8::try_from(v)?),
307            Value::I32(v) => vis.visit_i8(i8::try_from(v)?),
308            Value::I64(v) => vis.visit_i8(i8::try_from(v)?),
309            Value::I128(v) => vis.visit_i8(i8::try_from(v)?),
310            Value::U8(v) => vis.visit_i8(i8::try_from(v)?),
311            Value::U16(v) => vis.visit_i8(i8::try_from(v)?),
312            Value::U32(v) => vis.visit_i8(i8::try_from(v)?),
313            Value::U64(v) => vis.visit_i8(i8::try_from(v)?),
314            Value::U128(v) => vis.visit_i8(i8::try_from(v)?),
315            v => Err(Error(anyhow!("invalid type: {:?}, expect i8", v))),
316        }
317    }
318
319    fn deserialize_i16<V>(self, vis: V) -> Result<V::Value, Self::Error>
320    where
321        V: Visitor<'de>,
322    {
323        match self.0 {
324            Value::I8(v) => vis.visit_i16(i16::from(v)),
325            Value::I16(v) => vis.visit_i16(v),
326            Value::I32(v) => vis.visit_i16(i16::try_from(v)?),
327            Value::I64(v) => vis.visit_i16(i16::try_from(v)?),
328            Value::I128(v) => vis.visit_i16(i16::try_from(v)?),
329            Value::U8(v) => vis.visit_i16(i16::from(v)),
330            Value::U16(v) => vis.visit_i16(i16::try_from(v)?),
331            Value::U32(v) => vis.visit_i16(i16::try_from(v)?),
332            Value::U64(v) => vis.visit_i16(i16::try_from(v)?),
333            Value::U128(v) => vis.visit_i16(i16::try_from(v)?),
334            v => Err(Error(anyhow!("invalid type: {:?}, expect i16", v))),
335        }
336    }
337
338    fn deserialize_i32<V>(self, vis: V) -> Result<V::Value, Self::Error>
339    where
340        V: Visitor<'de>,
341    {
342        match self.0 {
343            Value::I8(v) => vis.visit_i32(i32::from(v)),
344            Value::I16(v) => vis.visit_i32(i32::from(v)),
345            Value::I32(v) => vis.visit_i32(v),
346            Value::I64(v) => vis.visit_i32(i32::try_from(v)?),
347            Value::I128(v) => vis.visit_i32(i32::try_from(v)?),
348            Value::U8(v) => vis.visit_i32(i32::from(v)),
349            Value::U16(v) => vis.visit_i32(i32::from(v)),
350            Value::U32(v) => vis.visit_i32(i32::try_from(v)?),
351            Value::U64(v) => vis.visit_i32(i32::try_from(v)?),
352            Value::U128(v) => vis.visit_i32(i32::try_from(v)?),
353            v => Err(Error(anyhow!("invalid type: {:?}", v))),
354        }
355    }
356
357    fn deserialize_i64<V>(self, vis: V) -> Result<V::Value, Self::Error>
358    where
359        V: Visitor<'de>,
360    {
361        match self.0 {
362            Value::I8(v) => vis.visit_i64(i64::from(v)),
363            Value::I16(v) => vis.visit_i64(i64::from(v)),
364            Value::I32(v) => vis.visit_i64(i64::from(v)),
365            Value::I64(v) => vis.visit_i64(v),
366            Value::I128(v) => vis.visit_i64(i64::try_from(v)?),
367            Value::U8(v) => vis.visit_i64(i64::from(v)),
368            Value::U16(v) => vis.visit_i32(i32::from(v)),
369            Value::U32(v) => vis.visit_i64(i64::from(v)),
370            Value::U64(v) => vis.visit_i64(i64::try_from(v)?),
371            Value::U128(v) => vis.visit_i64(i64::try_from(v)?),
372            v => Err(Error(anyhow!("invalid type: {:?}, expect i64", v))),
373        }
374    }
375
376    fn deserialize_u8<V>(self, vis: V) -> Result<V::Value, Self::Error>
377    where
378        V: Visitor<'de>,
379    {
380        match self.0 {
381            Value::I8(v) => vis.visit_u8(u8::try_from(v)?),
382            Value::I16(v) => vis.visit_u8(u8::try_from(v)?),
383            Value::I32(v) => vis.visit_u8(u8::try_from(v)?),
384            Value::I64(v) => vis.visit_u8(u8::try_from(v)?),
385            Value::I128(v) => vis.visit_u8(u8::try_from(v)?),
386            Value::U8(v) => vis.visit_u8(v),
387            Value::U16(v) => vis.visit_u8(u8::try_from(v)?),
388            Value::U32(v) => vis.visit_u8(u8::try_from(v)?),
389            Value::U64(v) => vis.visit_u8(u8::try_from(v)?),
390            Value::U128(v) => vis.visit_u8(u8::try_from(v)?),
391            v => Err(Error(anyhow!("invalid type: {:?}, expect u8", v))),
392        }
393    }
394
395    fn deserialize_u16<V>(self, vis: V) -> Result<V::Value, Self::Error>
396    where
397        V: Visitor<'de>,
398    {
399        match self.0 {
400            Value::I8(v) => vis.visit_u16(u16::try_from(v)?),
401            Value::I16(v) => vis.visit_u16(u16::try_from(v)?),
402            Value::I32(v) => vis.visit_u16(u16::try_from(v)?),
403            Value::I64(v) => vis.visit_u16(u16::try_from(v)?),
404            Value::I128(v) => vis.visit_u16(u16::try_from(v)?),
405            Value::U8(v) => vis.visit_u16(u16::from(v)),
406            Value::U16(v) => vis.visit_u16(v),
407            Value::U32(v) => vis.visit_u16(u16::try_from(v)?),
408            Value::U64(v) => vis.visit_u16(u16::try_from(v)?),
409            Value::U128(v) => vis.visit_u16(u16::try_from(v)?),
410            v => Err(Error(anyhow!("invalid type: {:?}, expect u16", v))),
411        }
412    }
413
414    fn deserialize_u32<V>(self, vis: V) -> Result<V::Value, Self::Error>
415    where
416        V: Visitor<'de>,
417    {
418        match self.0 {
419            Value::I8(v) => vis.visit_u32(u32::try_from(v)?),
420            Value::I16(v) => vis.visit_u32(u32::try_from(v)?),
421            Value::I32(v) => vis.visit_u32(u32::try_from(v)?),
422            Value::I64(v) => vis.visit_u32(u32::try_from(v)?),
423            Value::I128(v) => vis.visit_u32(u32::try_from(v)?),
424            Value::U8(v) => vis.visit_u32(u32::from(v)),
425            Value::U16(v) => vis.visit_u32(u32::from(v)),
426            Value::U32(v) => vis.visit_u32(v),
427            Value::U64(v) => vis.visit_u32(u32::try_from(v)?),
428            Value::U128(v) => vis.visit_u32(u32::try_from(v)?),
429            v => Err(Error(anyhow!("invalid type: {:?}, expect u32", v))),
430        }
431    }
432
433    fn deserialize_u64<V>(self, vis: V) -> Result<V::Value, Self::Error>
434    where
435        V: Visitor<'de>,
436    {
437        match self.0 {
438            Value::I8(v) => vis.visit_u64(u64::try_from(v)?),
439            Value::I16(v) => vis.visit_u64(u64::try_from(v)?),
440            Value::I32(v) => vis.visit_u64(u64::try_from(v)?),
441            Value::I64(v) => vis.visit_u64(u64::try_from(v)?),
442            Value::I128(v) => vis.visit_u64(u64::try_from(v)?),
443            Value::U8(v) => vis.visit_u64(u64::from(v)),
444            Value::U16(v) => vis.visit_u64(u64::from(v)),
445            Value::U32(v) => vis.visit_u64(u64::from(v)),
446            Value::U64(v) => vis.visit_u64(v),
447            Value::U128(v) => vis.visit_u64(u64::try_from(v)?),
448            v => Err(Error(anyhow!("invalid type: {:?}, expect u64", v))),
449        }
450    }
451
452    fn deserialize_f32<V>(self, vis: V) -> Result<V::Value, Self::Error>
453    where
454        V: Visitor<'de>,
455    {
456        match self.0 {
457            Value::F32(v) => vis.visit_f32(v),
458            Value::F64(v) => vis.visit_f32(v as f32),
459            v => Err(Error(anyhow!("invalid type: {:?}, expect f32", v))),
460        }
461    }
462
463    fn deserialize_f64<V>(self, vis: V) -> Result<V::Value, Self::Error>
464    where
465        V: Visitor<'de>,
466    {
467        match self.0 {
468            Value::F32(v) => vis.visit_f64(f64::from(v)),
469            Value::F64(v) => vis.visit_f64(v),
470            v => Err(Error(anyhow!("invalid type: {:?}, expect f64", v))),
471        }
472    }
473
474    fn deserialize_char<V>(self, vis: V) -> Result<V::Value, Self::Error>
475    where
476        V: Visitor<'de>,
477    {
478        match self.0 {
479            Value::Char(v) => vis.visit_char(v),
480            v => Err(Error(anyhow!("invalid type: {:?}, expect char", v))),
481        }
482    }
483
484    fn deserialize_str<V>(self, vis: V) -> Result<V::Value, Self::Error>
485    where
486        V: Visitor<'de>,
487    {
488        match self.0 {
489            Value::Str(v) => vis.visit_string(v),
490            v => Err(Error(anyhow!("invalid type: {:?}, expect str", v))),
491        }
492    }
493
494    fn deserialize_string<V>(self, vis: V) -> Result<V::Value, Self::Error>
495    where
496        V: Visitor<'de>,
497    {
498        match self.0 {
499            Value::Str(v) => vis.visit_string(v),
500            v => Err(Error(anyhow!("invalid type: {:?}, expect string", v))),
501        }
502    }
503
504    fn deserialize_bytes<V>(self, vis: V) -> Result<V::Value, Self::Error>
505    where
506        V: Visitor<'de>,
507    {
508        match self.0 {
509            Value::Bytes(v) => vis.visit_byte_buf(v),
510            v => Err(Error(anyhow!("invalid type: {:?}, expect bytes", v))),
511        }
512    }
513
514    fn deserialize_byte_buf<V>(self, vis: V) -> Result<V::Value, Self::Error>
515    where
516        V: Visitor<'de>,
517    {
518        match self.0 {
519            Value::Bytes(v) => vis.visit_byte_buf(v),
520            v => Err(Error(anyhow!("invalid type: {:?}, expect bytes_buf", v))),
521        }
522    }
523
524    fn deserialize_option<V>(self, vis: V) -> Result<V::Value, Self::Error>
525    where
526        V: Visitor<'de>,
527    {
528        match self.0 {
529            Value::None => vis.visit_none(),
530            Value::Some(v) => vis.visit_some(Deserializer(*v)),
531            v => Err(Error(anyhow!("invalid type: {:?}, expect option", v))),
532        }
533    }
534
535    fn deserialize_unit<V>(self, vis: V) -> Result<V::Value, Self::Error>
536    where
537        V: Visitor<'de>,
538    {
539        match self.0 {
540            Value::Unit => vis.visit_unit(),
541            v => Err(Error(anyhow!("invalid type: {:?}, expect unit", v))),
542        }
543    }
544
545    fn deserialize_unit_struct<V>(self, name: &'static str, vis: V) -> Result<V::Value, Self::Error>
546    where
547        V: Visitor<'de>,
548    {
549        match self.0 {
550            Value::UnitStruct(vn) if vn == name => vis.visit_unit(),
551            v => Err(Error(anyhow!("invalid type: {:?}, expect unit struct", v))),
552        }
553    }
554
555    fn deserialize_newtype_struct<V>(
556        self,
557        name: &'static str,
558        vis: V,
559    ) -> Result<V::Value, Self::Error>
560    where
561        V: Visitor<'de>,
562    {
563        match self.0 {
564            Value::NewtypeStruct(vn, vv) if vn == name => {
565                vis.visit_newtype_struct(Deserializer(*vv))
566            }
567            v => Err(Error(anyhow!(
568                "invalid type: {:?}, expect newtype struct",
569                v
570            ))),
571        }
572    }
573
574    fn deserialize_seq<V>(self, vis: V) -> Result<V::Value, Self::Error>
575    where
576        V: Visitor<'de>,
577    {
578        match self.0 {
579            Value::Tuple(v) => vis.visit_seq(SeqAccessor::new(v)),
580            Value::Seq(v) => vis.visit_seq(SeqAccessor::new(v)),
581            v => Err(Error(anyhow!("invalid type: {:?}, expect seq", v))),
582        }
583    }
584
585    fn deserialize_tuple<V>(self, len: usize, vis: V) -> Result<V::Value, Self::Error>
586    where
587        V: Visitor<'de>,
588    {
589        match self.0 {
590            Value::Tuple(v) if len == v.len() => vis.visit_seq(SeqAccessor::new(v)),
591            Value::Seq(v) if len == v.len() => vis.visit_seq(SeqAccessor::new(v)),
592            v => Err(Error(anyhow!("invalid type: {:?}, expect tuple", v))),
593        }
594    }
595
596    fn deserialize_tuple_struct<V>(
597        self,
598        name: &'static str,
599        len: usize,
600        vis: V,
601    ) -> Result<V::Value, Self::Error>
602    where
603        V: Visitor<'de>,
604    {
605        match self.0 {
606            Value::TupleStruct(vn, vf) if name == vn && len == vf.len() => {
607                vis.visit_seq(SeqAccessor::new(vf))
608            }
609            v => Err(Error(anyhow!("invalid type: {:?}, expect tuple struct", v))),
610        }
611    }
612
613    fn deserialize_map<V>(self, vis: V) -> Result<V::Value, Self::Error>
614    where
615        V: Visitor<'de>,
616    {
617        match self.0 {
618            Value::Map(v) => vis.visit_map(MapAccessor::new(v)),
619            v => Err(Error(anyhow!("invalid type: {:?}, expect map", v))),
620        }
621    }
622
623    fn deserialize_struct<V>(
624        self,
625        name: &'static str,
626        fields: &'static [&'static str],
627        vis: V,
628    ) -> Result<V::Value, Self::Error>
629    where
630        V: Visitor<'de>,
631    {
632        match self.0 {
633            Value::Struct(vn, mut vf) if vn == name => {
634                let mut vs = Vec::with_capacity(fields.len());
635                for key in fields {
636                    // Use `remove` instead of `get` & `clone` here.
637                    // - As serde will make sure to not access the same field twice.
638                    // - The order of key is not needed to preserve during deserialize.
639                    match vf.shift_remove(key) {
640                        Some(v) => vs.push(v),
641                        None => return Err(Error(anyhow!("field not exist"))),
642                    }
643                }
644                vis.visit_seq(SeqAccessor::new(vs))
645            }
646            Value::Map(fields) => vis.visit_map(MapAccessor::new(fields)),
647            v => Err(Error(anyhow!("invalid type: {:?}, expect struct", v))),
648        }
649    }
650
651    fn deserialize_enum<V>(
652        self,
653        name: &'static str,
654        variants: &'static [&'static str],
655        vis: V,
656    ) -> Result<V::Value, Self::Error>
657    where
658        V: Visitor<'de>,
659    {
660        vis.visit_enum(EnumAccessor::new(name, variants, self.0))
661    }
662
663    fn deserialize_identifier<V>(self, vis: V) -> Result<V::Value, Self::Error>
664    where
665        V: Visitor<'de>,
666    {
667        self.deserialize_str(vis)
668    }
669
670    fn deserialize_ignored_any<V>(self, vis: V) -> Result<V::Value, Self::Error>
671    where
672        V: Visitor<'de>,
673    {
674        self.deserialize_any(vis)
675    }
676}
677
678impl From<Value> for Deserializer {
679    fn from(v: Value) -> Self {
680        Self(v)
681    }
682}
683
684struct SeqAccessor {
685    elements: IntoIter<Value>,
686}
687
688impl SeqAccessor {
689    fn new(elements: Vec<Value>) -> Self {
690        Self {
691            elements: elements.into_iter(),
692        }
693    }
694}
695
696impl<'de> de::SeqAccess<'de> for SeqAccessor {
697    type Error = Error;
698
699    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
700    where
701        T: DeserializeSeed<'de>,
702    {
703        match self.elements.next() {
704            None => Ok(None),
705            Some(v) => Ok(Some(seed.deserialize(Deserializer(v))?)),
706        }
707    }
708}
709
710struct MapAccessor {
711    cache_value: Option<Value>,
712    entries: indexmap::map::IntoIter<Value, Value>,
713}
714
715impl MapAccessor {
716    fn new(entries: IndexMap<Value, Value>) -> Self {
717        Self {
718            cache_value: None,
719            entries: entries.into_iter(),
720        }
721    }
722}
723impl<'de> de::MapAccess<'de> for MapAccessor {
724    type Error = Error;
725
726    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
727    where
728        K: DeserializeSeed<'de>,
729    {
730        debug_assert!(
731            self.cache_value.is_none(),
732            "value for the last entry is not deserialized"
733        );
734
735        match self.entries.next() {
736            None => Ok(None),
737            Some((k, v)) => {
738                self.cache_value = Some(v);
739                Ok(Some(seed.deserialize(Deserializer(k))?))
740            }
741        }
742    }
743
744    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
745    where
746        V: DeserializeSeed<'de>,
747    {
748        let value = self
749            .cache_value
750            .take()
751            .expect("value for current entry is missing");
752        seed.deserialize(Deserializer(value))
753    }
754}
755
756struct EnumAccessor {
757    name: &'static str,
758    variants: &'static [&'static str],
759    value: Value,
760}
761
762impl EnumAccessor {
763    fn new(name: &'static str, variants: &'static [&'static str], value: Value) -> Self {
764        Self {
765            name,
766            variants,
767            value,
768        }
769    }
770}
771
772impl<'de> de::EnumAccess<'de> for EnumAccessor {
773    type Error = Error;
774    type Variant = VariantAccessor;
775
776    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
777    where
778        V: DeserializeSeed<'de>,
779    {
780        let value = match &self.value {
781            Value::UnitVariant {
782                name: vn,
783                variant_index: vvi,
784                variant: vv,
785            } if &self.name == vn && &self.variants[*vvi as usize] == vv => {
786                seed.deserialize(Deserializer(Value::Str(vv.to_string())))?
787            }
788            Value::TupleVariant {
789                name: vn,
790                variant_index: vvi,
791                variant: vv,
792                ..
793            } if &self.name == vn && &self.variants[*vvi as usize] == vv => {
794                seed.deserialize(Deserializer(Value::Str(vv.to_string())))?
795            }
796            Value::StructVariant {
797                name: vn,
798                variant_index: vvi,
799                variant: vv,
800                ..
801            } if &self.name == vn && &self.variants[*vvi as usize] == vv => {
802                seed.deserialize(Deserializer(Value::Str(vv.to_string())))?
803            }
804            Value::NewtypeVariant {
805                name: vn,
806                variant_index: vvi,
807                variant: vv,
808                ..
809            } if &self.name == vn && &self.variants[*vvi as usize] == vv => {
810                seed.deserialize(Deserializer(Value::Str(vv.to_string())))?
811            }
812            _ => return Err(Error(anyhow!("invalid type"))),
813        };
814
815        Ok((value, VariantAccessor::new(self.value)))
816    }
817}
818
819struct VariantAccessor {
820    value: Value,
821}
822
823impl VariantAccessor {
824    fn new(value: Value) -> Self {
825        Self { value }
826    }
827}
828
829impl<'de> de::VariantAccess<'de> for VariantAccessor {
830    type Error = Error;
831
832    fn unit_variant(self) -> Result<(), Self::Error> {
833        match self.value {
834            Value::UnitVariant { .. } => Ok(()),
835            _ => Err(Error(anyhow!("invalid type"))),
836        }
837    }
838
839    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
840    where
841        T: DeserializeSeed<'de>,
842    {
843        match self.value {
844            Value::NewtypeVariant { value, .. } => Ok(seed.deserialize(Deserializer(*value))?),
845            _ => Err(Error(anyhow!("invalid type"))),
846        }
847    }
848
849    fn tuple_variant<V>(self, len: usize, vis: V) -> Result<V::Value, Self::Error>
850    where
851        V: Visitor<'de>,
852    {
853        match self.value {
854            Value::TupleVariant { fields, .. } if len == fields.len() => {
855                vis.visit_seq(SeqAccessor::new(fields))
856            }
857            _ => Err(Error(anyhow!("invalid type"))),
858        }
859    }
860
861    fn struct_variant<V>(
862        self,
863        fields: &'static [&'static str],
864        vis: V,
865    ) -> Result<V::Value, Self::Error>
866    where
867        V: Visitor<'de>,
868    {
869        match self.value {
870            Value::Struct(_, mut vf) => {
871                let mut vs = Vec::with_capacity(fields.len());
872                for key in fields {
873                    // Use `remove` instead of `get` & `clone` here.
874                    // - As serde will make sure to not access the same field twice.
875                    // - The order of key is not needed to preserve during deserialize.
876                    match vf.shift_remove(key) {
877                        Some(v) => vs.push(v),
878                        None => return Err(Error(anyhow!("field not exist"))),
879                    }
880                }
881                vis.visit_seq(SeqAccessor::new(vs))
882            }
883            _ => Err(Error(anyhow!("invalid type"))),
884        }
885    }
886}
887
888#[cfg(test)]
889mod tests {
890    use anyhow::Result;
891    use indexmap::indexmap;
892
893    use super::*;
894    use crate::de::from_value;
895
896    #[derive(Debug, PartialEq, serde::Deserialize)]
897    struct TestStruct {
898        a: bool,
899        b: i32,
900        c: u64,
901        d: String,
902        e: f64,
903    }
904
905    #[test]
906    fn test_from_value() {
907        let v: bool = from_value(Value::Bool(true)).expect("must success");
908        assert!(v);
909
910        let v: TestStruct = from_value(Value::Struct(
911            "TestStruct",
912            indexmap! {
913                "a" => Value::Bool(true),
914                "b" => Value::I32(1),
915                "c" => Value::U64(2),
916                "d" => Value::Str("Hello, World!".to_string()),
917                "e" => Value::F64(4.5)
918            },
919        ))
920        .expect("must success");
921        assert_eq!(
922            v,
923            TestStruct {
924                a: true,
925                b: 1,
926                c: 2,
927                d: "Hello, World!".to_string(),
928                e: 4.5
929            }
930        )
931    }
932
933    #[test]
934    fn test_deserialize() -> Result<()> {
935        let content = r#"{
936            "a": true,
937            "b": 1,
938            "c": 2,
939            "d": "Hello, World!",
940            "e": 4.5
941        }"#;
942        let raw: TestStruct = serde_json::from_str(content)?;
943        let value: Value = serde_json::from_str(content)?;
944        println!("{:?}", value);
945
946        assert_eq!(TestStruct::from_value(value)?, raw);
947
948        Ok(())
949    }
950}
serde_bridge/de.rs

serde_bridge/
de.rs
