[][src]Struct 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: 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 you 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 you 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.

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]

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

impl<W: Write, C> UnderlyingWrite for Serializer<W, C>[src]

type Write = W

Underlying writer type.

Auto Trait Implementations

impl<W, C> RefUnwindSafe for Serializer<W, C> where
    C: RefUnwindSafe,
    W: RefUnwindSafe

impl<W, C> Send for Serializer<W, C> where
    C: Send,
    W: Send

impl<W, C> Sync for Serializer<W, C> where
    C: Sync,
    W: Sync

impl<W, C> Unpin for Serializer<W, C> where
    C: Unpin,
    W: Unpin

impl<W, C> UnwindSafe for Serializer<W, C> where
    C: UnwindSafe,
    W: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.