mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-04-23 00:08:01 +00:00
Thomas Bahn
522 lines
12 KiB
Rust
522 lines
12 KiB
Rust
use std::collections::BTreeMap;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
pub trait Serialize {
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E>;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
pub trait Serializer<S, R, E> {
|
|
fn visit<
|
|
T: Serialize,
|
|
>(&mut self, value: &T) -> Result<R, E>;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
pub trait Visitor<S, R, E> {
|
|
fn visit_null(&self, state: &mut S) -> Result<R, E>;
|
|
|
|
fn visit_bool(&self, state: &mut S, v: bool) -> Result<R, E>;
|
|
|
|
#[inline]
|
|
fn visit_int(&self, state: &mut S, v: int) -> Result<R, E> {
|
|
self.visit_i64(state, v as i64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_i8(&self, state: &mut S, v: i8) -> Result<R, E> {
|
|
self.visit_i64(state, v as i64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_i16(&self, state: &mut S, v: i16) -> Result<R, E> {
|
|
self.visit_i64(state, v as i64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_i32(&self, state: &mut S, v: i32) -> Result<R, E> {
|
|
self.visit_i64(state, v as i64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_i64(&self, state: &mut S, v: i64) -> Result<R, E>;
|
|
|
|
#[inline]
|
|
fn visit_uint(&self, state: &mut S, v: uint) -> Result<R, E> {
|
|
self.visit_u64(state, v as u64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_u8(&self, state: &mut S, v: u8) -> Result<R, E> {
|
|
self.visit_u64(state, v as u64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_u16(&self, state: &mut S, v: u16) -> Result<R, E> {
|
|
self.visit_u64(state, v as u64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_u32(&self, state: &mut S, v: u32) -> Result<R, E> {
|
|
self.visit_u64(state, v as u64)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_u64(&self, state: &mut S, v: u64) -> Result<R, E>;
|
|
|
|
#[inline]
|
|
fn visit_f32(&self, state: &mut S, v: f32) -> Result<R, E> {
|
|
self.visit_f64(state, v as f64)
|
|
}
|
|
|
|
fn visit_f64(&self, state: &mut S, v: f64) -> Result<R, E>;
|
|
|
|
fn visit_char(&self, state: &mut S, value: char) -> Result<R, E>;
|
|
|
|
fn visit_str(&self, state: &mut S, value: &str) -> Result<R, E>;
|
|
|
|
fn visit_seq<
|
|
V: SeqVisitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E>;
|
|
|
|
#[inline]
|
|
fn visit_named_seq<
|
|
V: SeqVisitor<S, R, E>,
|
|
>(&self, state: &mut S, _name: &'static str, visitor: V) -> Result<R, E> {
|
|
self.visit_seq(state, visitor)
|
|
}
|
|
|
|
#[inline]
|
|
fn visit_enum<
|
|
V: SeqVisitor<S, R, E>,
|
|
>(&self, state: &mut S, _name: &'static str, _variant: &'static str, visitor: V) -> Result<R, E> {
|
|
self.visit_seq(state, visitor)
|
|
}
|
|
|
|
fn visit_seq_elt<
|
|
T: Serialize,
|
|
>(&self, state: &mut S, first: bool, value: T) -> Result<R, E>;
|
|
|
|
fn visit_map<
|
|
V: MapVisitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E>;
|
|
|
|
#[inline]
|
|
fn visit_named_map<
|
|
V: MapVisitor<S, R, E>,
|
|
>(&self, state: &mut S, _name: &'static str, visitor: V) -> Result<R, E> {
|
|
self.visit_map(state, visitor)
|
|
}
|
|
|
|
fn visit_map_elt<
|
|
K: Serialize,
|
|
V: Serialize,
|
|
>(&self, state: &mut S, first: bool, key: K, value: V) -> Result<R, E>;
|
|
}
|
|
|
|
pub trait SeqVisitor<S, R, E> {
|
|
fn visit<
|
|
V: Visitor<S, R, E>,
|
|
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E>;
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> (uint, Option<uint>) {
|
|
(0, None)
|
|
}
|
|
}
|
|
|
|
pub trait MapVisitor<S, R, E> {
|
|
fn visit<
|
|
V: Visitor<S, R, E>,
|
|
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E>;
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> (uint, Option<uint>) {
|
|
(0, None)
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
impl Serialize for () {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
visitor.visit_null(state)
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
macro_rules! impl_visit {
|
|
($ty:ty, $method:ident) => {
|
|
impl Serialize for $ty {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
visitor.$method(state, *self)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit!(bool, visit_bool);
|
|
impl_visit!(int, visit_int);
|
|
impl_visit!(i8, visit_i8);
|
|
impl_visit!(i16, visit_i16);
|
|
impl_visit!(i32, visit_i32);
|
|
impl_visit!(i64, visit_i64);
|
|
impl_visit!(uint, visit_uint);
|
|
impl_visit!(u8, visit_u8);
|
|
impl_visit!(u16, visit_u16);
|
|
impl_visit!(u32, visit_u32);
|
|
impl_visit!(u64, visit_u64);
|
|
impl_visit!(f32, visit_f32);
|
|
impl_visit!(f64, visit_f64);
|
|
impl_visit!(char, visit_char);
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
impl<'a> Serialize for &'a str {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
visitor.visit_str(state, *self)
|
|
}
|
|
}
|
|
|
|
impl Serialize for String {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
visitor.visit_str(state, self.as_slice())
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
pub struct SeqIteratorVisitor<Iter> {
|
|
iter: Iter,
|
|
first: bool,
|
|
}
|
|
|
|
impl<T, Iter: Iterator<T>> SeqIteratorVisitor<Iter> {
|
|
#[inline]
|
|
pub fn new(iter: Iter) -> SeqIteratorVisitor<Iter> {
|
|
SeqIteratorVisitor {
|
|
iter: iter,
|
|
first: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<
|
|
T: Serialize,
|
|
Iter: Iterator<T>,
|
|
S,
|
|
R,
|
|
E,
|
|
> SeqVisitor<S, R, E> for SeqIteratorVisitor<Iter> {
|
|
#[inline]
|
|
fn visit<
|
|
V: Visitor<S, R, E>,
|
|
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E> {
|
|
let first = self.first;
|
|
self.first = false;
|
|
|
|
match self.iter.next() {
|
|
Some(value) => {
|
|
let value = try!(visitor.visit_seq_elt(state, first, value));
|
|
Ok(Some(value))
|
|
}
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> (uint, Option<uint>) {
|
|
self.iter.size_hint()
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
impl<
|
|
T: Serialize,
|
|
> Serialize for Vec<T> {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
visitor.visit_seq(state, SeqIteratorVisitor::new(self.iter()))
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
macro_rules! tuple_impls {
|
|
($(
|
|
($($T:ident),+) {
|
|
$($state:pat => $method:ident,)+
|
|
}
|
|
)+) => {
|
|
$(
|
|
impl<
|
|
$($T: Serialize),+
|
|
> Serialize for ($($T,)+) {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
struct Visitor<'a, $($T: 'a),+> {
|
|
state: uint,
|
|
tuple: &'a ($($T,)+),
|
|
}
|
|
|
|
impl<
|
|
'a,
|
|
S,
|
|
R,
|
|
E,
|
|
$($T: Serialize),+
|
|
> SeqVisitor<S, R, E> for Visitor<'a, $($T),+> {
|
|
fn visit<
|
|
V: self::Visitor<S, R, E>,
|
|
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E> {
|
|
match self.state {
|
|
$(
|
|
$state => {
|
|
self.state += 1;
|
|
let value = self.tuple.$method();
|
|
let value = try!(visitor.visit_seq_elt(state, true, value));
|
|
Ok(Some(value))
|
|
}
|
|
)+
|
|
_ => {
|
|
Ok(None)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
visitor.visit_seq(state, Visitor {
|
|
state: 0,
|
|
tuple: self,
|
|
})
|
|
}
|
|
}
|
|
)+
|
|
}
|
|
}
|
|
|
|
tuple_impls! {
|
|
(T0) {
|
|
0 => ref0,
|
|
}
|
|
(T0, T1) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
}
|
|
(T0, T1, T2, T3) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
}
|
|
(T0, T1, T2, T3, T4) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
}
|
|
(T0, T1, T2, T3, T4, T5) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
5 => ref5,
|
|
}
|
|
(T0, T1, T2, T3, T4, T5, T6) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
5 => ref5,
|
|
6 => ref6,
|
|
}
|
|
(T0, T1, T2, T3, T4, T5, T6, T7) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
5 => ref5,
|
|
6 => ref6,
|
|
7 => ref7,
|
|
}
|
|
(T0, T1, T2, T3, T4, T5, T6, T7, T8) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
5 => ref5,
|
|
6 => ref6,
|
|
7 => ref7,
|
|
8 => ref8,
|
|
}
|
|
(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
5 => ref5,
|
|
6 => ref6,
|
|
7 => ref7,
|
|
8 => ref8,
|
|
9 => ref9,
|
|
}
|
|
(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
5 => ref5,
|
|
6 => ref6,
|
|
7 => ref7,
|
|
8 => ref8,
|
|
9 => ref9,
|
|
10 => ref10,
|
|
}
|
|
(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {
|
|
0 => ref0,
|
|
1 => ref1,
|
|
2 => ref2,
|
|
3 => ref3,
|
|
4 => ref4,
|
|
5 => ref5,
|
|
6 => ref6,
|
|
7 => ref7,
|
|
8 => ref8,
|
|
9 => ref9,
|
|
10 => ref10,
|
|
11 => ref11,
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
pub struct MapIteratorVisitor<Iter> {
|
|
iter: Iter,
|
|
first: bool,
|
|
}
|
|
|
|
impl<K, V, Iter: Iterator<(K, V)>> MapIteratorVisitor<Iter> {
|
|
#[inline]
|
|
pub fn new(iter: Iter) -> MapIteratorVisitor<Iter> {
|
|
MapIteratorVisitor {
|
|
iter: iter,
|
|
first: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<
|
|
K: Serialize,
|
|
V: Serialize,
|
|
Iter: Iterator<(K, V)>,
|
|
S,
|
|
R,
|
|
E,
|
|
> MapVisitor<S, R, E> for MapIteratorVisitor<Iter> {
|
|
#[inline]
|
|
fn visit<
|
|
V: Visitor<S, R, E>,
|
|
>(&mut self, state: &mut S, visitor: V) -> Result<Option<R>, E> {
|
|
let first = self.first;
|
|
self.first = false;
|
|
|
|
match self.iter.next() {
|
|
Some((key, value)) => {
|
|
let value = try!(visitor.visit_map_elt(state, first, key, value));
|
|
Ok(Some(value))
|
|
}
|
|
None => Ok(None)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> (uint, Option<uint>) {
|
|
self.iter.size_hint()
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
impl<
|
|
K: Serialize + Ord,
|
|
V: Serialize,
|
|
> Serialize for BTreeMap<K, V> {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
visitor.visit_map(state, MapIteratorVisitor::new(self.iter()))
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
impl<
|
|
'a,
|
|
T: Serialize,
|
|
> Serialize for &'a T {
|
|
#[inline]
|
|
fn visit<
|
|
S,
|
|
R,
|
|
E,
|
|
V: Visitor<S, R, E>,
|
|
>(&self, state: &mut S, visitor: V) -> Result<R, E> {
|
|
(**self).visit(state, visitor)
|
|
}
|
|
}
|