mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-06-23 04:51:03 +00:00
Merge branch origin/master into origin/enum
Conflicts:
serde/src/de/mod.rs
serde_codegen/src/de.rs
testing/tests/test_bytes.rs
This commit is contained in:
David Tolnay
+3
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "serde"
|
||||
version = "0.8.4"
|
||||
version = "0.8.21"
|
||||
authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
|
||||
license = "MIT/Apache-2.0"
|
||||
description = "A generic serialization/deserialization framework"
|
||||
@@ -11,6 +11,8 @@ readme = "../README.md"
|
||||
keywords = ["serde", "serialization"]
|
||||
include = ["Cargo.toml", "src/**/*.rs"]
|
||||
|
||||
publish = false # this branch contains breaking changes for 0.9
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
|
||||
|
||||
+36
-24
@@ -19,6 +19,15 @@ pub struct Bytes<'a> {
|
||||
bytes: &'a [u8],
|
||||
}
|
||||
|
||||
impl<'a> Bytes<'a> {
|
||||
/// Wrap an existing `&[u8]`.
|
||||
pub fn new(bytes: &'a [u8]) -> Self {
|
||||
Bytes {
|
||||
bytes: bytes,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> fmt::Debug for Bytes<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
try!(f.write_str("b\""));
|
||||
@@ -31,18 +40,14 @@ impl<'a> fmt::Debug for Bytes<'a> {
|
||||
|
||||
impl<'a> From<&'a [u8]> for Bytes<'a> {
|
||||
fn from(bytes: &'a [u8]) -> Self {
|
||||
Bytes {
|
||||
bytes: bytes,
|
||||
}
|
||||
Bytes::new(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(feature = "std", feature = "collections"))]
|
||||
impl<'a> From<&'a Vec<u8>> for Bytes<'a> {
|
||||
fn from(bytes: &'a Vec<u8>) -> Self {
|
||||
Bytes {
|
||||
bytes: bytes,
|
||||
}
|
||||
Bytes::new(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -79,7 +84,7 @@ mod bytebuf {
|
||||
use de;
|
||||
|
||||
#[cfg(feature = "collections")]
|
||||
use collections::Vec;
|
||||
use collections::{String, Vec};
|
||||
|
||||
/// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
|
||||
#[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
|
||||
@@ -90,15 +95,18 @@ mod bytebuf {
|
||||
impl ByteBuf {
|
||||
/// Construct a new, empty `ByteBuf`.
|
||||
pub fn new() -> Self {
|
||||
ByteBuf {
|
||||
bytes: Vec::new(),
|
||||
}
|
||||
ByteBuf::from(Vec::new())
|
||||
}
|
||||
|
||||
/// Construct a new, empty `ByteBuf` with the specified capacity.
|
||||
pub fn with_capacity(cap: usize) -> Self {
|
||||
ByteBuf::from(Vec::with_capacity(cap))
|
||||
}
|
||||
|
||||
/// Wrap existing bytes in a `ByteBuf`.
|
||||
pub fn from<T: Into<Vec<u8>>>(bytes: T) -> Self {
|
||||
ByteBuf {
|
||||
bytes: Vec::with_capacity(cap)
|
||||
bytes: bytes.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -121,9 +129,7 @@ mod bytebuf {
|
||||
|
||||
impl From<Vec<u8>> for ByteBuf {
|
||||
fn from(bytes: Vec<u8>) -> Self {
|
||||
ByteBuf {
|
||||
bytes: bytes,
|
||||
}
|
||||
ByteBuf::from(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -179,9 +185,7 @@ mod bytebuf {
|
||||
fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
|
||||
where E: de::Error,
|
||||
{
|
||||
Ok(ByteBuf {
|
||||
bytes: Vec::new(),
|
||||
})
|
||||
Ok(ByteBuf::new())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@@ -197,25 +201,33 @@ mod bytebuf {
|
||||
|
||||
try!(visitor.end());
|
||||
|
||||
Ok(ByteBuf {
|
||||
bytes: values,
|
||||
})
|
||||
Ok(ByteBuf::from(values))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
|
||||
where E: de::Error,
|
||||
{
|
||||
self.visit_byte_buf(v.to_vec())
|
||||
Ok(ByteBuf::from(v))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
|
||||
where E: de::Error,
|
||||
{
|
||||
Ok(ByteBuf {
|
||||
bytes: v,
|
||||
})
|
||||
Ok(ByteBuf::from(v))
|
||||
}
|
||||
|
||||
fn visit_str<E>(&mut self, v: &str) -> Result<ByteBuf, E>
|
||||
where E: de::Error,
|
||||
{
|
||||
Ok(ByteBuf::from(v))
|
||||
}
|
||||
|
||||
fn visit_string<E>(&mut self, v: String) -> Result<ByteBuf, E>
|
||||
where E: de::Error,
|
||||
{
|
||||
Ok(ByteBuf::from(v))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+76
-99
@@ -282,6 +282,12 @@ impl Visitor for StringVisitor {
|
||||
Ok(v)
|
||||
}
|
||||
|
||||
fn visit_unit<E>(&mut self) -> Result<String, E>
|
||||
where E: Error,
|
||||
{
|
||||
Ok(String::new())
|
||||
}
|
||||
|
||||
fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<String, E>
|
||||
where E: Error,
|
||||
{
|
||||
@@ -511,27 +517,26 @@ seq_impl!(
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct ArrayVisitor0<T> {
|
||||
marker: PhantomData<T>,
|
||||
struct ArrayVisitor<A> {
|
||||
marker: PhantomData<A>,
|
||||
}
|
||||
|
||||
impl<T> ArrayVisitor0<T> {
|
||||
/// Construct a `ArrayVisitor0<T>`.
|
||||
impl<A> ArrayVisitor<A> {
|
||||
pub fn new() -> Self {
|
||||
ArrayVisitor0 {
|
||||
ArrayVisitor {
|
||||
marker: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Visitor for ArrayVisitor0<T> where T: Deserialize + Default {
|
||||
impl<T> Visitor for ArrayVisitor<[T; 0]> where T: Deserialize {
|
||||
type Value = [T; 0];
|
||||
|
||||
#[inline]
|
||||
fn visit_unit<E>(&mut self) -> Result<[T; 0], E>
|
||||
where E: Error,
|
||||
{
|
||||
Ok([T::default(); 0])
|
||||
Ok([])
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@@ -539,37 +544,24 @@ impl<T> Visitor for ArrayVisitor0<T> where T: Deserialize + Default {
|
||||
where V: SeqVisitor,
|
||||
{
|
||||
try!(visitor.end());
|
||||
Ok([T::default(); 0])
|
||||
Ok([])
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Deserialize for [T; 0]
|
||||
where T: Deserialize + Default
|
||||
where T: Deserialize
|
||||
{
|
||||
fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error>
|
||||
where D: Deserializer,
|
||||
{
|
||||
deserializer.deserialize_seq(ArrayVisitor0::new())
|
||||
deserializer.deserialize_seq_fixed_size(0, ArrayVisitor::<[T; 0]>::new())
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! array_impls {
|
||||
($($visitor:ident, $len:expr => ($($name:ident),+),)+) => {
|
||||
($($len:expr => ($($name:ident)+))+) => {
|
||||
$(
|
||||
struct $visitor<T> {
|
||||
marker: PhantomData<T>,
|
||||
}
|
||||
|
||||
impl<T> $visitor<T> {
|
||||
/// Construct a `ArrayVisitor*<T>`.
|
||||
pub fn new() -> Self {
|
||||
$visitor {
|
||||
marker: PhantomData
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Visitor for $visitor<T> where T: Deserialize {
|
||||
impl<T> Visitor for ArrayVisitor<[T; $len]> where T: Deserialize {
|
||||
type Value = [T; $len];
|
||||
|
||||
#[inline]
|
||||
@@ -579,13 +571,13 @@ macro_rules! array_impls {
|
||||
$(
|
||||
let $name = match try!(visitor.visit()) {
|
||||
Some(val) => val,
|
||||
None => { return Err(Error::end_of_stream()); }
|
||||
None => return Err(Error::end_of_stream()),
|
||||
};
|
||||
)+;
|
||||
)+
|
||||
|
||||
try!(visitor.end());
|
||||
|
||||
Ok([$($name,)+])
|
||||
Ok([$($name),+])
|
||||
}
|
||||
}
|
||||
|
||||
@@ -595,7 +587,7 @@ macro_rules! array_impls {
|
||||
fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
|
||||
where D: Deserializer,
|
||||
{
|
||||
deserializer.deserialize_seq_fixed_size($len, $visitor::new())
|
||||
deserializer.deserialize_seq_fixed_size($len, ArrayVisitor::<[T; $len]>::new())
|
||||
}
|
||||
}
|
||||
)+
|
||||
@@ -603,71 +595,58 @@ macro_rules! array_impls {
|
||||
}
|
||||
|
||||
array_impls! {
|
||||
ArrayVisitor1, 1 => (a),
|
||||
ArrayVisitor2, 2 => (a, b),
|
||||
ArrayVisitor3, 3 => (a, b, c),
|
||||
ArrayVisitor4, 4 => (a, b, c, d),
|
||||
ArrayVisitor5, 5 => (a, b, c, d, e),
|
||||
ArrayVisitor6, 6 => (a, b, c, d, e, f),
|
||||
ArrayVisitor7, 7 => (a, b, c, d, e, f, g),
|
||||
ArrayVisitor8, 8 => (a, b, c, d, e, f, g, h),
|
||||
ArrayVisitor9, 9 => (a, b, c, d, e, f, g, h, i),
|
||||
ArrayVisitor10, 10 => (a, b, c, d, e, f, g, h, i, j),
|
||||
ArrayVisitor11, 11 => (a, b, c, d, e, f, g, h, i, j, k),
|
||||
ArrayVisitor12, 12 => (a, b, c, d, e, f, g, h, i, j, k, l),
|
||||
ArrayVisitor13, 13 => (a, b, c, d, e, f, g, h, i, j, k, l, m),
|
||||
ArrayVisitor14, 14 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n),
|
||||
ArrayVisitor15, 15 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o),
|
||||
ArrayVisitor16, 16 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p),
|
||||
ArrayVisitor17, 17 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q),
|
||||
ArrayVisitor18, 18 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r),
|
||||
ArrayVisitor19, 19 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s),
|
||||
ArrayVisitor20, 20 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s ,t),
|
||||
ArrayVisitor21, 21 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u),
|
||||
ArrayVisitor22, 22 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v),
|
||||
ArrayVisitor23, 23 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w),
|
||||
ArrayVisitor24, 24 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x),
|
||||
ArrayVisitor25, 25 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y),
|
||||
ArrayVisitor26, 26 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y, z),
|
||||
ArrayVisitor27, 27 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y, z, aa),
|
||||
ArrayVisitor28, 28 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y, z, aa, ab),
|
||||
ArrayVisitor29, 29 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y, z, aa, ab, ac),
|
||||
ArrayVisitor30, 30 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y, z, aa, ab, ac, ad),
|
||||
ArrayVisitor31, 31 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y, z, aa, ab, ac, ad, ae),
|
||||
ArrayVisitor32, 32 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
|
||||
y, z, aa, ab, ac, ad, ae, af),
|
||||
1 => (a)
|
||||
2 => (a b)
|
||||
3 => (a b c)
|
||||
4 => (a b c d)
|
||||
5 => (a b c d e)
|
||||
6 => (a b c d e f)
|
||||
7 => (a b c d e f g)
|
||||
8 => (a b c d e f g h)
|
||||
9 => (a b c d e f g h i)
|
||||
10 => (a b c d e f g h i j)
|
||||
11 => (a b c d e f g h i j k)
|
||||
12 => (a b c d e f g h i j k l)
|
||||
13 => (a b c d e f g h i j k l m)
|
||||
14 => (a b c d e f g h i j k l m n)
|
||||
15 => (a b c d e f g h i j k l m n o)
|
||||
16 => (a b c d e f g h i j k l m n o p)
|
||||
17 => (a b c d e f g h i j k l m n o p q)
|
||||
18 => (a b c d e f g h i j k l m n o p q r)
|
||||
19 => (a b c d e f g h i j k l m n o p q r s)
|
||||
20 => (a b c d e f g h i j k l m n o p q r s t)
|
||||
21 => (a b c d e f g h i j k l m n o p q r s t u)
|
||||
22 => (a b c d e f g h i j k l m n o p q r s t u v)
|
||||
23 => (a b c d e f g h i j k l m n o p q r s t u v w)
|
||||
24 => (a b c d e f g h i j k l m n o p q r s t u v w x)
|
||||
25 => (a b c d e f g h i j k l m n o p q r s t u v w x y)
|
||||
26 => (a b c d e f g h i j k l m n o p q r s t u v w x y z)
|
||||
27 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa)
|
||||
28 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab)
|
||||
29 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac)
|
||||
30 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad)
|
||||
31 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae)
|
||||
32 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae af)
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! tuple_impls {
|
||||
($($len:expr => $visitor:ident => ($($name:ident),+),)+) => {
|
||||
($($len:expr => $visitor:ident => ($($name:ident)+))+) => {
|
||||
$(
|
||||
/// Construct a tuple visitor.
|
||||
pub struct $visitor<$($name,)+> {
|
||||
marker: PhantomData<($($name,)+)>,
|
||||
}
|
||||
|
||||
impl<
|
||||
$($name: Deserialize,)+
|
||||
> $visitor<$($name,)+> {
|
||||
impl<$($name: Deserialize,)+> $visitor<$($name,)+> {
|
||||
/// Construct a `TupleVisitor*<T>`.
|
||||
pub fn new() -> Self {
|
||||
$visitor { marker: PhantomData }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl<
|
||||
$($name: Deserialize,)+
|
||||
> Visitor for $visitor<$($name,)+> {
|
||||
impl<$($name: Deserialize),+> Visitor for $visitor<$($name,)+> {
|
||||
type Value = ($($name,)+);
|
||||
|
||||
#[inline]
|
||||
@@ -678,9 +657,9 @@ macro_rules! tuple_impls {
|
||||
$(
|
||||
let $name = match try!(visitor.visit()) {
|
||||
Some(value) => value,
|
||||
None => { return Err(Error::end_of_stream()); }
|
||||
None => return Err(Error::end_of_stream()),
|
||||
};
|
||||
)+;
|
||||
)+
|
||||
|
||||
try!(visitor.end());
|
||||
|
||||
@@ -688,9 +667,7 @@ macro_rules! tuple_impls {
|
||||
}
|
||||
}
|
||||
|
||||
impl<
|
||||
$($name: Deserialize),+
|
||||
> Deserialize for ($($name,)+) {
|
||||
impl<$($name: Deserialize),+> Deserialize for ($($name,)+) {
|
||||
#[inline]
|
||||
fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
|
||||
where D: Deserializer,
|
||||
@@ -703,22 +680,22 @@ macro_rules! tuple_impls {
|
||||
}
|
||||
|
||||
tuple_impls! {
|
||||
1 => TupleVisitor1 => (T0),
|
||||
2 => TupleVisitor2 => (T0, T1),
|
||||
3 => TupleVisitor3 => (T0, T1, T2),
|
||||
4 => TupleVisitor4 => (T0, T1, T2, T3),
|
||||
5 => TupleVisitor5 => (T0, T1, T2, T3, T4),
|
||||
6 => TupleVisitor6 => (T0, T1, T2, T3, T4, T5),
|
||||
7 => TupleVisitor7 => (T0, T1, T2, T3, T4, T5, T6),
|
||||
8 => TupleVisitor8 => (T0, T1, T2, T3, T4, T5, T6, T7),
|
||||
9 => TupleVisitor9 => (T0, T1, T2, T3, T4, T5, T6, T7, T8),
|
||||
10 => TupleVisitor10 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
|
||||
11 => TupleVisitor11 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
|
||||
12 => TupleVisitor12 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
|
||||
13 => TupleVisitor13 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12),
|
||||
14 => TupleVisitor14 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13),
|
||||
15 => TupleVisitor15 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14),
|
||||
16 => TupleVisitor16 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15),
|
||||
1 => TupleVisitor1 => (T0)
|
||||
2 => TupleVisitor2 => (T0 T1)
|
||||
3 => TupleVisitor3 => (T0 T1 T2)
|
||||
4 => TupleVisitor4 => (T0 T1 T2 T3)
|
||||
5 => TupleVisitor5 => (T0 T1 T2 T3 T4)
|
||||
6 => TupleVisitor6 => (T0 T1 T2 T3 T4 T5)
|
||||
7 => TupleVisitor7 => (T0 T1 T2 T3 T4 T5 T6)
|
||||
8 => TupleVisitor8 => (T0 T1 T2 T3 T4 T5 T6 T7)
|
||||
9 => TupleVisitor9 => (T0 T1 T2 T3 T4 T5 T6 T7 T8)
|
||||
10 => TupleVisitor10 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9)
|
||||
11 => TupleVisitor11 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10)
|
||||
12 => TupleVisitor12 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11)
|
||||
13 => TupleVisitor13 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12)
|
||||
14 => TupleVisitor14 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13)
|
||||
15 => TupleVisitor15 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14)
|
||||
16 => TupleVisitor16 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15)
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@@ -808,7 +785,7 @@ map_impl!(
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[cfg(all(feature = "unstable", feature = "std"))]
|
||||
#[cfg(feature = "std")]
|
||||
impl Deserialize for net::IpAddr {
|
||||
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
|
||||
where D: Deserializer,
|
||||
|
||||
@@ -11,71 +11,6 @@ use collections::{String, Vec};
|
||||
use core::fmt;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Macro helper to not have to re-implement all the defaulted methods.
|
||||
/// Every given method ignores all arguments and forwards to `deserialize`.
|
||||
/// Note that `deserialize_enum` simply returns an `Error::invalid_type`.
|
||||
macro_rules! de_forward_to_deserialize {
|
||||
($($func:ident),*) => {
|
||||
$(de_forward_to_deserialize!{func: $func})*
|
||||
};
|
||||
(func: deserialize_unit_struct) => {
|
||||
de_forward_to_deserialize!{named: deserialize_unit_struct}
|
||||
};
|
||||
(func: deserialize_newtype_struct) => {
|
||||
de_forward_to_deserialize!{named: deserialize_newtype_struct}
|
||||
};
|
||||
(func: deserialize_tuple) => {
|
||||
de_forward_to_deserialize!{tup_fn: deserialize_tuple}
|
||||
};
|
||||
(func: deserialize_seq_fixed_size) => {
|
||||
de_forward_to_deserialize!{tup_fn: deserialize_seq_fixed_size}
|
||||
};
|
||||
(func: deserialize_tuple_struct) => {
|
||||
#[inline]
|
||||
fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor {
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
(func: deserialize_struct) => {
|
||||
#[inline]
|
||||
fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor {
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
(func: deserialize_enum) => {
|
||||
#[inline]
|
||||
fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor {
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
(named: $func:ident) => {
|
||||
#[inline]
|
||||
fn $func<__V>(&mut self, _: &str, visitor: __V) -> Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor {
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
(tup_fn: $func: ident) => {
|
||||
#[inline]
|
||||
fn $func<__V>(&mut self, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor {
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
(func: $func:ident) => {
|
||||
#[inline]
|
||||
fn $func<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor {
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// modules come after macros
|
||||
|
||||
pub mod impls;
|
||||
pub mod value;
|
||||
|
||||
+189
-167
@@ -178,20 +178,10 @@ impl<E> de::Deserializer for UnitDeserializer<E>
|
||||
{
|
||||
type Error = E;
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple enum ignored_any
|
||||
}
|
||||
|
||||
fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
|
||||
@@ -229,21 +219,11 @@ macro_rules! primitive_deserializer {
|
||||
{
|
||||
type Error = E;
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str
|
||||
string unit option seq seq_fixed_size bytes map unit_struct
|
||||
newtype_struct tuple_struct struct struct_field tuple enum
|
||||
ignored_any
|
||||
}
|
||||
|
||||
fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
|
||||
@@ -311,20 +291,10 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
|
||||
visitor.visit_enum(self)
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -407,20 +377,10 @@ impl<E> de::Deserializer for StringDeserializer<E>
|
||||
visitor.visit_enum(self)
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -505,20 +465,10 @@ impl<'a, E> de::Deserializer for CowStrDeserializer<'a, E>
|
||||
visitor.visit_enum(self)
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -596,21 +546,10 @@ impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
|
||||
visitor.visit_seq(self)
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple enum ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -719,21 +658,10 @@ impl<V_, E> de::Deserializer for SeqVisitorDeserializer<V_, E>
|
||||
visitor.visit_seq(&mut self.visitor)
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple enum ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -778,6 +706,15 @@ impl<I, K, V, E> MapDeserializer<I, K, V, E>
|
||||
marker: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
fn next(&mut self) -> Option<(K, V)> {
|
||||
self.iter.next().map(|(k, v)| {
|
||||
if let Some(len) = self.len.as_mut() {
|
||||
*len -= 1;
|
||||
}
|
||||
(k, v)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
|
||||
@@ -794,21 +731,26 @@ impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
|
||||
visitor.visit_map(self)
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
fn deserialize_seq<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
|
||||
where V_: de::Visitor,
|
||||
{
|
||||
visitor.visit_seq(self)
|
||||
}
|
||||
|
||||
fn deserialize_seq_fixed_size<V_>(&mut self, len: usize, mut visitor: V_) -> Result<V_::Value, Self::Error>
|
||||
where V_: de::Visitor,
|
||||
{
|
||||
match self.len {
|
||||
Some(map_len) if map_len == len => visitor.visit_seq(self),
|
||||
Some(_) => Err(de::Error::invalid_length(len)),
|
||||
None => visitor.visit_seq(self),
|
||||
}
|
||||
}
|
||||
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option bytes map unit_struct newtype_struct tuple_struct struct
|
||||
struct_field tuple enum ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -823,14 +765,11 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
|
||||
fn visit_key<T>(&mut self) -> Result<Option<T>, Self::Error>
|
||||
where T: de::Deserialize,
|
||||
{
|
||||
match self.iter.next() {
|
||||
match self.next() {
|
||||
Some((key, value)) => {
|
||||
if let Some(len) = self.len.as_mut() {
|
||||
*len -= 1;
|
||||
}
|
||||
self.value = Some(value);
|
||||
let mut de = key.into_deserializer();
|
||||
Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
|
||||
de::Deserialize::deserialize(&mut de).map(Some)
|
||||
}
|
||||
None => Ok(None),
|
||||
}
|
||||
@@ -864,6 +803,123 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, K, V, E> de::SeqVisitor for MapDeserializer<I, K, V, E>
|
||||
where I: Iterator<Item=(K, V)>,
|
||||
K: ValueDeserializer<E>,
|
||||
V: ValueDeserializer<E>,
|
||||
E: de::Error,
|
||||
{
|
||||
type Error = E;
|
||||
|
||||
fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
|
||||
where T: de::Deserialize,
|
||||
{
|
||||
match self.next() {
|
||||
Some(kv) => {
|
||||
let mut de = PairDeserializer(Some(kv), PhantomData);
|
||||
de::Deserialize::deserialize(&mut de).map(Some)
|
||||
}
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
fn end(&mut self) -> Result<(), Self::Error> {
|
||||
de::MapVisitor::end(self)
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
de::MapVisitor::size_hint(self)
|
||||
}
|
||||
}
|
||||
|
||||
// Used in the `impl SeqVisitor for MapDeserializer` to visit the map as a
|
||||
// sequence of pairs.
|
||||
struct PairDeserializer<A, B, E>(Option<(A, B)>, PhantomData<E>);
|
||||
|
||||
impl<A, B, E> de::Deserializer for PairDeserializer<A, B, E>
|
||||
where A: ValueDeserializer<E>,
|
||||
B: ValueDeserializer<E>,
|
||||
E: de::Error
|
||||
{
|
||||
type Error = E;
|
||||
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option bytes map unit_struct newtype_struct tuple_struct struct
|
||||
struct_field tuple enum ignored_any
|
||||
}
|
||||
|
||||
fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
self.deserialize_seq(visitor)
|
||||
}
|
||||
|
||||
fn deserialize_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
match self.0.take() {
|
||||
Some((k, v)) => {
|
||||
visitor.visit_seq(PairVisitor(Some(k), Some(v), PhantomData))
|
||||
}
|
||||
None => Err(de::Error::end_of_stream()),
|
||||
}
|
||||
}
|
||||
|
||||
fn deserialize_seq_fixed_size<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
|
||||
where V: de::Visitor,
|
||||
{
|
||||
if len == 2 {
|
||||
self.deserialize_seq(visitor)
|
||||
} else {
|
||||
Err(de::Error::invalid_length(len))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
|
||||
|
||||
impl<A, B, E> de::SeqVisitor for PairVisitor<A, B, E>
|
||||
where A: ValueDeserializer<E>,
|
||||
B: ValueDeserializer<E>,
|
||||
E: de::Error,
|
||||
{
|
||||
type Error = E;
|
||||
|
||||
fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
|
||||
where T: de::Deserialize,
|
||||
{
|
||||
if let Some(k) = self.0.take() {
|
||||
let mut de = k.into_deserializer();
|
||||
de::Deserialize::deserialize(&mut de).map(Some)
|
||||
} else if let Some(v) = self.1.take() {
|
||||
let mut de = v.into_deserializer();
|
||||
de::Deserialize::deserialize(&mut de).map(Some)
|
||||
} else {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
fn end(&mut self) -> Result<(), Self::Error> {
|
||||
if self.1.is_none() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(de::Error::invalid_length(self.size_hint().0))
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let len = if self.0.is_some() {
|
||||
2
|
||||
} else if self.1.is_some() {
|
||||
1
|
||||
} else {
|
||||
0
|
||||
};
|
||||
(len, Some(len))
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[cfg(any(feature = "std", feature = "collections"))]
|
||||
@@ -925,21 +981,10 @@ impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
|
||||
visitor.visit_map(&mut self.visitor)
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple enum ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -972,25 +1017,13 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
|
||||
}
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple enum ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[cfg(any(feature = "std", feature = "collections"))]
|
||||
@@ -1023,20 +1056,9 @@ impl<E> de::Deserializer for ByteBufDeserializer<E>
|
||||
}
|
||||
}
|
||||
|
||||
de_forward_to_deserialize!{
|
||||
deserialize_bool,
|
||||
deserialize_f64, deserialize_f32,
|
||||
deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
|
||||
deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
|
||||
deserialize_char, deserialize_str, deserialize_string,
|
||||
deserialize_ignored_any,
|
||||
deserialize_bytes,
|
||||
deserialize_unit_struct, deserialize_unit,
|
||||
deserialize_seq, deserialize_seq_fixed_size,
|
||||
deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
|
||||
deserialize_tuple,
|
||||
deserialize_enum,
|
||||
deserialize_struct, deserialize_tuple_struct,
|
||||
deserialize_option
|
||||
forward_to_deserialize! {
|
||||
bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
tuple_struct struct struct_field tuple enum ignored_any
|
||||
}
|
||||
}
|
||||
|
||||
@@ -45,6 +45,9 @@ macro_rules! format {
|
||||
($s:expr, $($rest:tt)*) => ($s)
|
||||
}
|
||||
|
||||
#[macro_use]
|
||||
mod macros;
|
||||
|
||||
pub mod bytes;
|
||||
pub mod de;
|
||||
#[cfg(feature = "std")]
|
||||
|
||||
@@ -0,0 +1,151 @@
|
||||
#[cfg(feature = "std")]
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! forward_to_deserialize_method {
|
||||
($func:ident($($arg:ty),*)) => {
|
||||
#[inline]
|
||||
fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::std::result::Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor
|
||||
{
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "std"))]
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! forward_to_deserialize_method {
|
||||
($func:ident($($arg:ty),*)) => {
|
||||
#[inline]
|
||||
fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::core::result::Result<__V::Value, Self::Error>
|
||||
where __V: $crate::de::Visitor
|
||||
{
|
||||
self.deserialize(visitor)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! forward_to_deserialize_helper {
|
||||
(bool) => {
|
||||
forward_to_deserialize_method!{deserialize_bool()}
|
||||
};
|
||||
(usize) => {
|
||||
forward_to_deserialize_method!{deserialize_usize()}
|
||||
};
|
||||
(u8) => {
|
||||
forward_to_deserialize_method!{deserialize_u8()}
|
||||
};
|
||||
(u16) => {
|
||||
forward_to_deserialize_method!{deserialize_u16()}
|
||||
};
|
||||
(u32) => {
|
||||
forward_to_deserialize_method!{deserialize_u32()}
|
||||
};
|
||||
(u64) => {
|
||||
forward_to_deserialize_method!{deserialize_u64()}
|
||||
};
|
||||
(isize) => {
|
||||
forward_to_deserialize_method!{deserialize_isize()}
|
||||
};
|
||||
(i8) => {
|
||||
forward_to_deserialize_method!{deserialize_i8()}
|
||||
};
|
||||
(i16) => {
|
||||
forward_to_deserialize_method!{deserialize_i16()}
|
||||
};
|
||||
(i32) => {
|
||||
forward_to_deserialize_method!{deserialize_i32()}
|
||||
};
|
||||
(i64) => {
|
||||
forward_to_deserialize_method!{deserialize_i64()}
|
||||
};
|
||||
(f32) => {
|
||||
forward_to_deserialize_method!{deserialize_f32()}
|
||||
};
|
||||
(f64) => {
|
||||
forward_to_deserialize_method!{deserialize_f64()}
|
||||
};
|
||||
(char) => {
|
||||
forward_to_deserialize_method!{deserialize_char()}
|
||||
};
|
||||
(str) => {
|
||||
forward_to_deserialize_method!{deserialize_str()}
|
||||
};
|
||||
(string) => {
|
||||
forward_to_deserialize_method!{deserialize_string()}
|
||||
};
|
||||
(unit) => {
|
||||
forward_to_deserialize_method!{deserialize_unit()}
|
||||
};
|
||||
(option) => {
|
||||
forward_to_deserialize_method!{deserialize_option()}
|
||||
};
|
||||
(seq) => {
|
||||
forward_to_deserialize_method!{deserialize_seq()}
|
||||
};
|
||||
(seq_fixed_size) => {
|
||||
forward_to_deserialize_method!{deserialize_seq_fixed_size(usize)}
|
||||
};
|
||||
(bytes) => {
|
||||
forward_to_deserialize_method!{deserialize_bytes()}
|
||||
};
|
||||
(map) => {
|
||||
forward_to_deserialize_method!{deserialize_map()}
|
||||
};
|
||||
(unit_struct) => {
|
||||
forward_to_deserialize_method!{deserialize_unit_struct(&'static str)}
|
||||
};
|
||||
(newtype_struct) => {
|
||||
forward_to_deserialize_method!{deserialize_newtype_struct(&'static str)}
|
||||
};
|
||||
(tuple_struct) => {
|
||||
forward_to_deserialize_method!{deserialize_tuple_struct(&'static str, usize)}
|
||||
};
|
||||
(struct) => {
|
||||
forward_to_deserialize_method!{deserialize_struct(&'static str, &'static [&'static str])}
|
||||
};
|
||||
(struct_field) => {
|
||||
forward_to_deserialize_method!{deserialize_struct_field()}
|
||||
};
|
||||
(tuple) => {
|
||||
forward_to_deserialize_method!{deserialize_tuple(usize)}
|
||||
};
|
||||
(enum) => {
|
||||
forward_to_deserialize_method!{deserialize_enum(&'static str, &'static [&'static str])}
|
||||
};
|
||||
(ignored_any) => {
|
||||
forward_to_deserialize_method!{deserialize_ignored_any()}
|
||||
};
|
||||
}
|
||||
|
||||
/// Helper to forward `Deserializer` methods to `Deserializer::deserialize`.
|
||||
/// Every given method ignores all arguments and forwards to `deserialize`.
|
||||
/// Note that `deserialize_enum` simply returns an `Error::invalid_type`; a
|
||||
/// better approach is tracked in [serde-rs/serde#521][1].
|
||||
///
|
||||
/// ```rust,ignore
|
||||
/// impl Deserializer for MyDeserializer {
|
||||
/// fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
|
||||
/// where V: Visitor
|
||||
/// {
|
||||
/// /* ... */
|
||||
/// }
|
||||
///
|
||||
/// forward_to_deserialize! {
|
||||
/// bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
|
||||
/// unit option seq seq_fixed_size bytes map unit_struct newtype_struct
|
||||
/// tuple_struct struct struct_field tuple enum ignored_any
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// [1]: https://github.com/serde-rs/serde/issues/521
|
||||
#[macro_export]
|
||||
macro_rules! forward_to_deserialize {
|
||||
($($func:ident)*) => {
|
||||
$(forward_to_deserialize_helper!{$func})*
|
||||
};
|
||||
}
|
||||
+3
-11
@@ -313,11 +313,6 @@ impl Serialize for () {
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// FIXME(rust #19630) Remove this work-around
|
||||
macro_rules! e {
|
||||
($e:expr) => { $e }
|
||||
}
|
||||
|
||||
macro_rules! tuple_impls {
|
||||
($(
|
||||
$TupleVisitor:ident ($len:expr, $($T:ident),+) {
|
||||
@@ -334,7 +329,7 @@ macro_rules! tuple_impls {
|
||||
{
|
||||
let mut state = try!(serializer.serialize_tuple($len));
|
||||
$(
|
||||
try!(serializer.serialize_tuple_elt(&mut state, &e!(self.$idx)));
|
||||
try!(serializer.serialize_tuple_elt(&mut state, &self.$idx));
|
||||
)+
|
||||
serializer.serialize_tuple_end(state)
|
||||
}
|
||||
@@ -640,15 +635,12 @@ impl Serialize for Duration {
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[cfg(all(feature = "std", feature = "unstable"))]
|
||||
#[cfg(feature = "std")]
|
||||
impl Serialize for net::IpAddr {
|
||||
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
|
||||
where S: Serializer,
|
||||
{
|
||||
match *self {
|
||||
net::IpAddr::V4(ref addr) => addr.serialize(serializer),
|
||||
net::IpAddr::V6(ref addr) => addr.serialize(serializer),
|
||||
}
|
||||
self.to_string().serialize(serializer)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user