corepack/
seq_serializer.rs

1//! The sequence serializer that formats sequences in messagepack.
2//
3// This Source Code Form is subject to the terms of the Mozilla Public License,
4// v. 2.0. If a copy of the MPL was not distributed with this file, You can
5// obtain one at https://mozilla.org/MPL/2.0/.
6#[cfg(feature = "alloc")]
7use alloc::vec::Vec;
8
9use serde::ser::{Serialize, SerializeSeq, SerializeTupleVariant, SerializeTuple,
10                 SerializeTupleStruct};
11
12use byteorder::{ByteOrder, BigEndian};
13
14use ser::Serializer;
15
16use error::Error;
17
18use defs::*;
19
20pub struct SeqSerializer<'a, F: 'a + FnMut(&[u8]) -> Result<(), Error>> {
21    count: usize,
22    size: Option<usize>,
23    buffer: Vec<u8>,
24    output: &'a mut F,
25}
26
27impl<'a, F: 'a + FnMut(&[u8]) -> Result<(), Error>> SeqSerializer<'a, F> {
28    pub fn new(output: &'a mut F) -> SeqSerializer<'a, F> {
29        SeqSerializer {
30            count: 0,
31            size: None,
32            buffer: vec![],
33            output: output,
34        }
35    }
36
37    pub fn hint_size(&mut self, size: Option<usize>) -> Result<(), Error> {
38        self.size = size;
39
40        if let Some(size) = self.size {
41            // output this now because we know it
42            self.output_sequence_header(size)
43        } else {
44            Ok(())
45        }
46    }
47
48    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
49        where T: ?Sized + Serialize
50    {
51        self.count += 1;
52
53        if self.should_serialize_directly() {
54            self.serialize_directly(value)
55        } else {
56            self.serialize_into_buffer(value)
57        }
58    }
59
60    fn finish(mut self) -> Result<(), Error> {
61        if let Some(size) = self.size {
62            self.check_item_count_matches_size(size)?;
63            Ok(())
64        } else {
65            let count = self.count;
66            self.output_sequence_header(count)?;
67            (self.output)(self.buffer.as_slice())
68        }
69    }
70
71    fn check_item_count_matches_size(&self, size: usize) -> Result<(), Error> {
72        if size != self.count {
73            Err(Error::BadLength)
74        } else {
75            Ok(())
76        }
77    }
78
79    fn should_serialize_directly(&mut self) -> bool {
80        self.size.is_some()
81    }
82
83    fn serialize_into_buffer<T>(&mut self, value: &T) -> Result<(), Error>
84        where T: ?Sized + Serialize
85    {
86        let mut target = Serializer::new(|bytes| {
87            self.buffer.extend_from_slice(bytes);
88            Ok(())
89        });
90
91        value.serialize(&mut target)
92    }
93
94    fn serialize_directly<T>(&mut self, value: &T) -> Result<(), Error>
95        where T: ?Sized + Serialize
96    {
97        let mut target = Serializer::new(|bytes| (self.output)(bytes));
98
99        value.serialize(&mut target)
100    }
101
102    fn output_sequence_header(&mut self, size: usize) -> Result<(), Error> {
103        if size <= MAX_FIXARRAY {
104            (self.output)(&[size as u8 | FIXARRAY_MASK])
105        } else if size <= MAX_ARRAY16 {
106            let mut buf = [ARRAY16; U16_BYTES + 1];
107            BigEndian::write_u16(&mut buf[1..], size as u16);
108            (self.output)(&buf)
109        } else if size <= MAX_ARRAY32 {
110            let mut buf = [ARRAY32; U32_BYTES + 1];
111            BigEndian::write_u32(&mut buf[1..], size as u32);
112            (self.output)(&buf)
113        } else {
114            Err(Error::TooBig)
115        }
116    }
117}
118
119impl<'a, F: 'a + FnMut(&[u8]) -> Result<(), Error>> SerializeSeq for SeqSerializer<'a, F> {
120    type Ok = ();
121    type Error = Error;
122
123    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
124        where T: ?Sized + Serialize
125    {
126        SeqSerializer::serialize_element(self, value)
127    }
128
129    fn end(self) -> Result<(), Error> {
130        SeqSerializer::finish(self)
131    }
132}
133
134impl<'a, F: 'a + FnMut(&[u8]) -> Result<(), Error>> SerializeTupleVariant for SeqSerializer<'a, F> {
135    type Ok = ();
136    type Error = Error;
137
138    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
139        where T: ?Sized + Serialize
140    {
141        SeqSerializer::serialize_element(self, value)
142    }
143
144    fn end(self) -> Result<(), Error> {
145        SeqSerializer::finish(self)
146    }
147}
148
149impl<'a, F: 'a + FnMut(&[u8]) -> Result<(), Error>> SerializeTupleStruct for SeqSerializer<'a, F> {
150    type Ok = ();
151    type Error = Error;
152
153    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
154        where T: ?Sized + Serialize
155    {
156        SeqSerializer::serialize_element(self, value)
157    }
158
159    fn end(self) -> Result<(), Error> {
160        SeqSerializer::finish(self)
161    }
162}
163
164impl<'a, F: 'a + FnMut(&[u8]) -> Result<(), Error>> SerializeTuple for SeqSerializer<'a, F> {
165    type Ok = ();
166    type Error = Error;
167
168    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
169        where T: ?Sized + Serialize
170    {
171        SeqSerializer::serialize_element(self, value)
172    }
173
174    fn end(self) -> Result<(), Error> {
175        SeqSerializer::finish(self)
176    }
177}
corepack/seq_serializer.rs

corepack/
seq_serializer.rs
