Struct Serializer

pub struct Serializer<W>
where
    W: Writer,
{ /* private fields */ }

Implementations

impl<W> Serializer<W>

where W: Writer,

pub fn new(writer: W) -> Serializer<W>

pub fn serialize_bool(&mut self, value: bool) -> Result<()>

pub fn serialize_u8(&mut self, value: u8) -> Result<()>

pub fn serialize_u16(&mut self, value: u16) -> Result<()>

pub fn serialize_u32(&mut self, value: u32) -> Result<()>

pub fn serialize_u64(&mut self, value: u64) -> Result<()>

pub fn serialize_u128(&mut self, value: u128) -> Result<()>

pub fn serialize_i8(&mut self, value: i8) -> Result<()>

pub fn serialize_i16(&mut self, value: i16) -> Result<()>

pub fn serialize_i32(&mut self, value: i32) -> Result<()>

pub fn serialize_i64(&mut self, value: i64) -> Result<()>

pub fn serialize_i128(&mut self, value: i128) -> Result<()>

pub fn serialize_f32(&mut self, value: f32) -> Result<()>

pub fn serialize_f64(&mut self, value: f64) -> Result<()>

pub fn serialize_char(&mut self, value: char) -> Result<()>

pub fn serialize_str(&mut self, value: &str) -> Result<()>

pub fn serialize_none(&mut self) -> Result<()>

pub fn serialize_some<T>(&mut self, value: &T) -> Result<()>

where T: ?Sized + Serialize,

pub fn serialize_seq<'a>( &'a mut self, length: u32, ) -> Result<SeqSerializer<'a, W>>

pub fn serialize_map<'a>( &'a mut self, length: u32, ) -> Result<MapSerializer<'a, W>>

pub fn serialize_enum_variant(&mut self, variant_index: u32) -> Result<()>

Start serializing an enum - this encodes the tag that specifies which variant is being encoded. Data contained in the variant should be serialized following this.

pub fn serialize_handle(&mut self, handle: Handle) -> Result<()>