[−][src]Struct rmp_serde::encode::Serializer
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 choice may be not ideal for you.
An enum value is represented as a single-entry map whose key is the variant id and whose value is a sequence containing all associated data. If the enum does not have associated data, the sequence is empty.
All instances of ErrorKind::Interrupted
are handled by this function and the underlying
operation is retried.
Implementations
impl<W: Write, C> Serializer<W, C>
[src]
pub fn get_ref(&self) -> &W
[src]
Gets a reference to the underlying writer.
pub fn get_mut(&mut self) -> &mut W
[src]
Gets a mutable reference to the underlying writer.
It is inadvisable to directly write to the underlying writer.
pub fn into_inner(self) -> W
[src]
Unwraps this Serializer
, returning the underlying writer.
impl<W: Write> Serializer<W, DefaultConfig>
[src]
pub fn new(wr: W) -> Self
[src]
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 and enums using the most compact representation.
impl<W: Write, C> Serializer<W, C>
[src]
pub fn with_struct_map(self) -> Serializer<W, StructMapConfig<C>>
[src]
Consumes this serializer returning the new one, which will serialize structs as a map.
This is used, when the default struct serialization as a tuple does not fit your requirements.
pub fn with_struct_tuple(self) -> Serializer<W, StructTupleConfig<C>>
[src]
Consumes this serializer returning the new one, which will serialize structs as a tuple without field names.
This is the default MessagePack serialization mechanism, emitting the most compact representation.
pub fn with_string_variants(self) -> Serializer<W, VariantStringConfig<C>>
[src]
Consumes this serializer returning the new one, which will serialize enum variants as strings.
This is used, when the default struct serialization as integers does not fit your requirements.
pub fn with_integer_variants(self) -> Serializer<W, VariantIntegerConfig<C>>
[src]
Consumes this serializer returning the new one, which will serialize enum variants as a their integer indices.
This is the default MessagePack serialization mechanism, emitting the most compact representation.
pub fn with_human_readable(self) -> Serializer<W, HumanReadableConfig<C>>
[src]
Consumes this serializer returning the new one, which will serialize some types in
human-readable representations (Serializer::is_human_readable
will return true
). Note
that the overall representation is still binary, but some types such as IP addresses will
be saved as human-readable strings.
This is primarily useful if you need to interoperate with serializations produced by older
versions of rmp-serde
.
pub fn with_binary(self) -> Serializer<W, BinaryConfig<C>>
[src]
Consumes this serializer returning the new one, which will serialize types as binary
(Serializer::is_human_readable
will return false
).
This is the default MessagePack serialization mechanism, emitting the most compact representation.
Trait Implementations
impl<W: Debug, C: Debug> Debug for Serializer<W, C>
[src]
impl<'a, W, C> Serializer for &'a mut Serializer<W, C> where
W: Write,
C: SerializerConfig,
[src]
W: Write,
C: SerializerConfig,
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. Read more
type Error = Error
The error type when some error occurs during serialization.
type SerializeSeq = Compound<'a, W, C>
Type returned from serialize_seq
for serializing the content of the
sequence. Read more
type SerializeTuple = Compound<'a, W, C>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = Compound<'a, W, C>
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = Compound<'a, W, C>
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = Compound<'a, W, C>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = Compound<'a, W, C>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = Compound<'a, W, C>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
pub fn is_human_readable(&self) -> bool
[src]
pub fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_none(self) -> Result<(), Self::Error>
[src]
pub fn serialize_some<T: ?Sized + Serialize>(
self,
v: &T
) -> Result<(), Self::Error>
[src]
self,
v: &T
) -> Result<(), Self::Error>
pub fn serialize_unit(self) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_unit_struct(
self,
_name: &'static str
) -> Result<Self::Ok, Self::Error>
[src]
self,
_name: &'static str
) -> Result<Self::Ok, Self::Error>
pub fn serialize_unit_variant(
self,
_name: &str,
idx: u32,
variant: &'static str
) -> Result<Self::Ok, Self::Error>
[src]
self,
_name: &str,
idx: u32,
variant: &'static str
) -> Result<Self::Ok, Self::Error>
pub fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
name: &'static str,
value: &T
) -> Result<(), Self::Error>
[src]
self,
name: &'static str,
value: &T
) -> Result<(), Self::Error>
pub fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
_name: &'static str,
idx: u32,
variant: &'static str,
value: &T
) -> Result<Self::Ok, Self::Error>
[src]
self,
_name: &'static str,
idx: u32,
variant: &'static str,
value: &T
) -> Result<Self::Ok, Self::Error>
pub fn serialize_seq(
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Error>
[src]
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Error>
pub fn serialize_tuple(
self,
len: usize
) -> Result<Self::SerializeTuple, Self::Error>
[src]
self,
len: usize
) -> Result<Self::SerializeTuple, Self::Error>
pub fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>
[src]
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>
pub fn serialize_tuple_variant(
self,
_name: &'static str,
idx: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Error>
[src]
self,
_name: &'static str,
idx: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Error>
pub fn serialize_map(
self,
len: Option<usize>
) -> Result<Self::SerializeMap, Error>
[src]
self,
len: Option<usize>
) -> Result<Self::SerializeMap, Error>
pub fn serialize_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeStruct, Self::Error>
[src]
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeStruct, Self::Error>
pub fn serialize_struct_variant(
self,
name: &'static str,
id: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeStructVariant, Error>
[src]
self,
name: &'static str,
id: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeStructVariant, Error>
pub fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>
[src]
pub fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>
[src]
pub fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
[src]
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
pub fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator<Item = (K, V)>,
K: Serialize,
V: Serialize,
[src]
I: IntoIterator<Item = (K, V)>,
K: Serialize,
V: Serialize,
pub fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<W: Write, C> UnderlyingWrite for Serializer<W, C>
[src]
Auto Trait Implementations
impl<W, C> RefUnwindSafe for Serializer<W, C> where
C: RefUnwindSafe,
W: RefUnwindSafe,
C: RefUnwindSafe,
W: RefUnwindSafe,
impl<W, C> Send for Serializer<W, C> where
C: Send,
W: Send,
C: Send,
W: Send,
impl<W, C> Sync for Serializer<W, C> where
C: Sync,
W: Sync,
C: Sync,
W: Sync,
impl<W, C> Unpin for Serializer<W, C> where
C: Unpin,
W: Unpin,
C: Unpin,
W: Unpin,
impl<W, C> UnwindSafe for Serializer<W, C> where
C: UnwindSafe,
W: UnwindSafe,
C: UnwindSafe,
W: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,