Enum Emit 

pub enum Emit<'a> {
    Atom(Atom<'a>),
    Struct(Boxed<dyn StructEmitter + 'a>),
    Map(Boxed<dyn MapEmitter + 'a>),
    Seq(Boxed<dyn SeqEmitter + 'a>),
    Forward(SerializeHandle<'a>),
}

Describes how a value is emitted, returned by Serialize::serialize.

A value is either emitted as an atom, by a stateful emitter or by forwarding to another value. For instance Emit::Atom(Atom::Bool(true)) is emitted to a serializer directly. On the other hand an Emit::Map contains a stateful emitter that keeps yielding values until it’s done walking over the map.

The emitters are typically allocated in the arena of the state with Emit::seq, Emit::map and Emit::structure (see Boxed). They are the serialization equivalent of the Sinks of deserialization: they hold the state of a value that is being serialized.

Variants

Atom(Atom<'a>)

Struct(Boxed<dyn StructEmitter + 'a>)

Map(Boxed<dyn MapEmitter + 'a>)

Seq(Boxed<dyn SeqEmitter + 'a>)

Forward(SerializeHandle<'a>)

Serializes another value in place of this one.

The driver serializes the value in the handle as if it was produced instead of the value that returned the Emit. This is useful to serialize a value by converting it into another value first as the handle can own that value:

use deser::ser::{Emit, Serialize, SerializeHandle};
use deser::{Error, State};

struct Point(u32, u32);

impl Serialize for Point {
    fn serialize<'a>(value: &'a Self, state: &mut State) -> Result<Emit<'a>, Error> {
        // serialize as a vector
        Ok(Emit::Forward(SerializeHandle::arena(
            vec![value.0, value.1],
            state,
        )))
    }
}

The container_shape of the value that returned the Emit is not used, the forwarded value provides its own. finish is invoked on the forwarded value first and then on the value that returned the Emit.

Values that forward cannot be flattened into structs.

Implementations

impl<'a> Emit<'a>

pub fn seq<E: SeqEmitter + 'a>(emitter: E, state: &mut State) -> Emit<'a>

Emits a sequence with an emitter in the arena of the serialization.

pub fn map<E: MapEmitter + 'a>(emitter: E, state: &mut State) -> Emit<'a>

Emits a map with an emitter in the arena of the state.

pub fn structure<E: StructEmitter + 'a>( emitter: E, state: &mut State, ) -> Emit<'a>

Emits a struct with an emitter in the arena of the serialization.

Trait Implementations

impl<'a> From<&'a [u8]> for Emit<'a>

fn from(value: &'a [u8]) -> Emit<'a>

Converts to this type from the input type.

impl<'a> From<&'a str> for Emit<'a>

fn from(value: &'a str) -> Emit<'a>

Converts to this type from the input type.

impl From<()> for Emit<'static>

fn from(_: ()) -> Emit<'static>

Converts to this type from the input type.

impl<'a> From<Atom<'a>> for Emit<'a>

fn from(atom: Atom<'a>) -> Self

Converts to this type from the input type.

impl From<String> for Emit<'static>

fn from(value: String) -> Emit<'static>

Converts to this type from the input type.

impl From<bool> for Emit<'static>

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<char> for Emit<'static>

fn from(value: char) -> Self

Converts to this type from the input type.

impl From<f32> for Emit<'static>

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Emit<'static>

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i64> for Emit<'static>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<isize> for Emit<'static>

fn from(value: isize) -> Self

Converts to this type from the input type.

impl From<u64> for Emit<'static>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<usize> for Emit<'static>

fn from(value: usize) -> Self

Converts to this type from the input type.