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> { unimplemented!() }
146
147    fn serialize_tuple_variant(
148        self,
149        _name: &'static str,
150        _variant_index: u32,
151        _variant: &'static str,
152        _len: usize,
153    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
154        unimplemented!()
155    }
156
157    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
158        self.pos += super::serialize_map_start(len.ok_or(Error::InvalidType)?, &mut self.buf[self.pos..])?;
159        Ok(SerializeMap::new(self))
160    }
161
162    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
163        match name {
164            #[cfg(feature = "ext")]
165            crate::ext::TYPE_NAME => {
166                // special handling to support serializing MsgPack Ext type
167                // SerializeStruct will reset `self.serializing_ext` when `end()` is called on it
168                self.state = State::Ext(None);
169            }
170            #[cfg(feature = "timestamp")]
171            crate::timestamp::TYPE_NAME => {
172                self.state = State::Timestamp(None, None);
173            }
174            _ => {
175                self.pos += super::serialize_map_start(len, &mut self.buf[self.pos..])?;
176            }
177        }
178        Ok(SerializeStruct::new(self))
179    }
180
181    fn serialize_struct_variant(
182        self,
183        _name: &'static str,
184        _variant_index: u32,
185        _variant: &'static str,
186        _len: usize,
187    ) -> Result<Self::SerializeStructVariant, Self::Error> {
188        unimplemented!()
189    }
190
191    fn collect_str<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
192    where T: core::fmt::Display {
193        unimplemented!()
194    }
195}
196
197/// Serializes the given data structure as a JSON byte vector
198pub fn to_array<T>(value: &T, buf: &mut [u8]) -> Result<usize, Error>
199where T: ::serde::ser::Serialize + ?Sized {
200    let mut ser = Serializer::new(buf);
201    value.serialize(&mut ser)?;
202    Ok(ser.pos)
203}
204
205impl ::serde::ser::Error for Error {
206    fn custom<T>(_msg: T) -> Self
207    where T: core::fmt::Display {
208        unimplemented!()
209    }
210}
211
212#[cfg(not(feature = "std"))]
213impl ::serde::ser::StdError for Error {}
214
215impl<'a, 'b> ::serde::ser::SerializeTupleVariant for &'a mut Serializer<'b> {
216    type Ok = ();
217    type Error = Error;
218
219    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
220    where T: ?Sized + serde::Serialize {
221        value.serialize(&mut **self)
222    }
223
224    fn end(self) -> Result<(), Error> {
225        self.state = State::Normal;
226        Ok(())
227    }
228}
229
230// impl<'a, 'b> ser::SerializeStruct for &'a mut Serializer<'b> {
231//     type Ok = ();
232//     type Error = Error;
233
234//     fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
235//     where T: ::serde::ser::Serialize {
236//         key.serialize(&mut **self)?;
237//         value.serialize(&mut **self)?;
238//         Ok(())
239//     }
240
241//     fn end(self) -> Result<(), Error> {
242//         self.serializing_ext = false;
243//         Ok(())
244//     }
245// }
246
247pub(crate) enum Unreachable {}
248
249impl ::serde::ser::SerializeTupleStruct for Unreachable {
250    type Ok = ();
251    type Error = Error;
252
253    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error> { unreachable!() }
254
255    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
256}
257
258impl ::serde::ser::SerializeTupleVariant for Unreachable {
259    type Ok = ();
260    type Error = Error;
261
262    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error> { unreachable!() }
263
264    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
265}
266
267impl ::serde::ser::SerializeMap for Unreachable {
268    type Ok = ();
269    type Error = Error;
270
271    fn serialize_key<T: ?Sized>(&mut self, _key: &T) -> Result<Self::Ok, Self::Error>
272    where T: ::serde::ser::Serialize {
273        unreachable!()
274    }
275
276    fn serialize_value<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error>
277    where T: ::serde::ser::Serialize {
278        unreachable!()
279    }
280
281    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
282}
283
284impl ::serde::ser::SerializeStructVariant for Unreachable {
285    type Ok = ();
286    type Error = Error;
287
288    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, _value: &T) -> Result<Self::Ok, Self::Error>
289    where T: ::serde::ser::Serialize {
290        unreachable!()
291    }
292
293    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
294}
295
296impl ::serde::ser::SerializeTuple for Unreachable {
297    type Ok = ();
298    type Error = Error;
299
300    fn serialize_element<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
301    where T: serde::Serialize {
302        unreachable!()
303    }
304    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
305}
306
307impl ::serde::ser::SerializeSeq for Unreachable {
308    type Ok = ();
309    type Error = Error;
310
311    fn serialize_element<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
312    where T: serde::Serialize {
313        unreachable!()
314    }
315    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
316}
317
318impl ::serde::ser::SerializeStruct for Unreachable {
319    type Ok = ();
320    type Error = Error;
321
322    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, _value: &T) -> Result<(), Self::Error>
323    where T: serde::Serialize {
324        unreachable!()
325    }
326    fn end(self) -> Result<Self::Ok, Self::Error> { unreachable!() }
327}
embedded_msgpack/encode/serde/mod.rs

embedded_msgpack/encode/serde/
mod.rs
