serde_scale/
ser.rs

1// Copyright (C) 2020 Stephane Raux. Distributed under the zlib license.
2
3use crate::{Error, Write};
4use serde::Serialize;
5use core::{
6    convert::TryFrom,
7    fmt::{self, Debug, Display},
8};
9
10#[cfg(feature = "alloc")]
11use alloc::vec::Vec;
12
13/// Serializes a value using the SCALE encoding
14#[cfg(feature = "alloc")]
15pub fn to_vec<T: Serialize>(x: &T) -> Result<Vec<u8>, Error<core::convert::Infallible>> {
16    let mut serializer = Serializer::new(Vec::new());
17    x.serialize(&mut serializer)?;
18    Ok(serializer.0)
19}
20
21/// Serializer for the SCALE encoding
22#[derive(Debug)]
23pub struct Serializer<W>(W);
24
25impl<W: Write> Serializer<W> {
26    /// Returns a serializer using the given writer
27    pub fn new(out: W) -> Self {
28        Self(out)
29    }
30
31    /// Returns the underlying writer
32    pub fn into_inner(self) -> W {
33        self.0
34    }
35
36    fn serialize_compact(&mut self, v: u64) -> Result<(), Error<W::Error>> {
37        if v < 0x40 {
38            let bytes = [(v << 2 & 0xff) as u8];
39            Ok(self.0.write(&bytes)?)
40        } else if v < 0x4000 {
41            let bytes = [
42                ((v << 2 | 0x1) & 0xff) as u8,
43                (v >> 6 & 0xff) as u8,
44            ];
45            Ok(self.0.write(&bytes)?)
46        } else if v < 0x4000_0000 {
47            let high = v >> 6;
48            let bytes = [
49                ((v << 2 | 0x2) & 0xff) as u8,
50                (high & 0xff) as u8,
51                (high >> 8 & 0xff) as u8,
52                (high >> 16 & 0xff) as u8,
53            ];
54            Ok(self.0.write(&bytes)?)
55        } else {
56            let mut bytes = [0u8; 9];
57            let mut v = v;
58            let src = core::iter::from_fn(|| {
59                if v == 0 { return None; }
60                let low = (v & 0xff) as u8;
61                v >>= 8;
62                Some(low)
63            });
64            let end = bytes.iter_mut()
65                .skip(1)
66                .zip(src)
67                .enumerate()
68                .map(|(i, (dst, src))| {
69                    *dst = src;
70                    i
71                })
72                .last()
73                .unwrap() + 1;
74            bytes[0] = (end - 4 << 2 & 0x3) as u8;
75            Ok(self.0.write(&bytes[..end + 1])?)
76        }
77    }
78}
79
80impl<'a, W: Write> serde::Serializer for &'a mut Serializer<W> {
81    type Ok = ();
82    type Error = Error<W::Error>;
83    type SerializeSeq = Compound<'a, W>;
84    type SerializeTuple = Compound<'a, W>;
85    type SerializeTupleStruct = Compound<'a, W>;
86    type SerializeTupleVariant = Compound<'a, W>;
87    type SerializeMap = Compound<'a, W>;
88    type SerializeStruct = Compound<'a, W>;
89    type SerializeStructVariant = Compound<'a, W>;
90
91    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
92        self.serialize_u8(v as u8)
93    }
94
95    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
96        Ok(self.0.write(&v.to_le_bytes())?)
97    }
98
99    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
100        Ok(self.0.write(&v.to_le_bytes())?)
101    }
102
103    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
104        Ok(self.0.write(&v.to_le_bytes())?)
105    }
106
107    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
108        Ok(self.0.write(&v.to_le_bytes())?)
109    }
110
111    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
112        Ok(self.0.write(&v.to_le_bytes())?)
113    }
114
115    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
116        Ok(self.0.write(&v.to_le_bytes())?)
117    }
118
119    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
120        Ok(self.0.write(&v.to_le_bytes())?)
121    }
122
123    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
124        Ok(self.0.write(&v.to_le_bytes())?)
125    }
126
127    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
128        Err(Error::FloatingPointUnsupported)
129    }
130
131    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
132        Err(Error::FloatingPointUnsupported)
133    }
134
135    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
136        self.serialize_u32(v as u32)
137    }
138
139    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
140        self.serialize_bytes(v.as_bytes())
141    }
142
143    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
144        let len = v.len();
145        let len = u64::try_from(len).map_err(|_| Error::CollectionTooLargeToSerialize { len })?;
146        self.serialize_compact(len)?;
147        Ok(self.0.write(v)?)
148    }
149
150    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
151        self.serialize_u8(0)
152    }
153
154    fn serialize_some<T>(self, v: &T) -> Result<Self::Ok, Self::Error>
155    where
156        T: Serialize + ?Sized,
157    {
158        if let Ok(x) = v.serialize(OptionalBoolSerializer) {
159            return self.serialize_u8(x);
160        }
161        self.serialize_u8(1)?;
162        v.serialize(self)
163    }
164
165    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
166        Ok(())
167    }
168
169    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
170        self.serialize_unit()
171    }
172
173    fn serialize_unit_variant(
174        self,
175        name: &'static str,
176        variant_index: u32,
177        variant: &'static str,
178    ) -> Result<Self::Ok, Self::Error> {
179        let discriminant = u8::try_from(variant_index).map_err(|_| {
180            Error::TooManyVariants {
181                enum_name: name,
182                variant_name: variant,
183                variant_index,
184            }
185        })?;
186        self.serialize_u8(discriminant)
187    }
188
189    fn serialize_newtype_struct<T>(
190        self,
191        _: &'static str,
192        value: &T,
193    ) -> Result<Self::Ok, Self::Error>
194    where
195        T: Serialize + ?Sized,
196    {
197        value.serialize(self)
198    }
199
200    fn serialize_newtype_variant<T>(
201        self,
202        name: &'static str,
203        variant_index: u32,
204        variant: &'static str,
205        value: &T,
206    ) -> Result<Self::Ok, Self::Error>
207    where
208        T: Serialize + ?Sized,
209    {
210        self.serialize_unit_variant(name, variant_index, variant)?;
211        value.serialize(self)
212    }
213
214    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
215        let len = len.ok_or(Error::LengthNeeded)?;
216        let len = u64::try_from(len).map_err(|_| Error::CollectionTooLargeToSerialize { len })?;
217        self.serialize_compact(len)?;
218        Ok(Compound(self))
219    }
220
221    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
222        Ok(Compound(self))
223    }
224
225    fn serialize_tuple_struct(
226        self,
227        _: &'static str,
228        _: usize,
229    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
230        Ok(Compound(self))
231    }
232
233    fn serialize_tuple_variant(
234        self,
235        name: &'static str,
236        variant_index: u32,
237        variant: &'static str,
238        _: usize,
239    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
240        self.serialize_unit_variant(name, variant_index, variant)?;
241        Ok(Compound(self))
242    }
243
244    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
245        let len = len.ok_or(Error::LengthNeeded)?;
246        let len = u64::try_from(len).map_err(|_| Error::CollectionTooLargeToSerialize { len })?;
247        self.serialize_compact(len)?;
248        Ok(Compound(self))
249    }
250
251    fn serialize_struct(
252        self,
253        _: &'static str,
254        _: usize,
255    ) -> Result<Self::SerializeStruct, Self::Error> {
256        Ok(Compound(self))
257    }
258
259    fn serialize_struct_variant(
260        self,
261        name: &'static str,
262        variant_index: u32,
263        variant: &'static str,
264        _: usize,
265    ) -> Result<Self::SerializeStructVariant, Self::Error> {
266        self.serialize_unit_variant(name, variant_index, variant)?;
267        Ok(Compound(self))
268    }
269
270    #[cfg(not(feature = "alloc"))]
271    fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
272    where
273        T: core::fmt::Display,
274    {
275        Err(serde::ser::Error::custom("Unsupported `collect_str` without `alloc` feature"))
276    }
277}
278
279mod compound {
280    pub struct Compound<'a, W>(pub &'a mut super::Serializer<W>);
281}
282
283use compound::Compound;
284
285impl<W: Write> serde::ser::SerializeSeq for Compound<'_, W> {
286    type Ok = ();
287    type Error = Error<W::Error>;
288
289    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
290    where
291        T: Serialize + ?Sized,
292    {
293        value.serialize(&mut *self.0)
294    }
295
296    fn end(self) -> Result<Self::Ok, Self::Error> {
297        Ok(())
298    }
299}
300
301impl<W: Write> serde::ser::SerializeTuple for Compound<'_, W> {
302    type Ok = ();
303    type Error = Error<W::Error>;
304
305    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
306    where
307        T: Serialize + ?Sized,
308    {
309        value.serialize(&mut *self.0)
310    }
311
312    fn end(self) -> Result<Self::Ok, Self::Error> {
313        Ok(())
314    }
315}
316
317impl<W: Write> serde::ser::SerializeTupleStruct for Compound<'_, W> {
318    type Ok = ();
319    type Error = Error<W::Error>;
320
321    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
322    where
323        T: Serialize + ?Sized,
324    {
325        value.serialize(&mut *self.0)
326    }
327
328    fn end(self) -> Result<Self::Ok, Self::Error> {
329        Ok(())
330    }
331}
332
333impl<W: Write> serde::ser::SerializeTupleVariant for Compound<'_, W> {
334    type Ok = ();
335    type Error = Error<W::Error>;
336
337    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
338    where
339        T: Serialize + ?Sized,
340    {
341        value.serialize(&mut *self.0)
342    }
343
344    fn end(self) -> Result<Self::Ok, Self::Error> {
345        Ok(())
346    }
347}
348
349impl<W: Write> serde::ser::SerializeMap for Compound<'_, W> {
350    type Ok = ();
351    type Error = Error<W::Error>;
352
353    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
354    where
355        T: Serialize + ?Sized,
356    {
357        self.0.serialize_compact(2)?;
358        key.serialize(&mut *self.0)
359    }
360
361    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
362    where
363        T: Serialize + ?Sized,
364    {
365        value.serialize(&mut *self.0)
366    }
367
368    fn end(self) -> Result<Self::Ok, Self::Error> {
369        Ok(())
370    }
371}
372
373impl<W: Write> serde::ser::SerializeStruct for Compound<'_, W> {
374    type Ok = ();
375    type Error = Error<W::Error>;
376
377    fn serialize_field<T>(&mut self, _: &'static str, value: &T) -> Result<(), Self::Error>
378    where
379        T: Serialize + ?Sized,
380    {
381        value.serialize(&mut *self.0)
382    }
383
384    fn end(self) -> Result<Self::Ok, Self::Error> {
385        Ok(())
386    }
387}
388
389impl<W: Write> serde::ser::SerializeStructVariant for Compound<'_, W> {
390    type Ok = ();
391    type Error = Error<W::Error>;
392
393    fn serialize_field<T>(&mut self, _: &'static str, value: &T) -> Result<(), Self::Error>
394    where
395        T: Serialize + ?Sized,
396    {
397        value.serialize(&mut *self.0)
398    }
399
400    fn end(self) -> Result<Self::Ok, Self::Error> {
401        Ok(())
402    }
403}
404
405struct OptionalBoolSerializer;
406type Impossible = serde::ser::Impossible<u8, VoidError>;
407
408#[derive(Debug)]
409struct VoidError;
410
411impl Display for VoidError {
412    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
413        f.write_str("VoidError")
414    }
415}
416
417impl serde::ser::StdError for VoidError {}
418
419impl serde::ser::Error for VoidError {
420    fn custom<T: Display>(_: T) -> Self {
421        VoidError
422    }
423}
424
425impl serde::Serializer for OptionalBoolSerializer {
426    type Ok = u8;
427    type Error = VoidError;
428    type SerializeSeq = Impossible;
429    type SerializeTuple = Impossible;
430    type SerializeTupleStruct = Impossible;
431    type SerializeTupleVariant = Impossible;
432    type SerializeMap = Impossible;
433    type SerializeStruct = Impossible;
434    type SerializeStructVariant = Impossible;
435
436    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
437        Ok(if v { 1 } else { 2 })
438    }
439
440    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
441        Err(VoidError)
442    }
443
444    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
445        Err(VoidError)
446    }
447
448    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
449        Err(VoidError)
450    }
451
452    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
453        Err(VoidError)
454    }
455
456    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
457        Err(VoidError)
458    }
459
460    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
461        Err(VoidError)
462    }
463
464    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
465        Err(VoidError)
466    }
467
468    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
469        Err(VoidError)
470    }
471
472    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
473        Err(VoidError)
474    }
475
476    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
477        Err(VoidError)
478    }
479
480    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
481        Err(VoidError)
482    }
483
484    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
485        Err(VoidError)
486    }
487
488    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
489        Err(VoidError)
490    }
491
492    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
493        Err(VoidError)
494    }
495
496    fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
497    where
498        T: Serialize + ?Sized,
499    {
500        Err(VoidError)
501    }
502
503    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
504        Err(VoidError)
505    }
506
507    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
508        Err(VoidError)
509    }
510
511    fn serialize_unit_variant(
512        self,
513        _: &'static str,
514        _: u32,
515        _: &'static str,
516    ) -> Result<Self::Ok, Self::Error> {
517        Err(VoidError)
518    }
519
520    fn serialize_newtype_struct<T>(
521        self,
522        _: &'static str,
523        _: &T,
524    ) -> Result<Self::Ok, Self::Error>
525    where
526        T: Serialize + ?Sized,
527    {
528        Err(VoidError)
529    }
530
531    fn serialize_newtype_variant<T>(
532        self,
533        _: &'static str,
534        _: u32,
535        _: &'static str,
536        _: &T,
537    ) -> Result<Self::Ok, Self::Error>
538    where
539        T: Serialize + ?Sized,
540    {
541        Err(VoidError)
542    }
543
544    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
545        Err(VoidError)
546    }
547
548    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
549        Err(VoidError)
550    }
551
552    fn serialize_tuple_struct(
553        self,
554        _: &'static str,
555        _: usize,
556    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
557        Err(VoidError)
558    }
559
560    fn serialize_tuple_variant(
561        self,
562        _: &'static str,
563        _: u32,
564        _: &'static str,
565        _: usize,
566    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
567        Err(VoidError)
568    }
569
570    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
571        Err(VoidError)
572    }
573
574    fn serialize_struct(
575        self,
576        _: &'static str,
577        _: usize,
578    ) -> Result<Self::SerializeStruct, Self::Error> {
579        Err(VoidError)
580    }
581
582    fn serialize_struct_variant(
583        self,
584        _: &'static str,
585        _: u32,
586        _: &'static str,
587        _: usize,
588    ) -> Result<Self::SerializeStructVariant, Self::Error> {
589        Err(VoidError)
590    }
591
592    #[cfg(not(feature = "alloc"))]
593    fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
594    where
595        T: core::fmt::Display,
596    {
597        Err(VoidError)
598    }
599}
600
601#[cfg(all(test, feature = "alloc"))]
602mod tests {
603    use crate::to_vec;
604
605    #[test]
606    fn none_bool_serializes_as_0() {
607        assert_eq!(to_vec(&None::<bool>).unwrap(), [0]);
608    }
609
610    #[test]
611    fn some_true_serializes_as_1() {
612        assert_eq!(to_vec(&Some(true)).unwrap(), [1]);
613    }
614
615    #[test]
616    fn some_false_serializes_as_2() {
617        assert_eq!(to_vec(&Some(false)).unwrap(), [2]);
618    }
619}
serde_scale/ser.rs

serde_scale/
ser.rs
