amp_serde/
ser.rs

1use std::convert::TryInto;
2
3use bytes::BufMut;
4use serde::ser::{
5    Impossible, SerializeMap, SerializeSeq, SerializeStruct, SerializeTuple, SerializeTupleStruct,
6};
7use serde::Serialize;
8
9use crate::Error;
10
11pub(crate) const AMP_KEY_LIMIT: usize = 0xff;
12pub(crate) const AMP_VALUE_LIMIT: usize = 0xffff;
13
14#[derive(Debug)]
15pub struct Serializer;
16
17pub struct BufferSerializer<'a>(&'a Serializer, Vec<u8>);
18
19impl<'a> SerializeSeq for BufferSerializer<'a> {
20    type Ok = Vec<u8>;
21    type Error = Error;
22
23    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
24        Self::push_value(&value.serialize(self.0)?, &mut self.1)
25    }
26
27    fn end(self) -> Result<Self::Ok, Self::Error> {
28        Ok(self.1)
29    }
30}
31
32impl<'a> SerializeTuple for BufferSerializer<'a> {
33    type Ok = Vec<u8>;
34    type Error = Error;
35
36    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
37        Self::push_value(&value.serialize(self.0)?, &mut self.1)
38    }
39
40    fn end(self) -> Result<Self::Ok, Self::Error> {
41        Ok(self.1)
42    }
43}
44
45impl<'a> SerializeTupleStruct for BufferSerializer<'a> {
46    type Ok = Vec<u8>;
47    type Error = Error;
48
49    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
50        Self::push_value(&value.serialize(self.0)?, &mut self.1)
51    }
52
53    fn end(self) -> Result<Self::Ok, Self::Error> {
54        Ok(self.1)
55    }
56}
57
58impl<'a> SerializeMap for BufferSerializer<'a> {
59    type Ok = Vec<u8>;
60    type Error = Error;
61
62    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
63        Self::push_key(&key.serialize(self.0)?, &mut self.1)
64    }
65
66    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
67        Self::push_value(&value.serialize(self.0)?, &mut self.1)
68    }
69
70    fn end(mut self) -> Result<Self::Ok, Self::Error> {
71        self.1.put_u16(0);
72        Ok(self.1)
73    }
74}
75
76impl<'a> SerializeStruct for BufferSerializer<'a> {
77    type Ok = Vec<u8>;
78    type Error = Error;
79
80    fn serialize_field<T: ?Sized + Serialize>(
81        &mut self,
82        key: &'static str,
83        value: &T,
84    ) -> Result<(), Self::Error> {
85        Self::push_key(&key.serialize(self.0)?, &mut self.1)?;
86        Self::push_value(&value.serialize(self.0)?, &mut self.1)?;
87        Ok(())
88    }
89
90    fn end(mut self) -> Result<Self::Ok, Self::Error> {
91        self.1.put_u16(0);
92        Ok(self.1)
93    }
94}
95
96impl BufferSerializer<'_> {
97    fn push_value(input: &[u8], output: &mut Vec<u8>) -> Result<(), Error> {
98        if input.len() > AMP_VALUE_LIMIT {
99            return Err(Error::ValueTooLong);
100        }
101
102        output.put_u16(input.len().try_into().unwrap());
103        output.extend_from_slice(input);
104        Ok(())
105    }
106
107    fn push_key(input: &[u8], output: &mut Vec<u8>) -> Result<(), Error> {
108        if input.is_empty() {
109            return Err(Error::EmptyKey);
110        }
111        if input.len() > AMP_KEY_LIMIT {
112            return Err(Error::KeyTooLong);
113        }
114
115        output.put_u16(input.len().try_into().unwrap());
116        output.extend_from_slice(input);
117        Ok(())
118    }
119}
120
121impl<'a> serde::Serializer for &'a Serializer {
122    type Ok = Vec<u8>;
123    type Error = Error;
124
125    type SerializeSeq = BufferSerializer<'a>;
126    type SerializeTuple = BufferSerializer<'a>;
127    type SerializeTupleStruct = BufferSerializer<'a>;
128    type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
129    type SerializeMap = BufferSerializer<'a>;
130    type SerializeStruct = BufferSerializer<'a>;
131    type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
132
133    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
134        if v {
135            Ok(b"True".to_vec())
136        } else {
137            Ok(b"False".to_vec())
138        }
139    }
140
141    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
142        self.serialize_i64(v as i64)
143    }
144
145    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
146        self.serialize_i64(v as i64)
147    }
148
149    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
150        self.serialize_i64(v as i64)
151    }
152
153    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
154        Ok(format!("{}", v).into())
155    }
156
157    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
158        self.serialize_u64(v as u64)
159    }
160
161    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
162        self.serialize_u64(v as u64)
163    }
164
165    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
166        self.serialize_u64(v as u64)
167    }
168
169    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
170        Ok(format!("{}", v).into())
171    }
172
173    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
174        Ok(format!("{}", v).into())
175    }
176
177    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
178        Ok(format!("{}", v).into())
179    }
180
181    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
182        // A char encoded as UTF-8 takes 4 bytes at most.
183        let mut buf = [0; 4];
184        self.serialize_str(v.encode_utf8(&mut buf))
185    }
186
187    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
188        Ok(v.as_bytes().into())
189    }
190
191    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
192        Ok(value.into())
193    }
194
195    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
196        Err(Error::Unsupported)
197    }
198
199    fn serialize_some<T: ?Sized + serde::Serialize>(self, v: &T) -> Result<Self::Ok, Self::Error> {
200        v.serialize(self)
201    }
202
203    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
204        Err(Error::Unsupported)
205    }
206
207    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
208        Err(Error::Unsupported)
209    }
210
211    fn serialize_unit_variant(
212        self,
213        _name: &str,
214        _idx: u32,
215        _variant: &'static str,
216    ) -> Result<Self::Ok, Self::Error> {
217        Err(Error::Unsupported)
218    }
219
220    fn serialize_newtype_struct<T: ?Sized + serde::Serialize>(
221        self,
222        _name: &'static str,
223        value: &T,
224    ) -> Result<Self::Ok, Self::Error> {
225        value.serialize(self)
226    }
227
228    fn serialize_newtype_variant<T: ?Sized + serde::Serialize>(
229        self,
230        _name: &'static str,
231        _idx: u32,
232        _variant: &'static str,
233        _value: &T,
234    ) -> Result<Self::Ok, Self::Error> {
235        Err(Error::Unsupported)
236    }
237
238    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
239        Ok(BufferSerializer(self, Vec::new()))
240    }
241
242    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
243        self.serialize_seq(Some(len))
244    }
245
246    fn serialize_tuple_struct(
247        self,
248        _name: &'static str,
249        len: usize,
250    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
251        self.serialize_seq(Some(len))
252    }
253
254    fn serialize_tuple_variant(
255        self,
256        _name: &'static str,
257        _idx: u32,
258        _variant: &'static str,
259        _len: usize,
260    ) -> Result<Self::SerializeTupleVariant, Error> {
261        Err(Error::Unsupported)
262    }
263
264    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
265        Ok(BufferSerializer(self, Vec::new()))
266    }
267
268    fn serialize_struct(
269        self,
270        _name: &'static str,
271        _len: usize,
272    ) -> Result<Self::SerializeStruct, Self::Error> {
273        Ok(BufferSerializer(self, Vec::new()))
274    }
275
276    fn serialize_struct_variant(
277        self,
278        _name: &'static str,
279        _id: u32,
280        _variant: &'static str,
281        _len: usize,
282    ) -> Result<Self::SerializeStructVariant, Error> {
283        Err(Error::Unsupported)
284    }
285}
286
287pub fn to_bytes<T: Serialize>(value: T) -> Result<Vec<u8>, Error> {
288    value.serialize(&Serializer)
289}
amp_serde/ser.rs

amp_serde/
ser.rs
