wasm_msgpack/encode/serde/
mod.rs

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

wasm_msgpack/encode/serde/
mod.rs
