Struct Serializer 

pub(crate) struct Serializer<'a, W: Write> {
    out: &'a mut W,
    depth: u32,
    sep: bool,
    fin: bool,
}

Stateful writer for the compact database record format.

Separator state controls record boundaries in the compact encoding. Debug builds track container depth and explicit prefix finalization to validate the layout.

Fields

out: &'a mut W

depth: u32

sep: bool

fin: bool

Implementations

impl<W: Write> Serializer<'_, W>

const SEP: &'static [u8]

fn tuple_start(&mut self)

fn tuple_end(&mut self) -> Result

fn sequence_start(&mut self)

fn sequence_end(&mut self) -> Result

fn record_start(&mut self) -> Result

fn separator(&mut self) -> Result

fn write(&mut self, buf: &[u8]) -> Result

fn set_finalized(&mut self)

fn is_finalized(&self) -> bool

Trait Implementations

impl<W: Write> SerializeMap for &mut Serializer<'_, W>

type Error = Error

Must match the Error type of our Serializer.

type Ok = ()

Must match the Ok type of our Serializer.

fn serialize_key<T: Serialize + ?Sized>(&mut self, _key: &T) -> Result<Self::Ok>

Serialize a map key.

fn serialize_value<T: Serialize + ?Sized>( &mut self, _val: &T, ) -> Result<Self::Ok>

Serialize a map value.

fn end(self) -> Result<Self::Ok>

Finish serializing a map.

fn serialize_entry<K, V>( &mut self, key: &K, value: &V, ) -> Result<(), Self::Error>

where K: Serialize + ?Sized, V: Serialize + ?Sized,

Serialize a map entry consisting of a key and a value.

impl<W: Write> SerializeSeq for &mut Serializer<'_, W>

type Error = Error

Must match the Error type of our Serializer.

type Ok = ()

Must match the Ok type of our Serializer.

fn serialize_element<T: Serialize + ?Sized>( &mut self, val: &T, ) -> Result<Self::Ok>

Serialize a sequence element.

fn end(self) -> Result<Self::Ok>

Finish serializing a sequence.

impl<W: Write> SerializeStruct for &mut Serializer<'_, W>

type Error = Error

Must match the Error type of our Serializer.

type Ok = ()

Must match the Ok type of our Serializer.

fn serialize_field<T: Serialize + ?Sized>( &mut self, _key: &'static str, _val: &T, ) -> Result<Self::Ok>

Serialize a struct field.

fn end(self) -> Result<Self::Ok>

Finish serializing a struct.

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct field has been skipped.

impl<W: Write> SerializeStructVariant for &mut Serializer<'_, W>

type Error = Error

Must match the Error type of our Serializer.

type Ok = ()

Must match the Ok type of our Serializer.

fn serialize_field<T: Serialize + ?Sized>( &mut self, _key: &'static str, _val: &T, ) -> Result<Self::Ok>

Serialize a struct variant field.

fn end(self) -> Result<Self::Ok>

Finish serializing a struct variant.

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct variant field has been skipped.

impl<W: Write> SerializeTuple for &mut Serializer<'_, W>

type Error = Error

Must match the Error type of our Serializer.

type Ok = ()

Must match the Ok type of our Serializer.

fn serialize_element<T: Serialize + ?Sized>( &mut self, val: &T, ) -> Result<Self::Ok>

Serialize a tuple element.

fn end(self) -> Result<Self::Ok>

Finish serializing a tuple.

impl<W: Write> SerializeTupleStruct for &mut Serializer<'_, W>

type Error = Error

Must match the Error type of our Serializer.

type Ok = ()

Must match the Ok type of our Serializer.

fn serialize_field<T: Serialize + ?Sized>( &mut self, val: &T, ) -> Result<Self::Ok>

Serialize a tuple struct field.

fn end(self) -> Result<Self::Ok>

Finish serializing a tuple struct.

impl<W: Write> SerializeTupleVariant for &mut Serializer<'_, W>

type Error = Error

Must match the Error type of our Serializer.

type Ok = ()

Must match the Ok type of our Serializer.

fn serialize_field<T: Serialize + ?Sized>( &mut self, val: &T, ) -> Result<Self::Ok>

Serialize a tuple variant field.

fn end(self) -> Result<Self::Ok>

Finish serializing a tuple variant.

impl<W: Write> Serializer for &mut Serializer<'_, W>

type Error = Error

The error type when some error occurs during serialization.

type Ok = ()

The output type produced by this Serializer during successful serialization. Most serializers that produce text or binary output should set Ok = () and serialize into an io::Write or buffer contained within the Serializer instance. Serializers that build in-memory data structures may be simplified by using Ok to propagate the data structure around.

type SerializeMap = &mut Serializer<'_, W>

Type returned from serialize_map for serializing the content of the map.

type SerializeSeq = &mut Serializer<'_, W>

Type returned from serialize_seq for serializing the content of the sequence.

type SerializeStruct = &mut Serializer<'_, W>

Type returned from serialize_struct for serializing the content of the struct.

type SerializeStructVariant = &mut Serializer<'_, W>

Type returned from serialize_struct_variant for serializing the content of the struct variant.

type SerializeTuple = &mut Serializer<'_, W>

Type returned from serialize_tuple for serializing the content of the tuple.

type SerializeTupleStruct = &mut Serializer<'_, W>

Type returned from serialize_tuple_struct for serializing the content of the tuple struct.

type SerializeTupleVariant = &mut Serializer<'_, W>

Type returned from serialize_tuple_variant for serializing the content of the tuple variant.

fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq>

Begin to serialize a variably sized sequence. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple>

Begin to serialize a statically sized sequence whose length will be known at deserialization time without looking at the serialized data. This call must be followed by zero or more calls to serialize_element, then a call to end.

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

Begin to serialize a tuple struct like struct Rgb(u8, u8, u8). This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_tuple_variant( self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize, ) -> Result<Self::SerializeTupleVariant>

Begin to serialize a tuple variant like E::T in enum E { T(u8, u8) }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap>

Begin to serialize a map. This call must be followed by zero or more calls to serialize_key and serialize_value, then a call to end.

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

Begin to serialize a struct like struct Rgb { r: u8, g: u8, b: u8 }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_struct_variant( self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize, ) -> Result<Self::SerializeStructVariant>

Begin to serialize a struct variant like E::S in enum E { S { r: u8, g: u8, b: u8 } }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_newtype_struct<T>( self, name: &'static str, value: &T, ) -> Result<Self::Ok>

where T: Serialize + ?Sized,

Serialize a newtype struct like struct Millimeters(u8).

fn serialize_newtype_variant<T: Serialize + ?Sized>( self, _name: &'static str, _idx: u32, _var: &'static str, _value: &T, ) -> Result<Self::Ok>

Serialize a newtype variant like E::N in enum E { N(u8) }.

fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok>

Serialize a unit struct like struct Unit or PhantomData<T>.

fn serialize_unit_variant( self, _name: &'static str, _idx: u32, _var: &'static str, ) -> Result<Self::Ok>

Serialize a unit variant like E::A in enum E { A, B }.

fn serialize_some<T: Serialize + ?Sized>(self, val: &T) -> Result<Self::Ok>

Serialize a Some(T) value.

fn serialize_none(self) -> Result<Self::Ok>

Serialize a None value.

fn serialize_char(self, v: char) -> Result<Self::Ok>

Serialize a character.

fn serialize_str(self, v: &str) -> Result<Self::Ok>

Serialize a &str.

fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok>

Serialize a chunk of raw byte data.

fn serialize_f64(self, _v: f64) -> Result<Self::Ok>

Serialize an f64 value.

fn serialize_f32(self, _v: f32) -> Result<Self::Ok>

Serialize an f32 value.

fn serialize_i64(self, v: i64) -> Result<Self::Ok>

Serialize an i64 value.

fn serialize_i32(self, v: i32) -> Result<Self::Ok>

Serialize an i32 value.

fn serialize_i16(self, _v: i16) -> Result<Self::Ok>

Serialize an i16 value.

fn serialize_i8(self, _v: i8) -> Result<Self::Ok>

Serialize an i8 value.

fn serialize_u64(self, v: u64) -> Result<Self::Ok>

Serialize a u64 value.

fn serialize_u32(self, v: u32) -> Result<Self::Ok>

Serialize a u32 value.

fn serialize_u16(self, _v: u16) -> Result<Self::Ok>

Serialize a u16 value.

fn serialize_u8(self, v: u8) -> Result<Self::Ok>

Serialize a u8 value.

fn serialize_bool(self, _v: bool) -> Result<Self::Ok>

Serialize a bool value.

fn serialize_unit(self) -> Result<Self::Ok>

Serialize a () value.

fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>

Serialize an i128 value.

fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>

Serialize a u128 value.

fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where I: IntoIterator, <I as IntoIterator>::Item: Serialize,

Collect an iterator as a sequence.

fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where K: Serialize, V: Serialize, I: IntoIterator<Item = (K, V)>,

Collect an iterator as a map.

fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>

where T: Display + ?Sized,

Serialize a string produced by an implementation of Display.

fn is_human_readable(&self) -> bool

Determine whether Serialize implementations should serialize in human-readable form.