1use alloc::vec::Vec;
2use core::u32;
3
4use super::config::{IntEncoding, SizeLimit};
5use super::{Error, ErrorKind, Result};
6use crate::config::{BincodeByteOrder, Options};
7use crate::io::Write;
8use core::mem::size_of;
9
10pub struct Serializer<W, O: Options> {
18 writer: W,
19 sizes_list: alloc::vec::IntoIter<u32>,
20 _options: O,
21}
22
23macro_rules! impl_serialize_literal {
24 ($ser_method:ident($ty:ty) = $write:ident()) => {
25 pub(crate) fn $ser_method(&mut self, v: $ty) -> Result<()> {
26 self.writer
27 .$write::<<O::Endian as BincodeByteOrder>::Endian>(v)
28 .map_err(Into::into)
29 }
30 };
31}
32
33impl<W: Write, O: Options> Serializer<W, O> {
34 pub fn new(w: W, options: O, sizes_list: Vec<u32>) -> Serializer<W, O> {
36 Serializer {
37 writer: w,
38 sizes_list: sizes_list.into_iter(),
39 _options: options,
40 }
41 }
42
43 fn take_size(&mut self) -> Result<u32> {
44 self.sizes_list
45 .next()
46 .ok_or_else(|| ErrorKind::SizeLimit.into())
47 }
48
49 pub(crate) fn serialize_byte(&mut self, v: u8) -> Result<()> {
50 self.writer.write_u8(v).map_err(Into::into)
51 }
52
53 impl_serialize_literal! {serialize_literal_u16(u16) = write_u16()}
54 impl_serialize_literal! {serialize_literal_u32(u32) = write_u32()}
55 impl_serialize_literal! {serialize_literal_u64(u64) = write_u64()}
56
57 serde_if_integer128! {
58 impl_serialize_literal!{serialize_literal_u128(u128) = write_u128()}
59 }
60}
61
62macro_rules! impl_serialize_int {
63 ($ser_method:ident($ty:ty) = $ser_int:ident()) => {
64 fn $ser_method(self, v: $ty) -> Result<()> {
65 O::IntEncoding::$ser_int(self, v)
66 }
67 };
68}
69
70impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
71 type Ok = ();
72 type Error = Error;
73 type SerializeSeq = Compound<'a, W, O>;
74 type SerializeTuple = Compound<'a, W, O>;
75 type SerializeTupleStruct = Compound<'a, W, O>;
76 type SerializeTupleVariant = Compound<'a, W, O>;
77 type SerializeMap = Compound<'a, W, O>;
78 type SerializeStruct = Compound<'a, W, O>;
79 type SerializeStructVariant = Compound<'a, W, O>;
80
81 fn serialize_unit(self) -> Result<()> {
82 Ok(())
83 }
84
85 fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
86 Ok(())
87 }
88
89 fn serialize_bool(self, v: bool) -> Result<()> {
90 self.serialize_byte(v as u8)
91 }
92
93 fn serialize_u8(self, v: u8) -> Result<()> {
94 self.serialize_byte(v)
95 }
96
97 impl_serialize_int! {serialize_u16(u16) = serialize_u16()}
98 impl_serialize_int! {serialize_u32(u32) = serialize_u32()}
99 impl_serialize_int! {serialize_u64(u64) = serialize_u64()}
100
101 fn serialize_i8(self, v: i8) -> Result<()> {
102 self.serialize_byte(v as u8)
103 }
104
105 impl_serialize_int! {serialize_i16(i16) = serialize_i16()}
106 impl_serialize_int! {serialize_i32(i32) = serialize_i32()}
107 impl_serialize_int! {serialize_i64(i64) = serialize_i64()}
108
109 serde_if_integer128! {
110 impl_serialize_int!{serialize_u128(u128) = serialize_u128()}
111 impl_serialize_int!{serialize_i128(i128) = serialize_i128()}
112 }
113
114 fn serialize_f32(self, v: f32) -> Result<()> {
115 self.writer
116 .write_f32::<<O::Endian as BincodeByteOrder>::Endian>(v)
117 .map_err(Into::into)
118 }
119
120 fn serialize_f64(self, v: f64) -> Result<()> {
121 self.writer
122 .write_f64::<<O::Endian as BincodeByteOrder>::Endian>(v)
123 .map_err(Into::into)
124 }
125
126 fn serialize_str(self, v: &str) -> Result<()> {
127 O::IntEncoding::serialize_len(self, v.len())?;
128 self.writer.write_all(v.as_bytes()).map_err(Into::into)
129 }
130
131 fn serialize_char(self, c: char) -> Result<()> {
132 self.writer
133 .write_all(encode_utf8(c).as_slice())
134 .map_err(Into::into)
135 }
136
137 fn serialize_bytes(self, v: &[u8]) -> Result<()> {
138 O::IntEncoding::serialize_len(self, v.len())?;
139 self.writer.write_all(v).map_err(Into::into)
140 }
141
142 fn serialize_none(self) -> Result<()> {
143 self.writer.write_u8(0).map_err(Into::into)
144 }
145
146 fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
147 where
148 T: serde::Serialize,
149 {
150 self.writer.write_u8(1)?;
151 v.serialize(self)
152 }
153
154 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
155 let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
156 O::IntEncoding::serialize_len(self, len)?;
157 Ok(Compound { ser: self })
158 }
159
160 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
161 Ok(Compound { ser: self })
162 }
163
164 fn serialize_tuple_struct(
165 self,
166 _name: &'static str,
167 _len: usize,
168 ) -> Result<Self::SerializeTupleStruct> {
169 Ok(Compound { ser: self })
170 }
171
172 fn serialize_tuple_variant(
173 self,
174 _name: &'static str,
175 variant_index: u32,
176 variant: &'static str,
177 _len: usize,
178 ) -> Result<Self::SerializeTupleVariant> {
179 let variant_index = variant.parse().unwrap_or(variant_index);
180 O::IntEncoding::serialize_u32(self, variant_index)?;
181 let s = self.take_size()?;
182 O::IntEncoding::serialize_u32(self, s)?;
183 Ok(Compound { ser: self })
184 }
185
186 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
187 let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
188 O::IntEncoding::serialize_len(self, len)?;
189 Ok(Compound { ser: self })
190 }
191
192 fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
193 let s = self.take_size()?;
194 O::IntEncoding::serialize_u32(self, s)?;
195 Ok(Compound { ser: self })
196 }
197
198 fn serialize_struct_variant(
199 self,
200 _name: &'static str,
201 variant_index: u32,
202 variant: &'static str,
203 _len: usize,
204 ) -> Result<Self::SerializeStructVariant> {
205 let variant_index = variant.parse().unwrap_or(variant_index);
206 O::IntEncoding::serialize_u32(self, variant_index)?;
207 let s = self.take_size()?;
208 O::IntEncoding::serialize_u32(self, s)?;
209 Ok(Compound { ser: self })
210 }
211
212 fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
213 where
214 T: serde::ser::Serialize,
215 {
216 value.serialize(self)
217 }
218
219 fn serialize_newtype_variant<T: ?Sized>(
220 self,
221 _name: &'static str,
222 variant_index: u32,
223 variant: &'static str,
224 value: &T,
225 ) -> Result<()>
226 where
227 T: serde::ser::Serialize,
228 {
229 let variant_index = variant.parse().unwrap_or(variant_index);
230 O::IntEncoding::serialize_u32(self, variant_index)?;
231 let s = self.take_size()?;
232 O::IntEncoding::serialize_u32(self, s)?;
233 value.serialize(self)
234 }
235
236 fn serialize_unit_variant(
237 self,
238 _name: &'static str,
239 variant_index: u32,
240 variant: &'static str,
241 ) -> Result<()> {
242 let variant_index = variant.parse().unwrap_or(variant_index);
243 O::IntEncoding::serialize_u32(self, variant_index)?;
244 let s = self.take_size()?;
245 O::IntEncoding::serialize_u32(self, s)?;
246 Ok(())
247 }
248
249 fn is_human_readable(&self) -> bool {
250 false
251 }
252}
253
254struct SizedSegment {
255 index: usize,
256 cur_size: u64,
257}
258
259pub(crate) struct SizeChecker<O: Options> {
260 pub options: O,
261 pub total: u64,
262 pub sizes_list: Vec<u32>,
263}
264
265impl<O: Options> SizeChecker<O> {
266 fn add_raw(&mut self, size: u64) -> Result<()> {
267 self.options.limit().add(size)?;
268 self.total += size;
269
270 Ok(())
271 }
272
273 fn add_discriminant(&mut self, idx: u32) -> Result<()> {
274 let bytes = O::IntEncoding::u32_size(idx);
275 self.add_raw(bytes)
276 }
277
278 fn add_len(&mut self, len: usize) -> Result<()> {
279 let bytes = O::IntEncoding::len_size(len);
280 self.add_raw(bytes)
281 }
282
283 fn begin_sized_segment(&mut self) -> SizedSegment {
284 let index = self.sizes_list.len();
285 self.sizes_list.push(0);
286 let cur_size = self.total;
287 SizedSegment { index, cur_size }
288 }
289
290 fn end_sized_segment(&mut self, s: SizedSegment) -> Result<()> {
291 let SizedSegment { index, cur_size } = s;
292 let self_size = self.total - cur_size;
293 if self_size > core::u32::MAX as u64 {
294 Err(ErrorKind::SizeLimit)?;
295 }
296 self.sizes_list[index] = self_size as u32;
297 self.add_discriminant(self_size as u32)
298 }
299}
300
301macro_rules! impl_size_int {
302 ($ser_method:ident($ty:ty) = $size_method:ident()) => {
303 fn $ser_method(self, v: $ty) -> Result<()> {
304 self.add_raw(O::IntEncoding::$size_method(v))
305 }
306 };
307}
308
309impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
310 type Ok = ();
311 type Error = Error;
312 type SerializeSeq = SizeCompound<'a, O>;
313 type SerializeTuple = SizeCompound<'a, O>;
314 type SerializeTupleStruct = SizeCompound<'a, O>;
315 type SerializeTupleVariant = SizeCompound<'a, O>;
316 type SerializeMap = SizeCompound<'a, O>;
317 type SerializeStruct = SizeCompound<'a, O>;
318 type SerializeStructVariant = SizeCompound<'a, O>;
319
320 fn serialize_unit(self) -> Result<()> {
321 Ok(())
322 }
323
324 fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
325 Ok(())
326 }
327
328 fn serialize_bool(self, _: bool) -> Result<()> {
329 self.add_raw(1)
330 }
331
332 fn serialize_u8(self, _: u8) -> Result<()> {
333 self.add_raw(1)
334 }
335 fn serialize_i8(self, _: i8) -> Result<()> {
336 self.add_raw(1)
337 }
338
339 impl_size_int! {serialize_u16(u16) = u16_size()}
340 impl_size_int! {serialize_u32(u32) = u32_size()}
341 impl_size_int! {serialize_u64(u64) = u64_size()}
342 impl_size_int! {serialize_i16(i16) = i16_size()}
343 impl_size_int! {serialize_i32(i32) = i32_size()}
344 impl_size_int! {serialize_i64(i64) = i64_size()}
345
346 serde_if_integer128! {
347 impl_size_int!{serialize_u128(u128) = u128_size()}
348 impl_size_int!{serialize_i128(i128) = i128_size()}
349 }
350
351 fn serialize_f32(self, _: f32) -> Result<()> {
352 self.add_raw(size_of::<f32>() as u64)
353 }
354
355 fn serialize_f64(self, _: f64) -> Result<()> {
356 self.add_raw(size_of::<f64>() as u64)
357 }
358
359 fn serialize_str(self, v: &str) -> Result<()> {
360 self.add_len(v.len())?;
361 self.add_raw(v.len() as u64)
362 }
363
364 fn serialize_char(self, c: char) -> Result<()> {
365 self.add_raw(encode_utf8(c).as_slice().len() as u64)
366 }
367
368 fn serialize_bytes(self, v: &[u8]) -> Result<()> {
369 self.add_len(v.len())?;
370 self.add_raw(v.len() as u64)
371 }
372
373 fn serialize_none(self) -> Result<()> {
374 self.add_raw(1)
375 }
376
377 fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
378 where
379 T: serde::Serialize,
380 {
381 self.add_raw(1)?;
382 v.serialize(self)
383 }
384
385 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
386 let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
387
388 self.add_len(len)?;
389 Ok(SizeCompound {
390 ser: self,
391 sized_segment: None,
392 })
393 }
394
395 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
396 Ok(SizeCompound {
397 ser: self,
398 sized_segment: None,
399 })
400 }
401
402 fn serialize_tuple_struct(
403 self,
404 _name: &'static str,
405 _len: usize,
406 ) -> Result<Self::SerializeTupleStruct> {
407 Ok(SizeCompound {
408 ser: self,
409 sized_segment: None,
410 })
411 }
412
413 fn serialize_tuple_variant(
414 self,
415 _name: &'static str,
416 variant_index: u32,
417 variant: &'static str,
418 _len: usize,
419 ) -> Result<Self::SerializeTupleVariant> {
420 let variant_index = variant.parse().unwrap_or(variant_index);
421 self.add_raw(O::IntEncoding::u32_size(variant_index))?;
422 let sized_segment = Some(self.begin_sized_segment());
423 Ok(SizeCompound {
424 ser: self,
425 sized_segment,
426 })
427 }
428
429 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
430 let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
431
432 self.add_len(len)?;
433 Ok(SizeCompound {
434 ser: self,
435 sized_segment: None,
436 })
437 }
438
439 fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
440 let sized_segment = Some(self.begin_sized_segment());
441 Ok(SizeCompound {
442 ser: self,
443 sized_segment,
444 })
445 }
446
447 fn serialize_struct_variant(
448 self,
449 _name: &'static str,
450 variant_index: u32,
451 variant: &'static str,
452 _len: usize,
453 ) -> Result<Self::SerializeStructVariant> {
454 let variant_index = variant.parse().unwrap_or(variant_index);
455 self.add_discriminant(variant_index)?;
456 let sized_segment = Some(self.begin_sized_segment());
457 Ok(SizeCompound {
458 ser: self,
459 sized_segment,
460 })
461 }
462
463 fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(
464 self,
465 _name: &'static str,
466 v: &V,
467 ) -> Result<()> {
468 v.serialize(self)
469 }
470
471 fn serialize_unit_variant(
472 self,
473 _name: &'static str,
474 variant_index: u32,
475 variant: &'static str,
476 ) -> Result<()> {
477 let variant_index = variant.parse().unwrap_or(variant_index);
478 self.add_discriminant(variant_index)?;
479 let ss = self.begin_sized_segment();
480 self.end_sized_segment(ss)?;
481 Ok(())
482 }
483
484 fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(
485 self,
486 _name: &'static str,
487 variant_index: u32,
488 variant: &'static str,
489 value: &V,
490 ) -> Result<()> {
491 let variant_index = variant.parse().unwrap_or(variant_index);
492 self.add_discriminant(variant_index)?;
493 let ss = self.begin_sized_segment();
494 let ret = value.serialize(&mut *self);
495 self.end_sized_segment(ss)?;
496 ret
497 }
498
499 fn is_human_readable(&self) -> bool {
500 false
501 }
502}
503
504pub struct Compound<'a, W: 'a, O: Options + 'a> {
505 ser: &'a mut Serializer<W, O>,
506}
507
508impl<'a, W, O> serde::ser::SerializeSeq for Compound<'a, W, O>
509where
510 W: Write,
511 O: Options,
512{
513 type Ok = ();
514 type Error = Error;
515
516 #[inline]
517 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
518 where
519 T: serde::ser::Serialize,
520 {
521 value.serialize(&mut *self.ser)
522 }
523
524 #[inline]
525 fn end(self) -> Result<()> {
526 Ok(())
527 }
528}
529
530impl<'a, W, O> serde::ser::SerializeTuple for Compound<'a, W, O>
531where
532 W: Write,
533 O: Options,
534{
535 type Ok = ();
536 type Error = Error;
537
538 #[inline]
539 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
540 where
541 T: serde::ser::Serialize,
542 {
543 value.serialize(&mut *self.ser)
544 }
545
546 #[inline]
547 fn end(self) -> Result<()> {
548 Ok(())
549 }
550}
551
552impl<'a, W, O> serde::ser::SerializeTupleStruct for Compound<'a, W, O>
553where
554 W: Write,
555 O: Options,
556{
557 type Ok = ();
558 type Error = Error;
559
560 #[inline]
561 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
562 where
563 T: serde::ser::Serialize,
564 {
565 value.serialize(&mut *self.ser)
566 }
567
568 #[inline]
569 fn end(self) -> Result<()> {
570 Ok(())
571 }
572}
573
574impl<'a, W, O> serde::ser::SerializeTupleVariant for Compound<'a, W, O>
575where
576 W: Write,
577 O: Options,
578{
579 type Ok = ();
580 type Error = Error;
581
582 #[inline]
583 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
584 where
585 T: serde::ser::Serialize,
586 {
587 value.serialize(&mut *self.ser)
588 }
589
590 #[inline]
591 fn end(self) -> Result<()> {
592 Ok(())
593 }
594}
595
596impl<'a, W, O> serde::ser::SerializeMap for Compound<'a, W, O>
597where
598 W: Write,
599 O: Options,
600{
601 type Ok = ();
602 type Error = Error;
603
604 #[inline]
605 fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
606 where
607 K: serde::ser::Serialize,
608 {
609 value.serialize(&mut *self.ser)
610 }
611
612 #[inline]
613 fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
614 where
615 V: serde::ser::Serialize,
616 {
617 value.serialize(&mut *self.ser)
618 }
619
620 #[inline]
621 fn end(self) -> Result<()> {
622 Ok(())
623 }
624}
625
626impl<'a, W, O> serde::ser::SerializeStruct for Compound<'a, W, O>
627where
628 W: Write,
629 O: Options,
630{
631 type Ok = ();
632 type Error = Error;
633
634 #[inline]
635 fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
636 where
637 T: serde::ser::Serialize,
638 {
639 value.serialize(&mut *self.ser)
640 }
641
642 #[inline]
643 fn end(self) -> Result<()> {
644 Ok(())
645 }
646}
647
648impl<'a, W, O> serde::ser::SerializeStructVariant for Compound<'a, W, O>
649where
650 W: Write,
651 O: Options,
652{
653 type Ok = ();
654 type Error = Error;
655
656 #[inline]
657 fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
658 where
659 T: serde::ser::Serialize,
660 {
661 value.serialize(&mut *self.ser)
662 }
663
664 #[inline]
665 fn end(self) -> Result<()> {
666 Ok(())
667 }
668}
669
670pub(crate) struct SizeCompound<'a, S: Options + 'a> {
671 ser: &'a mut SizeChecker<S>,
672 sized_segment: Option<SizedSegment>,
673}
674
675impl<'a, O: Options> serde::ser::SerializeSeq for SizeCompound<'a, O> {
676 type Ok = ();
677 type Error = Error;
678
679 #[inline]
680 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
681 where
682 T: serde::ser::Serialize,
683 {
684 value.serialize(&mut *self.ser)
685 }
686
687 #[inline]
688 fn end(mut self) -> Result<()> {
689 if let Some(ss) = self.sized_segment.take() {
690 self.ser.end_sized_segment(ss)?;
691 }
692 Ok(())
693 }
694}
695
696impl<'a, O: Options> serde::ser::SerializeTuple for SizeCompound<'a, O> {
697 type Ok = ();
698 type Error = Error;
699
700 #[inline]
701 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
702 where
703 T: serde::ser::Serialize,
704 {
705 value.serialize(&mut *self.ser)
706 }
707
708 #[inline]
709 fn end(mut self) -> Result<()> {
710 if let Some(ss) = self.sized_segment.take() {
711 self.ser.end_sized_segment(ss)?;
712 }
713 Ok(())
714 }
715}
716
717impl<'a, O: Options> serde::ser::SerializeTupleStruct for SizeCompound<'a, O> {
718 type Ok = ();
719 type Error = Error;
720
721 #[inline]
722 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
723 where
724 T: serde::ser::Serialize,
725 {
726 value.serialize(&mut *self.ser)
727 }
728
729 #[inline]
730 fn end(mut self) -> Result<()> {
731 if let Some(ss) = self.sized_segment.take() {
732 self.ser.end_sized_segment(ss)?;
733 }
734 Ok(())
735 }
736}
737
738impl<'a, O: Options> serde::ser::SerializeTupleVariant for SizeCompound<'a, O> {
739 type Ok = ();
740 type Error = Error;
741
742 #[inline]
743 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
744 where
745 T: serde::ser::Serialize,
746 {
747 value.serialize(&mut *self.ser)
748 }
749
750 #[inline]
751 fn end(mut self) -> Result<()> {
752 if let Some(ss) = self.sized_segment.take() {
753 self.ser.end_sized_segment(ss)?;
754 }
755 Ok(())
756 }
757}
758
759impl<'a, O: Options + 'a> serde::ser::SerializeMap for SizeCompound<'a, O> {
760 type Ok = ();
761 type Error = Error;
762
763 #[inline]
764 fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
765 where
766 K: serde::ser::Serialize,
767 {
768 value.serialize(&mut *self.ser)
769 }
770
771 #[inline]
772 fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
773 where
774 V: serde::ser::Serialize,
775 {
776 value.serialize(&mut *self.ser)
777 }
778
779 #[inline]
780 fn end(mut self) -> Result<()> {
781 if let Some(ss) = self.sized_segment.take() {
782 self.ser.end_sized_segment(ss)?;
783 }
784 Ok(())
785 }
786}
787
788impl<'a, O: Options> serde::ser::SerializeStruct for SizeCompound<'a, O> {
789 type Ok = ();
790 type Error = Error;
791
792 #[inline]
793 fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
794 where
795 T: serde::ser::Serialize,
796 {
797 value.serialize(&mut *self.ser)
798 }
799
800 #[inline]
801 fn end(mut self) -> Result<()> {
802 if let Some(ss) = self.sized_segment.take() {
803 self.ser.end_sized_segment(ss)?;
804 }
805 Ok(())
806 }
807}
808
809impl<'a, O: Options> serde::ser::SerializeStructVariant for SizeCompound<'a, O> {
810 type Ok = ();
811 type Error = Error;
812
813 #[inline]
814 fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
815 where
816 T: serde::ser::Serialize,
817 {
818 value.serialize(&mut *self.ser)
819 }
820
821 #[inline]
822 fn end(mut self) -> Result<()> {
823 if let Some(ss) = self.sized_segment.take() {
824 self.ser.end_sized_segment(ss)?;
825 }
826 Ok(())
827 }
828}
829const TAG_CONT: u8 = 0b1000_0000;
830const TAG_TWO_B: u8 = 0b1100_0000;
831const TAG_THREE_B: u8 = 0b1110_0000;
832const TAG_FOUR_B: u8 = 0b1111_0000;
833const MAX_ONE_B: u32 = 0x80;
834const MAX_TWO_B: u32 = 0x800;
835const MAX_THREE_B: u32 = 0x10000;
836
837fn encode_utf8(c: char) -> EncodeUtf8 {
838 let code = c as u32;
839 let mut buf = [0; 4];
840 let pos = if code < MAX_ONE_B {
841 buf[3] = code as u8;
842 3
843 } else if code < MAX_TWO_B {
844 buf[2] = ((code >> 6) & 0x1F) as u8 | TAG_TWO_B;
845 buf[3] = (code & 0x3F) as u8 | TAG_CONT;
846 2
847 } else if code < MAX_THREE_B {
848 buf[1] = ((code >> 12) & 0x0F) as u8 | TAG_THREE_B;
849 buf[2] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
850 buf[3] = (code & 0x3F) as u8 | TAG_CONT;
851 1
852 } else {
853 buf[0] = ((code >> 18) & 0x07) as u8 | TAG_FOUR_B;
854 buf[1] = ((code >> 12) & 0x3F) as u8 | TAG_CONT;
855 buf[2] = ((code >> 6) & 0x3F) as u8 | TAG_CONT;
856 buf[3] = (code & 0x3F) as u8 | TAG_CONT;
857 0
858 };
859 EncodeUtf8 { buf, pos }
860}
861
862struct EncodeUtf8 {
863 buf: [u8; 4],
864 pos: usize,
865}
866
867impl EncodeUtf8 {
868 fn as_slice(&self) -> &[u8] {
869 &self.buf[self.pos..]
870 }
871}