ucpack/
de.rs

1use serde::de::{self, EnumAccess, IntoDeserializer, SeqAccess, VariantAccess};
2
3use crate::{buffer::ReadBuffer, macros::unimpl, macros::unimpl_de, UcPackError};
4
5/// A `serde` compatible Deserializer which works
6/// on a [ReadBuffer]
7pub struct Deserializer<B: ReadBuffer> {
8    buffer: B,
9}
10
11impl<B: ReadBuffer> Deserializer<B> {
12    pub fn new(buffer: B) -> Self {
13        Self { buffer }
14    }
15
16    fn read_u16(&mut self) -> Result<u16, UcPackError> {
17        self.buffer.read_n().map(u16::from_le_bytes)
18    }
19}
20
21impl<'de, 'a, B: ReadBuffer> de::Deserializer<'de> for &'a mut Deserializer<B> {
22    type Error = UcPackError;
23
24    fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
25    where
26        V: de::Visitor<'de>,
27    {
28        unimpl!(name = "any")
29    }
30
31    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
32    where
33        V: de::Visitor<'de>,
34    {
35        let a = match self.buffer.read_u8()? {
36            0 => false,
37            1 => true,
38            _ => return Err(UcPackError::InvalidData),
39        };
40
41        visitor.visit_bool(a)
42    }
43
44    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
45    where
46        V: de::Visitor<'de>,
47    {
48        visitor.visit_i8(self.buffer.read_u8()? as i8)
49    }
50
51    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
52    where
53        V: de::Visitor<'de>,
54    {
55        visitor.visit_i16(self.read_u16()? as i16)
56    }
57
58    unimpl_de!(deserialize_i32, i32);
59    unimpl_de!(deserialize_i64, i64);
60
61    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
62    where
63        V: de::Visitor<'de>,
64    {
65        visitor.visit_u8(self.buffer.read_u8()?)
66    }
67
68    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
69    where
70        V: de::Visitor<'de>,
71    {
72        visitor.visit_u16(self.read_u16()?)
73    }
74
75    unimpl_de!(deserialize_u32, u32);
76    unimpl_de!(deserialize_u64, u64);
77
78    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
79    where
80        V: de::Visitor<'de>,
81    {
82        let float = self.buffer.read_n().map(f32::from_le_bytes)?;
83        visitor.visit_f32(float)
84    }
85
86    unimpl_de!(deserialize_f64, f64);
87    unimpl_de!(deserialize_char, char);
88    unimpl_de!(deserialize_str, &str);
89    unimpl_de!(deserialize_string, name = "String");
90    unimpl_de!(deserialize_bytes, &[u8]);
91    unimpl_de!(deserialize_byte_buf, name = "byte_buf");
92    unimpl_de!(deserialize_option, name = "option");
93    unimpl_de!(deserialize_unit, name = "unit");
94
95    fn deserialize_unit_struct<V>(self, name: &'static str, _: V) -> Result<V::Value, Self::Error>
96    where
97        V: de::Visitor<'de>,
98    {
99        unimpl!(name = name)
100    }
101
102    fn deserialize_newtype_struct<V>(
103        self,
104        _: &'static str,
105        visitor: V,
106    ) -> Result<V::Value, Self::Error>
107    where
108        V: de::Visitor<'de>,
109    {
110        visitor.visit_newtype_struct(self)
111    }
112
113    unimpl_de!(deserialize_seq, name = "seq");
114
115    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
116    where
117        V: de::Visitor<'de>,
118    {
119        visitor.visit_seq(SeriesAccess::new(self, len))
120    }
121
122    fn deserialize_tuple_struct<V>(
123        self,
124        _: &'static str,
125        len: usize,
126        visitor: V,
127    ) -> Result<V::Value, Self::Error>
128    where
129        V: de::Visitor<'de>,
130    {
131        self.deserialize_tuple(len, visitor)
132    }
133
134    unimpl_de!(deserialize_map, name = "map");
135
136    fn deserialize_struct<V>(
137        self,
138        _: &'static str,
139        fields: &'static [&'static str],
140        visitor: V,
141    ) -> Result<V::Value, Self::Error>
142    where
143        V: de::Visitor<'de>,
144    {
145        self.deserialize_tuple(fields.len(), visitor)
146    }
147
148    fn deserialize_enum<V>(
149        self,
150        _: &'static str,
151        _: &'static [&'static str],
152        visitor: V,
153    ) -> Result<V::Value, Self::Error>
154    where
155        V: de::Visitor<'de>,
156    {
157        visitor.visit_enum(self)
158    }
159
160    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
161    where
162        V: de::Visitor<'de>,
163    {
164        self.deserialize_u8(visitor)
165    }
166
167    fn deserialize_ignored_any<V>(self, _: V) -> Result<V::Value, Self::Error>
168    where
169        V: de::Visitor<'de>,
170    {
171        unimpl!(name = "ignored type")
172    }
173}
174
175impl<'a, 'de, B: ReadBuffer> VariantAccess<'a> for &'de mut Deserializer<B> {
176    type Error = UcPackError;
177
178    fn unit_variant(self) -> Result<(), Self::Error> {
179        Ok(())
180    }
181
182    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
183    where
184        T: de::DeserializeSeed<'a>,
185    {
186        seed.deserialize(self)
187    }
188
189    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
190    where
191        V: de::Visitor<'a>,
192    {
193        de::Deserializer::deserialize_tuple(self, len, visitor)
194    }
195
196    fn struct_variant<V>(
197        self,
198        fields: &'static [&'static str],
199        visitor: V,
200    ) -> Result<V::Value, Self::Error>
201    where
202        V: de::Visitor<'a>,
203    {
204        de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
205    }
206}
207
208impl<'a, 'de, B: ReadBuffer> EnumAccess<'a> for &'de mut Deserializer<B> {
209    type Error = UcPackError;
210    type Variant = Self;
211
212    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
213    where
214        V: de::DeserializeSeed<'a>,
215    {
216        let variant = self.buffer.read_u8()?;
217        let v = seed.deserialize(variant.into_deserializer())?;
218        Ok((v, self))
219    }
220}
221
222struct SeriesAccess<'a, B: ReadBuffer + 'a> {
223    deserializer: &'a mut Deserializer<B>,
224    remaining: usize,
225}
226
227impl<'a, B: ReadBuffer + 'a> SeriesAccess<'a, B> {
228    fn new(deserializer: &'a mut Deserializer<B>, len: usize) -> Self {
229        Self {
230            deserializer,
231            remaining: len,
232        }
233    }
234}
235
236impl<'a, 'seq, B: ReadBuffer> SeqAccess<'seq> for SeriesAccess<'a, B> {
237    type Error = UcPackError;
238
239    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
240    where
241        T: de::DeserializeSeed<'seq>,
242    {
243        // check if remaining
244        if self.remaining <= 0 {
245            return Ok(None);
246        }
247
248        self.remaining -= 1;
249        seed.deserialize(&mut *self.deserializer).map(Some)
250    }
251}
ucpack/de.rs

ucpack/
de.rs
