extendr_api/
deserializer.rs

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

extendr_api/
deserializer.rs
