1use super::{Error, Result};
3use crate::BinaryWriter;
4use serde::ser::{self, Serialize};
5
6#[doc(hidden)]
7pub struct SerializeArray<'a, 'b> {
8 ser: &'a mut Serializer<'b>,
9}
10
11impl<'a, 'b> ser::SerializeSeq for SerializeArray<'a, 'b> {
12 type Ok = usize;
13 type Error = Error;
14
15 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
16 where
17 T: Serialize,
18 {
19 value.serialize(&mut *self.ser)?;
20 Ok(())
21 }
22
23 fn end(self) -> Result<Self::Ok> {
24 Ok(0)
25 }
26}
27
28impl<'a, 'b> ser::SerializeTuple for SerializeArray<'a, 'b> {
29 type Ok = usize;
30 type Error = Error;
31
32 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
33 where
34 T: Serialize,
35 {
36 ser::SerializeSeq::serialize_element(self, value)
37 }
38
39 fn end(self) -> Result<Self::Ok> {
40 ser::SerializeSeq::end(self)
41 }
42}
43
44impl<'a, 'b> ser::SerializeTupleStruct for SerializeArray<'a, 'b> {
45 type Ok = usize;
46 type Error = Error;
47
48 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
49 where
50 T: Serialize,
51 {
52 ser::SerializeSeq::serialize_element(self, value)
53 }
54
55 fn end(self) -> Result<Self::Ok> {
56 ser::SerializeSeq::end(self)
57 }
58}
59
60#[doc(hidden)]
61pub struct SerializeObject<'a, 'b> {
62 ser: &'a mut Serializer<'b>,
63}
64
65impl<'a, 'b> ser::SerializeStruct for SerializeObject<'a, 'b> {
66 type Ok = usize;
67 type Error = Error;
68 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
69 where
70 T: Serialize,
71 {
72 self.ser.writer.write_string(key)?;
73 value.serialize(&mut *self.ser)?;
74 Ok(())
75 }
76
77 fn end(self) -> Result<Self::Ok> {
78 Ok(0)
79 }
80
81 fn skip_field(&mut self, _key: &'static str) -> Result<()> {
82 Ok(())
83 }
84}
85
86impl<'a, 'b> ser::SerializeMap for SerializeObject<'a, 'b> {
87 type Ok = usize;
88 type Error = Error;
89
90 fn serialize_key<T>(&mut self, key: &T) -> Result<()>
91 where
92 T: ?Sized + Serialize,
93 {
94 key.serialize(&mut *self.ser)?;
95 Ok(())
96 }
97
98 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>
99 where
100 T: Serialize,
101 {
102 value.serialize(&mut *self.ser)?;
103 Ok(())
104 }
105
106 fn end(self) -> Result<Self::Ok> {
107 Ok(0)
108 }
109
110 fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<()>
111 where
112 K: Serialize,
113 V: Serialize,
114 {
115 self.serialize_key(key)?;
116 self.serialize_value(value)?;
117 Ok(())
118 }
119}
120
121impl<'a, 'b> ser::SerializeTupleVariant for SerializeArray<'a, 'b> {
122 type Ok = usize;
123 type Error = Error;
124
125 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
126 where
127 T: Serialize,
128 {
129 value.serialize(&mut *self.ser)?;
130 Ok(())
131 }
132
133 fn end(self) -> Result<Self::Ok> {
134 Ok(0)
135 }
136}
137
138impl<'a, 'b> ser::SerializeStructVariant for SerializeObject<'a, 'b> {
139 type Ok = usize;
140 type Error = Error;
141
142 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
143 where
144 T: Serialize,
145 {
146 self.ser.writer.write_string(key)?;
147 value.serialize(&mut *self.ser)?;
148 Ok(())
149 }
150
151 fn end(self) -> Result<Self::Ok> {
152 Ok(0)
153 }
154
155 fn skip_field(&mut self, _key: &'static str) -> Result<()> {
156 Ok(())
157 }
158}
159
160pub struct Serializer<'a> {
162 pub writer: BinaryWriter<'a>,
164}
165
166impl<'a, 'b> ser::Serializer for &'a mut Serializer<'b> {
167 type Ok = usize;
168 type Error = Error;
169
170 type SerializeSeq = SerializeArray<'a, 'b>;
171 type SerializeTuple = SerializeArray<'a, 'b>;
172 type SerializeTupleStruct = SerializeArray<'a, 'b>;
173 type SerializeTupleVariant = SerializeArray<'a, 'b>;
174 type SerializeMap = SerializeObject<'a, 'b>;
175 type SerializeStruct = SerializeObject<'a, 'b>;
176 type SerializeStructVariant = SerializeObject<'a, 'b>;
177
178 fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
179 Ok(self.writer.write_bool(v)?)
180 }
181
182 fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
183 Ok(self.writer.write_i8(v)?)
184 }
185
186 fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
187 Ok(self.writer.write_i16(v)?)
188 }
189
190 fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
191 Ok(self.writer.write_i32(v)?)
192 }
193
194 fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
195 Ok(self.writer.write_i64(v)?)
196 }
197
198 fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
199 Ok(self.writer.write_u8(v)?)
200 }
201
202 fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
203 Ok(self.writer.write_u16(v)?)
204 }
205
206 fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
207 Ok(self.writer.write_u32(v)?)
208 }
209
210 fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
211 Ok(self.writer.write_u64(v)?)
212 }
213
214 fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
215 Ok(self.writer.write_f32(v)?)
216 }
217
218 fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
219 Ok(self.writer.write_f64(v)?)
220 }
221
222 fn serialize_char(self, v: char) -> Result<Self::Ok> {
223 Ok(self.writer.write_char(v)?)
224 }
225
226 fn serialize_str(self, v: &str) -> Result<Self::Ok> {
227 Ok(self.writer.write_string(v)?)
228 }
229
230 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
231 Ok(self.writer.write_bytes(v)?)
232 }
233
234 fn serialize_none(self) -> Result<Self::Ok> {
235 Ok(self.writer.write_u8(0)?)
236 }
237
238 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
239 where
240 T: ?Sized + Serialize,
241 {
242 self.writer.write_u8(1)?;
243 value.serialize(self)
244 }
245
246 fn serialize_unit(self) -> Result<Self::Ok> {
247 Ok(self.writer.write_u8(0)?)
248 }
249
250 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
251 self.serialize_unit()
252 }
253
254 fn serialize_unit_variant(
255 self,
256 _name: &'static str,
257 _variant_index: u32,
258 variant: &'static str,
259 ) -> Result<Self::Ok> {
260 self.writer.write_string(variant)?;
261 self.serialize_unit()
262 }
263
264 fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
265 where
266 T: ?Sized + Serialize,
267 {
268 value.serialize(self)
269 }
270
271 fn serialize_newtype_variant<T>(
272 self,
273 _name: &'static str,
274 _variant_index: u32,
275 variant: &'static str,
276 value: &T,
277 ) -> Result<Self::Ok>
278 where
279 T: ?Sized + Serialize,
280 {
281 self.writer.write_string(variant)?;
282 value.serialize(self)
283 }
284
285 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
286 if let Some(len) = len {
287 if len > u32::MAX as usize {
288 return Err(Error::TooManyItems);
289 }
290 }
291 self.writer.write_u32(len.map(|l| l as u32).unwrap_or(0))?;
292 Ok(SerializeArray { ser: self })
293 }
294
295 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
296 self.serialize_seq(Some(len))
297 }
298
299 fn serialize_tuple_struct(
300 self,
301 name: &'static str,
302 len: usize,
303 ) -> Result<Self::SerializeTupleStruct> {
304 self.writer.write_string(name)?;
306 self.serialize_seq(Some(len))
307 }
308
309 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
310 if let Some(len) = len {
311 if len > u32::MAX as usize {
312 return Err(Error::TooManyItems);
313 }
314 }
315 self.writer.write_u32(len.map(|l| l as u32).unwrap_or(0))?;
316 Ok(SerializeObject { ser: self })
317 }
318
319 fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
320 self.serialize_map(Some(len))
321 }
322
323 fn serialize_tuple_variant(
324 self,
325 _name: &'static str,
326 _variant_index: u32,
327 variant: &'static str,
328 len: usize,
329 ) -> Result<Self::SerializeTupleVariant> {
330 self.writer.write_string(variant)?;
331 self.serialize_seq(Some(len))
332 }
333
334 fn serialize_struct_variant(
335 self,
336 _name: &'static str,
337 _variant_index: u32,
338 variant: &'static str,
339 len: usize,
340 ) -> Result<Self::SerializeStructVariant> {
341 self.writer.write_string(variant)?;
342 self.serialize_struct(variant, len)
343 }
344}