serde_resp/
de.rs

1use crate::{Error, RESPType, Result};
2
3use serde::de::{self, DeserializeOwned, DeserializeSeed, SeqAccess, Visitor};
4use serde::Deserialize;
5
6use std::fmt;
7use std::io::{BufRead, BufReader, Cursor, Read};
8
9/// Deserializer for RESP format
10pub struct Deserializer<'de, R: BufRead> {
11    reader: &'de mut R,
12}
13
14impl<'de, R: BufRead> Deserializer<'de, R> {
15    /// Method for building Deserializer
16    pub fn from_buf_reader(reader: &'de mut R) -> Deserializer<'de, R> {
17        Deserializer { reader }
18    }
19}
20
21/// Deserialize from str.
22///
23/// This function simple wraps the `&str` with `Cursor` and calls [from_buf_reader](from_buf_reader).
24///
25/// # Errors
26/// Please refer to [Error](Error)
27pub fn from_str<T>(s: &str) -> Result<T>
28where
29    T: DeserializeOwned,
30{
31    let mut reader = Cursor::new(s);
32    from_buf_reader(&mut reader)
33}
34
35/// Deserialize from reader with `Read` trait.
36///
37/// This function simply wraps the reader with a `BufReader` and calls [from_buf_reader](from_buf_reader).
38/// If your reader has `BufRead` trait, use [from_buf_reader](from_buf_reader) instead.
39///
40/// # Errors
41/// Please refer to [Error](Error)
42pub fn from_reader<T, R>(reader: &mut R) -> Result<T>
43where
44    T: DeserializeOwned,
45    R: Read,
46{
47    let mut reader = BufReader::new(reader);
48    from_buf_reader(&mut reader)
49}
50
51/// Deserialize from reader with `BufRead` trait.
52///
53/// # Errors
54/// Please refer to [Error](Error)
55pub fn from_buf_reader<T, R>(reader: &mut R) -> Result<T>
56where
57    T: DeserializeOwned,
58    R: BufRead,
59{
60    let mut deserializer = Deserializer::from_buf_reader(reader);
61    let t = T::deserialize(&mut deserializer)?;
62    Ok(t)
63}
64
65impl<'de, R: BufRead> Deserializer<'de, R> {
66    // read until LF, trim end, and parse to isize.
67    fn read_isize(&mut self) -> Result<isize> {
68        let mut buffer = String::new();
69        self.reader.read_line(&mut buffer)?;
70        let trimmed = buffer.trim_end();
71        match trimmed.parse::<isize>() {
72            Ok(x) => Ok(x),
73            Err(_) => Err(Error::Syntax),
74        }
75    }
76}
77
78impl<'de, 'a, R: BufRead> de::Deserializer<'de> for &'a mut Deserializer<'de, R> {
79    type Error = Error;
80
81    // You see, this is a bit hacky...
82    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
83    where
84        V: Visitor<'de>,
85    {
86        let mut buf = [0u8; 1];
87        self.reader.read_exact(&mut buf)?;
88        match buf[0] {
89            b'+' => self.deserialize_str(visitor),      // SimpleString
90            b'-' => self.deserialize_string(visitor),   // Error
91            b':' => self.deserialize_i64(visitor),      // Integer
92            b'$' => self.deserialize_byte_buf(visitor), // BulkString
93            b'*' => self.deserialize_seq(visitor),      // Array
94            _ => return Err(Error::Syntax),
95        }
96    }
97
98    fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value>
99    where
100        V: Visitor<'de>,
101    {
102        unimplemented!()
103    }
104
105    fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value>
106    where
107        V: Visitor<'de>,
108    {
109        unimplemented!()
110    }
111
112    fn deserialize_i16<V>(self, _visitor: V) -> Result<V::Value>
113    where
114        V: Visitor<'de>,
115    {
116        unimplemented!()
117    }
118
119    fn deserialize_i32<V>(self, _visitor: V) -> Result<V::Value>
120    where
121        V: Visitor<'de>,
122    {
123        unimplemented!()
124    }
125
126    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
127    where
128        V: Visitor<'de>,
129    {
130        let mut buffer = String::new();
131        self.reader.read_line(&mut buffer)?;
132        match buffer.trim_end().parse::<i64>() {
133            Ok(x) => visitor.visit_i64(x),
134            Err(_) => Err(Error::Syntax),
135        }
136    }
137
138    fn deserialize_u8<V>(self, _visitor: V) -> Result<V::Value>
139    where
140        V: Visitor<'de>,
141    {
142        unimplemented!()
143    }
144
145    fn deserialize_u16<V>(self, _visitor: V) -> Result<V::Value>
146    where
147        V: Visitor<'de>,
148    {
149        unimplemented!()
150    }
151
152    fn deserialize_u32<V>(self, _visitor: V) -> Result<V::Value>
153    where
154        V: Visitor<'de>,
155    {
156        unimplemented!()
157    }
158
159    fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value>
160    where
161        V: Visitor<'de>,
162    {
163        unimplemented!()
164    }
165
166    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
167    where
168        V: Visitor<'de>,
169    {
170        unimplemented!()
171    }
172
173    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
174    where
175        V: Visitor<'de>,
176    {
177        unimplemented!()
178    }
179
180    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
181    where
182        V: Visitor<'de>,
183    {
184        unimplemented!()
185    }
186
187    // SimpleString
188    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
189    where
190        V: Visitor<'de>,
191    {
192        let mut buffer = String::new();
193        self.reader.read_line(&mut buffer)?;
194        visitor.visit_str(buffer.trim_end())
195    }
196
197    // Error
198    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
199    where
200        V: Visitor<'de>,
201    {
202        let mut buffer = String::new();
203        self.reader.read_line(&mut buffer)?;
204        visitor.visit_string(buffer.trim_end().to_string())
205    }
206
207    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
208    where
209        V: Visitor<'de>,
210    {
211        unimplemented!()
212    }
213
214    // BulkString
215    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
216    where
217        V: Visitor<'de>,
218    {
219        let x = self.read_isize()?;
220        if x < 0 {
221            return visitor.visit_none();
222        }
223        let mut buffer = vec![0u8; (x + 2) as usize]; // also read CRLF
224        self.reader.read_exact(&mut buffer)?;
225        if buffer.split_off(x as usize) != b"\r\n" {
226            return Err(Error::Syntax); // Not CRLF
227        }
228        visitor.visit_byte_buf(buffer)
229    }
230
231    fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value>
232    where
233        V: Visitor<'de>,
234    {
235        unimplemented!()
236    }
237
238    fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value>
239    where
240        V: Visitor<'de>,
241    {
242        unimplemented!()
243    }
244
245    fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
246    where
247        V: Visitor<'de>,
248    {
249        unimplemented!()
250    }
251
252    fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>
253    where
254        V: Visitor<'de>,
255    {
256        unimplemented!()
257    }
258
259    // Deserialization of compound types like sequences and maps happens by
260    // passing the visitor an "Access" object that gives it the ability to
261    // iterate through the data contained in the sequence.
262    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
263    where
264        V: Visitor<'de>,
265    {
266        let x = self.read_isize()?;
267        if x < 0 {
268            return visitor.visit_unit();
269        }
270        visitor.visit_seq(RESPArray::new(&mut self, x as usize))
271    }
272
273    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
274    where
275        V: Visitor<'de>,
276    {
277        unimplemented!()
278    }
279
280    fn deserialize_tuple_struct<V>(
281        self,
282        _name: &'static str,
283        _len: usize,
284        _visitor: V,
285    ) -> Result<V::Value>
286    where
287        V: Visitor<'de>,
288    {
289        unimplemented!()
290    }
291
292    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value>
293    where
294        V: Visitor<'de>,
295    {
296        unimplemented!()
297    }
298
299    fn deserialize_struct<V>(
300        self,
301        _name: &'static str,
302        _fields: &'static [&'static str],
303        _visitor: V,
304    ) -> Result<V::Value>
305    where
306        V: Visitor<'de>,
307    {
308        unimplemented!()
309    }
310
311    fn deserialize_enum<V>(
312        self,
313        _name: &'static str,
314        _variants: &'static [&'static str],
315        _visitor: V,
316    ) -> Result<V::Value>
317    where
318        V: Visitor<'de>,
319    {
320        unimplemented!()
321    }
322
323    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
324    where
325        V: Visitor<'de>,
326    {
327        unimplemented!()
328    }
329
330    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
331    where
332        V: Visitor<'de>,
333    {
334        unimplemented!()
335    }
336}
337
338struct RESPArray<'a, 'de: 'a, R: BufRead> {
339    de: &'a mut Deserializer<'de, R>,
340    remain_len: usize,
341}
342
343impl<'a, 'de, R: BufRead> RESPArray<'a, 'de, R> {
344    fn new(de: &'a mut Deserializer<'de, R>, len: usize) -> Self {
345        RESPArray {
346            de,
347            remain_len: len,
348        }
349    }
350}
351
352// `SeqAccess` is provided to the `Visitor` to give it the ability to iterate
353// through elements of the sequence.
354impl<'de, 'a, R: BufRead> SeqAccess<'de> for RESPArray<'a, 'de, R> {
355    type Error = Error;
356
357    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
358    where
359        T: DeserializeSeed<'de>,
360    {
361        if self.remain_len == 0 {
362            return Ok(None);
363        }
364        self.remain_len -= 1;
365        seed.deserialize(&mut *self.de).map(Some)
366    }
367
368    fn size_hint(&self) -> Option<usize> {
369        Some(self.remain_len)
370    }
371}
372
373struct RESPTypeVisitor;
374
375impl<'de> Visitor<'de> for RESPTypeVisitor {
376    type Value = RESPType;
377
378    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
379        formatter.write_str("A RESP value")
380    }
381
382    fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
383    where
384        E: de::Error,
385    {
386        Ok(RESPType::Integer(v))
387    }
388
389    // SimpleString
390    fn visit_str<E>(self, v: &str) -> std::result::Result<Self::Value, E>
391    where
392        E: de::Error,
393    {
394        Ok(RESPType::SimpleString(v.to_string()))
395    }
396
397    // Error
398    fn visit_string<E>(self, v: String) -> std::result::Result<Self::Value, E>
399    where
400        E: de::Error,
401    {
402        Ok(RESPType::Error(v))
403    }
404
405    // BulkString
406    fn visit_byte_buf<E>(self, v: Vec<u8>) -> std::result::Result<Self::Value, E>
407    where
408        E: de::Error,
409    {
410        Ok(RESPType::BulkString(Some(v)))
411    }
412
413    // null BulkString
414    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
415    where
416        E: de::Error,
417    {
418        Ok(RESPType::BulkString(None))
419    }
420
421    // null Array
422    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
423    where
424        E: de::Error,
425    {
426        Ok(RESPType::Array(None))
427    }
428
429    fn visit_seq<A>(
430        self,
431        mut seq: A,
432    ) -> std::result::Result<Self::Value, <A as SeqAccess<'de>>::Error>
433    where
434        A: SeqAccess<'de>,
435    {
436        let mut arr: Vec<RESPType> = Vec::with_capacity(seq.size_hint().unwrap_or_default());
437        loop {
438            match seq.next_element()? {
439                None => break,
440                Some(elem) => arr.push(elem),
441            };
442        }
443        Ok(RESPType::Array(Some(arr)))
444    }
445}
446
447impl<'de> Deserialize<'de> for RESPType {
448    fn deserialize<D>(
449        deserializer: D,
450    ) -> std::result::Result<Self, <D as de::Deserializer<'de>>::Error>
451    where
452        D: de::Deserializer<'de>,
453    {
454        deserializer.deserialize_any(RESPTypeVisitor)
455    }
456}
serde_resp/de.rs

serde_resp/
de.rs
