embedded_msgpack/encode/serde/
mod.rs

1use self::{map::SerializeMap, seq::SerializeSeq, struct_::SerializeStruct};
2use super::Error;
3use crate::encode::SerializeIntoSlice;
4
5mod map;
6mod seq;
7mod struct_;
8
9pub(crate) struct Serializer<'a> {
10    buf: &'a mut [u8],
11    pos: usize,
12    state: State,
13}
14
15enum State {
16    Normal,
17    #[cfg(feature = "ext")]
18    Ext(Option<i8>),
19    #[cfg(feature = "timestamp")]
20    Timestamp(Option<i64>, Option<u32>),
21}
22
23impl<'a> Serializer<'a> {
24    fn new(buf: &'a mut [u8]) -> Self {
25        Serializer {
26            buf,
27            pos: 0,
28            state: State::Normal,
29        }
30    }
31    #[allow(clippy::clippy::needless_pass_by_value)]
32    fn append<S: SerializeIntoSlice>(&mut self, value: S) -> Result<(), Error> {
33        self.pos += value.write_into_slice(&mut self.buf[self.pos..])?;
34        Ok(())
35    }
36}
37
38impl<'a, 'b> ::serde::ser::Serializer for &'a mut Serializer<'b> {
39    type Ok = ();
40    type Error = Error;
41    type SerializeSeq = SerializeSeq<'a, 'b>;
42    type SerializeTuple = SerializeSeq<'a, 'b>;
43    type SerializeTupleStruct = Unreachable;
44    type SerializeTupleVariant = &'a mut Serializer<'b>;
45    type SerializeMap = SerializeMap<'a, 'b>;
46    type SerializeStruct = SerializeStruct<'a, 'b>;
47    type SerializeStructVariant = Unreachable;
48
49    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> { self.append(v) }
50    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
51        match self.state {
52            #[cfg(feature = "ext")]
53            State::Ext(_) => {
54                // serialize Ext type
55                self.state = State::Ext(Some(v));
56                Ok(())
57            }
58            _ => self.append(v),
59        }
60    }
61    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> { self.append(v) }
62    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> { self.append(v) }
63    #[cfg(feature = "i64")]
64    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> { self.append(v) }
65    #[cfg(not(feature = "i64"))]
66    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { unimplemented!() }
67    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> { self.append(v) }
68    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> { self.append(v) }
69    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> { self.append(v) }
70    #[cfg(feature = "u64")]
71    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> { self.append(v) }
72    #[cfg(not(feature = "u64"))]
73    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { unimplemented!() }
74    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> { self.append(v) }
75    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> { self.append(v) }
76
77    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
78        let mut b = [0; 4];
79        let v: &str = v.encode_utf8(&mut b);
80        self.append(v)
81    }
82
83    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> { self.append(v) }
84
85    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
86        match self.state {
87            #[cfg(feature = "ext")]
88            State::Ext(typ) => {
89                let typ = typ.ok_or(Error::InvalidType)?;
90                self.state = State::Normal;
91                let ext = crate::Ext::new(typ, v);
92                self.pos += (&ext).write_into_slice(&mut self.buf[self.pos..])?;
93                Ok(())
94            }
95            _ => {
96                let v = super::Binary::new(v);
97                self.append(v)
98            }
99        }
100    }
101
102    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
103        let x: Option<()> = None;
104        self.append(x)
105    }
106
107    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok, Self::Error>
108    where T: ::serde::ser::Serialize {
109        v.serialize(self)
110    }
111
112    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { unimplemented!() }
113
114    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { unimplemented!() }
115
116    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
117        self.serialize_str(variant)
118    }
119
120    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, v: &T) -> Result<Self::Ok, Self::Error>
121    where T: ::serde::ser::Serialize {
122        v.serialize(self)
123    }
124
125    fn serialize_newtype_variant<T: ?Sized>(
126        self,
127        _name: &'static str,
128        _variant_index: u32,
129        _variant: &'static str,
130        _value: &T,
131    ) -> Result<Self::Ok, Self::Error>
132    where
133        T: ::serde::ser::Serialize,
134    {
135        unimplemented!()
136    }
137
138    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
139        self.pos += crate::encode::serialize_array_start(len.ok_or(Error::InvalidType)?, &mut self.buf[self.pos..])?;
140        Ok(SerializeSeq::new(self))
141    }
142
143    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> { self.serialize_seq(Some(len)) }
144
145    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
146        unimplemented!()
147    }
148
149    fn serialize_tuple_variant(
150        self,
151        _name: &'static str,
152        _variant_index: u32,
153        _variant: &'static str,
154        _len: usize,
155    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
156        unimplemented!()
157    }
158
159    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
160        self.pos += super::serialize_map_start(len.ok_or(Error::InvalidType)?, &mut self.buf[self.pos..])?;
161        Ok(SerializeMap::new(self))
162    }
163
164    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
165        match name {
166            #[cfg(feature = "ext")]
167            crate::ext::TYPE_NAME => {
168                // special handling to support serializing MsgPack Ext type
169                // SerializeStruct will reset `self.serializing_ext` when `end()` is called on it
170                self.state = State::Ext(None);
171            }
172            #[cfg(feature = "timestamp")]
173            crate::timestamp::TYPE_NAME => {
174                self.state = State::Timestamp(None, None);
175            }
176            _ => {
177                self.pos += super::serialize_map_start(len, &mut self.buf[self.pos..])?;
178            }
179        }
180        Ok(SerializeStruct::new(self))
181    }
182
183    fn serialize_struct_variant(
184        self,
185        _name: &'static str,
186        _variant_index: u32,
187        _variant: &'static str,
188        _len: usize,
189    ) -> Result<Self::SerializeStructVariant, Self::Error> {
190        unimplemented!()
191    }
192
193    fn collect_str<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
194    where T: core::fmt::Display {
195        unimplemented!()
196    }
197}
198
199/// Serializes the given data structure as a JSON byte vector
200pub fn to_array<T>(value: &T, buf: &mut [u8]) -> Result<usize, Error>
201where T: ::serde::ser::Serialize + ?Sized {
202    let mut ser = Serializer::new(buf);
203    value.serialize(&mut ser)?;
204    Ok(ser.pos)
205}
206
207impl ::serde::ser::Error for Error {
208    fn custom<T>(_msg: T) -> Self
209    where T: core::fmt::Display {
210        unimplemented!()
211    }
212}
213
214#[cfg(not(feature = "std"))]
215impl ::serde::ser::StdError for Error {}
216
217impl<'a, 'b> ::serde::ser::SerializeTupleVariant for &'a mut Serializer<'b> {
218    type Ok = ();
219    type Error = Error;
220
221    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
222    where T: ?Sized + serde::Serialize {
223        value.serialize(&mut **self)
224    }
225
226    fn end(self) -> Result<(), Error> {
227        self.state = State::Normal;
228        Ok(())
229    }
230}
231
232// impl<'a, 'b> ser::SerializeStruct for &'a mut Serializer<'b> {
233//     type Ok = ();
234//     type Error = Error;
235
236//     fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
237//     where T: ::serde::ser::Serialize {
238//         key.serialize(&mut **self)?;
239//         value.serialize(&mut **self)?;
240//         Ok(())
241//     }
242
243//     fn end(self) -> Result<(), Error> {
244//         self.serializing_ext = false;
245//         Ok(())
246//     }
247// }
248
249pub(crate) enum Unreachable {}
250
251impl ::serde::ser::SerializeTupleStruct for Unreachable {
252    type Ok = ();
253    type Error = Error;
254
255    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error> { unreachable!() }
256
257    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
258}
259
260impl ::serde::ser::SerializeTupleVariant for Unreachable {
261    type Ok = ();
262    type Error = Error;
263
264    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error> { unreachable!() }
265
266    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
267}
268
269impl ::serde::ser::SerializeMap for Unreachable {
270    type Ok = ();
271    type Error = Error;
272
273    fn serialize_key<T: ?Sized>(&mut self, _key: &T) -> Result<Self::Ok, Self::Error>
274    where T: ::serde::ser::Serialize {
275        unreachable!()
276    }
277
278    fn serialize_value<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error>
279    where T: ::serde::ser::Serialize {
280        unreachable!()
281    }
282
283    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
284}
285
286impl ::serde::ser::SerializeStructVariant for Unreachable {
287    type Ok = ();
288    type Error = Error;
289
290    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, _value: &T) -> Result<Self::Ok, Self::Error>
291    where T: ::serde::ser::Serialize {
292        unreachable!()
293    }
294
295    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
296}
297
298impl ::serde::ser::SerializeTuple for Unreachable {
299    type Ok = ();
300    type Error = Error;
301
302    fn serialize_element<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
303    where T: serde::Serialize {
304        unreachable!()
305    }
306    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
307}
308
309impl ::serde::ser::SerializeSeq for Unreachable {
310    type Ok = ();
311    type Error = Error;
312
313    fn serialize_element<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
314    where T: serde::Serialize {
315        unreachable!()
316    }
317    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
318}
319
320impl ::serde::ser::SerializeStruct for Unreachable {
321    type Ok = ();
322    type Error = Error;
323
324    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, _value: &T) -> Result<(), Self::Error>
325    where T: serde::Serialize {
326        unreachable!()
327    }
328    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
329}
embedded_msgpack/encode/serde/mod.rs

embedded_msgpack/encode/serde/
mod.rs
