Struct rmp_serde::encode::Serializer

pub struct Serializer<W, V> { /* fields omitted */ }

Represents MessagePack serialization implementation.

Note

MessagePack has no specification about how to encode enum types. Thus we are free to do whatever we want, so the given chose may be not ideal for you.

Every Rust enum value can be represented as a tuple of index with a value.

All instances of ErrorKind::Interrupted are handled by this function and the underlying operation is retried.

Methods

impl<W: Write> Serializer<W, StructMapWriter>

fn new_named(wr: W) -> Self

Constructs a new MessagePack serializer whose output will be written to the writer specified.

Note

This is the default constructor, which returns a serializer that will serialize structs using large named representation.

impl<W, V> Serializer<W, V>

fn set_max_depth(&mut self, depth: usize)

Changes the maximum nesting depth that is allowed

impl<W: Write> Serializer<W, StructArrayWriter>

fn new(wr: W) -> Self

Constructs a new MessagePack serializer whose output will be written to the writer specified.

Note

This is the default constructor, which returns a serializer that will serialize structs using compact tuple representation, without field names.

fn compact(wr: W) -> Self

impl<W: Write, V> Serializer<W, V>

fn get_ref(&self) -> &W

Gets a reference to the underlying writer.

fn get_mut(&mut self) -> &mut W

Gets a mutable reference to the underlying writer.

It is inadvisable to directly write to the underlying writer.

fn into_inner(self) -> W

Unwraps this Serializer, returning the underlying writer.

impl<W: Write, V: VariantWriter> Serializer<W, V>

fn with(wr: W, vw: V) -> Self

Creates a new MessagePack encoder whose output will be written to the writer specified.

Trait Implementations

impl<'a, W: Write, V: VariantWriter> Serializer for &'a mut Serializer<W, V>

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 Error = Error

The error type when some error occurs during serialization.

type SerializeSeq = Compound<'a, W, V>

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

type SerializeTuple = Compound<'a, W, V>

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

type SerializeTupleStruct = Compound<'a, W, V>

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

type SerializeTupleVariant = Compound<'a, W, V>

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

type SerializeMap = Compound<'a, W, V>

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

type SerializeStruct = Compound<'a, W, V>

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

type SerializeStructVariant = Compound<'a, W, V>

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

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

Serialize a bool value.

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

Serialize an i8 value.

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

Serialize an i16 value.

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

Serialize an i32 value.

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

Serialize an i64 value.

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

Serialize a u8 value.

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

Serialize a u16 value.

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

Serialize a u32 value.

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

Serialize a u64 value.

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

Serialize an f32 value.

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

Serialize an f64 value.

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

Serialize a character.

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

Serialize a &str.

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

Serialize a chunk of raw byte data.

fn serialize_none(self) -> Result<(), Self::Error>

Serialize a [None] value.

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

Serialize a [Some(T)] value.

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

Serialize a () value.

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

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

fn serialize_unit_variant(
    self,
    _name: &str,
    idx: u32,
    _variant: &str
) -> Result<Self::Ok, Self::Error>

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

fn serialize_newtype_struct<T: ?Sized + Serialize>(
    self,
    name: &'static str,
    value: &T
) -> Result<(), Self::Error>

Serialize a newtype struct like struct Millimeters(u8).

fn serialize_newtype_variant<T: ?Sized + Serialize>(
    self,
    name: &'static str,
    variant_index: u32,
    variant: &'static str,
    value: &T
) -> Result<Self::Ok, Self::Error>

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

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

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, Self::Error>

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, Self::Error>

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,
    _variant: &'static str,
    len: usize
) -> Result<Self::SerializeTupleVariant, Error>

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, Error>

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, Self::Error>

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,
    id: u32,
    _variant: &'static str,
    len: usize
) -> Result<Self::SerializeStructVariant, Error>

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 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
    I: IntoIterator<Item = (K, V)>,
    K: Serialize,
    V: Serialize, 

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.