rsv_core/
deserializer.rs

1use std::str::from_utf8;
2
3use serde::{de::SeqAccess, Deserializer};
4
5use crate::error::{Error, ErrorKind};
6use crate::utils::{NULL_BYTE, VALUE_TERM_BYTE, ROW_TERM_BYTE};
7
8pub struct DeRecord<'de> {
9    buf: &'de [u8],
10}
11
12impl<'de> DeRecord<'de> {
13    pub(crate) fn from_ref(buf: &'de [u8]) -> Self {
14        DeRecord { buf }
15    }
16
17    fn next_is_null(&mut self) -> Result<bool, Error> {
18        match self.buf[0] == NULL_BYTE {
19            true => {
20                if self.buf[1] == VALUE_TERM_BYTE {
21                    self.buf = &self.buf[2..];
22                    Ok(true)
23                } else {
24                    Err(Error(ErrorKind::Deserialize(
25                        format!("Expected TERM_BYTE after NULL_BYTE, got {:?}", self.buf[1])
26                    )))
27                }
28            },
29            false => Ok(false),
30        }
31    }
32
33    fn next_value(&mut self) -> Result<Option<&str>, Error> {
34        // Check if value is null byte
35        if self.buf[0] == NULL_BYTE {
36            if self.buf[1] == VALUE_TERM_BYTE {
37                self.buf = &self.buf[2..];
38                return Ok(None);
39            } else {
40                return Err(Error(ErrorKind::Deserialize(
41                    format!("Expected TERM_BYTE after NULL_BYTE, got {:?}", self.buf[1])
42                )));
43            }
44        }
45
46        // Check if value is empty string
47        if self.buf[0] == VALUE_TERM_BYTE {
48            self.buf = &self.buf[1..];
49            return Ok(Some(""));
50        }
51
52        // Parse UTF-8 String
53        for i in 1..self.buf.len() {
54            if self.buf[i] == VALUE_TERM_BYTE {
55                let value = &self.buf[0..i];
56                self.buf = &self.buf[i + 1..];
57
58                return Ok(Some(from_utf8(value)?));
59            }
60        }
61
62        Err(Error(ErrorKind::Deserialize(
63            "Unable to find VALUE_TERM_BYTE in record".to_owned()
64        )))
65    }
66
67    fn next_str_value(&mut self) -> Result<&str, Error> {
68        let value = self.next_value()?;
69        let value = value.ok_or(Error(ErrorKind::Deserialize(
70            "Got None but expected string".to_owned()
71        )))?;
72
73        Ok(value)
74    }
75}
76
77impl<'a, 'de> Deserializer<'de> for &'a mut DeRecord<'de> {
78    type Error = Error;
79
80    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
81    where
82        V: serde::de::Visitor<'de> {
83        todo!()
84    }
85
86    fn deserialize_bool<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
87    where
88        V: serde::de::Visitor<'de> {
89        let value = self.next_str_value()?;
90
91        match value {
92            "true" => visitor.visit_bool(true),
93            "false" => visitor.visit_bool(false),
94            _ => Err(Error(ErrorKind::Deserialize("Failed to deserialize bool".to_owned()))),
95        }
96    }
97
98    fn deserialize_i8<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
99    where
100        V: serde::de::Visitor<'de> {
101        let value = self.next_str_value()?;
102        let value = value.parse().unwrap();
103
104        visitor.visit_i8(value)
105    }
106
107    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
108    where
109        V: serde::de::Visitor<'de> {
110        let value = self.next_str_value()?;
111        let value = value.parse().unwrap();
112
113        visitor.visit_i16(value)
114    }
115
116    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
117    where
118        V: serde::de::Visitor<'de> {
119        let value = self.next_str_value()?;
120        let value = value.parse().unwrap();
121
122        visitor.visit_i32(value)
123    }
124
125    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
126    where
127        V: serde::de::Visitor<'de> {
128        let value = self.next_str_value()?;
129        let value = value.parse().unwrap();
130
131        visitor.visit_i64(value)
132    }
133
134    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
135    where
136        V: serde::de::Visitor<'de> {
137        let value = self.next_str_value()?;
138        let value = value.parse().unwrap();
139
140        visitor.visit_u8(value)}
141
142    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
143    where
144        V: serde::de::Visitor<'de> {
145        let value = self.next_str_value()?;
146        let value = value.parse().unwrap();
147
148        visitor.visit_u16(value)}
149
150    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
151    where
152        V: serde::de::Visitor<'de> {
153        let value = self.next_str_value()?;
154        let value = value.parse().unwrap();
155
156        visitor.visit_u32(value)
157    }
158
159    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
160    where
161        V: serde::de::Visitor<'de> {
162        let value = self.next_str_value()?;
163        let value = value.parse().unwrap();
164
165        visitor.visit_u64(value)
166    }
167
168    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
169    where
170        V: serde::de::Visitor<'de> {
171        let value = self.next_str_value()?;
172        let value = value.parse().unwrap();
173
174        visitor.visit_f32(value)
175    }
176
177    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
178    where
179        V: serde::de::Visitor<'de> {
180        let value = self.next_str_value()?;
181        let value = value.parse().unwrap();
182
183        visitor.visit_f64(value)
184    }
185
186    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
187    where
188        V: serde::de::Visitor<'de> {
189        let value = self.next_str_value()?;
190        if value.len() <= 1 {
191            return Err(Error(ErrorKind::Deserialize(
192                format!("Expected 1 character, got {}", value.len())
193            )));
194        }
195        let value = value.chars().next().unwrap_or_default();
196        visitor.visit_char(value)
197    }
198
199    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
200    where
201        V: serde::de::Visitor<'de> {
202        let value = self.next_str_value()?;
203        visitor.visit_str(value)
204    }
205
206    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
207    where
208        V: serde::de::Visitor<'de> {
209        let value = self.next_str_value()?;
210        visitor.visit_string(value.to_owned())
211    }
212
213    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
214    where
215        V: serde::de::Visitor<'de> {
216        todo!()
217    }
218
219    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
220    where
221        V: serde::de::Visitor<'de> {
222        todo!()
223    }
224
225    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
226    where
227        V: serde::de::Visitor<'de> {
228        let value = self.next_is_null()?;
229        match value {
230            true => visitor.visit_none(),
231            false => visitor.visit_some(self)
232        }
233    }
234
235    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
236    where
237        V: serde::de::Visitor<'de> {
238        todo!()
239    }
240
241    fn deserialize_unit_struct<V>(
242        self,
243        name: &'static str,
244        visitor: V,
245    ) -> Result<V::Value, Self::Error>
246    where
247        V: serde::de::Visitor<'de> {
248        todo!()
249    }
250
251    fn deserialize_newtype_struct<V>(
252        self,
253        name: &'static str,
254        visitor: V,
255    ) -> Result<V::Value, Self::Error>
256    where
257        V: serde::de::Visitor<'de> {
258        todo!()
259    }
260
261    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
262    where
263        V: serde::de::Visitor<'de> {
264        visitor.visit_seq(self)
265    }
266
267    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
268    where
269        V: serde::de::Visitor<'de> {
270        todo!()
271    }
272
273    fn deserialize_tuple_struct<V>(
274        self,
275        name: &'static str,
276        len: usize,
277        visitor: V,
278    ) -> Result<V::Value, Self::Error>
279    where
280        V: serde::de::Visitor<'de> {
281        todo!()
282    }
283
284    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
285    where
286        V: serde::de::Visitor<'de> {
287        visitor.visit_seq(self)
288    }
289
290    fn deserialize_struct<V>(
291        self,
292        name: &'static str,
293        fields: &'static [&'static str],
294        visitor: V,
295    ) -> Result<V::Value, Self::Error>
296    where
297        V: serde::de::Visitor<'de> {
298        visitor.visit_seq(self)
299    }
300
301    fn deserialize_enum<V>(
302        self,
303        name: &'static str,
304        variants: &'static [&'static str],
305        visitor: V,
306    ) -> Result<V::Value, Self::Error>
307    where
308        V: serde::de::Visitor<'de> {
309        todo!()
310    }
311
312    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
313    where
314        V: serde::de::Visitor<'de> {
315        todo!()
316    }
317
318    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
319    where
320        V: serde::de::Visitor<'de> {
321        todo!()
322    }
323
324    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
325    where
326        V: serde::de::Visitor<'de>,
327    {
328        let _ = visitor;
329        Err(serde::de::Error::custom("i128 is not supported"))
330    }
331
332    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
333    where
334        V: serde::de::Visitor<'de>,
335    {
336        let _ = visitor;
337        Err(serde::de::Error::custom("u128 is not supported"))
338    }
339
340    fn is_human_readable(&self) -> bool {
341        true
342    }
343}
344
345impl<'a, 'de> SeqAccess<'de> for DeRecord<'de> {
346    type Error = Error;
347
348    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
349    where
350        T: serde::de::DeserializeSeed<'de> {
351        if self.buf.len() == 0 || self.buf[0] == ROW_TERM_BYTE {
352            return Ok(None);
353        }
354
355        seed.deserialize(self).map(Some)
356    }
357}
rsv_core/deserializer.rs

rsv_core/
deserializer.rs
