Module miniserde::ser

Serialization traits.

Serialization in miniserde works by traversing an input object and decomposing it iteratively into a stream of fragments.

Serializing a primitive

use miniserde::ser::{Fragment, Serialize};

// The data structure that we want to serialize as a primitive.
struct MyBoolean(bool);

impl Serialize for MyBoolean {
    fn begin(&self) -> Fragment {
        Fragment::Bool(self.0)
    }
}

Serializing a sequence

use miniserde::ser::{Fragment, Seq, Serialize};

// Some custom sequence type that we want to serialize.
struct MyVec<T>(Vec<T>);

impl<T: Serialize> Serialize for MyVec<T> {
    fn begin(&self) -> Fragment {
        Fragment::Seq(Box::new(SliceStream { iter: self.0.iter() }))
    }
}

struct SliceStream<'a, T: 'a> {
    iter: std::slice::Iter<'a, T>,
}

impl<'a, T: Serialize> Seq for SliceStream<'a, T> {
    fn next(&mut self) -> Option<&Serialize> {
        let element = self.iter.next()?;
        Some(element)
    }
}

Serializing a map or struct

This code demonstrates what is generated for structs by #[derive(MiniSerialize)].

use miniserde::ser::{Fragment, Map, Serialize};
use std::borrow::Cow;

// The struct that we would like to serialize.
struct Demo {
    code: u32,
    message: String,
}

impl Serialize for Demo {
    fn begin(&self) -> Fragment {
        Fragment::Map(Box::new(DemoStream {
            data: self,
            state: 0,
        }))
    }
}

struct DemoStream<'a> {
    data: &'a Demo,
    state: usize,
}

impl<'a> Map for DemoStream<'a> {
    fn next(&mut self) -> Option<(Cow<str>, &Serialize)> {
        let state = self.state;
        self.state += 1;
        match state {
            0 => Some((Cow::Borrowed("code"), &self.data.code)),
            1 => Some((Cow::Borrowed("message"), &self.data.message)),
            _ => None,
        }
    }
}

Enums

Fragment

One unit of output produced during serialization.

Traits

Map	Trait that can iterate key-value entries of a map or struct.
Seq	Trait that can iterate elements of a sequence.
Serialize	Trait for data structures that can be serialized to a JSON string.