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::null())
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
810            .set_names(keys)
811            .map_err(<M::Error as serde::de::Error>::custom)?;
812        Ok(result.into())
813    }
814
815    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
816    where
817        E: serde::de::Error,
818    {
819        Ok(Robj::null())
820    }
821
822    fn visit_newtype_struct<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
823    where
824        D: Deserializer<'de>,
825    {
826        deserializer.deserialize_any(self)
827    }
828
829    fn visit_enum<A>(self, _data: A) -> std::result::Result<Self::Value, A::Error>
830    where
831        A: EnumAccess<'de>,
832    {
833        // TODO: find an example of this.
834        unimplemented!();
835        // let (de, variant) = data.variant()?;
836        // de.deserialize_any(self)
837    }
838}
839
840impl<'de> Deserialize<'de> for Robj {
841    fn deserialize<D>(deserializer: D) -> std::result::Result<Robj, D::Error>
842    where
843        D: Deserializer<'de>,
844    {
845        deserializer.deserialize_any(RobjVisitor)
846    }
847}
848
849struct IntegersVisitor;
850
851impl<'de> Visitor<'de> for IntegersVisitor {
852    type Value = Integers;
853
854    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
855        formatter.write_str("a value convertable to Integers")
856    }
857
858    fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
859    where
860        E: serde::de::Error,
861    {
862        if v > i32::MIN as i64 && v <= i32::MAX as i64 {
863            Ok(Integers::from_values([v as i32]))
864        } else {
865            Err(serde::de::Error::custom("out of range for Integers"))
866        }
867    }
868
869    fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
870    where
871        E: serde::de::Error,
872    {
873        if v <= i32::MAX as u64 {
874            Ok(Integers::from_values([v as i32]))
875        } else {
876            Err(serde::de::Error::custom("out of range for Integers"))
877        }
878    }
879
880    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
881    where
882        E: serde::de::Error,
883    {
884        Ok(Integers::from_values([Rint::na()]))
885    }
886
887    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
888    where
889        D: Deserializer<'de>,
890    {
891        deserializer.deserialize_any(self)
892    }
893
894    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
895    where
896        A: SeqAccess<'de>,
897    {
898        let mut values: Vec<Rint> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
899        while let Some(value) = seq.next_element()? {
900            values.push(value);
901        }
902        Ok(Integers::from_values(values))
903    }
904
905    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
906    where
907        E: serde::de::Error,
908    {
909        Ok(Integers::from_values([Rint::na()]))
910    }
911}
912
913impl<'de> Deserialize<'de> for Integers {
914    fn deserialize<D>(deserializer: D) -> std::result::Result<Integers, D::Error>
915    where
916        D: Deserializer<'de>,
917    {
918        deserializer.deserialize_any(IntegersVisitor)
919    }
920}
921
922struct DoublesVisitor;
923
924impl<'de> Visitor<'de> for DoublesVisitor {
925    type Value = Doubles;
926
927    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
928        formatter.write_str("a value convertable to Doubles")
929    }
930
931    fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
932    where
933        E: serde::de::Error,
934    {
935        Ok(Doubles::from_values([v as f64]))
936    }
937
938    fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
939    where
940        E: serde::de::Error,
941    {
942        Ok(Doubles::from_values([v as f64]))
943    }
944
945    fn visit_f64<E>(self, v: f64) -> std::result::Result<Self::Value, E>
946    where
947        E: serde::de::Error,
948    {
949        Ok(Doubles::from_values([v]))
950    }
951
952    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
953    where
954        E: serde::de::Error,
955    {
956        Ok(Doubles::from_values([Rfloat::na()]))
957    }
958
959    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
960    where
961        D: Deserializer<'de>,
962    {
963        deserializer.deserialize_any(self)
964    }
965
966    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
967    where
968        A: SeqAccess<'de>,
969    {
970        let mut values: Vec<Rfloat> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
971        while let Some(value) = seq.next_element()? {
972            values.push(value);
973        }
974        Ok(Doubles::from_values(values))
975    }
976
977    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
978    where
979        E: serde::de::Error,
980    {
981        Ok(Doubles::from_values([Rfloat::na()]))
982    }
983}
984
985impl<'de> Deserialize<'de> for Doubles {
986    fn deserialize<D>(deserializer: D) -> std::result::Result<Doubles, D::Error>
987    where
988        D: Deserializer<'de>,
989    {
990        deserializer.deserialize_any(DoublesVisitor)
991    }
992}
993
994struct LogicalsVisitor;
995
996impl<'de> Visitor<'de> for LogicalsVisitor {
997    type Value = Logicals;
998
999    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
1000        formatter.write_str("a value convertable to Logicals")
1001    }
1002
1003    fn visit_bool<E>(self, v: bool) -> std::result::Result<Self::Value, E>
1004    where
1005        E: serde::de::Error,
1006    {
1007        Ok(Logicals::from_values([v]))
1008    }
1009
1010    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
1011    where
1012        E: serde::de::Error,
1013    {
1014        Ok(Logicals::from_values([Rbool::na()]))
1015    }
1016
1017    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
1018    where
1019        D: Deserializer<'de>,
1020    {
1021        deserializer.deserialize_any(self)
1022    }
1023
1024    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
1025    where
1026        A: SeqAccess<'de>,
1027    {
1028        let mut values: Vec<Rbool> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
1029        while let Some(value) = seq.next_element()? {
1030            values.push(value);
1031        }
1032        Ok(Logicals::from_values(values))
1033    }
1034
1035    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
1036    where
1037        E: serde::de::Error,
1038    {
1039        Ok(Logicals::from_values([Rbool::na()]))
1040    }
1041}
1042
1043impl<'de> Deserialize<'de> for Logicals {
1044    fn deserialize<D>(deserializer: D) -> std::result::Result<Logicals, D::Error>
1045    where
1046        D: Deserializer<'de>,
1047    {
1048        deserializer.deserialize_any(LogicalsVisitor)
1049    }
1050}
1051
1052struct StringsVisitor;
1053
1054impl<'de> Visitor<'de> for StringsVisitor {
1055    type Value = Strings;
1056
1057    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
1058        formatter.write_str("a value convertable to Strings")
1059    }
1060
1061    fn visit_str<E>(self, v: &str) -> std::result::Result<Self::Value, E>
1062    where
1063        E: serde::de::Error,
1064    {
1065        Ok(v.into())
1066    }
1067
1068    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
1069    where
1070        E: serde::de::Error,
1071    {
1072        Ok(Strings::from_values([<&str>::na()]))
1073    }
1074
1075    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
1076    where
1077        D: Deserializer<'de>,
1078    {
1079        deserializer.deserialize_any(self)
1080    }
1081
1082    fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
1083    where
1084        A: SeqAccess<'de>,
1085    {
1086        let mut values: Vec<Rstr> = Vec::with_capacity(seq.size_hint().unwrap_or(8));
1087        while let Some(value) = seq.next_element()? {
1088            values.push(value);
1089        }
1090        Ok(Strings::from_values(values))
1091    }
1092
1093    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
1094    where
1095        E: serde::de::Error,
1096    {
1097        Ok(Strings::from_values([<&str>::na()]))
1098    }
1099}
1100
1101impl<'de> Deserialize<'de> for Strings {
1102    fn deserialize<D>(deserializer: D) -> std::result::Result<Strings, D::Error>
1103    where
1104        D: Deserializer<'de>,
1105    {
1106        deserializer.deserialize_any(StringsVisitor)
1107    }
1108}
1109
1110struct RstrVisitor;
1111
1112impl<'de> Visitor<'de> for RstrVisitor {
1113    type Value = Rstr;
1114
1115    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
1116        formatter.write_str("a value convertable to Rstr")
1117    }
1118
1119    fn visit_str<E>(self, v: &str) -> std::result::Result<Self::Value, E>
1120    where
1121        E: serde::de::Error,
1122    {
1123        Ok(v.into())
1124    }
1125
1126    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
1127    where
1128        E: serde::de::Error,
1129    {
1130        Ok(Rstr::na())
1131    }
1132
1133    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
1134    where
1135        D: Deserializer<'de>,
1136    {
1137        deserializer.deserialize_any(self)
1138    }
1139
1140    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
1141    where
1142        E: serde::de::Error,
1143    {
1144        Ok(Rstr::na())
1145    }
1146}
1147
1148impl<'de> Deserialize<'de> for Rstr {
1149    fn deserialize<D>(deserializer: D) -> std::result::Result<Rstr, D::Error>
1150    where
1151        D: Deserializer<'de>,
1152    {
1153        deserializer.deserialize_any(RstrVisitor)
1154    }
1155}
extendr_api/deserializer.rs

extendr_api/
deserializer.rs
