Struct rmp_serde::encode::Serializer
[−]
[src]
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>
[src]
fn set_max_depth(&mut self, depth: usize)
Changes the maximum nesting depth that is allowed
impl<'a> Serializer<'a, StructArrayWriter>
[src]
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>
[src]
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>
[src]
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. Read more
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. Read more
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. Read more
fn serialize_u64(&mut self, val: u64) -> Result<(), Error>
Serializes a
u64` 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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
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. Read more
fn serialize_struct<V>(&mut self, _name: &str, visitor: V) -> Result<(), Error> where V: MapVisitor
Serializes a struct. Read more
fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> Result<(), Error> where V: Serialize
Serializes an element of a struct. Read more
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. Read more
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. Read more
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. Read more
fn serialize_tuple<V>(&mut self, visitor: V) -> Result<(), Self::Error> where V: SeqVisitor
Serializes a tuple. Read more
fn serialize_tuple_elt<T>(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize
Serializes a tuple element. Read more
fn serialize_fixed_size_array<V>(&mut self, visitor: V) -> Result<(), Self::Error> where V: SeqVisitor
Serializes a fixed-size array. Read more
fn serialize_tuple_struct<V>(&mut self, _name: &'static str, visitor: V) -> Result<(), Self::Error> where V: SeqVisitor
Serializes a tuple struct. Read more
fn serialize_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize
Serializes a tuple struct element. Read more
fn serialize_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize
Serializes a tuple element. Read more
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. Read more