1use crate::{Error, Result};
2use byteorder::{NativeEndian, WriteBytesExt};
3use serde::ser::{
4 SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
5 SerializeTupleStruct, SerializeTupleVariant,
6};
7use std::io::Write;
8
9pub struct Serializer<W> {
10 writer: W,
11}
12
13impl<W> Serializer<W>
14where
15 W: Write,
16{
17 pub fn new(w: W) -> Self {
18 Serializer { writer: w }
19 }
20}
21
22impl<W> serde::Serializer for &mut Serializer<W>
23where
24 W: Write,
25{
26 type Ok = ();
27 type Error = Error;
28
29 type SerializeSeq = Self;
30 type SerializeTuple = Self;
31 type SerializeTupleStruct = Self;
32 type SerializeTupleVariant = Self;
33 type SerializeMap = Self;
34 type SerializeStruct = Self;
35 type SerializeStructVariant = Self;
36
37 #[inline]
38 fn serialize_unit(self) -> Result<()> {
39 Ok(())
40 }
41
42 #[inline]
43 fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
44 Ok(())
45 }
46
47 #[inline]
48 fn serialize_bool(self, v: bool) -> Result<()> {
49 self.writer.write_u8(v as u8).map_err(From::from)
50 }
51
52 #[inline]
53 fn serialize_u8(self, v: u8) -> Result<()> {
54 self.writer.write_u8(v).map_err(From::from)
55 }
56
57 #[inline]
58 fn serialize_u16(self, v: u16) -> Result<()> {
59 self.writer.write_u16::<NativeEndian>(v).map_err(From::from)
60 }
61
62 #[inline]
63 fn serialize_u32(self, v: u32) -> Result<()> {
64 self.writer.write_u32::<NativeEndian>(v).map_err(From::from)
65 }
66
67 #[inline]
68 fn serialize_u64(self, v: u64) -> Result<()> {
69 self.writer.write_u64::<NativeEndian>(v).map_err(From::from)
70 }
71
72 #[inline]
73 fn serialize_u128(self, v: u128) -> Result<()> {
74 self.writer
75 .write_u128::<NativeEndian>(v)
76 .map_err(From::from)
77 }
78
79 #[inline]
80 fn serialize_i8(self, v: i8) -> Result<()> {
81 self.writer.write_i8(v).map_err(From::from)
82 }
83
84 #[inline]
85 fn serialize_i16(self, v: i16) -> Result<()> {
86 self.writer.write_i16::<NativeEndian>(v).map_err(From::from)
87 }
88
89 #[inline]
90 fn serialize_i32(self, v: i32) -> Result<()> {
91 self.writer.write_i32::<NativeEndian>(v).map_err(From::from)
92 }
93
94 #[inline]
95 fn serialize_i64(self, v: i64) -> Result<()> {
96 self.writer.write_i64::<NativeEndian>(v).map_err(From::from)
97 }
98
99 #[inline]
100 fn serialize_i128(self, v: i128) -> Result<()> {
101 self.writer
102 .write_i128::<NativeEndian>(v)
103 .map_err(From::from)
104 }
105
106 #[inline]
107 fn serialize_f32(self, v: f32) -> Result<()> {
108 self.writer.write_f32::<NativeEndian>(v).map_err(From::from)
109 }
110
111 #[inline]
112 fn serialize_f64(self, v: f64) -> Result<()> {
113 self.writer.write_f64::<NativeEndian>(v).map_err(From::from)
114 }
115
116 #[inline]
117 fn serialize_str(self, v: &str) -> Result<()> {
118 self.serialize_u64(v.len() as u64)?;
119 self.writer.write_all(v.as_bytes()).map_err(From::from)
120 }
121
122 #[inline]
123 fn serialize_char(self, c: char) -> Result<()> {
124 self.writer
125 .write_all(encode_utf8(c).as_slice())
126 .map_err(From::from)
127 }
128
129 #[inline]
130 fn serialize_bytes(self, v: &[u8]) -> Result<()> {
131 self.serialize_u64(v.len() as u64)?;
132 self.writer.write_all(v).map_err(From::from)
133 }
134
135 #[inline]
136 fn serialize_none(self) -> Result<()> {
137 self.writer.write_u8(0).map_err(From::from)
138 }
139
140 #[inline]
141 fn serialize_some<T>(self, v: &T) -> Result<()>
142 where
143 T: ?Sized + serde::Serialize,
144 {
145 self.writer.write_u8(1)?;
146 v.serialize(self)
147 }
148
149 #[inline]
150 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
151 let len = len.expect("do not know how to serialize a sequence with no length");
152 self.serialize_u64(len as u64)?;
153 Ok(self)
154 }
155
156 #[inline]
157 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
158 Ok(self)
159 }
160
161 #[inline]
162 fn serialize_tuple_struct(
163 self,
164 _name: &'static str,
165 _len: usize,
166 ) -> Result<Self::SerializeTupleStruct> {
167 Ok(self)
168 }
169
170 #[inline]
171 fn serialize_tuple_variant(
172 self,
173 _name: &'static str,
174 variant_index: u32,
175 _variant: &'static str,
176 _len: usize,
177 ) -> Result<Self::SerializeTupleVariant> {
178 self.serialize_u32(variant_index)?;
179 Ok(self)
180 }
181
182 #[inline]
183 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
184 let len = len.expect("do not know how to serialize a map with no length");
185 self.serialize_u64(len as u64)?;
186 Ok(self)
187 }
188
189 #[inline]
190 fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
191 Ok(self)
192 }
193
194 #[inline]
195 fn serialize_struct_variant(
196 self,
197 _name: &'static str,
198 variant_index: u32,
199 _variant: &'static str,
200 _len: usize,
201 ) -> Result<Self::SerializeStructVariant> {
202 self.serialize_u32(variant_index)?;
203 Ok(self)
204 }
205
206 #[inline]
207 fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
208 where
209 T: ?Sized + serde::ser::Serialize,
210 {
211 value.serialize(self)
212 }
213
214 #[inline]
215 fn serialize_newtype_variant<T>(
216 self,
217 _name: &'static str,
218 variant_index: u32,
219 _variant: &'static str,
220 value: &T,
221 ) -> Result<()>
222 where
223 T: ?Sized + serde::ser::Serialize,
224 {
225 self.serialize_u32(variant_index)?;
226 value.serialize(self)
227 }
228
229 #[inline]
230 fn serialize_unit_variant(
231 self,
232 _name: &'static str,
233 variant_index: u32,
234 _variant: &'static str,
235 ) -> Result<()> {
236 self.serialize_u32(variant_index)
237 }
238
239 fn is_human_readable(&self) -> bool {
240 false
241 }
242}
243
244impl<W> SerializeSeq for &mut Serializer<W>
245where
246 W: Write,
247{
248 type Ok = ();
249 type Error = Error;
250
251 #[inline]
252 fn serialize_element<V>(&mut self, value: &V) -> Result<()>
253 where
254 V: ?Sized + serde::Serialize,
255 {
256 value.serialize(&mut **self)
257 }
258
259 #[inline]
260 fn end(self) -> Result<()> {
261 Ok(())
262 }
263}
264
265impl<W> SerializeTuple for &mut Serializer<W>
266where
267 W: Write,
268{
269 type Ok = ();
270 type Error = Error;
271
272 #[inline]
273 fn serialize_element<V>(&mut self, value: &V) -> Result<()>
274 where
275 V: ?Sized + serde::Serialize,
276 {
277 value.serialize(&mut **self)
278 }
279
280 #[inline]
281 fn end(self) -> Result<()> {
282 Ok(())
283 }
284}
285
286impl<W> SerializeTupleStruct for &mut Serializer<W>
287where
288 W: Write,
289{
290 type Ok = ();
291 type Error = Error;
292
293 #[inline]
294 fn serialize_field<V>(&mut self, value: &V) -> Result<()>
295 where
296 V: ?Sized + serde::Serialize,
297 {
298 value.serialize(&mut **self)
299 }
300
301 #[inline]
302 fn end(self) -> Result<()> {
303 Ok(())
304 }
305}
306
307impl<W> SerializeTupleVariant for &mut Serializer<W>
308where
309 W: Write,
310{
311 type Ok = ();
312 type Error = Error;
313
314 #[inline]
315 fn serialize_field<V>(&mut self, value: &V) -> Result<()>
316 where
317 V: ?Sized + serde::Serialize,
318 {
319 value.serialize(&mut **self)
320 }
321
322 #[inline]
323 fn end(self) -> Result<()> {
324 Ok(())
325 }
326}
327
328impl<W> SerializeMap for &mut Serializer<W>
329where
330 W: Write,
331{
332 type Ok = ();
333 type Error = Error;
334
335 #[inline]
336 fn serialize_key<K>(&mut self, key: &K) -> Result<()>
337 where
338 K: ?Sized + serde::Serialize,
339 {
340 key.serialize(&mut **self)
341 }
342
343 #[inline]
344 fn serialize_value<V>(&mut self, value: &V) -> Result<()>
345 where
346 V: ?Sized + serde::Serialize,
347 {
348 value.serialize(&mut **self)
349 }
350
351 #[inline]
352 fn end(self) -> Result<()> {
353 Ok(())
354 }
355}
356
357impl<W> SerializeStruct for &mut Serializer<W>
358where
359 W: Write,
360{
361 type Ok = ();
362 type Error = Error;
363
364 #[inline]
365 fn serialize_field<V>(&mut self, _key: &'static str, value: &V) -> Result<()>
366 where
367 V: ?Sized + serde::Serialize,
368 {
369 value.serialize(&mut **self)
370 }
371
372 #[inline]
373 fn end(self) -> Result<()> {
374 Ok(())
375 }
376}
377
378impl<W> SerializeStructVariant for &mut Serializer<W>
379where
380 W: Write,
381{
382 type Ok = ();
383 type Error = Error;
384
385 #[inline]
386 fn serialize_field<V>(&mut self, _key: &'static str, value: &V) -> Result<()>
387 where
388 V: ?Sized + serde::Serialize,
389 {
390 value.serialize(&mut **self)
391 }
392
393 #[inline]
394 fn end(self) -> Result<()> {
395 Ok(())
396 }
397}
398
399#[inline]
400fn encode_utf8(c: char) -> EncodeUtf8 {
401 const TAG_CONT: u8 = 0b1000_0000;
402 const TAG_TWO_B: u8 = 0b1100_0000;
403 const TAG_THREE_B: u8 = 0b1110_0000;
404 const TAG_FOUR_B: u8 = 0b1111_0000;
405 const MAX_ONE_B: u32 = 0x80;
406 const MAX_TWO_B: u32 = 0x800;
407 const MAX_THREE_B: u32 = 0x10000;
408
409 let code = c as u32;
410 let mut buf = [0; 4];
411 let pos = if code < MAX_ONE_B {
412 buf[3] = code as u8;
413 3
414 } else if code < MAX_TWO_B {
415 buf[2] = ((code >> 6) & 0x1F) as u8 | TAG_TWO_B;
416 buf[3] = (code & 0x3F) as u8 | TAG_CONT;
417 2
418 } else if code < MAX_THREE_B {
419 buf[1] = ((code >> 12) & 0x0F) as u8 | TAG_THREE_B;
420 buf[2] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
421 buf[3] = (code & 0x3F) as u8 | TAG_CONT;
422 1
423 } else {
424 buf[0] = ((code >> 18) & 0x07) as u8 | TAG_FOUR_B;
425 buf[1] = ((code >> 12) & 0x3F) as u8 | TAG_CONT;
426 buf[2] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
427 buf[3] = (code & 0x3F) as u8 | TAG_CONT;
428 0
429 };
430 EncodeUtf8 { buf, pos }
431}
432
433struct EncodeUtf8 {
434 buf: [u8; 4],
435 pos: usize,
436}
437
438impl EncodeUtf8 {
439 #[inline]
440 fn as_slice(&self) -> &[u8] {
441 &self.buf[self.pos..]
442 }
443}