Expand description
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<&dyn Serialize> {
let element = self.iter.next()?;
Some(element)
}
}
§Serializing a map or struct
This code demonstrates what is generated for structs by
#[derive(Serialize)]
.
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>, &dyn 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§
- One unit of output produced during serialization.
Traits§
- Trait that can iterate key-value entries of a map or struct.
- Trait that can iterate elements of a sequence.
- Trait for data structures that can be serialized to a JSON string.