avrow 0.2.1

Avrow is a fast, type safe serde based data serialization library
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use super::de_impl::{ArrayDeserializer, ByteSeqDeserializer, MapDeserializer, StructReader};
use crate::error::AvrowErr;

use crate::value::Value;

use serde::de::IntoDeserializer;
use serde::de::{self, Visitor};
use serde::forward_to_deserialize_any;

pub(crate) struct SerdeReader<'de> {
    pub(crate) inner: &'de Value,
}

impl<'de> SerdeReader<'de> {
    pub(crate) fn new(inner: &'de Value) -> Self {
        SerdeReader { inner }
    }
}

impl<'de, 'a> de::Deserializer<'de> for &'a mut SerdeReader<'de> {
    type Error = AvrowErr;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        match self.inner {
            Value::Null => visitor.visit_unit(),
            Value::Boolean(v) => visitor.visit_bool(*v),
            Value::Int(v) => visitor.visit_i32(*v),
            Value::Long(v) => visitor.visit_i64(*v),
            Value::Float(v) => visitor.visit_f32(*v),
            Value::Double(v) => visitor.visit_f64(*v),
            Value::Str(ref v) => visitor.visit_borrowed_str(v),
            Value::Bytes(ref bytes) => visitor.visit_borrowed_bytes(&bytes),
            Value::Array(items) => visitor.visit_seq(ArrayDeserializer::new(&items)),
            Value::Enum(s) => visitor.visit_enum(s.as_str().into_deserializer()),
            _ => Err(AvrowErr::Unsupported),
        }
    }

    forward_to_deserialize_any! {
        unit bool u8 i8 i16 i32 i64 u16 u32 u64 f32 f64 str bytes byte_buf string ignored_any enum
    }

    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        visitor.visit_some(self)
    }

    fn deserialize_unit_struct<V>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        visitor.visit_unit()
    }

    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        match self.inner {
            Value::Array(ref items) => visitor.visit_seq(ArrayDeserializer::new(items)),
            // TODO figure out the correct byte stram to use
            Value::Bytes(buf) | Value::Fixed(buf) => {
                let byte_seq_deser = ByteSeqDeserializer { input: buf.iter() };
                visitor.visit_seq(byte_seq_deser)
            }
            Value::Union(v) => match v.as_ref() {
                Value::Array(ref items) => visitor.visit_seq(ArrayDeserializer::new(items)),
                _ => Err(AvrowErr::Unsupported),
            },
            _ => Err(AvrowErr::Unsupported),
        }
    }

    // avro bytes
    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_seq(visitor)
    }

    // for struct field
    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        self.deserialize_str(visitor)
    }

    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        match self.inner {
            Value::Map(m) => {
                let map_de = MapDeserializer {
                    keys: m.keys(),
                    values: m.values(),
                };
                visitor.visit_map(map_de)
            }
            v => Err(AvrowErr::UnexpectedAvroValue {
                value: format!("{:?}", v),
            }),
        }
    }

    fn deserialize_struct<V>(
        self,
        _a: &'static str,
        _b: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        match self.inner {
            Value::Record(ref r) => visitor.visit_map(StructReader::new(r.fields.iter())),
            Value::Union(ref inner) => match **inner {
                Value::Record(ref rec) => visitor.visit_map(StructReader::new(rec.fields.iter())),
                _ => Err(de::Error::custom("Union variant not a record/struct")),
            },
            _ => Err(de::Error::custom("Must be a record/struct")),
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    /// Not yet supported types
    ///////////////////////////////////////////////////////////////////////////

    fn deserialize_tuple_struct<V>(
        self,
        _name: &'static str,
        _len: usize,
        _visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        // TODO it is not clear to what avro schema can a tuple map to
        Err(AvrowErr::Unsupported)
    }

    fn deserialize_newtype_struct<V>(
        self,
        _name: &'static str,
        _visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        Err(AvrowErr::Unsupported)
    }

    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        Err(AvrowErr::Unsupported)
    }
}