serde_arrow 0.14.0

Convert sequences of Rust objects to Arrow arrays and back again
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use serde::de::Visitor;

use crate::internal::error::{fail, Error, Result};

pub struct EnumAccess<'de>(pub &'de str);

impl<'de> serde::de::EnumAccess<'de> for EnumAccess<'_> {
    type Error = Error;
    type Variant = UnitVariant;

    fn variant_seed<V: serde::de::DeserializeSeed<'de>>(
        self,
        seed: V,
    ) -> Result<(V::Value, Self::Variant), Self::Error> {
        struct SeedDeserializer<'a>(&'a str);

        macro_rules! unimplemented {
            ($lifetime:lifetime, $name:ident $($tt:tt)*) => {
                fn $name<V: Visitor<$lifetime>>(self $($tt)*, _: V) -> Result<V::Value> {
                    fail!("Unsupported: EnumDeserializer does not implement {}", stringify!($name))
                }
            };
        }

        impl<'de> serde::de::Deserializer<'de> for SeedDeserializer<'_> {
            type Error = Error;

            fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
                self.deserialize_str(visitor)
            }

            fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
                self.deserialize_str(visitor)
            }

            fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
                visitor.visit_str(self.0)
            }

            fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
                visitor.visit_string(self.0.to_owned())
            }

            unimplemented!('de, deserialize_u64);
            unimplemented!('de, deserialize_bool);
            unimplemented!('de, deserialize_i8);
            unimplemented!('de, deserialize_i16);
            unimplemented!('de, deserialize_i32);
            unimplemented!('de, deserialize_i64);
            unimplemented!('de, deserialize_u8);
            unimplemented!('de, deserialize_u16);
            unimplemented!('de, deserialize_u32);
            unimplemented!('de, deserialize_f32);
            unimplemented!('de, deserialize_f64);
            unimplemented!('de, deserialize_char);
            unimplemented!('de, deserialize_bytes);
            unimplemented!('de, deserialize_byte_buf);
            unimplemented!('de, deserialize_option);
            unimplemented!('de, deserialize_unit);
            unimplemented!('de, deserialize_unit_struct, _: &'static str);
            unimplemented!('de, deserialize_newtype_struct, _: &'static str);
            unimplemented!('de, deserialize_seq);
            unimplemented!('de, deserialize_tuple, _: usize);
            unimplemented!('de, deserialize_tuple_struct, _: &'static str, _: usize);
            unimplemented!('de, deserialize_map);
            unimplemented!('de, deserialize_struct, _: &'static str, _: &'static [&'static str]);
            unimplemented!('de, deserialize_enum, _: &'static str, _: &'static [&'static str]);
            unimplemented!('de, deserialize_ignored_any);
        }

        Ok((seed.deserialize(SeedDeserializer(self.0))?, UnitVariant))
    }
}

pub struct UnitVariant;

impl<'de> serde::de::VariantAccess<'de> for UnitVariant {
    type Error = Error;

    fn newtype_variant_seed<T: serde::de::DeserializeSeed<'de>>(self, _: T) -> Result<T::Value> {
        fail!("Unsupported: cannot deserialize enums with data from strings")
    }

    fn struct_variant<V: Visitor<'de>>(self, _: &'static [&'static str], _: V) -> Result<V::Value> {
        fail!("Unsupported: cannot deserialize enums with data from strings")
    }

    fn tuple_variant<V: Visitor<'de>>(self, _: usize, _: V) -> Result<V::Value> {
        fail!("Unsupported: cannot deserialize enums with data from strings")
    }

    fn unit_variant(self) -> Result<(), Self::Error> {
        Ok(())
    }
}