Struct rmp_serde::encode::Serializer

pub struct Serializer<'a, W: VariantWriter> {
    // some fields omitted
}

Represents MessagePack serialization implementation.

Note

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

Every Rust variant value can be represented as a tuple of index and a value.

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

Methods

impl<'a, W: VariantWriter> Serializer<'a, W>

fn set_max_depth(&mut self, depth: usize)

Changes the maximum nesting depth that is allowed

impl<'a> Serializer<'a, StructArrayWriter>

fn new(wr: &'a mut Write) -> Serializer<'a, StructArrayWriter>

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

impl<'a, W: VariantWriter> Serializer<'a, W>

fn with(wr: &'a mut Write, vw: W) -> Serializer<'a, W>

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

Trait Implementations

impl<'a, W: VariantWriter> Serializer for Serializer<'a, W>

type Error = Error

The error type that can be returned if some error occurs during serialization.

fn serialize_unit(&mut self) -> Result<(), Error>

Serializes a () value.

fn serialize_bool(&mut self, val: bool) -> Result<(), Error>

Serializes a bool value.

fn serialize_u8(&mut self, val: u8) -> Result<(), Error>

Serializes a u8 value. By default it casts the value to a u64 and passes it to the serialize_u64 method.

fn serialize_u16(&mut self, val: u16) -> Result<(), Error>

Serializes a u32 value. By default it casts the value to a u64 and passes it to the serialize_u64 method.

fn serialize_u32(&mut self, val: u32) -> Result<(), Error>

Serializes a u32 value. By default it casts the value to a u64 and passes it to the serialize_u64 method.

fn serialize_u64(&mut self, val: u64) -> Result<(), Error>

Serializes au64` value.

fn serialize_usize(&mut self, val: usize) -> Result<(), Error>

Serializes a usize value. By default it casts the value to a u64 and passes it to the serialize_u64 method.

fn serialize_i8(&mut self, val: i8) -> Result<(), Error>

Serializes a i8 value. By default it casts the value to a i64 and passes it to the serialize_i64 method.

fn serialize_i16(&mut self, val: i16) -> Result<(), Error>

Serializes a i16 value. By default it casts the value to a i64 and passes it to the serialize_i64 method.

fn serialize_i32(&mut self, val: i32) -> Result<(), Error>

Serializes a i32 value. By default it casts the value to a i64 and passes it to the serialize_i64 method.

fn serialize_i64(&mut self, val: i64) -> Result<(), Error>

Serializes a i64 value.

fn serialize_isize(&mut self, val: isize) -> Result<(), Error>

Serializes a isize value. By default it casts the value to a i64 and passes it to the serialize_i64 method.

fn serialize_f32(&mut self, val: f32) -> Result<(), Error>

Serializes a f32 value. By default it casts the value to a f64 and passes it to the serialize_f64 method.

fn serialize_f64(&mut self, val: f64) -> Result<(), Error>

Serializes a f64 value.

fn serialize_char(&mut self, val: char) -> Result<(), Error>

Serializes a character. By default it serializes it as a &str containing a single character.

fn serialize_str(&mut self, val: &str) -> Result<(), Error>

Serializes a &str.

fn serialize_unit_variant(&mut self, _name: &str, variant_index: usize, _variant: &str) -> Result<(), Error>

Serializes a unit variant, otherwise known as a variant with no arguments.

fn serialize_tuple_variant<V>(&mut self, _name: &str, variant_index: usize, _variant: &str, visitor: V) -> Result<(), Error> where V: SeqVisitor

Encodes and attempts to write the enum value into the Write.

Currently we encode variant types as a tuple of id with array of args, like: [id, [args...]]

fn serialize_struct_variant<V>(&mut self, _name: &str, variant_index: usize, _variant: &str, visitor: V) -> Result<(), Error> where V: MapVisitor

Serializes a struct variant.

fn serialize_none(&mut self) -> Result<(), Error>

Serializes a None value..serialize

fn serialize_some<T>(&mut self, v: T) -> Result<(), Error> where T: Serialize

Serializes a Some(...) value.

fn serialize_seq<V>(&mut self, visitor: V) -> Result<(), Error> where V: SeqVisitor

Serializes a sequence.

fn serialize_seq_elt<V>(&mut self, value: V) -> Result<(), Error> where V: Serialize

Serializes a sequence element.

fn serialize_map<V>(&mut self, visitor: V) -> Result<(), Error> where V: MapVisitor

Serializes a map.

fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Error> where K: Serialize, V: Serialize

Serializes a map element (key-value pair).

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

Serializes a unit struct value.

fn serialize_struct<V>(&mut self, _name: &str, visitor: V) -> Result<(), Error> where V: MapVisitor

Serializes a struct.

fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> Result<(), Error> where V: Serialize

Serializes an element of a struct.

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

Enables those serialization formats that support serializing byte slices separately from generic arrays. By default it serializes as a regular array.

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

Allows a tuple struct with a single element, also known as a newtyped value, to be more efficiently serialized than a tuple struct with multiple items. By default it just serializes the value as a tuple struct sequence.

fn serialize_newtype_variant<T>(&mut self, name: &'static str, variant_index: usize, variant: &'static str, value: T) -> Result<(), Self::Error> where T: Serialize

Allows a variant with a single item to be more efficiently serialized than a variant with multiple items. By default it just serializes the value as a tuple variant sequence.

fn serialize_tuple<V>(&mut self, visitor: V) -> Result<(), Self::Error> where V: SeqVisitor

Serializes a tuple.

fn serialize_tuple_elt<T>(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize

Serializes a tuple element.

fn serialize_fixed_size_array<V>(&mut self, visitor: V) -> Result<(), Self::Error> where V: SeqVisitor

Serializes a fixed-size array.

fn serialize_tuple_struct<V>(&mut self, _name: &'static str, visitor: V) -> Result<(), Self::Error> where V: SeqVisitor

Serializes a tuple struct.

fn serialize_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize

Serializes a tuple struct element.

fn serialize_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize

Serializes a tuple element.

fn serialize_struct_variant_elt<V>(&mut self, key: &'static str, value: V) -> Result<(), Self::Error> where V: Serialize

Serializes an element of a struct variant.