Struct otter_api_tests::imports::rmp_serde::encode::Serializer

pub struct Serializer<W, C = DefaultConfig> { /* 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 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, C> Serializer<W, C> where
    W: Write, 

pub fn get_ref(&self) -> &W

Gets a reference to the underlying writer.

pub 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.

pub fn into_inner(self) -> W

Unwraps this Serializer, returning the underlying writer.

impl<W> Serializer<W, DefaultConfig> where
    W: Write, 

pub fn new(wr: W) -> Serializer<W, DefaultConfig>

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, C> Serializer<W, C> where
    W: Write, 

pub fn with_struct_map(self) -> Serializer<W, StructMapConfig<C>>

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

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

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

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

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

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, C> Debug for Serializer<W, C> where
    C: Debug,
    W: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a, W, C> Serializer for &'a mut Serializer<W, C> where
    C: SerializerConfig,
    W: Write, 

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 = MaybeUnknownLengthCompound<'a, W, C>

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

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

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

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

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

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

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

type SerializeMap = MaybeUnknownLengthCompound<'a, W, C>

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

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

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

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

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

pub fn is_human_readable(&self) -> bool

Determine whether Serialize implementations should serialize in human-readable form.

pub fn serialize_bool(
    self,
    v: bool
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a bool value.

pub fn serialize_i8(
    self,
    v: i8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize an i8 value.

pub fn serialize_i16(
    self,
    v: i16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize an i16 value.

pub fn serialize_i32(
    self,
    v: i32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize an i32 value.

pub fn serialize_i64(
    self,
    v: i64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize an i64 value.

pub fn serialize_u8(
    self,
    v: u8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a u8 value.

pub fn serialize_u16(
    self,
    v: u16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a u16 value.

pub fn serialize_u32(
    self,
    v: u32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a u32 value.

pub fn serialize_u64(
    self,
    v: u64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a u64 value.

pub fn serialize_f32(
    self,
    v: f32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize an f32 value.

pub fn serialize_f64(
    self,
    v: f64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize an f64 value.

pub fn serialize_char(
    self,
    v: char
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a character.

pub fn serialize_str(
    self,
    v: &str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a &str.

pub fn serialize_bytes(
    self,
    value: &[u8]
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a chunk of raw byte data.

pub fn serialize_none(
    self
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a None value.

pub fn serialize_some<T>(
    self,
    v: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error> where
    T: Serialize + ?Sized, 

Serialize a Some(T) value.

pub fn serialize_unit(
    self
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

Serialize a () value.

pub fn serialize_unit_struct(
    self,
    _name: &'static str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

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

pub fn serialize_unit_variant(
    self,
    _name: &str,
    idx: u32,
    variant: &'static str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>

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

pub fn serialize_newtype_struct<T>(
    self,
    name: &'static str,
    value: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error> where
    T: Serialize + ?Sized, 

Serialize a newtype struct like struct Millimeters(u8).

pub fn serialize_newtype_variant<T>(
    self,
    _name: &'static str,
    idx: u32,
    variant: &'static str,
    value: &T
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error> where
    T: Serialize + ?Sized, 

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

pub fn serialize_seq(
    self,
    len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::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.

pub fn serialize_tuple(
    self,
    len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTuple, <&'a mut Serializer<W, C> as Serializer>::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.

pub fn serialize_tuple_struct(
    self,
    _name: &'static str,
    len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTupleStruct, <&'a mut Serializer<W, C> as Serializer>::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.

pub fn serialize_tuple_variant(
    self,
    _name: &'static str,
    idx: u32,
    variant: &'static str,
    len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::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.

pub fn serialize_map(
    self,
    len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::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.

pub fn serialize_struct(
    self,
    _name: &'static str,
    len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeStruct, <&'a mut Serializer<W, C> as Serializer>::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.

pub fn serialize_struct_variant(
    self,
    name: &'static str,
    id: u32,
    variant: &'static str,
    len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::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.

pub fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>

Serialize an i128 value.

pub fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>

Serialize a u128 value.

pub 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.

pub fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
    K: Serialize,
    V: Serialize,
    I: IntoIterator<Item = (K, V)>, 

Collect an iterator as a map.

pub 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.

impl<W, C> UnderlyingWrite for Serializer<W, C> where
    W: Write, 

type Write = W

Underlying writer type.

pub fn get_ref(&self) -> &<Serializer<W, C> as UnderlyingWrite>::Write

Gets a reference to the underlying writer.

pub fn get_mut(&mut self) -> &mut <Serializer<W, C> as UnderlyingWrite>::Write

Gets a mutable reference to the underlying writer.

pub fn into_inner(self) -> <Serializer<W, C> as UnderlyingWrite>::Write

Unwraps this Serializer, returning the underlying writer.