/rust/registry/src/index.crates.io-1949cf8c6b5b557f/bincode-1.3.3/src/ser/mod.rs

Source
use std::io::Write;
use std::u32;

use serde;

use byteorder::WriteBytesExt;

use super::config::{IntEncoding, SizeLimit};
use super::{Error, ErrorKind, Result};
use config::{BincodeByteOrder, Options};
use std::mem::size_of;

/// An Serializer that encodes values directly into a Writer.
///
/// The specified byte-order will impact the endianness that is
/// used during the encoding.
///
/// This struct should not be used often.
/// For most cases, prefer the `encode_into` function.
pub struct Serializer<W, O: Options> {
    writer: W,
    _options: O,
}

macro_rules! impl_serialize_literal {
    ($ser_method:ident($ty:ty) = $write:ident()) => {
        pub(crate) fn $ser_method(&mut self, v: $ty) -> Result<()> {
            self.writer
                .$write::<<O::Endian as BincodeByteOrder>::Endian>(v)
                .map_err(Into::into)
        }
    };
}

impl<W: Write, O: Options> Serializer<W, O> {
    /// Creates a new Serializer with the given `Write`r.
    pub fn new(w: W, options: O) -> Serializer<W, O> {
        Serializer {
            writer: w,
            _options: options,
        }
    }

    pub(crate) fn serialize_byte(&mut self, v: u8) -> Result<()> {
        self.writer.write_u8(v).map_err(Into::into)
    }

    impl_serialize_literal! {serialize_literal_u16(u16) = write_u16()}
    impl_serialize_literal! {serialize_literal_u32(u32) = write_u32()}
    impl_serialize_literal! {serialize_literal_u64(u64) = write_u64()}

    serde_if_integer128! {
        impl_serialize_literal!{serialize_literal_u128(u128) = write_u128()}
    }
}

macro_rules! impl_serialize_int {
    ($ser_method:ident($ty:ty) = $ser_int:ident()) => {
        fn $ser_method(self, v: $ty) -> Result<()> {
            O::IntEncoding::$ser_int(self, v)
        }
    };
}

impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = Compound<'a, W, O>;
    type SerializeTuple = Compound<'a, W, O>;
    type SerializeTupleStruct = Compound<'a, W, O>;
    type SerializeTupleVariant = Compound<'a, W, O>;
    type SerializeMap = Compound<'a, W, O>;
    type SerializeStruct = Compound<'a, W, O>;
    type SerializeStructVariant = Compound<'a, W, O>;

    fn serialize_unit(self) -> Result<()> {
        Ok(())
    }

    fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
        Ok(())
    }

    fn serialize_bool(self, v: bool) -> Result<()> {
        self.serialize_byte(v as u8)
    }

    fn serialize_u8(self, v: u8) -> Result<()> {
        self.serialize_byte(v)
    }

    impl_serialize_int! {serialize_u16(u16) = serialize_u16()}
    impl_serialize_int! {serialize_u32(u32) = serialize_u32()}
    impl_serialize_int! {serialize_u64(u64) = serialize_u64()}

    fn serialize_i8(self, v: i8) -> Result<()> {
        self.serialize_byte(v as u8)
    }

    impl_serialize_int! {serialize_i16(i16) = serialize_i16()}
    impl_serialize_int! {serialize_i32(i32) = serialize_i32()}
    impl_serialize_int! {serialize_i64(i64) = serialize_i64()}

    serde_if_integer128! {
        impl_serialize_int!{serialize_u128(u128) = serialize_u128()}
        impl_serialize_int!{serialize_i128(i128) = serialize_i128()}
    }

    fn serialize_f32(self, v: f32) -> Result<()> {
        self.writer
            .write_f32::<<O::Endian as BincodeByteOrder>::Endian>(v)
            .map_err(Into::into)
    }

    fn serialize_f64(self, v: f64) -> Result<()> {
        self.writer
            .write_f64::<<O::Endian as BincodeByteOrder>::Endian>(v)
            .map_err(Into::into)
    }

    fn serialize_str(self, v: &str) -> Result<()> {
        O::IntEncoding::serialize_len(self, v.len())?;
        self.writer.write_all(v.as_bytes()).map_err(Into::into)
    }

    fn serialize_char(self, c: char) -> Result<()> {
        self.writer
            .write_all(encode_utf8(c).as_slice())
            .map_err(Into::into)
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
        O::IntEncoding::serialize_len(self, v.len())?;
        self.writer.write_all(v).map_err(Into::into)
    }

    fn serialize_none(self) -> Result<()> {
        self.writer.write_u8(0).map_err(Into::into)
    }

    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        self.writer.write_u8(1)?;
        v.serialize(self)
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
        O::IntEncoding::serialize_len(self, len)?;
        Ok(Compound { ser: self })
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
        Ok(Compound { ser: self })
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Ok(Compound { ser: self })
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        O::IntEncoding::serialize_u32(self, variant_index)?;
        Ok(Compound { ser: self })
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
        let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;
        O::IntEncoding::serialize_len(self, len)?;
        Ok(Compound { ser: self })
    }

    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
        Ok(Compound { ser: self })
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        O::IntEncoding::serialize_u32(self, variant_index)?;
        Ok(Compound { ser: self })
    }

    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(self)
    }

    fn serialize_newtype_variant<T: ?Sized>(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        value: &T,
    ) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        O::IntEncoding::serialize_u32(self, variant_index)?;
        value.serialize(self)
    }

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
    ) -> Result<()> {
        O::IntEncoding::serialize_u32(self, variant_index)
    }

    fn is_human_readable(&self) -> bool {
        false
    }
}

pub(crate) struct SizeChecker<O: Options> {
    pub options: O,
    pub total: u64,
}

impl<O: Options> SizeChecker<O> {
    fn add_raw(&mut self, size: u64) -> Result<()> {
        self.options.limit().add(size)?;
        self.total += size;

        Ok(())
    }

    fn add_discriminant(&mut self, idx: u32) -> Result<()> {
        let bytes = O::IntEncoding::u32_size(idx);
        self.add_raw(bytes)
    }

    fn add_len(&mut self, len: usize) -> Result<()> {
        let bytes = O::IntEncoding::len_size(len);
        self.add_raw(bytes)
    }
}

macro_rules! impl_size_int {
    ($ser_method:ident($ty:ty) = $size_method:ident()) => {
        fn $ser_method(self, v: $ty) -> Result<()> {
            self.add_raw(O::IntEncoding::$size_method(v))
        }
    };
}

impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = SizeCompound<'a, O>;
    type SerializeTuple = SizeCompound<'a, O>;
    type SerializeTupleStruct = SizeCompound<'a, O>;
    type SerializeTupleVariant = SizeCompound<'a, O>;
    type SerializeMap = SizeCompound<'a, O>;
    type SerializeStruct = SizeCompound<'a, O>;
    type SerializeStructVariant = SizeCompound<'a, O>;

    fn serialize_unit(self) -> Result<()> {
        Ok(())
    }

    fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
        Ok(())
    }

    fn serialize_bool(self, _: bool) -> Result<()> {
        self.add_raw(1)
    }

    fn serialize_u8(self, _: u8) -> Result<()> {
        self.add_raw(1)
    }
    fn serialize_i8(self, _: i8) -> Result<()> {
        self.add_raw(1)
    }

    impl_size_int! {serialize_u16(u16) = u16_size()}
    impl_size_int! {serialize_u32(u32) = u32_size()}
    impl_size_int! {serialize_u64(u64) = u64_size()}
    impl_size_int! {serialize_i16(i16) = i16_size()}
    impl_size_int! {serialize_i32(i32) = i32_size()}
    impl_size_int! {serialize_i64(i64) = i64_size()}

    serde_if_integer128! {
        impl_size_int!{serialize_u128(u128) = u128_size()}
        impl_size_int!{serialize_i128(i128) = i128_size()}
    }

    fn serialize_f32(self, _: f32) -> Result<()> {
        self.add_raw(size_of::<f32>() as u64)
    }

    fn serialize_f64(self, _: f64) -> Result<()> {
        self.add_raw(size_of::<f64>() as u64)
    }

    fn serialize_str(self, v: &str) -> Result<()> {
        self.add_len(v.len())?;
        self.add_raw(v.len() as u64)
    }

    fn serialize_char(self, c: char) -> Result<()> {
        self.add_raw(encode_utf8(c).as_slice().len() as u64)
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
        self.add_len(v.len())?;
        self.add_raw(v.len() as u64)
    }

    fn serialize_none(self) -> Result<()> {
        self.add_raw(1)
    }

    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
    where
        T: serde::Serialize,
    {
        self.add_raw(1)?;
        v.serialize(self)
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;

        self.add_len(len)?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
        Ok(SizeCompound { ser: self })
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        Ok(SizeCompound { ser: self })
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        self.add_raw(O::IntEncoding::u32_size(variant_index))?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
        let len = len.ok_or(ErrorKind::SequenceMustHaveLength)?;

        self.add_len(len)?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
        Ok(SizeCompound { ser: self })
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        self.add_discriminant(variant_index)?;
        Ok(SizeCompound { ser: self })
    }

    fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(
        self,
        _name: &'static str,
        v: &V,
    ) -> Result<()> {
        v.serialize(self)
    }

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
    ) -> Result<()> {
        self.add_discriminant(variant_index)
    }

    fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(
        self,
        _name: &'static str,
        variant_index: u32,
        _variant: &'static str,
        value: &V,
    ) -> Result<()> {
        self.add_discriminant(variant_index)?;
        value.serialize(self)
    }

    fn is_human_readable(&self) -> bool {
        false
    }
}

pub struct Compound<'a, W: 'a, O: Options + 'a> {
    ser: &'a mut Serializer<W, O>,
}

impl<'a, W, O> serde::ser::SerializeSeq for Compound<'a, W, O>
where
    W: Write,
    O: Options,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W, O> serde::ser::SerializeTuple for Compound<'a, W, O>
where
    W: Write,
    O: Options,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W, O> serde::ser::SerializeTupleStruct for Compound<'a, W, O>
where
    W: Write,
    O: Options,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W, O> serde::ser::SerializeTupleVariant for Compound<'a, W, O>
where
    W: Write,
    O: Options,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W, O> serde::ser::SerializeMap for Compound<'a, W, O>
where
    W: Write,
    O: Options,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
    where
        K: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
    where
        V: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W, O> serde::ser::SerializeStruct for Compound<'a, W, O>
where
    W: Write,
    O: Options,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, W, O> serde::ser::SerializeStructVariant for Compound<'a, W, O>
where
    W: Write,
    O: Options,
{
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

pub(crate) struct SizeCompound<'a, S: Options + 'a> {
    ser: &'a mut SizeChecker<S>,
}

impl<'a, O: Options> serde::ser::SerializeSeq for SizeCompound<'a, O> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, O: Options> serde::ser::SerializeTuple for SizeCompound<'a, O> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, O: Options> serde::ser::SerializeTupleStruct for SizeCompound<'a, O> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, O: Options> serde::ser::SerializeTupleVariant for SizeCompound<'a, O> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, O: Options + 'a> serde::ser::SerializeMap for SizeCompound<'a, O> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
    where
        K: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
    where
        V: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, O: Options> serde::ser::SerializeStruct for SizeCompound<'a, O> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}

impl<'a, O: Options> serde::ser::SerializeStructVariant for SizeCompound<'a, O> {
    type Ok = ();
    type Error = Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
    where
        T: serde::ser::Serialize,
    {
        value.serialize(&mut *self.ser)
    }

    #[inline]
    fn end(self) -> Result<()> {
        Ok(())
    }
}
const TAG_CONT: u8 = 0b1000_0000;
const TAG_TWO_B: u8 = 0b1100_0000;
const TAG_THREE_B: u8 = 0b1110_0000;
const TAG_FOUR_B: u8 = 0b1111_0000;
const MAX_ONE_B: u32 = 0x80;
const MAX_TWO_B: u32 = 0x800;
const MAX_THREE_B: u32 = 0x10000;

fn encode_utf8(c: char) -> EncodeUtf8 {
    let code = c as u32;
    let mut buf = [0; 4];
    let pos = if code < MAX_ONE_B {
        buf[3] = code as u8;
        3
    } else if code < MAX_TWO_B {
        buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
        2
    } else if code < MAX_THREE_B {
        buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
        1
    } else {
        buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
        buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
        0
    };
    EncodeUtf8 { buf, pos }
}

struct EncodeUtf8 {
    buf: [u8; 4],
    pos: usize,
}

impl EncodeUtf8 {
    fn as_slice(&self) -> &[u8] {
        &self.buf[self.pos..]
    }
}

Coverage Report

Created: 2026-08-14 07:08

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