Struct rmp_serde::encode::Serializer
[−]
[src]
pub struct Serializer<'a, W: VariantWriter> { /* 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.
type SeqState = ()
A state object that is initialized by serialize_seq
, passed to serialize_seq_elt
, and consumed by serialize_seq_end
. Use ()
if no state is required. Read more
type TupleState = ()
A state object that is initialized by serialize_tuple
, passed to serialize_tuple_elt
, and consumed by serialize_tuple_end
. Use ()
if no state is required. Read more
type TupleStructState = ()
A state object that is initialized by serialize_tuple_struct
, passed to serialize_tuple_struct_elt
, and consumed by serialize_tuple_struct_end
. Use ()
if no state is required. Read more
type TupleVariantState = ()
A state object that is initialized by serialize_tuple_variant
, passed to serialize_tuple_variant_elt
, and consumed by serialize_tuple_variant_end
. Use ()
if no state is required. Read more
type MapState = ()
A state object that is initialized by serialize_map
, passed to serialize_map_elt
, and consumed by serialize_map_end
. Use ()
if no state is required. Read more
type StructState = ()
A state object that is initialized by serialize_struct
, passed to serialize_struct_elt
, and consumed by serialize_struct_end
. Use ()
if no state is required. Read more
type StructVariantState = ()
A state object that is initialized by serialize_struct_variant
, passed to serialize_struct_variant_elt
, and consumed by serialize_struct_variant_end
. Use ()
if no state is required. Read more
fn serialize_unit(&mut self) -> Result<(), Error>
Serializes a ()
value. It's reasonable to just not serialize anything.
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. If the format does not differentiate between u8
and u64
, a reasonable implementation would be to cast the value to u64
and forward to serialize_u64
. Read more
fn serialize_u16(&mut self, val: u16) -> Result<(), Error>
Serializes a u16
value. If the format does not differentiate between u16
and u64
, a reasonable implementation would be to cast the value to u64
and forward to serialize_u64
. Read more
fn serialize_u32(&mut self, val: u32) -> Result<(), Error>
Serializes a u32
value. If the format does not differentiate between u32
and u64
, a reasonable implementation would be to cast the value to u64
and forward to serialize_u64
. 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. If the format does not differentiate between usize
and u64
, a reasonable implementation would be to cast the value to u64
and forward to serialize_u64
. Read more
fn serialize_i8(&mut self, val: i8) -> Result<(), Error>
Serializes an i8
value. If the format does not differentiate between i8
and i64
, a reasonable implementation would be to cast the value to i64
and forward to serialize_i64
. Read more
fn serialize_i16(&mut self, val: i16) -> Result<(), Error>
Serializes an i16
value. If the format does not differentiate between i16
and i64
, a reasonable implementation would be to cast the value to i64
and forward to serialize_i64
. Read more
fn serialize_i32(&mut self, val: i32) -> Result<(), Error>
Serializes an i32
value. If the format does not differentiate between i32
and i64
, a reasonable implementation would be to cast the value to i64
and forward to serialize_i64
. Read more
fn serialize_i64(&mut self, val: i64) -> Result<(), Error>
Serializes an i64
value.
fn serialize_isize(&mut self, val: isize) -> Result<(), Error>
Serializes an isize
value. If the format does not differentiate between isize
and i64
, a reasonable implementation would be to cast the value to i64
and forward to serialize_i64
. Read more
fn serialize_f32(&mut self, val: f32) -> Result<(), Error>
Serializes an f32
value. If the format does not differentiate between f32
and f64
, a reasonable implementation would be to cast the value to f64
and forward to serialize_f64
. Read more
fn serialize_f64(&mut self, val: f64) -> Result<(), Error>
Serializes an f64
value.
fn serialize_char(&mut self, val: char) -> Result<(), Error>
Serializes a character. If the format does not support characters, it is reasonable to serialize it as a single element str
or a u32
. 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>
_name: &str,
variant_index: usize,
_variant: &str)
-> Result<(), Error>
Serializes a unit variant, otherwise known as a variant with no arguments. A reasonable implementation would be to forward to serialize_unit
. Read more
fn serialize_tuple_variant(&mut self,
name: &'static str,
id: usize,
_variant: &'static str,
len: usize)
-> Result<Self::TupleVariantState, Error>
name: &'static str,
id: usize,
_variant: &'static str,
len: usize)
-> Result<Self::TupleVariantState, Error>
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_tuple_variant_elt<T>(&mut self,
state: &mut Self::TupleVariantState,
value: T)
-> Result<(), Self::Error> where T: Serialize
state: &mut Self::TupleVariantState,
value: T)
-> Result<(), Self::Error> where T: Serialize
Serializes a tuple variant element. Must have previously called serialize_tuple_variant
. Read more
fn serialize_tuple_variant_end(&mut self,
state: Self::TupleVariantState)
-> Result<(), Self::Error>
state: Self::TupleVariantState)
-> Result<(), Self::Error>
Finishes serializing a tuple variant.
fn serialize_none(&mut self) -> Result<(), Error>
Serializes a None
value.
fn serialize_some<V>(&mut self, v: V) -> Result<(), Error> where V: Serialize
Serializes a Some(...)
value.
fn serialize_seq(&mut self,
length: Option<usize>)
-> Result<Self::SeqState, Error>
length: Option<usize>)
-> Result<Self::SeqState, Error>
Begins to serialize a sequence. This call must be followed by zero or more calls to serialize_seq_elt
, then a call to serialize_seq_end
. Read more
fn serialize_seq_elt<V>(&mut self,
_state: &mut Self::SeqState,
value: V)
-> Result<Self::SeqState, Error> where V: Serialize
_state: &mut Self::SeqState,
value: V)
-> Result<Self::SeqState, Error> where V: Serialize
Serializes a sequence element. Must have previously called serialize_seq
. Read more
fn serialize_seq_end(&mut self,
_state: Self::SeqState)
-> Result<(), Self::Error>
_state: Self::SeqState)
-> Result<(), Self::Error>
Finishes serializing a sequence.
fn serialize_seq_fixed_size(&mut self,
size: usize)
-> Result<Self::SeqState, Self::Error>
size: usize)
-> Result<Self::SeqState, Self::Error>
Begins to serialize a sequence whose length will be known at deserialization time. This call must be followed by zero or more calls to serialize_seq_elt
, then a call to serialize_seq_end
. A reasonable implementation would be to forward to serialize_seq
. Read more
fn serialize_map(&mut self,
length: Option<usize>)
-> Result<Self::MapState, Error>
length: Option<usize>)
-> Result<Self::MapState, Error>
Begins to serialize a map. This call must be followed by zero or more calls to serialize_map_key
and serialize_map_value
, then a call to serialize_map_end
. Read more
fn serialize_map_key<T>(&mut self,
_state: &mut Self::MapState,
key: T)
-> Result<(), Self::Error> where T: Serialize
_state: &mut Self::MapState,
key: T)
-> Result<(), Self::Error> where T: Serialize
Serialize a map key. Must have previously called serialize_map
.
fn serialize_map_value<T>(&mut self,
_state: &mut Self::MapState,
value: T)
-> Result<(), Self::Error> where T: Serialize
_state: &mut Self::MapState,
value: T)
-> Result<(), Self::Error> where T: Serialize
Serialize a map value. Must have previously called serialize_map
.
fn serialize_map_end(&mut self,
_state: Self::MapState)
-> Result<(), Self::Error>
_state: Self::MapState)
-> Result<(), Self::Error>
Finishes serializing a map.
fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Error>
Serializes a unit struct value. A reasonable implementation would be to forward to serialize_unit
. Read more
fn serialize_tuple(&mut self,
len: usize)
-> Result<Self::TupleState, Self::Error>
len: usize)
-> Result<Self::TupleState, Self::Error>
Begins to serialize a tuple. This call must be followed by zero or more calls to serialize_tuple_elt
, then a call to serialize_tuple_end
. A reasonable implementation would be to forward to serialize_seq
. Read more
fn serialize_tuple_elt<T>(&mut self,
state: &mut Self::TupleState,
value: T)
-> Result<(), Self::Error> where T: Serialize
state: &mut Self::TupleState,
value: T)
-> Result<(), Self::Error> where T: Serialize
Serializes a tuple element. Must have previously called serialize_tuple
. Read more
fn serialize_tuple_end(&mut self,
state: Self::TupleState)
-> Result<(), Self::Error>
state: Self::TupleState)
-> Result<(), Self::Error>
Finishes serializing a tuple.
fn serialize_tuple_struct(&mut self,
_name: &'static str,
len: usize)
-> Result<Self::TupleStructState, Self::Error>
_name: &'static str,
len: usize)
-> Result<Self::TupleStructState, Self::Error>
Begins to serialize a tuple struct. This call must be followed by zero or more calls to serialize_tuple_struct_elt
, then a call to serialize_tuple_struct_end
. A reasonable implementation would be to forward to serialize_tuple
. Read more
fn serialize_tuple_struct_elt<T>(&mut self,
state: &mut Self::TupleStructState,
value: T)
-> Result<(), Self::Error> where T: Serialize
state: &mut Self::TupleStructState,
value: T)
-> Result<(), Self::Error> where T: Serialize
Serializes a tuple struct element. Must have previously called serialize_tuple_struct
. Read more
fn serialize_tuple_struct_end(&mut self,
state: Self::TupleStructState)
-> Result<(), Self::Error>
state: Self::TupleStructState)
-> Result<(), Self::Error>
Finishes serializing a tuple struct.
fn serialize_newtype_struct<T>(&mut self,
name: &'static str,
value: T)
-> Result<(), Self::Error> where T: Serialize
name: &'static str,
value: T)
-> Result<(), Self::Error> where T: Serialize
Allows a tuple struct with a single element, also known as a newtype struct, to be more efficiently serialized than a tuple struct with multiple items. A reasonable implementation would be to forward to serialize_tuple_struct
or to just serialize the inner value without wrapping. 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
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. A reasonable implementation would be to forward to serialize_tuple_variant
. Read more
fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Error>
Enables serializers to serialize byte slices more compactly or more efficiently than other types of slices. If no efficient implementation is available, a reasonable implementation would be to forward to serialize_seq
. If forwarded, the implementation looks usually just like this: rust let mut state = try!(self.serialize_seq(value)); for b in value { try!(self.serialize_seq_elt(&mut state, b)); } self.serialize_seq_end(state)
Read more
fn serialize_struct(&mut self,
_name: &'static str,
len: usize)
-> Result<Self::StructState, Self::Error>
_name: &'static str,
len: usize)
-> Result<Self::StructState, Self::Error>
Begins to serialize a struct. This call must be followed by zero or more
calls to serialize_struct_elt
, then a call to serialize_struct_end
.
fn serialize_struct_elt<V>(&mut self,
_state: &mut Self::StructState,
key: &'static str,
value: V)
-> Result<(), Self::Error> where V: Serialize
_state: &mut Self::StructState,
key: &'static str,
value: V)
-> Result<(), Self::Error> where V: Serialize
Serializes a struct field. Must have previously called
serialize_struct
.
fn serialize_struct_end(&mut self,
_state: Self::StructState)
-> Result<(), Error>
_state: Self::StructState)
-> Result<(), Error>
Finishes serializing a struct.
fn serialize_struct_variant(&mut self,
name: &'static str,
id: usize,
_variant: &'static str,
len: usize)
-> Result<Self::StructVariantState, Error>
name: &'static str,
id: usize,
_variant: &'static str,
len: usize)
-> Result<Self::StructVariantState, Error>
Begins to serialize a struct variant.
This call must be followed by zero or more calls to serialize_struct_variant_elt()
, then
a call to serialize_struct_variant_end()
.
fn serialize_struct_variant_elt<V>(&mut self,
state: &mut Self::StructVariantState,
key: &'static str,
value: V)
-> Result<(), Self::Error> where V: Serialize
state: &mut Self::StructVariantState,
key: &'static str,
value: V)
-> Result<(), Self::Error> where V: Serialize
Serialize a struct variant element.
Must have previously called serialize_struct_variant()
.
fn serialize_struct_variant_end(&mut self,
state: Self::StructVariantState)
-> Result<(), Self::Error>
state: Self::StructVariantState)
-> Result<(), Self::Error>
Finishes serializing a struct variant.