extendr_api/
deserializer.rs

Help
1//! Convert R objects to a wide variety of types.
2//!
3use crate::error::{Error, Result};
4use crate::na::CanBeNA;
5use crate::robj::{Attributes, Length, Robj, Types};
6use crate::scalar::{Rbool, Rfloat, Rint};
7use crate::wrapper::{Doubles, Integers, List, Logicals, Rstr, Strings};
8use crate::Rany;
9use serde::de::{
10    Deserialize, DeserializeSeed, Deserializer, EnumAccess, MapAccess, SeqAccess, VariantAccess,
11    Visitor,
12};
13use serde::forward_to_deserialize_any;
14use std::convert::TryFrom;
15
16/// Convert any R object to a Deserialize object.
17pub fn from_robj<'de, T>(robj: &'de Robj) -> Result<T>
18where
19    T: Deserialize<'de>,
20{
21    let t = T::deserialize(robj)?;
22    Ok(t)
23}
24
25// Allow errors to propagate to extendr errors.
26impl serde::de::Error for Error {
27    fn custom<T>(msg: T) -> Self
28    where
29        T: std::fmt::Display,
30    {
31        Error::Other(msg.to_string())
32    }
33}
34
35// Convert unnamed lists to sequences.
36struct ListGetter<'a> {
37    list: &'a [Robj],
38}
39
40impl<'de> SeqAccess<'de> for ListGetter<'de> {
41    type Error = Error;
42
43    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
44    where
45        T: DeserializeSeed<'de>,
46    {
47        if self.list.is_empty() {
48            Ok(None)
49        } else {
50            let e = &self.list[0];
51            self.list = &self.list[1..];
52            seed.deserialize(e).map(Some)
53        }
54    }
55}
56
57// Convert named lists to maps.
58struct NamedListGetter<'a> {
59    keys: &'a [Rstr],
60    values: &'a [Robj],
61}
62
63impl<'de> MapAccess<'de> for NamedListGetter<'de> {
64    type Error = Error;
65
66    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
67    where
68        K: DeserializeSeed<'de>,
69    {
70        if self.keys.is_empty() {
71            Ok(None)
72        } else {
73            let e = &self.keys[0];
74            self.keys = &self.keys[1..];
75            seed.deserialize(e).map(Some)
76        }
77    }
78
79    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
80    where
81        V: DeserializeSeed<'de>,
82    {
83        let e = &self.values[0];
84        self.values = &self.values[1..];
85        seed.deserialize(e)
86    }
87}
88
89// Allow us to use Integers, Doubles and Logicals.
90struct SliceGetter<'a, E> {
91    list: &'a [E],
92}
93
94// Allow us to use Integers and Rint.
95impl<'de> Deserializer<'de> for Rint {
96    type Error = Error;
97
98    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
99    where
100        V: Visitor<'de>,
101    {
102        if let Some(val) = self.into() {
103            visitor.visit_i32(val)
104        } else {
105            visitor.visit_unit()
106        }
107    }
108
109    forward_to_deserialize_any! {
110        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
111        bytes byte_buf option unit unit_struct newtype_struct seq tuple
112        tuple_struct map struct enum identifier ignored_any
113    }
114}
115
116// Allow us to use Doubles and Rfloat.
117impl<'de> Deserializer<'de> for Rfloat {
118    type Error = Error;
119
120    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
121    where
122        V: Visitor<'de>,
123    {
124        if let Some(val) = self.into() {
125            visitor.visit_f64(val)
126        } else {
127            visitor.visit_unit()
128        }
129    }
130
131    forward_to_deserialize_any! {
132        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
133        bytes byte_buf option unit unit_struct newtype_struct seq tuple
134        tuple_struct map struct enum identifier ignored_any
135    }
136}
137
138// Allow us to use Logicals and Rbool.
139impl<'de> Deserializer<'de> for Rbool {
140    type Error = Error;
141
142    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
143    where
144        V: Visitor<'de>,
145    {
146        if let Some(val) = self.into() {
147            visitor.visit_bool(val)
148        } else {
149            visitor.visit_unit()
150        }
151    }
152
153    forward_to_deserialize_any! {
154        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
155        bytes byte_buf option unit unit_struct newtype_struct seq tuple
156        tuple_struct map struct enum identifier ignored_any
157    }
158}
159
160// Decode identifiers from the "names" attribute of lists.
161impl<'de> Deserializer<'de> for &'de Rstr {
162    type Error = Error;
163
164    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
165    where
166        V: Visitor<'de>,
167    {
168        unimplemented!()
169    }
170
171    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
172    where
173        V: Visitor<'de>,
174    {
175        visitor.visit_borrowed_str(self.as_str())
176    }
177
178    forward_to_deserialize_any! {
179        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char string
180        str bytes byte_buf option unit unit_struct newtype_struct seq tuple
181        tuple_struct map struct enum ignored_any
182    }
183}
184
185// Get the variant name and content of an enum.
186impl<'de> EnumAccess<'de> for &'de Robj {
187    type Error = Error;
188    type Variant = Self;
189
190    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
191    where
192        V: DeserializeSeed<'de>,
193    {
194        match self.as_any() {
195            Rany::Strings(s) if s.len() == 1 => {
196                let variant = seed.deserialize(self)?;
197                Ok((variant, self))
198            }
199            Rany::List(list) if list.len() == 1 => {
200                if let Some(keys) = self.get_attrib(crate::wrapper::symbol::names_symbol()) {
201                    if let Ok(keys) = Strings::try_from(keys) {
202                        let keys = keys.as_slice();
203                        let values = &list.as_slice()[0];
204                        let variant = seed.deserialize(&keys[0])?;
205                        return Ok((variant, values));
206                    }
207                }
208                Err(Error::Other("Expected named List for enum".into()))
209            }
210            _ => Err(Error::Other("Expected String or List for enum".into())),
211        }
212    }
213}
214
215// Decode enum variants of various kinds.
216impl<'de> VariantAccess<'de> for &'de Robj {
217    type Error = Error;
218
219    fn unit_variant(self) -> Result<()> {
220        Ok(())
221    }
222
223    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
224    where
225        T: DeserializeSeed<'de>,
226    {
227        seed.deserialize(self)
228    }
229
230    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
231    where
232        V: Visitor<'de>,
233    {
234        serde::de::Deserializer::deserialize_seq(self, visitor)
235    }
236
237    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
238    where
239        V: Visitor<'de>,
240    {
241        serde::de::Deserializer::deserialize_map(self, visitor)
242    }
243}
244
245// Enable sequences from Integers, Doubles and Logicals.
246impl<'de, E: Deserializer<'de>> SeqAccess<'de> for SliceGetter<'de, E>
247where
248    Error: From<<E as Deserializer<'de>>::Error>,
249    E: Copy,
250{
251    type Error = Error;
252
253    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
254    where
255        T: DeserializeSeed<'de>,
256    {
257        if self.list.is_empty() {
258            Ok(None)
259        } else {
260            let res = seed.deserialize(self.list[0])?;
261            self.list = &self.list[1..];
262            Ok(Some(res))
263        }
264    }
265}
266
267// Given an Robj, generate a value of many kinds.
268impl<'de> Deserializer<'de> for &'de Robj {
269    type Error = Error;
270
271    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
272    where
273        V: Visitor<'de>,
274    {
275        let len = self.len();
276        match self.as_any() {
277            Rany::Null(_) => self.deserialize_unit(visitor),
278            Rany::Integers(_v) => {
279                if len == 1 {
280                    self.deserialize_i32(visitor)
281                } else {
282                    self.deserialize_seq(visitor)
283                }
284            }
285            Rany::Doubles(_v) => {
286                if len == 1 {
287                    self.deserialize_f64(visitor)
288                } else {
289                    self.deserialize_seq(visitor)
290                }
291            }
292            Rany::Logicals(_v) => {
293                if len == 1 {
294                    self.deserialize_bool(visitor)
295                } else {
296                    self.deserialize_seq(visitor)
297                }
298            }
299            Rany::List(_v) => self.deserialize_seq(visitor),
300            Rany::Strings(_v) => {
301                if len == 1 {
302                    self.deserialize_str(visitor)
303                } else {
304                    self.deserialize_seq(visitor)
305                }
306            }
307            _ => Err(Error::Other(format!(
308                "deserialize_any: unexpected {:?}",
309                self.rtype()
310            ))),
311        }
312    }
313
314    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
315    where
316        V: Visitor<'de>,
317    {
318        if let Rany::Null(_) = self.as_any() {
319            visitor.visit_unit()
320        } else {
321            Err(Error::ExpectedNull(self.clone()))
322        }
323    }
324
325    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
326    where
327        V: Visitor<'de>,
328    {
329        visitor.visit_bool(bool::try_from(self.clone())?)
330    }
331
332    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
333    where
334        V: Visitor<'de>,
335    {
336        visitor.visit_i8(i8::try_from(self.clone())?)
337    }
338
339    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
340    where
341        V: Visitor<'de>,
342    {
343        visitor.visit_i16(i16::try_from(self.clone())?)
344    }
345
346    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
347    where
348        V: Visitor<'de>,
349    {
350        visitor.visit_i32(i32::try_from(self.clone())?)
351    }
352
353    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
354    where
355        V: Visitor<'de>,
356    {
357        visitor.visit_i64(i64::try_from(self.clone())?)
358    }
359
360    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
361    where
362        V: Visitor<'de>,
363    {
364        visitor.visit_i128(i64::try_from(self.clone())? as i128)
365    }
366
367    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
368    where
369        V: Visitor<'de>,
370    {
371        visitor.visit_u8(u8::try_from(self.clone())?)
372    }
373
374    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
375    where
376        V: Visitor<'de>,
377    {
378        visitor.visit_u16(u16::try_from(self.clone())?)
379    }
380
381    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
382    where
383        V: Visitor<'de>,
384    {
385        visitor.visit_u32(u32::try_from(self.clone())?)
386    }
387
388    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
389    where
390        V: Visitor<'de>,
391    {
392        visitor.visit_u64(u64::try_from(self.clone())?)
393    }
394
395    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
396    where
397        V: Visitor<'de>,
398    {
399        visitor.visit_u128(u64::try_from(self.clone())? as u128)
400    }
401
402    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
403    where
404        V: Visitor<'de>,
405    {
406        visitor.visit_f32(f32::try_from(self.clone())?)
407    }
408
409    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
410    where
411        V: Visitor<'de>,
412    {
413        visitor.visit_f64(f64::try_from(self.clone())?)
414    }
415
416    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
417    where
418        V: Visitor<'de>,
419    {
420        let s = <&str>::try_from(self.clone())?;
421        let mut c = s.chars();
422        if let Some(ch) = c.next() {
423            if c.next() == None {
424                return visitor.visit_char(ch);
425            }
426        }
427        Err(Error::ExpectedString(self.clone()))
428    }
429
430    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
431    where
432        V: Visitor<'de>,
433    {
434        visitor.visit_borrowed_str(<&str>::try_from(self.clone())?)
435    }
436
437    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
438    where
439        V: Visitor<'de>,
440    {
441        visitor.visit_string(<&str>::try_from(self.clone())?.into())
442    }
443
444    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
445    where
446        V: Visitor<'de>,
447    {
448        if let Rany::Raw(val) = self.as_any() {
449            visitor.visit_bytes(val.as_slice())
450        } else {
451            Err(Error::ExpectedRaw(self.clone()))
452        }
453    }
454
455    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
456    where
457        V: Visitor<'de>,
458    {
459        if let Rany::Raw(val) = self.as_any() {
460            visitor.visit_byte_buf(val.as_slice().to_owned())
461        } else {
462            Err(Error::ExpectedRaw(self.clone()))
463        }
464    }
465
466    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
467    where
468        V: Visitor<'de>,
469    {
470        #![allow(clippy::if_same_then_else)]
471        if let Rany::Null(_) = self.as_any() {
472            visitor.visit_none()
473        } else if self.is_na() {
474            visitor.visit_none()
475        } else {
476            visitor.visit_some(self)
477        }
478    }
479
480    fn deserialize_unit_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
481    where
482        V: Visitor<'de>,
483    {
484        self.deserialize_unit(visitor)
485    }
486
487    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
488    where
489        V: Visitor<'de>,
490    {
491        visitor.visit_newtype_struct(self)
492    }
493
494    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
495    where
496        V: Visitor<'de>,
497    {
498        self.deserialize_seq(visitor)
499    }
500
501    fn deserialize_tuple_struct<V>(
502        self,
503        _name: &'static str,
504        _len: usize,
505        visitor: V,
506    ) -> Result<V::Value>
507    where
508        V: Visitor<'de>,
509    {
510        self.deserialize_seq(visitor)
511    }
512
513    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
514    where
515        V: Visitor<'de>,
516    {
517        match self.as_any() {
518            Rany::List(val) => {
519                let lg = ListGetter {
520                    list: val.as_slice(),
521                };
522                Ok(visitor.visit_seq(lg)?)
523            }
524            Rany::Integers(val) => {
525                let lg = SliceGetter { list: &*val };
526                Ok(visitor.visit_seq(lg)?)
527            }
528            Rany::Doubles(val) => {
529                let lg = SliceGetter { list: &*val };
530                Ok(visitor.visit_seq(lg)?)
531            }
532            Rany::Logicals(val) => {
533                let lg = SliceGetter { list: &*val };
534                Ok(visitor.visit_seq(lg)?)
535            }
536            Rany::Strings(_val) => {
537                // Grubby hack that will go away once PRs are merged.
538                // use std::convert::TryInto;
539                // let val : Strings = val.clone().try_into().unwrap();
540                // let lg = StringGetter { list: &*val };
541                // Ok(visitor.visit_seq(lg)?)
542                unimplemented!("Deserialize shortcut for Strings");
543            }
544            _ => Err(Error::ExpectedList(self.clone())),
545        }
546    }
547
548    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
549    where
550        V: Visitor<'de>,
551    {
552        match self.as_any() {
553            Rany::List(val) => {
554                if let Some(keys) = self.get_attrib(crate::wrapper::symbol::names_symbol()) {
555                    if let Ok(keys) = Strings::try_from(keys) {
556                        let keys = keys.as_slice();
557                        let lg = NamedListGetter {
558                            keys,
559                            values: val.as_slice(),
560                        };
561                        return visitor.visit_map(lg);
562                    }
563                }
564                Err(Error::ExpectedList(self.clone()))
565            }
566            _ => Err(Error::ExpectedList(self.clone())),
567        }
568    }
569
570    fn deserialize_struct<V>(
571        self,
572        _name: &'static str,
573        _fields: &'static [&'static str],
574        visitor: V,
575    ) -> Result<V::Value>
576    where
577        V: Visitor<'de>,
578    {
579        self.deserialize_map(visitor)
580    }
581
582    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
583    where
584        V: Visitor<'de>,
585    {
586        self.deserialize_str(visitor)
587    }
588
589    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
590    where
591        V: Visitor<'de>,
592    {
593        self.deserialize_any(visitor)
594    }
595
596    fn deserialize_enum<V>(
597        self,
598        _name: &'static str,
599        _variants: &'static [&'static str],
600        visitor: V,
601    ) -> Result<V::Value>
602    where
603        V: Visitor<'de>,
604    {
605        visitor.visit_enum(self)
606    }
607}
608
609struct RintVisitor;
610
611impl<'de> Visitor<'de> for RintVisitor {
612    type Value = Rint;
613
614    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
615        formatter.write_str("an integer between -2^31+1 and 2^31")
616    }
617
618    fn visit_i32<E>(self, value: i32) -> std::result::Result<Self::Value, E>
619    where
620        E: serde::de::Error,
621    {
622        Ok(value.into())
623    }
624
625    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
626    where
627        E: serde::de::Error,
628    {
629        Ok(Rint::na())
630    }
631}
632
633impl<'de> Deserialize<'de> for Rint {
634    fn deserialize<D>(deserializer: D) -> std::result::Result<Rint, D::Error>
635    where
636        D: Deserializer<'de>,
637    {
638        deserializer.deserialize_i32(RintVisitor)
639    }
640}
641
642struct RfloatVisitor;
643
644impl<'de> Visitor<'de> for RfloatVisitor {
645    type Value = Rfloat;
646
647    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
648        formatter.write_str("a floating point value")
649    }
650
651    fn visit_f64<E>(self, value: f64) -> std::result::Result<Self::Value, E>
652    where
653        E: serde::de::Error,
654    {
655        Ok(value.into())
656    }
657
658    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
659    where
660        E: serde::de::Error,
661    {
662        Ok(Rfloat::na())
663    }
664}
665
666impl<'de> Deserialize<'de> for Rfloat {
667    fn deserialize<D>(deserializer: D) -> std::result::Result<Rfloat, D::Error>
668    where
669        D: Deserializer<'de>,
670    {
671        deserializer.deserialize_f64(RfloatVisitor)
672    }
673}
674
675struct RboolVisitor;
676
677impl<'de> Visitor<'de> for RboolVisitor {
678    type Value = Rbool;
679
680    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
681        formatter.write_str("a boolean point value")
682    }
683
684    fn visit_bool<E>(self, value: bool) -> std::result::Result<Self::Value, E>
685    where
686        E: serde::de::Error,
687    {
688        Ok(value.into())
689    }
690
691    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
692    where
693        E: serde::de::Error,
694    {
695        Ok(Rbool::na())
696    }
697}
698
699impl<'de> Deserialize<'de> for Rbool {
700    fn deserialize<D>(deserializer: D) -> std::result::Result<Rbool, D::Error>
701    where
702        D: Deserializer<'de>,
703    {
704        deserializer.deserialize_bool(RboolVisitor)
705    }
706}
707
708struct RobjVisitor;
709
710impl<'de> Visitor<'de> for RobjVisitor {
711    type Value = Robj;
712
713    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
714        formatter.write_str("a value convertable to a Robj")
715    }
716
717    fn visit_bool<E>(self, value: bool) -> std::result::Result<Self::Value, E>
718    where
719        E: serde::de::Error,
720    {
721        Ok(value.into())
722    }
723
724    fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
725    where
726        E: serde::de::Error,
727    {
728        if v > i32::MIN as i64 && v <= i32::MAX as i64 {
729            Ok((v as i32).into())
730        } else {
731            Ok((v as f64).into())
732        }
733    }
734
735    fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
736    where
737        E: serde::de::Error,
738    {
739        if v <= i32::MAX as u64 {
740            Ok((v as i32).into())
741        } else {
742            Ok((v as f64).into())
743        }
744    }
745
746    fn visit_f64<E>(self, v: f64) -> std::result::Result<Self::Value, E>
747    where
748        E: serde::de::Error,
749    {
750        Ok(v.into())
751    }
752
753    fn visit_str<E>(self, v: &str) -> std::result::Result<Self::Value, E>
754    where
755        E: serde::de::Error,
756    {
757        Ok(v.into())
758    }
759
760    fn visit_bytes<E>(self, v: &[u8]) -> std::result::Result<Self::Value, E>
761    where
762        E: serde::de::Error,
763    {
764        Ok(v.into())
765    }
766
767    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
768    where
769        E: serde::de::Error,
770    {
771        Ok(Robj::from(()))
772    }
773
774    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
775    where
776        D: Deserializer<'de>,
777    {
778        deserializer.deserialize_any(self)
779    }
780
781    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
782    where
783        A: SeqAccess<'de>,
784    {
785        // All sequences get converted to lists at the moment.
786        // We could check the first element and then assume the rest are the sme.
787        let mut values: Vec<Robj> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
788        while let Some(value) = seq.next_element()? {
789            values.push(value);
790        }
791        Ok(values.into())
792    }
793
794    fn visit_map<M>(self, mut access: M) -> std::result::Result<Self::Value, M::Error>
795    where
796        M: MapAccess<'de>,
797    {
798        let mut keys: Vec<&str> = Vec::with_capacity(access.size_hint().unwrap_or(8));
799        let mut values: Vec<Robj> = Vec::with_capacity(access.size_hint().unwrap_or(8));
800
801        while let Some((key, value)) = access.next_entry()? {
802            keys.push(key);
803            values.push(value);
804        }
805        let mut result = List::from_values(values);
806        result.set_names(keys).unwrap();
807        Ok(result.into())
808    }
809
810    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
811    where
812        E: serde::de::Error,
813    {
814        Ok(Robj::from(()))
815    }
816
817    fn visit_newtype_struct<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
818    where
819        D: Deserializer<'de>,
820    {
821        deserializer.deserialize_any(self)
822    }
823
824    fn visit_enum<A>(self, _data: A) -> std::result::Result<Self::Value, A::Error>
825    where
826        A: EnumAccess<'de>,
827    {
828        // TODO: find an example of this.
829        unimplemented!();
830        // let (de, variant) = data.variant()?;
831        // de.deserialize_any(self)
832    }
833}
834
835impl<'de> Deserialize<'de> for Robj {
836    fn deserialize<D>(deserializer: D) -> std::result::Result<Robj, D::Error>
837    where
838        D: Deserializer<'de>,
839    {
840        deserializer.deserialize_any(RobjVisitor)
841    }
842}
843
844struct IntegersVisitor;
845
846impl<'de> Visitor<'de> for IntegersVisitor {
847    type Value = Integers;
848
849    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
850        formatter.write_str("a value convertable to Integers")
851    }
852
853    fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
854    where
855        E: serde::de::Error,
856    {
857        if v > i32::MIN as i64 && v <= i32::MAX as i64 {
858            Ok(Integers::from_values([v as i32]))
859        } else {
860            Err(serde::de::Error::custom("out of range for Integers"))
861        }
862    }
863
864    fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
865    where
866        E: serde::de::Error,
867    {
868        if v <= i32::MAX as u64 {
869            Ok(Integers::from_values([v as i32]))
870        } else {
871            Err(serde::de::Error::custom("out of range for Integers"))
872        }
873    }
874
875    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
876    where
877        E: serde::de::Error,
878    {
879        Ok(Integers::from_values([Rint::na()]))
880    }
881
882    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
883    where
884        D: Deserializer<'de>,
885    {
886        deserializer.deserialize_any(self)
887    }
888
889    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
890    where
891        A: SeqAccess<'de>,
892    {
893        let mut values: Vec<Rint> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
894        while let Some(value) = seq.next_element()? {
895            values.push(value);
896        }
897        Ok(Integers::from_values(values))
898    }
899
900    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
901    where
902        E: serde::de::Error,
903    {
904        Ok(Integers::from_values([Rint::na()]))
905    }
906}
907
908impl<'de> Deserialize<'de> for Integers {
909    fn deserialize<D>(deserializer: D) -> std::result::Result<Integers, D::Error>
910    where
911        D: Deserializer<'de>,
912    {
913        deserializer.deserialize_any(IntegersVisitor)
914    }
915}
916
917struct DoublesVisitor;
918
919impl<'de> Visitor<'de> for DoublesVisitor {
920    type Value = Doubles;
921
922    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
923        formatter.write_str("a value convertable to Doubles")
924    }
925
926    fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
927    where
928        E: serde::de::Error,
929    {
930        Ok(Doubles::from_values([v as f64]))
931    }
932
933    fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
934    where
935        E: serde::de::Error,
936    {
937        Ok(Doubles::from_values([v as f64]))
938    }
939
940    fn visit_f64<E>(self, v: f64) -> std::result::Result<Self::Value, E>
941    where
942        E: serde::de::Error,
943    {
944        Ok(Doubles::from_values([v]))
945    }
946
947    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
948    where
949        E: serde::de::Error,
950    {
951        Ok(Doubles::from_values([Rfloat::na()]))
952    }
953
954    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
955    where
956        D: Deserializer<'de>,
957    {
958        deserializer.deserialize_any(self)
959    }
960
961    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
962    where
963        A: SeqAccess<'de>,
964    {
965        let mut values: Vec<Rfloat> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
966        while let Some(value) = seq.next_element()? {
967            values.push(value);
968        }
969        Ok(Doubles::from_values(values))
970    }
971
972    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
973    where
974        E: serde::de::Error,
975    {
976        Ok(Doubles::from_values([Rfloat::na()]))
977    }
978}
979
980impl<'de> Deserialize<'de> for Doubles {
981    fn deserialize<D>(deserializer: D) -> std::result::Result<Doubles, D::Error>
982    where
983        D: Deserializer<'de>,
984    {
985        deserializer.deserialize_any(DoublesVisitor)
986    }
987}
988
989struct LogicalsVisitor;
990
991impl<'de> Visitor<'de> for LogicalsVisitor {
992    type Value = Logicals;
993
994    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
995        formatter.write_str("a value convertable to Logicals")
996    }
997
998    fn visit_bool<E>(self, v: bool) -> std::result::Result<Self::Value, E>
999    where
1000        E: serde::de::Error,
1001    {
1002        Ok(Logicals::from_values([v]))
1003    }
1004
1005    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
1006    where
1007        E: serde::de::Error,
1008    {
1009        Ok(Logicals::from_values([Rbool::na()]))
1010    }
1011
1012    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
1013    where
1014        D: Deserializer<'de>,
1015    {
1016        deserializer.deserialize_any(self)
1017    }
1018
1019    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
1020    where
1021        A: SeqAccess<'de>,
1022    {
1023        let mut values: Vec<Rbool> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
1024        while let Some(value) = seq.next_element()? {
1025            values.push(value);
1026        }
1027        Ok(Logicals::from_values(values))
1028    }
1029
1030    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
1031    where
1032        E: serde::de::Error,
1033    {
1034        Ok(Logicals::from_values([Rbool::na()]))
1035    }
1036}
1037
1038impl<'de> Deserialize<'de> for Logicals {
1039    fn deserialize<D>(deserializer: D) -> std::result::Result<Logicals, D::Error>
1040    where
1041        D: Deserializer<'de>,
1042    {
1043        deserializer.deserialize_any(LogicalsVisitor)
1044    }
1045}
1046
1047struct StringsVisitor;
1048
1049impl<'de> Visitor<'de> for StringsVisitor {
1050    type Value = Strings;
1051
1052    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
1053        formatter.write_str("a value convertable to Strings")
1054    }
1055
1056    fn visit_str<E>(self, v: &str) -> std::result::Result<Self::Value, E>
1057    where
1058        E: serde::de::Error,
1059    {
1060        Ok(v.into())
1061    }
1062
1063    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
1064    where
1065        E: serde::de::Error,
1066    {
1067        Ok(Strings::from_values([<&str>::na()]))
1068    }
1069
1070    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
1071    where
1072        D: Deserializer<'de>,
1073    {
1074        deserializer.deserialize_any(self)
1075    }
1076
1077    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
1078    where
1079        A: SeqAccess<'de>,
1080    {
1081        let mut values: Vec<Rstr> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
1082        while let Some(value) = seq.next_element()? {
1083            values.push(value);
1084        }
1085        Ok(Strings::from_values(values))
1086    }
1087
1088    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
1089    where
1090        E: serde::de::Error,
1091    {
1092        Ok(Strings::from_values([<&str>::na()]))
1093    }
1094}
1095
1096impl<'de> Deserialize<'de> for Strings {
1097    fn deserialize<D>(deserializer: D) -> std::result::Result<Strings, D::Error>
1098    where
1099        D: Deserializer<'de>,
1100    {
1101        deserializer.deserialize_any(StringsVisitor)
1102    }
1103}
1104
1105struct RstrVisitor;
1106
1107impl<'de> Visitor<'de> for RstrVisitor {
1108    type Value = Rstr;
1109
1110    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
1111        formatter.write_str("a value convertable to Rstr")
1112    }
1113
1114    fn visit_str<E>(self, v: &str) -> std::result::Result<Self::Value, E>
1115    where
1116        E: serde::de::Error,
1117    {
1118        Ok(v.into())
1119    }
1120
1121    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
1122    where
1123        E: serde::de::Error,
1124    {
1125        Ok(Rstr::from_string(<&str>::na()))
1126    }
1127
1128    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
1129    where
1130        D: Deserializer<'de>,
1131    {
1132        deserializer.deserialize_any(self)
1133    }
1134
1135    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
1136    where
1137        E: serde::de::Error,
1138    {
1139        Ok(Rstr::from_string(<&str>::na()))
1140    }
1141}
1142
1143impl<'de> Deserialize<'de> for Rstr {
1144    fn deserialize<D>(deserializer: D) -> std::result::Result<Rstr, D::Error>
1145    where
1146        D: Deserializer<'de>,
1147    {
1148        deserializer.deserialize_any(RstrVisitor)
1149    }
1150}
extendr_api/deserializer.rs

extendr_api/
deserializer.rs
