deseresp/
ser.rs

1use std::{io::Write, str};
2
3use serde::{
4    ser::{
5        SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
6        SerializeTupleStruct, SerializeTupleVariant,
7    },
8    Serialize,
9};
10
11use crate::{
12    types::{
13        BLOB_ERROR_TOKEN, BLOB_STRING_TOKEN, PUSH_TOKEN, SIMPLE_ERROR_TOKEN, SIMPLE_STRING_TOKEN,
14        WITH_ATTRIBUTE_TOKEN,
15    },
16    Error,
17};
18
19/// A RESP Serializer
20pub struct Serializer<W> {
21    writer: W,
22}
23
24impl<W: Write> Serializer<W> {
25    /// Creates a [`Serializer`] from an underlying [`Write`]
26    pub fn from_write(w: W) -> Self {
27        Serializer { writer: w }
28    }
29}
30
31/// Serialize to Vec<u8>
32pub fn to_vec<S: Serialize>(s: &S) -> Result<Vec<u8>, Error> {
33    let mut result = Vec::new();
34    let mut serializer = Serializer::from_write(&mut result);
35    s.serialize(&mut serializer)?;
36
37    Ok(result)
38}
39
40impl serde::ser::Error for Error {
41    fn custom<T>(msg: T) -> Self
42    where
43        T: std::fmt::Display,
44    {
45        Error::Custom(msg.to_string())
46    }
47}
48
49enum SeqKind {
50    KnownLength,
51    UnknownLength,
52}
53
54pub struct SeqSerializer<'a, W> {
55    se: &'a mut Serializer<W>,
56    kind: SeqKind,
57    with_key: bool,
58}
59
60impl<'a, W> SeqSerializer<'a, W> {
61    fn known_length(se: &'a mut Serializer<W>) -> Self {
62        SeqSerializer {
63            se,
64            kind: SeqKind::KnownLength,
65            with_key: true,
66        }
67    }
68
69    fn unknown_length(se: &'a mut Serializer<W>) -> Self {
70        SeqSerializer {
71            se,
72            kind: SeqKind::UnknownLength,
73            with_key: true,
74        }
75    }
76
77    fn without_key(mut self) -> Self {
78        self.with_key = false;
79        self
80    }
81}
82
83impl<'a, W: Write> SerializeSeq for SeqSerializer<'a, W> {
84    type Ok = ();
85    type Error = Error;
86
87    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
88    where
89        T: serde::Serialize,
90    {
91        value.serialize(&mut *self.se)
92    }
93
94    fn end(self) -> Result<Self::Ok, Self::Error> {
95        match self.kind {
96            SeqKind::UnknownLength => self.se.write_end(),
97            SeqKind::KnownLength => Ok(()),
98        }
99    }
100}
101
102impl<'a, W: Write> SerializeTuple for SeqSerializer<'a, W> {
103    type Ok = ();
104    type Error = Error;
105
106    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
107    where
108        T: serde::Serialize,
109    {
110        value.serialize(&mut *self.se)
111    }
112
113    fn end(self) -> Result<Self::Ok, Self::Error> {
114        match self.kind {
115            SeqKind::UnknownLength => self.se.write_end(),
116            SeqKind::KnownLength => Ok(()),
117        }
118    }
119}
120
121impl<'a, W: Write> SerializeTupleStruct for SeqSerializer<'a, W> {
122    type Ok = ();
123    type Error = Error;
124
125    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
126    where
127        T: serde::Serialize,
128    {
129        value.serialize(&mut *self.se)
130    }
131
132    fn end(self) -> Result<Self::Ok, Self::Error> {
133        match self.kind {
134            SeqKind::UnknownLength => self.se.write_end(),
135            SeqKind::KnownLength => Ok(()),
136        }
137    }
138}
139
140impl<'a, W: Write> SerializeTupleVariant for SeqSerializer<'a, W> {
141    type Ok = ();
142    type Error = Error;
143
144    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
145    where
146        T: serde::Serialize,
147    {
148        value.serialize(&mut *self.se)
149    }
150
151    fn end(self) -> Result<Self::Ok, Self::Error> {
152        match self.kind {
153            SeqKind::UnknownLength => self.se.write_end(),
154            SeqKind::KnownLength => Ok(()),
155        }
156    }
157}
158
159impl<'a, W: Write> SerializeMap for SeqSerializer<'a, W> {
160    type Ok = ();
161    type Error = Error;
162
163    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
164    where
165        T: serde::Serialize,
166    {
167        key.serialize(&mut *self.se)
168    }
169
170    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
171    where
172        T: serde::Serialize,
173    {
174        value.serialize(&mut *self.se)
175    }
176
177    fn end(self) -> Result<Self::Ok, Self::Error> {
178        match self.kind {
179            SeqKind::UnknownLength => self.se.write_end(),
180            SeqKind::KnownLength => Ok(()),
181        }
182    }
183}
184
185impl<'a, W: Write> SerializeStruct for SeqSerializer<'a, W> {
186    type Ok = ();
187    type Error = Error;
188
189    fn serialize_field<T: ?Sized>(
190        &mut self,
191        key: &'static str,
192        value: &T,
193    ) -> Result<(), Self::Error>
194    where
195        T: serde::Serialize,
196    {
197        if self.with_key {
198            key.serialize(&mut *self.se)?;
199        }
200        value.serialize(&mut *self.se)
201    }
202
203    fn end(self) -> Result<Self::Ok, Self::Error> {
204        match self.kind {
205            SeqKind::UnknownLength => self.se.write_end(),
206            SeqKind::KnownLength => Ok(()),
207        }
208    }
209}
210
211impl<'a, W: Write> SerializeStructVariant for SeqSerializer<'a, W> {
212    type Ok = ();
213    type Error = Error;
214
215    fn serialize_field<T: ?Sized>(
216        &mut self,
217        key: &'static str,
218        value: &T,
219    ) -> Result<(), Self::Error>
220    where
221        T: Serialize,
222    {
223        if self.with_key {
224            key.serialize(&mut *self.se)?;
225        }
226        value.serialize(&mut *self.se)
227    }
228
229    fn end(self) -> Result<Self::Ok, Self::Error> {
230        match self.kind {
231            SeqKind::UnknownLength => self.se.write_end(),
232            SeqKind::KnownLength => Ok(()),
233        }
234    }
235}
236
237macro_rules! serialize_err {
238    ($name:ident$(<$gen_name:ident: ?Sized>)?, $($ty:ty),* => $expr:expr) => {
239        fn $name$(<$gen_name: ?Sized>)?(self, $(_: $ty),*) -> Result<Self::Ok, Self::Error> {
240            $expr
241        }
242    };
243    ($name:ident$(<$gen_name:ident: ?Sized>)?, $($ty:ty),*: $return_typ:ty => $expr:expr) => {
244        fn $name$(<$gen_name: ?Sized>)?(self, $(_: $ty),*) -> $return_typ {
245            $expr
246        }
247    };
248}
249
250/// Custom type Serializer for Specific RESP types,
251/// supports: SimpleError, BlobError, SimpleString, BlobString
252struct RespSpecificSerializer<'a, W: Write> {
253    se: &'a mut Serializer<W>,
254    resp_kind: &'static str,
255}
256
257impl<'a, W: Write> serde::Serializer for RespSpecificSerializer<'a, W> {
258    type Ok = ();
259    type Error = Error;
260
261    type SerializeSeq = serde::ser::Impossible<(), Error>;
262    type SerializeTuple = serde::ser::Impossible<(), Error>;
263    type SerializeTupleStruct = serde::ser::Impossible<(), Error>;
264    type SerializeTupleVariant = serde::ser::Impossible<(), Error>;
265    type SerializeMap = serde::ser::Impossible<(), Error>;
266    type SerializeStruct = serde::ser::Impossible<(), Error>;
267    type SerializeStructVariant = serde::ser::Impossible<(), Error>;
268
269    serialize_err!(serialize_bool, bool => Err(Error::unexpected_value("bool")));
270    serialize_err!(serialize_i8, i8 => Err(Error::unexpected_value("i8")));
271    serialize_err!(serialize_i16, i16 => Err(Error::unexpected_value("i16")));
272    serialize_err!(serialize_i32, i32 => Err(Error::unexpected_value("i32")));
273    serialize_err!(serialize_i64, i64 => Err(Error::unexpected_value("i64")));
274    serialize_err!(serialize_u8, u8 => Err(Error::unexpected_value("u8")));
275    serialize_err!(serialize_u16, u16 => Err(Error::unexpected_value("u16")));
276    serialize_err!(serialize_u32, u32 => Err(Error::unexpected_value("u32")));
277    serialize_err!(serialize_u64, u64 => Err(Error::unexpected_value("u64")));
278    serialize_err!(serialize_f32, f32 => Err(Error::unexpected_value("f32")));
279    serialize_err!(serialize_f64, f64 => Err(Error::unexpected_value("f64")));
280    serialize_err!(serialize_char, char => Err(Error::unexpected_value("char")));
281    serialize_err!(serialize_none, => Err(Error::unexpected_value("none")));
282    serialize_err!(serialize_unit, => Err(Error::unexpected_value("unit")));
283    serialize_err!(serialize_some<T: ?Sized>, &T => Err(Error::unexpected_value("some")));
284    serialize_err!(serialize_unit_struct, &'static str => Err(Error::unexpected_value("unit")));
285    serialize_err!(serialize_unit_variant, &'static str, u32, &'static str =>
286        Err(Error::unexpected_value("unit_variant"))
287    );
288    serialize_err!(serialize_newtype_variant<T: ?Sized>, &'static str, u32, &'static str, &T =>
289        Err(Error::unexpected_value("newtype_variant"))
290    );
291    serialize_err!(serialize_struct_variant, &'static str, u32, &'static str, usize: Result<Self::SerializeStructVariant, Self::Error> =>
292        Err(Error::unexpected_value("struct_variant"))
293    );
294    serialize_err!(serialize_seq, Option<usize>:
295        Result<Self::SerializeSeq, Self::Error> =>
296        Err(Error::unexpected_value("seq"))
297    );
298    serialize_err!(serialize_tuple, usize:
299        Result<Self::SerializeTuple, Self::Error> =>
300        Err(Error::unexpected_value("tuple"))
301    );
302    serialize_err!(serialize_tuple_struct, &'static str, usize:
303        Result<Self::SerializeTupleStruct, Self::Error> =>
304        Err(Error::unexpected_value("tuple_struct"))
305    );
306    serialize_err!(serialize_tuple_variant,
307        &'static str, u32, &'static str, usize:
308        Result<Self::SerializeTupleStruct, Self::Error> =>
309        Err(Error::unexpected_value("tuple_variant"))
310    );
311    serialize_err!(serialize_map, Option<usize>:
312        Result<Self::SerializeMap, Self::Error> =>
313        Err(Error::unexpected_value("map"))
314    );
315    serialize_err!(serialize_struct, &'static str, usize:
316        Result<Self::SerializeMap, Self::Error> =>
317        Err(Error::unexpected_value("struct"))
318    );
319    serialize_err!(serialize_newtype_struct<T: ?Sized>, &'static str, &T =>
320        Err(Error::unexpected_value("newtype_struct"))
321    );
322
323    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
324        match self.resp_kind {
325            SIMPLE_ERROR_TOKEN => {
326                self.se.write_simple_error(v)?;
327                Ok(())
328            }
329            BLOB_ERROR_TOKEN => {
330                self.se.write_blob_error(v)?;
331                Ok(())
332            }
333            SIMPLE_STRING_TOKEN => {
334                self.se.write_simple_string(v)?;
335                Ok(())
336            }
337            BLOB_STRING_TOKEN => {
338                self.se.write_blob_string(v)?;
339                Ok(())
340            }
341            _ => unimplemented!(),
342        }
343    }
344
345    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
346        let s = str::from_utf8(v).map_err(|e| Error::utf8(e.valid_up_to()))?;
347        self.serialize_str(s)
348    }
349}
350
351struct PushSerializer<'a, W: Write> {
352    se: &'a mut Serializer<W>,
353}
354
355impl<'a, W: Write> serde::Serializer for PushSerializer<'a, W> {
356    type Ok = ();
357    type Error = Error;
358    type SerializeSeq = SeqSerializer<'a, W>;
359    type SerializeTuple = SeqSerializer<'a, W>;
360    type SerializeTupleStruct = SeqSerializer<'a, W>;
361    type SerializeTupleVariant = SeqSerializer<'a, W>;
362    type SerializeMap = SeqSerializer<'a, W>;
363    type SerializeStruct = SeqSerializer<'a, W>;
364    type SerializeStructVariant = SeqSerializer<'a, W>;
365
366    serialize_err!(serialize_bool, bool => Err(Error::unexpected_value("bool")));
367    serialize_err!(serialize_i8, i8 => Err(Error::unexpected_value("i8")));
368    serialize_err!(serialize_i16, i16 => Err(Error::unexpected_value("i16")));
369    serialize_err!(serialize_i32, i32 => Err(Error::unexpected_value("i32")));
370    serialize_err!(serialize_i64, i64 => Err(Error::unexpected_value("i64")));
371    serialize_err!(serialize_u8, u8 => Err(Error::unexpected_value("u8")));
372    serialize_err!(serialize_u16, u16 => Err(Error::unexpected_value("u16")));
373    serialize_err!(serialize_u32, u32 => Err(Error::unexpected_value("u32")));
374    serialize_err!(serialize_u64, u64 => Err(Error::unexpected_value("u64")));
375    serialize_err!(serialize_f32, f32 => Err(Error::unexpected_value("f32")));
376    serialize_err!(serialize_f64, f64 => Err(Error::unexpected_value("f64")));
377    serialize_err!(serialize_char, char => Err(Error::unexpected_value("char")));
378    serialize_err!(serialize_none, => Err(Error::unexpected_value("none")));
379    serialize_err!(serialize_unit, => Err(Error::unexpected_value("unit")));
380    serialize_err!(serialize_some<T: ?Sized>, &T => Err(Error::unexpected_value("some")));
381    serialize_err!(serialize_unit_struct, &'static str => Err(Error::unexpected_value("unit_struct")));
382    serialize_err!(serialize_unit_variant, &'static str, u32, &'static str =>
383        Err(Error::unexpected_value("unit_variant"))
384    );
385    serialize_err!(serialize_newtype_variant<T: ?Sized>, &'static str, u32, &'static str, &T =>
386        Err(Error::unexpected_value("newtype_variant"))
387    );
388    serialize_err!(serialize_str, &str => Err(Error::unexpected_value("string")));
389    serialize_err!(serialize_bytes, &[u8] => Err(Error::unexpected_value("bytes")));
390    serialize_err!(serialize_newtype_struct<T: ?Sized>, &'static str, &T =>
391        Err(Error::unexpected_value("newtype_struct"))
392    );
393    serialize_err!(serialize_map, Option<usize>: Result<Self::SerializeMap, Self::Error> => Err(Error::unexpected_value("map")));
394
395    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
396        if let Some(len) = len {
397            self.serialize_tuple(len)
398        } else {
399            Err(Error::unexpected_value("unknown len seq"))
400        }
401    }
402
403    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
404        self.se.write_push_len_marker(len)?;
405        Ok(SeqSerializer::known_length(self.se).without_key())
406    }
407
408    fn serialize_tuple_struct(
409        self,
410        _name: &'static str,
411        len: usize,
412    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
413        self.serialize_tuple(len)
414    }
415
416    fn serialize_tuple_variant(
417        self,
418        _name: &'static str,
419        _variant_index: u32,
420        _variant: &'static str,
421        len: usize,
422    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
423        self.serialize_tuple(len)
424    }
425
426    fn serialize_struct(
427        self,
428        _name: &'static str,
429        len: usize,
430    ) -> Result<Self::SerializeStruct, Self::Error> {
431        self.se.write_push_len_marker(len)?;
432        Ok(SeqSerializer::known_length(self.se).without_key())
433    }
434
435    fn serialize_struct_variant(
436        self,
437        _name: &'static str,
438        _variant_index: u32,
439        variant: &'static str,
440        len: usize,
441    ) -> Result<Self::SerializeStructVariant, Self::Error> {
442        self.serialize_struct(variant, len)
443    }
444}
445
446struct WithAttributeSerializer<'a, W: Write> {
447    se: &'a mut Serializer<W>,
448}
449
450impl<'a, W: Write> serde::Serializer for WithAttributeSerializer<'a, W> {
451    type Ok = ();
452    type Error = Error;
453    type SerializeSeq = serde::ser::Impossible<(), Error>;
454    type SerializeTuple = serde::ser::Impossible<(), Error>;
455    type SerializeTupleStruct = WithAttributeSeqSerializer<'a, W>;
456    type SerializeTupleVariant = serde::ser::Impossible<(), Error>;
457    type SerializeMap = serde::ser::Impossible<(), Error>;
458    type SerializeStruct = serde::ser::Impossible<(), Error>;
459    type SerializeStructVariant = serde::ser::Impossible<(), Error>;
460
461    serialize_err!(serialize_bool, bool => Err(Error::unexpected_value("bool")));
462    serialize_err!(serialize_i8, i8 => Err(Error::unexpected_value("i8")));
463    serialize_err!(serialize_i16, i16 => Err(Error::unexpected_value("i16")));
464    serialize_err!(serialize_i32, i32 => Err(Error::unexpected_value("i32")));
465    serialize_err!(serialize_i64, i64 => Err(Error::unexpected_value("i64")));
466    serialize_err!(serialize_u8, u8 => Err(Error::unexpected_value("u8")));
467    serialize_err!(serialize_u16, u16 => Err(Error::unexpected_value("u16")));
468    serialize_err!(serialize_u32, u32 => Err(Error::unexpected_value("u32")));
469    serialize_err!(serialize_u64, u64 => Err(Error::unexpected_value("u64")));
470    serialize_err!(serialize_f32, f32 => Err(Error::unexpected_value("f32")));
471    serialize_err!(serialize_f64, f64 => Err(Error::unexpected_value("f64")));
472    serialize_err!(serialize_char, char => Err(Error::unexpected_value("char")));
473    serialize_err!(serialize_none, => Err(Error::unexpected_value("none")));
474    serialize_err!(serialize_unit, => Err(Error::unexpected_value("unit")));
475    serialize_err!(serialize_some<T: ?Sized>, &T => Err(Error::unexpected_value("some")));
476    serialize_err!(serialize_unit_struct, &'static str => Err(Error::unexpected_value("unit_struct")));
477    serialize_err!(serialize_unit_variant, &'static str, u32, &'static str =>
478        Err(Error::unexpected_value("unit_variant"))
479    );
480    serialize_err!(serialize_newtype_variant<T: ?Sized>, &'static str, u32, &'static str, &T =>
481        Err(Error::unexpected_value("newtype_variant"))
482    );
483    serialize_err!(serialize_str, &str => Err(Error::unexpected_value("string")));
484    serialize_err!(serialize_bytes, &[u8] => Err(Error::unexpected_value("bytes")));
485    serialize_err!(serialize_newtype_struct<T: ?Sized>, &'static str, &T =>
486        Err(Error::unexpected_value("newtype_struct"))
487    );
488    serialize_err!(serialize_seq, Option<usize>: Result<Self::SerializeSeq, Self::Error> => Err(Error::unexpected_value("seq")));
489    serialize_err!(serialize_tuple, usize: Result<Self::SerializeTuple, Self::Error> =>
490        Err(Error::unexpected_value("tuple"))
491    );
492    serialize_err!(serialize_tuple_variant, &'static str, u32, &'static str, usize:
493        Result<Self::SerializeTupleVariant, Self::Error> =>
494        Err(Error::unexpected_value("tuple_variant"))
495    );
496    serialize_err!(serialize_map, Option<usize>: Result<Self::SerializeMap, Self::Error> =>
497        Err(Error::unexpected_value("map"))
498    );
499    serialize_err!(serialize_struct, &'static str, usize: Result<Self::SerializeStruct, Self::Error> =>
500        Err(Error::unexpected_value("struct"))
501    );
502    serialize_err!(serialize_struct_variant, &'static str, u32, &'static str, usize:
503        Result<Self::SerializeStruct, Self::Error> =>
504        Err(Error::unexpected_value("struct_variant"))
505    );
506
507    fn serialize_tuple_struct(
508        self,
509        name: &'static str,
510        _len: usize,
511    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
512        match name {
513            WITH_ATTRIBUTE_TOKEN => Ok(WithAttributeSeqSerializer::new(self.se)),
514            _ => Err(Error::unexpected_value("non_with_attribute_tuple_struct")),
515        }
516    }
517}
518
519enum WithAttributeState {
520    Attribute,
521    Value,
522    Done,
523}
524
525struct WithAttributeSeqSerializer<'a, W: Write> {
526    se: &'a mut Serializer<W>,
527    state: WithAttributeState,
528}
529
530impl<'a, W: Write> WithAttributeSeqSerializer<'a, W> {
531    fn new(se: &'a mut Serializer<W>) -> Self {
532        WithAttributeSeqSerializer {
533            se,
534            state: WithAttributeState::Attribute,
535        }
536    }
537}
538
539impl<'a, W: Write> SerializeTupleStruct for WithAttributeSeqSerializer<'a, W> {
540    type Ok = ();
541    type Error = Error;
542
543    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
544    where
545        T: Serialize,
546    {
547        match self.state {
548            WithAttributeState::Attribute => {
549                self.state = WithAttributeState::Value;
550                let serializer = AttributeSerializer { se: self.se };
551                value.serialize(serializer)
552            }
553            WithAttributeState::Value => {
554                self.state = WithAttributeState::Done;
555                value.serialize(&mut *self.se)
556            }
557            WithAttributeState::Done => Err(serde::ser::Error::custom(
558                "with_attribute only allow 2 fields",
559            )),
560        }
561    }
562
563    fn end(self) -> Result<Self::Ok, Self::Error> {
564        Ok(())
565    }
566}
567
568struct AttributeSerializer<'a, W: Write> {
569    se: &'a mut Serializer<W>,
570}
571
572impl<'a, W: Write> serde::Serializer for AttributeSerializer<'a, W> {
573    type Ok = ();
574    type Error = Error;
575    type SerializeSeq = serde::ser::Impossible<(), Error>;
576    type SerializeTuple = serde::ser::Impossible<(), Error>;
577    type SerializeTupleStruct = WithAttributeSeqSerializer<'a, W>;
578    type SerializeTupleVariant = serde::ser::Impossible<(), Error>;
579    type SerializeMap = SeqSerializer<'a, W>;
580    type SerializeStruct = SeqSerializer<'a, W>;
581    type SerializeStructVariant = SeqSerializer<'a, W>;
582
583    serialize_err!(serialize_bool, bool => Err(Error::unexpected_value("bool")));
584    serialize_err!(serialize_i8, i8 => Err(Error::unexpected_value("i8")));
585    serialize_err!(serialize_i16, i16 => Err(Error::unexpected_value("i16")));
586    serialize_err!(serialize_i32, i32 => Err(Error::unexpected_value("i32")));
587    serialize_err!(serialize_i64, i64 => Err(Error::unexpected_value("i64")));
588    serialize_err!(serialize_u8, u8 => Err(Error::unexpected_value("u8")));
589    serialize_err!(serialize_u16, u16 => Err(Error::unexpected_value("u16")));
590    serialize_err!(serialize_u32, u32 => Err(Error::unexpected_value("u32")));
591    serialize_err!(serialize_u64, u64 => Err(Error::unexpected_value("u64")));
592    serialize_err!(serialize_f32, f32 => Err(Error::unexpected_value("f32")));
593    serialize_err!(serialize_f64, f64 => Err(Error::unexpected_value("f64")));
594    serialize_err!(serialize_char, char => Err(Error::unexpected_value("char")));
595    serialize_err!(serialize_none, => Err(Error::unexpected_value("none")));
596    serialize_err!(serialize_unit, => Err(Error::unexpected_value("unit")));
597    serialize_err!(serialize_some<T: ?Sized>, &T => Err(Error::unexpected_value("some")));
598    serialize_err!(serialize_unit_struct, &'static str => Err(Error::unexpected_value("unit_struct")));
599    serialize_err!(serialize_unit_variant, &'static str, u32, &'static str =>
600        Err(Error::unexpected_value("unit_variant"))
601    );
602    serialize_err!(serialize_newtype_variant<T: ?Sized>, &'static str, u32, &'static str, &T =>
603        Err(Error::unexpected_value("newtype_variant"))
604    );
605    serialize_err!(serialize_str, &str => Err(Error::unexpected_value("string")));
606    serialize_err!(serialize_bytes, &[u8] => Err(Error::unexpected_value("bytes")));
607    serialize_err!(serialize_newtype_struct<T: ?Sized>, &'static str, &T =>
608        Err(Error::unexpected_value("newtype_struct"))
609    );
610    serialize_err!(serialize_seq, Option<usize>: Result<Self::SerializeSeq, Self::Error> => Err(Error::unexpected_value("seq")));
611    serialize_err!(serialize_tuple, usize: Result<Self::SerializeTuple, Self::Error> =>
612        Err(Error::unexpected_value("tuple"))
613    );
614    serialize_err!(serialize_tuple_struct, &'static str, usize:
615        Result<Self::SerializeTupleStruct, Self::Error> =>
616        Err(Error::unexpected_value("tuple_struct"))
617    );
618    serialize_err!(serialize_tuple_variant, &'static str, u32, &'static str, usize:
619        Result<Self::SerializeTupleVariant, Self::Error> =>
620        Err(Error::unexpected_value("tuple_variant"))
621    );
622
623    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
624        if let Some(l) = len {
625            self.se.write_attr_len_marker(l)?;
626            Ok(SeqSerializer::known_length(self.se))
627        } else {
628            Err(Error::unexpected_value("unknown size map"))
629        }
630    }
631
632    fn serialize_struct(
633        self,
634        _name: &'static str,
635        len: usize,
636    ) -> Result<Self::SerializeStruct, Self::Error> {
637        self.se.write_attr_len_marker(len)?;
638        Ok(SeqSerializer::known_length(self.se))
639    }
640
641    fn serialize_struct_variant(
642        self,
643        _name: &'static str,
644        _variant_index: u32,
645        variant: &'static str,
646        len: usize,
647    ) -> Result<Self::SerializeStructVariant, Self::Error> {
648        self.serialize_struct(variant, len)
649    }
650}
651
652impl<W: Write> Serializer<W> {
653    fn write_i64(&mut self, v: i64) -> Result<(), Error> {
654        write!(self.writer, ":{}\r\n", v).map_err(Error::io)?;
655
656        Ok(())
657    }
658    fn write_u64(&mut self, v: u64) -> Result<(), Error> {
659        write!(self.writer, ":{}\r\n", v).map_err(Error::io)?;
660
661        Ok(())
662    }
663    fn write_f64(&mut self, v: f64) -> Result<(), Error> {
664        if v.is_nan() {
665            return Err(Error::nan());
666        }
667
668        if v.is_infinite() {
669            if v.is_sign_positive() {
670                write!(self.writer, ",inf\r\n").map_err(Error::io)?;
671            } else {
672                write!(self.writer, ",-inf\r\n").map_err(Error::io)?;
673            }
674
675            return Ok(());
676        }
677
678        write!(self.writer, ",{:.}\r\n", v).map_err(Error::io)?;
679
680        Ok(())
681    }
682    fn write_bool(&mut self, v: bool) -> Result<(), Error> {
683        if v {
684            write!(self.writer, "#t\r\n").map_err(Error::io)?;
685        } else {
686            write!(self.writer, "#f\r\n").map_err(Error::io)?;
687        }
688
689        Ok(())
690    }
691    fn write_simple_string_char(&mut self, c: char) -> Result<(), Error> {
692        write!(self.writer, "+{}\r\n", c).map_err(Error::io)?;
693
694        Ok(())
695    }
696    fn write_simple_string(&mut self, s: &str) -> Result<(), Error> {
697        write!(self.writer, "+{}\r\n", s).map_err(Error::io)?;
698
699        Ok(())
700    }
701    fn write_blob_string(&mut self, s: &str) -> Result<(), Error> {
702        write!(self.writer, "${}\r\n{}\r\n", s.len(), s).map_err(Error::io)?;
703
704        Ok(())
705    }
706    fn write_simple_error(&mut self, s: &str) -> Result<(), Error> {
707        write!(self.writer, "-{}\r\n", s).map_err(Error::io)?;
708
709        Ok(())
710    }
711    fn write_blob_error(&mut self, s: &str) -> Result<(), Error> {
712        write!(self.writer, "!{}\r\n{}\r\n", s.len(), s).map_err(Error::io)?;
713
714        Ok(())
715    }
716    fn write_null(&mut self) -> Result<(), Error> {
717        write!(self.writer, "_\r\n").map_err(Error::io)?;
718
719        Ok(())
720    }
721    fn write_attr_len_marker(&mut self, len: usize) -> Result<(), Error> {
722        write!(self.writer, "|{}\r\n", len).map_err(Error::io)?;
723
724        Ok(())
725    }
726    fn write_push_len_marker(&mut self, len: usize) -> Result<(), Error> {
727        write!(self.writer, ">{}\r\n", len).map_err(Error::io)?;
728
729        Ok(())
730    }
731    fn write_array_len_marker(&mut self, len: usize) -> Result<(), Error> {
732        write!(self.writer, "*{}\r\n", len).map_err(Error::io)?;
733
734        Ok(())
735    }
736    fn write_array_nolen_marker(&mut self) -> Result<(), Error> {
737        write!(self.writer, "*?\r\n").map_err(Error::io)?;
738
739        Ok(())
740    }
741    fn write_map_len_marker(&mut self, len: usize) -> Result<(), Error> {
742        write!(self.writer, "%{}\r\n", len).map_err(Error::io)?;
743
744        Ok(())
745    }
746    fn write_map_nolen_marker(&mut self) -> Result<(), Error> {
747        write!(self.writer, "%?\r\n").map_err(Error::io)?;
748
749        Ok(())
750    }
751    fn write_end(&mut self) -> Result<(), Error> {
752        write!(self.writer, ".\r\n").map_err(Error::io)?;
753
754        Ok(())
755    }
756}
757
758impl<'a, W: Write> serde::Serializer for &'a mut Serializer<W> {
759    type Ok = ();
760    type Error = Error;
761    type SerializeSeq = SeqSerializer<'a, W>;
762    type SerializeTuple = SeqSerializer<'a, W>;
763    type SerializeTupleStruct = SeqSerializer<'a, W>;
764    type SerializeTupleVariant = SeqSerializer<'a, W>;
765    type SerializeMap = SeqSerializer<'a, W>;
766    type SerializeStruct = SeqSerializer<'a, W>;
767    type SerializeStructVariant = SeqSerializer<'a, W>;
768
769    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
770        self.write_bool(v)
771    }
772
773    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
774        self.serialize_i64(v as i64)
775    }
776
777    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
778        self.serialize_i64(v as i64)
779    }
780
781    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
782        self.serialize_i64(v as i64)
783    }
784
785    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
786        self.write_i64(v)
787    }
788
789    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
790        self.serialize_u64(v as u64)
791    }
792
793    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
794        self.serialize_u64(v as u64)
795    }
796
797    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
798        self.serialize_u64(v as u64)
799    }
800
801    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
802        self.write_u64(v)
803    }
804
805    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
806        self.serialize_f64(v as f64)
807    }
808
809    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
810        self.write_f64(v)
811    }
812
813    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
814        self.write_simple_string_char(v)
815    }
816
817    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
818        self.write_simple_string(v)
819    }
820
821    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
822        let s = str::from_utf8(v).map_err(|e| Error::utf8(e.valid_up_to()))?;
823        self.write_blob_string(s)
824    }
825
826    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
827        self.write_null()
828    }
829
830    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
831    where
832        T: serde::Serialize,
833    {
834        value.serialize(self)
835    }
836
837    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
838        self.write_null()
839    }
840
841    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
842        self.write_null()
843    }
844
845    /// Serialize as { variant => null }
846    fn serialize_unit_variant(
847        self,
848        _name: &'static str,
849        _variant_index: u32,
850        variant: &'static str,
851    ) -> Result<Self::Ok, Self::Error> {
852        self.write_map_len_marker(1)?;
853        self.write_simple_string(variant)?;
854        self.write_null()
855    }
856
857    fn serialize_newtype_struct<T: ?Sized>(
858        self,
859        name: &'static str,
860        value: &T,
861    ) -> Result<Self::Ok, Self::Error>
862    where
863        T: serde::Serialize,
864    {
865        match name {
866            SIMPLE_ERROR_TOKEN | BLOB_ERROR_TOKEN | SIMPLE_STRING_TOKEN | BLOB_STRING_TOKEN => {
867                let se = RespSpecificSerializer {
868                    se: self,
869                    resp_kind: name,
870                };
871                value.serialize(se)
872            }
873            PUSH_TOKEN => {
874                let se = PushSerializer { se: self };
875                value.serialize(se)
876            }
877            WITH_ATTRIBUTE_TOKEN => {
878                let se = WithAttributeSerializer { se: self };
879                value.serialize(se)
880            }
881            _ => value.serialize(self),
882        }
883    }
884
885    /// Serialize as { variant => T }
886    fn serialize_newtype_variant<T: ?Sized>(
887        self,
888        _name: &'static str,
889        _variant_index: u32,
890        variant: &'static str,
891        value: &T,
892    ) -> Result<Self::Ok, Self::Error>
893    where
894        T: serde::Serialize,
895    {
896        self.write_map_len_marker(1)?;
897        self.write_simple_string(variant)?;
898        value.serialize(self)
899    }
900
901    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
902        match len {
903            Some(l) => {
904                self.write_array_len_marker(l)?;
905                Ok(SeqSerializer::known_length(self))
906            }
907            None => {
908                self.write_array_nolen_marker()?;
909                Ok(SeqSerializer::unknown_length(self))
910            }
911        }
912    }
913
914    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
915        self.serialize_seq(Some(len))
916    }
917
918    fn serialize_tuple_struct(
919        self,
920        name: &'static str,
921        len: usize,
922    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
923        match name {
924            WITH_ATTRIBUTE_TOKEN => Ok(SeqSerializer::known_length(self)),
925            _ => self.serialize_seq(Some(len)),
926        }
927    }
928
929    /// Serialize as { variant => [tuple ele, .. ] }
930    fn serialize_tuple_variant(
931        self,
932        _name: &'static str,
933        _variant_index: u32,
934        variant: &'static str,
935        len: usize,
936    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
937        self.write_map_len_marker(1)?;
938        self.write_simple_string(variant)?;
939        self.serialize_seq(Some(len))
940    }
941
942    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
943        match len {
944            Some(l) => {
945                self.write_map_len_marker(l)?;
946                Ok(SeqSerializer::known_length(self))
947            }
948            None => {
949                self.write_map_nolen_marker()?;
950                Ok(SeqSerializer::unknown_length(self))
951            }
952        }
953    }
954
955    fn serialize_struct(
956        self,
957        _name: &'static str,
958        len: usize,
959    ) -> Result<Self::SerializeStruct, Self::Error> {
960        self.serialize_map(Some(len))
961    }
962
963    /// Serialize as { variant => { struct .. } }
964    fn serialize_struct_variant(
965        self,
966        _name: &'static str,
967        _variant_index: u32,
968        variant: &'static str,
969        len: usize,
970    ) -> Result<Self::SerializeStructVariant, Self::Error> {
971        self.write_map_len_marker(1)?;
972        self.write_simple_string(variant)?;
973        self.serialize_map(Some(len))
974    }
975}
976
977#[cfg(test)]
978mod tests {
979    use std::collections::BTreeMap;
980
981    use super::*;
982
983    #[test]
984    fn test_serialize_bool() {
985        let bool_t = true;
986        let buf = to_vec(&bool_t).unwrap();
987        assert_eq!(buf, b"#t\r\n");
988
989        let bool_t = false;
990        let buf = to_vec(&bool_t).unwrap();
991        assert_eq!(buf, b"#f\r\n");
992    }
993
994    #[test]
995    fn test_serialize_number() {
996        let num: i64 = 12345;
997        let buf = to_vec(&num).unwrap();
998        assert_eq!(buf, b":12345\r\n");
999
1000        let num: i64 = -12345;
1001        let buf = to_vec(&num).unwrap();
1002        assert_eq!(buf, b":-12345\r\n");
1003    }
1004
1005    #[test]
1006    fn test_serialize_double() {
1007        let num: f64 = 12345.1;
1008        let buf = to_vec(&num).unwrap();
1009        assert_eq!(buf, b",12345.1\r\n");
1010
1011        let num: f64 = f64::NEG_INFINITY;
1012        let buf = to_vec(&num).unwrap();
1013        assert_eq!(buf, b",-inf\r\n");
1014
1015        let num: f64 = f64::INFINITY;
1016        let buf = to_vec(&num).unwrap();
1017        assert_eq!(buf, b",inf\r\n");
1018    }
1019
1020    #[test]
1021    fn test_serialize_char() {
1022        let chr: char = 'e';
1023        let buf = to_vec(&chr).unwrap();
1024        assert_eq!(buf, b"+e\r\n");
1025    }
1026
1027    #[test]
1028    fn test_serialize_str() {
1029        let str: &str = "hello world";
1030        let buf = to_vec(&str).unwrap();
1031        assert_eq!(buf, b"+hello world\r\n");
1032    }
1033
1034    #[test]
1035    fn test_serialize_option() {
1036        let str: Option<&str> = None;
1037        let buf = to_vec(&str).unwrap();
1038        assert_eq!(buf, b"_\r\n");
1039
1040        let str: Option<&str> = Some("hello world");
1041        let buf = to_vec(&str).unwrap();
1042        assert_eq!(buf, b"+hello world\r\n");
1043    }
1044
1045    #[test]
1046    fn test_serialize_unit() {
1047        let unit: () = ();
1048        let buf = to_vec(&unit).unwrap();
1049        assert_eq!(buf, b"_\r\n");
1050    }
1051
1052    #[test]
1053    fn test_serialize_struct() {
1054        // newtype struct
1055        #[derive(Serialize)]
1056        struct NewType(usize);
1057
1058        let newtype = NewType(123);
1059        let buf = to_vec(&newtype).unwrap();
1060        assert_eq!(buf, b":123\r\n");
1061
1062        // struct struct
1063        #[derive(Serialize)]
1064        struct StructStruct {
1065            a: usize,
1066            b: String,
1067        }
1068
1069        let structstruct = StructStruct {
1070            a: 123,
1071            b: String::from("abc"),
1072        };
1073        let buf = to_vec(&structstruct).unwrap();
1074        assert_eq!(buf, b"%2\r\n+a\r\n:123\r\n+b\r\n+abc\r\n");
1075
1076        // unit struct
1077        #[derive(Serialize)]
1078        struct UnitT;
1079
1080        let unit: UnitT = UnitT;
1081        let buf = to_vec(&unit).unwrap();
1082        assert_eq!(buf, b"_\r\n");
1083
1084        // tuple struct
1085        #[derive(Serialize)]
1086        struct Tuple(usize, String);
1087
1088        let tuple = Tuple(123, String::from("abcd"));
1089        let buf = to_vec(&tuple).unwrap();
1090        assert_eq!(buf, b"*2\r\n:123\r\n+abcd\r\n");
1091    }
1092
1093    #[test]
1094    fn test_serialize_map() {
1095        let mut map = BTreeMap::new();
1096        map.insert("a", "b");
1097        map.insert("c", "d");
1098        let buf = to_vec(&map).unwrap();
1099        assert_eq!(buf, b"%2\r\n+a\r\n+b\r\n+c\r\n+d\r\n");
1100    }
1101
1102    #[test]
1103    fn test_serialize_seq() {
1104        let seq = vec!["a", "b", "c", "d"];
1105        let buf = to_vec(&seq).unwrap();
1106        assert_eq!(buf, b"*4\r\n+a\r\n+b\r\n+c\r\n+d\r\n");
1107
1108        let seq = (1, 3, String::from("abc"), 10.5);
1109        let buf = to_vec(&seq).unwrap();
1110        assert_eq!(buf, b"*4\r\n:1\r\n:3\r\n+abc\r\n,10.5\r\n");
1111    }
1112
1113    #[test]
1114    fn test_serialize_enum() {
1115        #[derive(Serialize)]
1116        enum Enum {
1117            Struct { a: usize, b: String },
1118            Tuple(usize, String),
1119            Unit,
1120        }
1121
1122        // struct variant
1123        let struct_variant = Enum::Struct {
1124            a: 123,
1125            b: String::from("abc"),
1126        };
1127        let buf = to_vec(&struct_variant).unwrap();
1128        assert_eq!(buf, b"%1\r\n+Struct\r\n%2\r\n+a\r\n:123\r\n+b\r\n+abc\r\n");
1129
1130        // tuple variant
1131        let tuple_variant = Enum::Tuple(123, String::from("abcd"));
1132        let buf = to_vec(&tuple_variant).unwrap();
1133        assert_eq!(buf, b"%1\r\n+Tuple\r\n*2\r\n:123\r\n+abcd\r\n");
1134
1135        // unit variant
1136        let unit_variant = Enum::Unit;
1137        let buf = to_vec(&unit_variant).unwrap();
1138        assert_eq!(buf, b"%1\r\n+Unit\r\n_\r\n");
1139    }
1140}
deseresp/ser.rs

deseresp/
ser.rs
