pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-29 19:57:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format in rfc style

Browse Source
This commit is contained in:
David Tolnay
2017-04-13 12:28:23 -07:00
parent c5bd760133
commit ea8fb97beb
25 changed files with 2822 additions and 2131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/src/de/ignored_any.rs
+14 -7
View File
@@ -10,7 +10,8 @@ pub struct IgnoredAny;
impl<'de> Deserialize<'de> for IgnoredAny {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
struct IgnoredAnyVisitor;
@@ -43,7 +44,8 @@ impl<'de> Deserialize<'de> for IgnoredAny {
#[inline]
fn visit_str<E>(self, _: &str) -> Result<IgnoredAny, E>
where E: Error
where
E: Error,
{
Ok(IgnoredAny)
}
@@ -55,14 +57,16 @@ impl<'de> Deserialize<'de> for IgnoredAny {
#[inline]
fn visit_some<D>(self, deserializer: D) -> Result<IgnoredAny, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
IgnoredAny::deserialize(deserializer)
}
#[inline]
fn visit_newtype_struct<D>(self, deserializer: D) -> Result<IgnoredAny, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
IgnoredAny::deserialize(deserializer)
}
@@ -74,7 +78,8 @@ impl<'de> Deserialize<'de> for IgnoredAny {
#[inline]
fn visit_seq<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
where V: SeqVisitor<'de>
where
V: SeqVisitor<'de>,
{
while let Some(_) = try!(visitor.visit::<IgnoredAny>()) {
// Gobble
@@ -84,7 +89,8 @@ impl<'de> Deserialize<'de> for IgnoredAny {
#[inline]
fn visit_map<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
where V: MapVisitor<'de>
where
V: MapVisitor<'de>,
{
while let Some((_, _)) = try!(visitor.visit::<IgnoredAny, IgnoredAny>()) {
// Gobble
@@ -94,7 +100,8 @@ impl<'de> Deserialize<'de> for IgnoredAny {
#[inline]
fn visit_bytes<E>(self, _: &[u8]) -> Result<IgnoredAny, E>
where E: Error
where
E: Error,
{
Ok(IgnoredAny)
}
serde/src/de/impls.rs
+176 -103
View File
@@ -1,7 +1,7 @@
use lib::*;
use de::{Deserialize, Deserializer, EnumVisitor, Error, SeqVisitor, Unexpected,
VariantVisitor, Visitor};
use de::{Deserialize, Deserializer, EnumVisitor, Error, SeqVisitor, Unexpected, VariantVisitor,
Visitor};
#[cfg(any(feature = "std", feature = "collections"))]
use de::MapVisitor;
@@ -20,7 +20,8 @@ impl<'de> Visitor<'de> for UnitVisitor {
}
fn visit_unit<E>(self) -> Result<(), E>
where E: Error
where
E: Error,
{
Ok(())
}
@@ -28,7 +29,8 @@ impl<'de> Visitor<'de> for UnitVisitor {
impl<'de> Deserialize<'de> for () {
fn deserialize<D>(deserializer: D) -> Result<(), D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_unit(UnitVisitor)
}
@@ -46,7 +48,8 @@ impl<'de> Visitor<'de> for BoolVisitor {
}
fn visit_bool<E>(self, v: bool) -> Result<bool, E>
where E: Error
where
E: Error,
{
Ok(v)
}
@@ -54,7 +57,8 @@ impl<'de> Visitor<'de> for BoolVisitor {
impl<'de> Deserialize<'de> for bool {
fn deserialize<D>(deserializer: D) -> Result<bool, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_bool(BoolVisitor)
}
@@ -155,14 +159,16 @@ impl<'de> Visitor<'de> for CharVisitor {
#[inline]
fn visit_char<E>(self, v: char) -> Result<char, E>
where E: Error
where
E: Error,
{
Ok(v)
}
#[inline]
fn visit_str<E>(self, v: &str) -> Result<char, E>
where E: Error
where
E: Error,
{
let mut iter = v.chars();
match (iter.next(), iter.next()) {
@@ -175,7 +181,8 @@ impl<'de> Visitor<'de> for CharVisitor {
impl<'de> Deserialize<'de> for char {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<char, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_char(CharVisitor)
}
@@ -195,19 +202,22 @@ impl<'de> Visitor<'de> for StringVisitor {
}
fn visit_str<E>(self, v: &str) -> Result<String, E>
where E: Error
where
E: Error,
{
Ok(v.to_owned())
}
fn visit_string<E>(self, v: String) -> Result<String, E>
where E: Error
where
E: Error,
{
Ok(v)
}
fn visit_bytes<E>(self, v: &[u8]) -> Result<String, E>
where E: Error
where
E: Error,
{
match str::from_utf8(v) {
Ok(s) => Ok(s.to_owned()),
@@ -216,11 +226,12 @@ impl<'de> Visitor<'de> for StringVisitor {
}
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<String, E>
where E: Error
where
E: Error,
{
match String::from_utf8(v) {
Ok(s) => Ok(s),
Err(e) => Err(Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self)),
Err(e) => Err(Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self),),
}
}
}
@@ -228,7 +239,8 @@ impl<'de> Visitor<'de> for StringVisitor {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de> Deserialize<'de> for String {
fn deserialize<D>(deserializer: D) -> Result<String, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_string(StringVisitor)
}
@@ -246,22 +258,24 @@ impl<'a> Visitor<'a> for StrVisitor {
}
fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Ok(v) // so easy
}
fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
str::from_utf8(v)
.map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
str::from_utf8(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
}
}
impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_str(StrVisitor)
}
@@ -279,13 +293,15 @@ impl<'a> Visitor<'a> for BytesVisitor {
}
fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Ok(v)
}
fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Ok(v.as_bytes())
}
@@ -293,7 +309,8 @@ impl<'a> Visitor<'a> for BytesVisitor {
impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_bytes(BytesVisitor)
}
@@ -313,7 +330,8 @@ impl<'de> Visitor<'de> for CStringVisitor {
}
fn visit_seq<V>(self, mut visitor: V) -> Result<CString, V::Error>
where V: SeqVisitor<'de>
where
V: SeqVisitor<'de>,
{
let len = cmp::min(visitor.size_hint().0, 4096);
let mut values = Vec::with_capacity(len);
@@ -326,25 +344,29 @@ impl<'de> Visitor<'de> for CStringVisitor {
}
fn visit_bytes<E>(self, v: &[u8]) -> Result<CString, E>
where E: Error
where
E: Error,
{
CString::new(v).map_err(Error::custom)
}
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<CString, E>
where E: Error
where
E: Error,
{
CString::new(v).map_err(Error::custom)
}
fn visit_str<E>(self, v: &str) -> Result<CString, E>
where E: Error
where
E: Error,
{
CString::new(v).map_err(Error::custom)
}
fn visit_string<E>(self, v: String) -> Result<CString, E>
where E: Error
where
E: Error,
{
CString::new(v).map_err(Error::custom)
}
@@ -353,7 +375,8 @@ impl<'de> Visitor<'de> for CStringVisitor {
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for CString {
fn deserialize<D>(deserializer: D) -> Result<CString, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_byte_buf(CStringVisitor)
}
@@ -362,7 +385,8 @@ impl<'de> Deserialize<'de> for CString {
#[cfg(all(feature = "std", feature = "unstable"))]
impl<'de> Deserialize<'de> for Box<CStr> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(CString::deserialize(deserializer));
Ok(s.into_boxed_c_str())
@@ -376,7 +400,8 @@ struct OptionVisitor<T> {
}
impl<'de, T> Visitor<'de> for OptionVisitor<T>
where T: Deserialize<'de>
where
T: Deserialize<'de>,
{
type Value = Option<T>;
@@ -386,31 +411,36 @@ impl<'de, T> Visitor<'de> for OptionVisitor<T>
#[inline]
fn visit_unit<E>(self) -> Result<Option<T>, E>
where E: Error
where
E: Error,
{
Ok(None)
}
#[inline]
fn visit_none<E>(self) -> Result<Option<T>, E>
where E: Error
where
E: Error,
{
Ok(None)
}
#[inline]
fn visit_some<D>(self, deserializer: D) -> Result<Option<T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
Ok(Some(try!(Deserialize::deserialize(deserializer))))
}
}
impl<'de, T> Deserialize<'de> for Option<T>
where T: Deserialize<'de>
where
T: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Option<T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_option(OptionVisitor { marker: PhantomData })
}
@@ -431,7 +461,8 @@ impl<'de, T> Visitor<'de> for PhantomDataVisitor<T> {
#[inline]
fn visit_unit<E>(self) -> Result<PhantomData<T>, E>
where E: Error
where
E: Error,
{
Ok(PhantomData)
}
@@ -439,7 +470,8 @@ impl<'de, T> Visitor<'de> for PhantomDataVisitor<T> {
impl<'de, T> Deserialize<'de> for PhantomData<T> {
fn deserialize<D>(deserializer: D) -> Result<PhantomData<T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let visitor = PhantomDataVisitor { marker: PhantomData };
deserializer.deserialize_unit_struct("PhantomData", visitor)
@@ -582,7 +614,8 @@ impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
#[inline]
fn visit_seq<V>(self, _: V) -> Result<[T; 0], V::Error>
where V: SeqVisitor<'de>
where
V: SeqVisitor<'de>,
{
Ok([])
}
@@ -591,7 +624,8 @@ impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
// Does not require T: Deserialize<'de>.
impl<'de, T> Deserialize<'de> for [T; 0] {
fn deserialize<D>(deserializer: D) -> Result<[T; 0], D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_seq_fixed_size(0, ArrayVisitor::<[T; 0]>::new())
}
@@ -824,7 +858,8 @@ map_impl!(
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for net::IpAddr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -837,7 +872,8 @@ impl<'de> Deserialize<'de> for net::IpAddr {
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for net::Ipv4Addr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -850,7 +886,8 @@ impl<'de> Deserialize<'de> for net::Ipv4Addr {
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for net::Ipv6Addr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -865,7 +902,8 @@ impl<'de> Deserialize<'de> for net::Ipv6Addr {
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for net::SocketAddr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -878,7 +916,8 @@ impl<'de> Deserialize<'de> for net::SocketAddr {
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for net::SocketAddrV4 {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -891,7 +930,8 @@ impl<'de> Deserialize<'de> for net::SocketAddrV4 {
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for net::SocketAddrV6 {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -915,13 +955,15 @@ impl<'de> Visitor<'de> for PathBufVisitor {
}
fn visit_str<E>(self, v: &str) -> Result<path::PathBuf, E>
where E: Error
where
E: Error,
{
Ok(From::from(v))
}
fn visit_string<E>(self, v: String) -> Result<path::PathBuf, E>
where E: Error
where
E: Error,
{
Ok(From::from(v))
}
@@ -931,7 +973,8 @@ impl<'de> Visitor<'de> for PathBufVisitor {
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for path::PathBuf {
fn deserialize<D>(deserializer: D) -> Result<path::PathBuf, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_string(PathBufVisitor)
}
@@ -951,7 +994,8 @@ static OSSTR_VARIANTS: &'static [&'static str] = &["Unix", "Windows"];
#[cfg(all(feature = "std", any(unix, windows)))]
impl<'de> Deserialize<'de> for OsStringKind {
fn deserialize<D>(deserializer: D) -> Result<OsStringKind, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
struct KindVisitor;
@@ -963,17 +1007,19 @@ impl<'de> Deserialize<'de> for OsStringKind {
}
fn visit_u32<E>(self, value: u32) -> Result<OsStringKind, E>
where E: Error,
where
E: Error,
{
match value {
0 => Ok(OsStringKind::Unix),
1 => Ok(OsStringKind::Windows),
_ => Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self))
_ => Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self),),
}
}
fn visit_str<E>(self, value: &str) -> Result<OsStringKind, E>
where E: Error,
where
E: Error,
{
match value {
"Unix" => Ok(OsStringKind::Unix),
@@ -983,7 +1029,8 @@ impl<'de> Deserialize<'de> for OsStringKind {
}
fn visit_bytes<E>(self, value: &[u8]) -> Result<OsStringKind, E>
where E: Error,
where
E: Error,
{
match value {
b"Unix" => Ok(OsStringKind::Unix),
@@ -991,9 +1038,7 @@ impl<'de> Deserialize<'de> for OsStringKind {
_ => {
match str::from_utf8(value) {
Ok(value) => Err(Error::unknown_variant(value, OSSTR_VARIANTS)),
Err(_) => {
Err(Error::invalid_value(Unexpected::Bytes(value), &self))
}
Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
}
}
}
@@ -1017,33 +1062,31 @@ impl<'de> Visitor<'de> for OsStringVisitor {
#[cfg(unix)]
fn visit_enum<V>(self, visitor: V) -> Result<OsString, V::Error>
where V: EnumVisitor<'de>,
where
V: EnumVisitor<'de>,
{
use std::os::unix::ffi::OsStringExt;
match try!(visitor.visit_variant()) {
(OsStringKind::Unix, variant) => {
variant.visit_newtype().map(OsString::from_vec)
}
(OsStringKind::Windows, _) => {
Err(Error::custom("cannot deserialize Windows OS string on Unix"))
}
(OsStringKind::Unix, variant) => variant.visit_newtype().map(OsString::from_vec),
(OsStringKind::Windows, _) => Err(Error::custom("cannot deserialize Windows OS string on Unix",),),
}
}
#[cfg(windows)]
fn visit_enum<V>(self, visitor: V) -> Result<OsString, V::Error>
where V: EnumVisitor<'de>,
where
V: EnumVisitor<'de>,
{
use std::os::windows::ffi::OsStringExt;
match try!(visitor.visit_variant()) {
(OsStringKind::Windows, variant) => {
variant.visit_newtype::<Vec<u16>>().map(|vec| OsString::from_wide(&vec))
}
(OsStringKind::Unix, _) => {
Err(Error::custom("cannot deserialize Unix OS string on Windows"))
variant
.visit_newtype::<Vec<u16>>()
.map(|vec| OsString::from_wide(&vec))
}
(OsStringKind::Unix, _) => Err(Error::custom("cannot deserialize Unix OS string on Windows",),),
}
}
}
@@ -1051,7 +1094,8 @@ impl<'de> Visitor<'de> for OsStringVisitor {
#[cfg(all(feature = "std", any(unix, windows)))]
impl<'de> Deserialize<'de> for OsString {
fn deserialize<D>(deserializer: D) -> Result<OsString, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor)
}
@@ -1062,7 +1106,8 @@ impl<'de> Deserialize<'de> for OsString {
#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<T> {
fn deserialize<D>(deserializer: D) -> Result<Box<T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Box::new(val))
@@ -1072,7 +1117,8 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<T> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<[T]> {
fn deserialize<D>(deserializer: D) -> Result<Box<[T]>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let v: Vec<T> = try!(Deserialize::deserialize(deserializer));
Ok(v.into_boxed_slice())
@@ -1082,7 +1128,8 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<[T]> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de> Deserialize<'de> for Box<str> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let s = try!(String::deserialize(deserializer));
Ok(s.into_boxed_str())
@@ -1092,7 +1139,8 @@ impl<'de> Deserialize<'de> for Box<str> {
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc<T> {
fn deserialize<D>(deserializer: D) -> Result<Arc<T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Arc::new(val))
@@ -1102,7 +1150,8 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc<T> {
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Rc<T> {
fn deserialize<D>(deserializer: D) -> Result<Rc<T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Rc::new(val))
@@ -1111,12 +1160,14 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Rc<T> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
where T: ToOwned,
T::Owned: Deserialize<'de>
where
T: ToOwned,
T::Owned: Deserialize<'de>,
{
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Cow<'a, T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Cow::Owned(val))
@@ -1136,7 +1187,8 @@ impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
#[cfg(feature = "std")]
impl<'de> Deserialize<'de> for Duration {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
enum Field {
Secs,
@@ -1145,7 +1197,8 @@ impl<'de> Deserialize<'de> for Duration {
impl<'de> Deserialize<'de> for Field {
fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
struct FieldVisitor;
@@ -1157,7 +1210,8 @@ impl<'de> Deserialize<'de> for Duration {
}
fn visit_str<E>(self, value: &str) -> Result<Field, E>
where E: Error
where
E: Error,
{
match value {
"secs" => Ok(Field::Secs),
@@ -1167,7 +1221,8 @@ impl<'de> Deserialize<'de> for Duration {
}
fn visit_bytes<E>(self, value: &[u8]) -> Result<Field, E>
where E: Error
where
E: Error,
{
match value {
b"secs" => Ok(Field::Secs),
@@ -1194,7 +1249,8 @@ impl<'de> Deserialize<'de> for Duration {
}
fn visit_seq<V>(self, mut visitor: V) -> Result<Duration, V::Error>
where V: SeqVisitor<'de>
where
V: SeqVisitor<'de>,
{
let secs: u64 = match try!(visitor.visit()) {
Some(value) => value,
@@ -1212,7 +1268,8 @@ impl<'de> Deserialize<'de> for Duration {
}
fn visit_map<V>(self, mut visitor: V) -> Result<Duration, V::Error>
where V: MapVisitor<'de>
where
V: MapVisitor<'de>,
{
let mut secs: Option<u64> = None;
let mut nanos: Option<u32> = None;
@@ -1262,7 +1319,8 @@ impl<'de> Deserialize<'de> for Duration {
#[cfg(feature = "std")]
impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
enum Field {
Start,
@@ -1271,7 +1329,8 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
impl<'de> Deserialize<'de> for Field {
fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
struct FieldVisitor;
@@ -1283,7 +1342,8 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
}
fn visit_str<E>(self, value: &str) -> Result<Field, E>
where E: Error
where
E: Error,
{
match value {
"start" => Ok(Field::Start),
@@ -1293,7 +1353,8 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
}
fn visit_bytes<E>(self, value: &[u8]) -> Result<Field, E>
where E: Error
where
E: Error,
{
match value {
b"start" => Ok(Field::Start),
@@ -1322,7 +1383,8 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
}
fn visit_seq<V>(self, mut visitor: V) -> Result<ops::Range<Idx>, V::Error>
where V: SeqVisitor<'de>
where
V: SeqVisitor<'de>,
{
let start: Idx = match try!(visitor.visit()) {
Some(value) => value,
@@ -1340,7 +1402,8 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
}
fn visit_map<V>(self, mut visitor: V) -> Result<ops::Range<Idx>, V::Error>
where V: MapVisitor<'de>
where
V: MapVisitor<'de>,
{
let mut start: Option<Idx> = None;
let mut end: Option<Idx> = None;
@@ -1385,10 +1448,12 @@ impl<'de, Idx: Deserialize<'de>> Deserialize<'de> for ops::Range<Idx> {
#[cfg(feature = "unstable")]
#[allow(deprecated)] // num::Zero is deprecated but there is no replacement
impl<'de, T> Deserialize<'de> for NonZero<T>
where T: Deserialize<'de> + PartialEq + Zeroable + Zero
where
T: Deserialize<'de> + PartialEq + Zeroable + Zero,
{
fn deserialize<D>(deserializer: D) -> Result<NonZero<T>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let value = try!(Deserialize::deserialize(deserializer));
if value == Zero::zero() {
@@ -1402,11 +1467,13 @@ impl<'de, T> Deserialize<'de> for NonZero<T>
impl<'de, T, E> Deserialize<'de> for Result<T, E>
where T: Deserialize<'de>,
E: Deserialize<'de>
where
T: Deserialize<'de>,
E: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Result<T, E>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
enum Field {
Ok,
@@ -1416,7 +1483,8 @@ impl<'de, T, E> Deserialize<'de> for Result<T, E>
impl<'de> Deserialize<'de> for Field {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
struct FieldVisitor;
@@ -1428,19 +1496,21 @@ impl<'de, T, E> Deserialize<'de> for Result<T, E>
}
fn visit_u32<E>(self, value: u32) -> Result<Field, E>
where E: Error
where
E: Error,
{
match value {
0 => Ok(Field::Ok),
1 => Ok(Field::Err),
_ => {
Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self))
Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self),)
}
}
}
fn visit_str<E>(self, value: &str) -> Result<Field, E>
where E: Error
where
E: Error,
{
match value {
"Ok" => Ok(Field::Ok),
@@ -1450,7 +1520,8 @@ impl<'de, T, E> Deserialize<'de> for Result<T, E>
}
fn visit_bytes<E>(self, value: &[u8]) -> Result<Field, E>
where E: Error
where
E: Error,
{
match value {
b"Ok" => Ok(Field::Ok),
@@ -1474,8 +1545,9 @@ impl<'de, T, E> Deserialize<'de> for Result<T, E>
struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E>
where T: Deserialize<'de>,
E: Deserialize<'de>
where
T: Deserialize<'de>,
E: Deserialize<'de>,
{
type Value = Result<T, E>;
@@ -1484,7 +1556,8 @@ impl<'de, T, E> Deserialize<'de> for Result<T, E>
}
fn visit_enum<V>(self, visitor: V) -> Result<Result<T, E>, V::Error>
where V: EnumVisitor<'de>
where
V: EnumVisitor<'de>,
{
match try!(visitor.visit_variant()) {
(Field::Ok, variant) => variant.visit_newtype().map(Ok),
serde/src/de/mod.rs
+246 -128
View File
@@ -421,7 +421,8 @@ pub trait Expected {
}
impl<'de, T> Expected for T
where T: Visitor<'de>
where
T: Visitor<'de>,
{
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
self.expecting(formatter)
@@ -474,7 +475,8 @@ pub trait Deserialize<'de>: Sized {
///
/// [impl-deserialize]: https://serde.rs/impl-deserialize.html
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>;
where
D: Deserializer<'de>;
}
/// A data structure that can be deserialized without borrowing any data from
@@ -499,7 +501,11 @@ pub trait Deserialize<'de>: Sized {
/// # }
/// ```
pub trait DeserializeOwned: for<'de> Deserialize<'de> {}
impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
impl<T> DeserializeOwned for T
where
T: for<'de> Deserialize<'de>,
{
}
/// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you
/// ever find yourself looking for a way to pass data into a `Deserialize` impl,
@@ -651,17 +657,20 @@ pub trait DeserializeSeed<'de>: Sized {
/// Equivalent to the more common `Deserialize::deserialize` method, except
/// with some initial piece of data (the seed) passed in.
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where D: Deserializer<'de>;
where
D: Deserializer<'de>;
}
impl<'de, T> DeserializeSeed<'de> for PhantomData<T>
where T: Deserialize<'de>
where
T: Deserialize<'de>,
{
type Value = T;
#[inline]
fn deserialize<D>(self, deserializer: D) -> Result<T, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
T::deserialize(deserializer)
}
@@ -764,43 +773,69 @@ pub trait Deserializer<'de>: Sized {
/// `Deserializer::deserialize` means your data type will be able to
/// deserialize from self-describing formats only, ruling out Bincode and
/// many others.
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `bool` value.
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `u8` value.
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `u16` value.
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `u32` value.
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `u64` value.
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting an `i8` value.
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting an `i16` value.
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting an `i32` value.
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting an `i64` value.
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `f32` value.
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `f64` value.
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a `char` value.
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a string value and does
/// not benefit from taking ownership of buffered data owned by the
@@ -809,7 +844,9 @@ pub trait Deserializer<'de>: Sized {
/// If the `Visitor` would benefit from taking ownership of `String` data,
/// indiciate this to the `Deserializer` by using `deserialize_string`
/// instead.
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a string value and would
/// benefit from taking ownership of buffered data owned by the
@@ -818,7 +855,9 @@ pub trait Deserializer<'de>: Sized {
/// If the `Visitor` would not benefit from taking ownership of `String`
/// data, indicate that to the `Deserializer` by using `deserialize_str`
/// instead.
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a byte array and does not
/// benefit from taking ownership of buffered data owned by the
@@ -827,7 +866,9 @@ pub trait Deserializer<'de>: Sized {
/// If the `Visitor` would benefit from taking ownership of `Vec<u8>` data,
/// indicate this to the `Deserializer` by using `deserialize_byte_buf`
/// instead.
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a byte array and would
/// benefit from taking ownership of buffered data owned by the
@@ -836,91 +877,116 @@ pub trait Deserializer<'de>: Sized {
/// If the `Visitor` would not benefit from taking ownership of `Vec<u8>`
/// data, indicate that to the `Deserializer` by using `deserialize_bytes`
/// instead.
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting an optional value.
///
/// This allows deserializers that encode an optional value as a nullable
/// value to convert the null value into `None` and a regular value into
/// `Some(value)`.
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a unit value.
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a unit struct with a
/// particular name.
fn deserialize_unit_struct<V>(self,
name: &'static str,
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor<'de>;
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a newtype struct with a
/// particular name.
fn deserialize_newtype_struct<V>(self,
name: &'static str,
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor<'de>;
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a sequence of values.
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a sequence of values and
/// knows how many values there are without looking at the serialized data.
fn deserialize_seq_fixed_size<V>(self,
len: usize,
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor<'de>;
fn deserialize_seq_fixed_size<V>(
self,
len: usize,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a tuple value with a
/// particular number of elements.
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>;
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a tuple struct with a
/// particular name and number of fields.
fn deserialize_tuple_struct<V>(self,
name: &'static str,
len: usize,
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor<'de>;
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a map of key-value pairs.
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>;
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting a struct with a particular
/// name and fields.
fn deserialize_struct<V>(self,
name: &'static str,
fields: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor<'de>;
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting the name of a struct
/// field or the discriminant of an enum variant.
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>;
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type is expecting an enum value with a
/// particular name and possible variants.
fn deserialize_enum<V>(self,
name: &'static str,
variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor<'de>;
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
/// Hint that the `Deserialize` type needs to deserialize a value whose type
/// doesn't matter because it is ignored.
///
/// Deserializers for non-self-describing formats may not support this mode.
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>;
where
V: Visitor<'de>;
}
///////////////////////////////////////////////////////////////////////////////
@@ -986,77 +1052,88 @@ pub trait Visitor<'de>: Sized {
/// Deserialize a `bool` into a `Value`.
fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Err(Error::invalid_type(Unexpected::Bool(v), &self))
}
/// Deserialize an `i8` into a `Value`.
fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_i64(v as i64)
}
/// Deserialize an `i16` into a `Value`.
fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_i64(v as i64)
}
/// Deserialize an `i32` into a `Value`.
fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_i64(v as i64)
}
/// Deserialize an `i64` into a `Value`.
fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Err(Error::invalid_type(Unexpected::Signed(v), &self))
}
/// Deserialize a `u8` into a `Value`.
fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_u64(v as u64)
}
/// Deserialize a `u16` into a `Value`.
fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_u64(v as u64)
}
/// Deserialize a `u32` into a `Value`.
fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_u64(v as u64)
}
/// Deserialize a `u64` into a `Value`.
fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
}
/// Deserialize a `f32` into a `Value`.
fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_f64(v as f64)
}
/// Deserialize a `f64` into a `Value`.
fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Err(Error::invalid_type(Unexpected::Float(v), &self))
}
@@ -1064,7 +1141,8 @@ pub trait Visitor<'de>: Sized {
/// Deserialize a `char` into a `Value`.
#[inline]
fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_str(utf8::encode(v).as_str())
}
@@ -1080,7 +1158,8 @@ pub trait Visitor<'de>: Sized {
/// It is never correct to implement `visit_string` without implementing
/// `visit_str`. Implement neither, both, or just `visit_str`.
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Err(Error::invalid_type(Unexpected::Str(v), &self))
}
@@ -1095,7 +1174,8 @@ pub trait Visitor<'de>: Sized {
/// The default implementation forwards to `visit_str`.
#[inline]
fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_str(v)
}
@@ -1117,28 +1197,32 @@ pub trait Visitor<'de>: Sized {
#[inline]
#[cfg(any(feature = "std", feature = "collections"))]
fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_str(&v)
}
/// Deserialize a `()` into a `Value`.
fn visit_unit<E>(self) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Err(Error::invalid_type(Unexpected::Unit, &self))
}
/// Deserialize an absent optional `Value`.
fn visit_none<E>(self) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Err(Error::invalid_type(Unexpected::Option, &self))
}
/// Deserialize a present optional `Value`.
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let _ = deserializer;
Err(Error::invalid_type(Unexpected::Option, &self))
@@ -1146,7 +1230,8 @@ pub trait Visitor<'de>: Sized {
/// Deserialize `Value` as a newtype struct.
fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
let _ = deserializer;
Err(Error::invalid_type(Unexpected::NewtypeStruct, &self))
@@ -1154,7 +1239,8 @@ pub trait Visitor<'de>: Sized {
/// Deserialize `Value` as a sequence of elements.
fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
where V: SeqVisitor<'de>
where
V: SeqVisitor<'de>,
{
let _ = visitor;
Err(Error::invalid_type(Unexpected::Seq, &self))
@@ -1162,7 +1248,8 @@ pub trait Visitor<'de>: Sized {
/// Deserialize `Value` as a key-value map.
fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
where V: MapVisitor<'de>
where
V: MapVisitor<'de>,
{
let _ = visitor;
Err(Error::invalid_type(Unexpected::Map, &self))
@@ -1170,7 +1257,8 @@ pub trait Visitor<'de>: Sized {
/// Deserialize `Value` as an enum.
fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
where V: EnumVisitor<'de>
where
V: EnumVisitor<'de>,
{
let _ = visitor;
Err(Error::invalid_type(Unexpected::Enum, &self))
@@ -1187,7 +1275,8 @@ pub trait Visitor<'de>: Sized {
/// It is never correct to implement `visit_byte_buf` without implementing
/// `visit_bytes`. Implement neither, both, or just `visit_bytes`.
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
let _ = v;
Err(Error::invalid_type(Unexpected::Bytes(v), &self))
@@ -1202,7 +1291,8 @@ pub trait Visitor<'de>: Sized {
/// The default implementation forwards to `visit_bytes`.
#[inline]
fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_bytes(v)
}
@@ -1224,7 +1314,8 @@ pub trait Visitor<'de>: Sized {
/// `Vec<u8>`.
#[cfg(any(feature = "std", feature = "collections"))]
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
self.visit_bytes(&v)
}
@@ -1247,7 +1338,8 @@ pub trait SeqVisitor<'de> {
/// `Deserialize` implementations should typically use `SeqVisitor::visit`
/// instead.
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: DeserializeSeed<'de>;
where
T: DeserializeSeed<'de>;
/// This returns `Ok(Some(value))` for the next value in the sequence, or
/// `Ok(None)` if there are no more remaining items.
@@ -1256,7 +1348,8 @@ pub trait SeqVisitor<'de> {
/// `SeqVisitor` implementations should not override the default behavior.
#[inline]
fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
where T: Deserialize<'de>
where
T: Deserialize<'de>,
{
self.visit_seed(PhantomData)
}
@@ -1269,20 +1362,23 @@ pub trait SeqVisitor<'de> {
}
impl<'de, 'a, V> SeqVisitor<'de> for &'a mut V
where V: SeqVisitor<'de>
where
V: SeqVisitor<'de>,
{
type Error = V::Error;
#[inline]
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, V::Error>
where T: DeserializeSeed<'de>
where
T: DeserializeSeed<'de>,
{
(**self).visit_seed(seed)
}
#[inline]
fn visit<T>(&mut self) -> Result<Option<T>, V::Error>
where T: Deserialize<'de>
where
T: Deserialize<'de>,
{
(**self).visit()
}
@@ -1309,14 +1405,16 @@ pub trait MapVisitor<'de> {
/// `Deserialize` implementations should typically use
/// `MapVisitor::visit_key` or `MapVisitor::visit` instead.
fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
where K: DeserializeSeed<'de>;
where
K: DeserializeSeed<'de>;
/// This returns a `Ok(value)` for the next value in the map.
///
/// `Deserialize` implementations should typically use
/// `MapVisitor::visit_value` instead.
fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
where V: DeserializeSeed<'de>;
where
V: DeserializeSeed<'de>;
/// This returns `Ok(Some((key, value)))` for the next (key-value) pair in
/// the map, or `Ok(None)` if there are no more remaining items.
@@ -1327,12 +1425,14 @@ pub trait MapVisitor<'de> {
/// `Deserialize` implementations should typically use `MapVisitor::visit`
/// instead.
#[inline]
fn visit_seed<K, V>(&mut self,
kseed: K,
vseed: V)
-> Result<Option<(K::Value, V::Value)>, Self::Error>
where K: DeserializeSeed<'de>,
V: DeserializeSeed<'de>
fn visit_seed<K, V>(
&mut self,
kseed: K,
vseed: V,
) -> Result<Option<(K::Value, V::Value)>, Self::Error>
where
K: DeserializeSeed<'de>,
V: DeserializeSeed<'de>,
{
match try!(self.visit_key_seed(kseed)) {
Some(key) => {
@@ -1350,7 +1450,8 @@ pub trait MapVisitor<'de> {
/// `MapVisitor` implementations should not override the default behavior.
#[inline]
fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
where K: Deserialize<'de>
where
K: Deserialize<'de>,
{
self.visit_key_seed(PhantomData)
}
@@ -1361,7 +1462,8 @@ pub trait MapVisitor<'de> {
/// `MapVisitor` implementations should not override the default behavior.
#[inline]
fn visit_value<V>(&mut self) -> Result<V, Self::Error>
where V: Deserialize<'de>
where
V: Deserialize<'de>,
{
self.visit_value_seed(PhantomData)
}
@@ -1373,8 +1475,9 @@ pub trait MapVisitor<'de> {
/// `MapVisitor` implementations should not override the default behavior.
#[inline]
fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
where K: Deserialize<'de>,
V: Deserialize<'de>
where
K: Deserialize<'de>,
V: Deserialize<'de>,
{
self.visit_seed(PhantomData, PhantomData)
}
@@ -1387,53 +1490,61 @@ pub trait MapVisitor<'de> {
}
impl<'de, 'a, V_> MapVisitor<'de> for &'a mut V_
where V_: MapVisitor<'de>
where
V_: MapVisitor<'de>,
{
type Error = V_::Error;
#[inline]
fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
where K: DeserializeSeed<'de>
where
K: DeserializeSeed<'de>,
{
(**self).visit_key_seed(seed)
}
#[inline]
fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
where V: DeserializeSeed<'de>
where
V: DeserializeSeed<'de>,
{
(**self).visit_value_seed(seed)
}
#[inline]
fn visit_seed<K, V>(&mut self,
kseed: K,
vseed: V)
-> Result<Option<(K::Value, V::Value)>, Self::Error>
where K: DeserializeSeed<'de>,
V: DeserializeSeed<'de>
fn visit_seed<K, V>(
&mut self,
kseed: K,
vseed: V,
) -> Result<Option<(K::Value, V::Value)>, Self::Error>
where
K: DeserializeSeed<'de>,
V: DeserializeSeed<'de>,
{
(**self).visit_seed(kseed, vseed)
}
#[inline]
fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, V_::Error>
where K: Deserialize<'de>,
V: Deserialize<'de>
where
K: Deserialize<'de>,
V: Deserialize<'de>,
{
(**self).visit()
}
#[inline]
fn visit_key<K>(&mut self) -> Result<Option<K>, V_::Error>
where K: Deserialize<'de>
where
K: Deserialize<'de>,
{
(**self).visit_key()
}
#[inline]
fn visit_value<V>(&mut self) -> Result<V, V_::Error>
where V: Deserialize<'de>
where
V: Deserialize<'de>,
{
(**self).visit_value()
}
@@ -1462,7 +1573,8 @@ pub trait EnumVisitor<'de>: Sized {
/// `Deserialize` implementations should typically use
/// `EnumVisitor::visit_variant` instead.
fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where V: DeserializeSeed<'de>;
where
V: DeserializeSeed<'de>;
/// `visit_variant` is called to identify which variant to deserialize.
///
@@ -1470,7 +1582,8 @@ pub trait EnumVisitor<'de>: Sized {
/// `EnumVisitor` implementations should not override the default behavior.
#[inline]
fn visit_variant<V>(self) -> Result<(V, Self::Variant), Self::Error>
where V: Deserialize<'de>
where
V: Deserialize<'de>,
{
self.visit_variant_seed(PhantomData)
}
@@ -1556,7 +1669,8 @@ pub trait VariantVisitor<'de>: Sized {
/// # }
/// ```
fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
where T: DeserializeSeed<'de>;
where
T: DeserializeSeed<'de>;
/// Called when deserializing a variant with a single value.
///
@@ -1565,7 +1679,8 @@ pub trait VariantVisitor<'de>: Sized {
/// behavior.
#[inline]
fn visit_newtype<T>(self) -> Result<T, Self::Error>
where T: Deserialize<'de>
where
T: Deserialize<'de>,
{
self.visit_newtype_seed(PhantomData)
}
@@ -1609,7 +1724,8 @@ pub trait VariantVisitor<'de>: Sized {
/// # }
/// ```
fn visit_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>;
where
V: Visitor<'de>;
/// Called when deserializing a struct-like variant.
///
@@ -1649,11 +1765,13 @@ pub trait VariantVisitor<'de>: Sized {
/// }
/// # }
/// ```
fn visit_struct<V>(self,
fields: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor<'de>;
fn visit_struct<V>(
self,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>;
}
///////////////////////////////////////////////////////////////////////////////
serde/src/de/utf8.rs
+1 -4
View File
@@ -31,10 +31,7 @@ pub fn encode(c: char) -> Encode {
buf[3] = (code & 0x3F) as u8 | TAG_CONT;
0
};
Encode {
buf: buf,
pos: pos,
}
Encode { buf: buf, pos: pos }
}
pub struct Encode {
serde/src/de/value.rs
+171 -114
View File
@@ -51,7 +51,8 @@ impl error::Error for Error {
///////////////////////////////////////////////////////////////////////////////
impl<'de, E> IntoDeserializer<'de, E> for ()
where E: de::Error
where
E: de::Error,
{
type Deserializer = UnitDeserializer<E>;
@@ -67,7 +68,8 @@ pub struct UnitDeserializer<E> {
}
impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
@@ -78,13 +80,15 @@ impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
}
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
visitor.visit_unit()
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
visitor.visit_none()
}
@@ -156,7 +160,8 @@ pub struct U32Deserializer<E> {
}
impl<'de, E> IntoDeserializer<'de, E> for u32
where E: de::Error
where
E: de::Error,
{
type Deserializer = U32Deserializer<E>;
@@ -169,7 +174,8 @@ impl<'de, E> IntoDeserializer<'de, E> for u32
}
impl<'de, E> de::Deserializer<'de> for U32Deserializer<E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
@@ -180,30 +186,35 @@ impl<'de, E> de::Deserializer<'de> for U32Deserializer<E>
}
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
visitor.visit_u32(self.value)
}
fn deserialize_enum<V>(self,
_name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_enum(self)
}
}
impl<'de, E> de::EnumVisitor<'de> for U32Deserializer<E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
type Variant = private::UnitOnly<E>;
fn visit_variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
where T: de::DeserializeSeed<'de>
where
T: de::DeserializeSeed<'de>,
{
seed.deserialize(self).map(private::unit_only)
}
@@ -219,7 +230,8 @@ pub struct StrDeserializer<'a, E> {
}
impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
where E: de::Error
where
E: de::Error,
{
type Deserializer = StrDeserializer<'a, E>;
@@ -232,22 +244,26 @@ impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
}
impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
visitor.visit_str(self.value)
}
fn deserialize_enum<V>(self,
_name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_enum(self)
}
@@ -260,13 +276,15 @@ impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E>
}
impl<'de, 'a, E> de::EnumVisitor<'de> for StrDeserializer<'a, E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
type Variant = private::UnitOnly<E>;
fn visit_variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
where T: de::DeserializeSeed<'de>
where
T: de::DeserializeSeed<'de>,
{
seed.deserialize(self).map(private::unit_only)
}
@@ -284,7 +302,8 @@ pub struct StringDeserializer<E> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, E> IntoDeserializer<'de, E> for String
where E: de::Error
where
E: de::Error,
{
type Deserializer = StringDeserializer<E>;
@@ -298,22 +317,26 @@ impl<'de, E> IntoDeserializer<'de, E> for String
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, E> de::Deserializer<'de> for StringDeserializer<E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
visitor.visit_string(self.value)
}
fn deserialize_enum<V>(self,
_name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_enum(self)
}
@@ -327,13 +350,15 @@ impl<'de, E> de::Deserializer<'de> for StringDeserializer<E>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, 'a, E> de::EnumVisitor<'de> for StringDeserializer<E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
type Variant = private::UnitOnly<E>;
fn visit_variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
where T: de::DeserializeSeed<'de>
where
T: de::DeserializeSeed<'de>,
{
seed.deserialize(self).map(private::unit_only)
}
@@ -351,7 +376,8 @@ pub struct CowStrDeserializer<'a, E> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
where E: de::Error
where
E: de::Error,
{
type Deserializer = CowStrDeserializer<'a, E>;
@@ -365,12 +391,14 @@ impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
match self.value {
Cow::Borrowed(string) => visitor.visit_str(string),
@@ -378,12 +406,14 @@ impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
}
}
fn deserialize_enum<V>(self,
_name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
fn deserialize_enum<V>(
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
visitor.visit_enum(self)
}
@@ -397,13 +427,15 @@ impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, 'a, E> de::EnumVisitor<'de> for CowStrDeserializer<'a, E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
type Variant = private::UnitOnly<E>;
fn visit_variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
where T: de::DeserializeSeed<'de>
where
T: de::DeserializeSeed<'de>,
{
seed.deserialize(self).map(private::unit_only)
}
@@ -420,8 +452,9 @@ pub struct SeqDeserializer<I, E> {
}
impl<I, E> SeqDeserializer<I, E>
where I: Iterator,
E: de::Error
where
I: Iterator,
E: de::Error,
{
/// Construct a new `SeqDeserializer<I>`.
pub fn new(iter: I) -> Self {
@@ -444,20 +477,22 @@ impl<I, E> SeqDeserializer<I, E>
} else {
// First argument is the number of elements in the data, second
// argument is the number of elements expected by the Deserialize.
Err(de::Error::invalid_length(self.count + remaining, &ExpectedInSeq(self.count)))
Err(de::Error::invalid_length(self.count + remaining, &ExpectedInSeq(self.count)),)
}
}
}
impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E>
where I: Iterator<Item = T>,
T: IntoDeserializer<'de, E>,
E: de::Error
where
I: Iterator<Item = T>,
T: IntoDeserializer<'de, E>,
E: de::Error,
{
type Error = E;
fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
let v = try!(visitor.visit_seq(&mut self));
try!(self.end());
@@ -472,14 +507,16 @@ impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E>
}
impl<'de, I, T, E> de::SeqVisitor<'de> for SeqDeserializer<I, E>
where I: Iterator<Item = T>,
T: IntoDeserializer<'de, E>,
E: de::Error
where
I: Iterator<Item = T>,
T: IntoDeserializer<'de, E>,
E: de::Error,
{
type Error = E;
fn visit_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error>
where V: de::DeserializeSeed<'de>
where
V: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => {
@@ -511,8 +548,9 @@ impl Expected for ExpectedInSeq {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
where T: IntoDeserializer<'de, E>,
E: de::Error
where
T: IntoDeserializer<'de, E>,
E: de::Error,
{
type Deserializer = SeqDeserializer<<Vec<T> as IntoIterator>::IntoIter, E>;
@@ -523,8 +561,9 @@ impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
where T: IntoDeserializer<'de, E> + Eq + Ord,
E: de::Error
where
T: IntoDeserializer<'de, E> + Eq + Ord,
E: de::Error,
{
type Deserializer = SeqDeserializer<<BTreeSet<T> as IntoIterator>::IntoIter, E>;
@@ -535,8 +574,9 @@ impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
#[cfg(feature = "std")]
impl<'de, T, E> IntoDeserializer<'de, E> for HashSet<T>
where T: IntoDeserializer<'de, E> + Eq + Hash,
E: de::Error
where
T: IntoDeserializer<'de, E> + Eq + Hash,
E: de::Error,
{
type Deserializer = SeqDeserializer<<HashSet<T> as IntoIterator>::IntoIter, E>;
@@ -556,19 +596,19 @@ pub struct SeqVisitorDeserializer<V_> {
impl<V_> SeqVisitorDeserializer<V_> {
/// Construct a new `SeqVisitorDeserializer<V_, E>`.
pub fn new(visitor: V_) -> Self {
SeqVisitorDeserializer {
visitor: visitor,
}
SeqVisitorDeserializer { visitor: visitor }
}
}
impl<'de, V_> de::Deserializer<'de> for SeqVisitorDeserializer<V_>
where V_: de::SeqVisitor<'de>
where
V_: de::SeqVisitor<'de>,
{
type Error = V_::Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
visitor.visit_seq(self.visitor)
}
@@ -584,11 +624,12 @@ impl<'de, V_> de::Deserializer<'de> for SeqVisitorDeserializer<V_>
/// A helper deserializer that deserializes a map.
pub struct MapDeserializer<'de, I, E>
where I: Iterator,
I::Item: private::Pair,
<I::Item as private::Pair>::First: IntoDeserializer<'de, E>,
<I::Item as private::Pair>::Second: IntoDeserializer<'de, E>,
E: de::Error
where
I: Iterator,
I::Item: private::Pair,
<I::Item as private::Pair>::First: IntoDeserializer<'de, E>,
<I::Item as private::Pair>::Second: IntoDeserializer<'de, E>,
E: de::Error,
{
iter: iter::Fuse<I>,
value: Option<<I::Item as private::Pair>::Second>,
@@ -598,11 +639,14 @@ pub struct MapDeserializer<'de, I, E>
}
impl<'de, I, E> MapDeserializer<'de, I, E>
where I: Iterator,
I::Item: private::Pair,
<I::Item as private::Pair>::First: IntoDeserializer<'de, E>,
<I::Item as private::Pair>::Second: IntoDeserializer<'de, E>,
E: de::Error
where
I: Iterator,
I::Item: private::Pair,
<I::Item as private::Pair>::First: IntoDeserializer<'de,
E>,
<I::Item as private::Pair>::Second: IntoDeserializer<'de,
E>,
E: de::Error,
{
/// Construct a new `MapDeserializer<I, K, V, E>`.
pub fn new(iter: I) -> Self {
@@ -627,12 +671,12 @@ impl<'de, I, E> MapDeserializer<'de, I, E>
} else {
// First argument is the number of elements in the data, second
// argument is the number of elements expected by the Deserialize.
Err(de::Error::invalid_length(self.count + remaining, &ExpectedInMap(self.count)))
Err(de::Error::invalid_length(self.count + remaining, &ExpectedInMap(self.count)),)
}
}
fn next_pair
(&mut self)
(&mut self,)
-> Option<(<I::Item as private::Pair>::First, <I::Item as private::Pair>::Second)> {
match self.iter.next() {
Some(kv) => {
@@ -811,9 +855,10 @@ impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
where A: IntoDeserializer<'de, E>,
B: IntoDeserializer<'de, E>,
E: de::Error
where
A: IntoDeserializer<'de, E>,
B: IntoDeserializer<'de, E>,
E: de::Error,
{
type Error = E;
@@ -824,13 +869,15 @@ impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
}
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
self.deserialize_seq(visitor)
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData);
let pair = try!(visitor.visit_seq(&mut pair_visitor));
@@ -845,7 +892,8 @@ impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
}
fn deserialize_seq_fixed_size<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
if len == 2 {
self.deserialize_seq(visitor)
@@ -860,14 +908,16 @@ impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
impl<'de, A, B, E> de::SeqVisitor<'de> for PairVisitor<A, B, E>
where A: IntoDeserializer<'de, E>,
B: IntoDeserializer<'de, E>,
E: de::Error
where
A: IntoDeserializer<'de, E>,
B: IntoDeserializer<'de, E>,
E: de::Error,
{
type Error = E;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed<'de>
where
T: de::DeserializeSeed<'de>,
{
if let Some(k) = self.0.take() {
seed.deserialize(k.into_deserializer()).map(Some)
@@ -906,9 +956,10 @@ impl Expected for ExpectedInMap {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
where K: IntoDeserializer<'de, E> + Eq + Ord,
V: IntoDeserializer<'de, E>,
E: de::Error
where
K: IntoDeserializer<'de, E> + Eq + Ord,
V: IntoDeserializer<'de, E>,
E: de::Error,
{
type Deserializer = MapDeserializer<'de, <BTreeMap<K, V> as IntoIterator>::IntoIter, E>;
@@ -919,9 +970,10 @@ impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
#[cfg(feature = "std")]
impl<'de, K, V, E> IntoDeserializer<'de, E> for HashMap<K, V>
where K: IntoDeserializer<'de, E> + Eq + Hash,
V: IntoDeserializer<'de, E>,
E: de::Error
where
K: IntoDeserializer<'de, E> + Eq + Hash,
V: IntoDeserializer<'de, E>,
E: de::Error,
{
type Deserializer = MapDeserializer<'de, <HashMap<K, V> as IntoIterator>::IntoIter, E>;
@@ -941,19 +993,19 @@ pub struct MapVisitorDeserializer<V_> {
impl<V_> MapVisitorDeserializer<V_> {
/// Construct a new `MapVisitorDeserializer<V_, E>`.
pub fn new(visitor: V_) -> Self {
MapVisitorDeserializer {
visitor: visitor,
}
MapVisitorDeserializer { visitor: visitor }
}
}
impl<'de, V_> de::Deserializer<'de> for MapVisitorDeserializer<V_>
where V_: de::MapVisitor<'de>
where
V_: de::MapVisitor<'de>,
{
type Error = V_::Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
visitor.visit_map(self.visitor)
}
@@ -982,7 +1034,8 @@ mod private {
}
impl<'de, E> de::VariantVisitor<'de> for UnitOnly<E>
where E: de::Error
where
E: de::Error,
{
type Error = E;
@@ -991,24 +1044,28 @@ mod private {
}
fn visit_newtype_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
where T: de::DeserializeSeed<'de>
where
T: de::DeserializeSeed<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"))
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),)
}
fn visit_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),)
}
fn visit_struct<V>(self,
_fields: &'static [&'static str],
_visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor<'de>
fn visit_struct<V>(
self,
_fields: &'static [&'static str],
_visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),)
}
}
serde/src/lib.rs
+1 -1
View File
@@ -135,7 +135,7 @@ mod lib {
pub use std::string::String;
#[cfg(all(feature = "collections", not(feature = "std")))]
pub use collections::string::{String, ToString};
#[cfg(feature = "std")]
pub use std::vec::Vec;
#[cfg(all(feature = "collections", not(feature = "std")))]
serde/src/private/de.rs
+436 -221
View File
File diff suppressed because it is too large Load Diff
serde/src/private/ser.rs
+258 -188
View File
@@ -12,23 +12,27 @@ pub fn constrain<T: ?Sized>(t: &T) -> &T {
}
/// Not public API.
pub fn serialize_tagged_newtype<S, T>(serializer: S,
type_ident: &'static str,
variant_ident: &'static str,
tag: &'static str,
variant_name: &'static str,
value: &T)
-> Result<S::Ok, S::Error>
where S: Serializer,
T: Serialize
pub fn serialize_tagged_newtype<S, T>(
serializer: S,
type_ident: &'static str,
variant_ident: &'static str,
tag: &'static str,
variant_name: &'static str,
value: &T,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
T: Serialize,
{
value.serialize(TaggedSerializer {
type_ident: type_ident,
variant_ident: variant_ident,
tag: tag,
variant_name: variant_name,
delegate: serializer,
})
value.serialize(
TaggedSerializer {
type_ident: type_ident,
variant_ident: variant_ident,
tag: tag,
variant_name: variant_name,
delegate: serializer,
},
)
}
struct TaggedSerializer<S> {
@@ -78,19 +82,23 @@ impl Display for Unsupported {
}
impl<S> TaggedSerializer<S>
where S: Serializer
where
S: Serializer,
{
fn bad_type(self, what: Unsupported) -> S::Error {
ser::Error::custom(format_args!(
ser::Error::custom(
format_args!(
"cannot serialize tagged newtype variant {}::{} containing {}",
self.type_ident,
self.variant_ident,
what))
what),
)
}
}
impl<S> Serializer for TaggedSerializer<S>
where S: Serializer
where
S: Serializer,
{
type Ok = S::Ok;
type Error = S::Error;
@@ -172,7 +180,8 @@ impl<S> Serializer for TaggedSerializer<S>
}
fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
where T: Serialize
where
T: Serialize,
{
Err(self.bad_type(Unsupported::Optional))
}
@@ -185,33 +194,38 @@ impl<S> Serializer for TaggedSerializer<S>
Err(self.bad_type(Unsupported::UnitStruct))
}
fn serialize_unit_variant(self,
_: &'static str,
_: u32,
inner_variant: &'static str)
-> Result<Self::Ok, Self::Error> {
fn serialize_unit_variant(
self,
_: &'static str,
_: u32,
inner_variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
let mut map = try!(self.delegate.serialize_map(Some(2)));
try!(map.serialize_entry(self.tag, self.variant_name));
try!(map.serialize_entry(inner_variant, &()));
map.end()
}
fn serialize_newtype_struct<T: ?Sized>(self,
_: &'static str,
value: &T)
-> Result<Self::Ok, Self::Error>
where T: Serialize
fn serialize_newtype_struct<T: ?Sized>(
self,
_: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
value.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized>(self,
_: &'static str,
_: u32,
inner_variant: &'static str,
inner_value: &T)
-> Result<Self::Ok, Self::Error>
where T: Serialize
fn serialize_newtype_variant<T: ?Sized>(
self,
_: &'static str,
_: u32,
inner_variant: &'static str,
inner_value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
let mut map = try!(self.delegate.serialize_map(Some(2)));
try!(map.serialize_entry(self.tag, self.variant_name));
@@ -231,36 +245,39 @@ impl<S> Serializer for TaggedSerializer<S>
Err(self.bad_type(Unsupported::Tuple))
}
fn serialize_tuple_struct(self,
_: &'static str,
_: usize)
-> Result<Self::SerializeTupleStruct, Self::Error> {
fn serialize_tuple_struct(
self,
_: &'static str,
_: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
Err(self.bad_type(Unsupported::TupleStruct))
}
#[cfg(not(any(feature = "std", feature = "collections")))]
fn serialize_tuple_variant(self,
_: &'static str,
_: u32,
_: &'static str,
_: usize)
-> Result<Self::SerializeTupleVariant, Self::Error> {
fn serialize_tuple_variant(
self,
_: &'static str,
_: u32,
_: &'static str,
_: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
// Lack of push-based serialization means we need to buffer the content
// of the tuple variant, so it requires std.
Err(self.bad_type(Unsupported::Enum))
}
#[cfg(any(feature = "std", feature = "collections"))]
fn serialize_tuple_variant(self,
_: &'static str,
_: u32,
inner_variant: &'static str,
len: usize)
-> Result<Self::SerializeTupleVariant, Self::Error> {
fn serialize_tuple_variant(
self,
_: &'static str,
_: u32,
inner_variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
let mut map = try!(self.delegate.serialize_map(Some(2)));
try!(map.serialize_entry(self.tag, self.variant_name));
try!(map.serialize_key(inner_variant));
Ok(SerializeTupleVariantAsMapValue::new(map, inner_variant, len))
Ok(SerializeTupleVariantAsMapValue::new(map, inner_variant, len),)
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
@@ -269,43 +286,47 @@ impl<S> Serializer for TaggedSerializer<S>
Ok(map)
}
fn serialize_struct(self,
name: &'static str,
len: usize)
-> Result<Self::SerializeStruct, Self::Error> {
fn serialize_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
let mut state = try!(self.delegate.serialize_struct(name, len + 1));
try!(state.serialize_field(self.tag, self.variant_name));
Ok(state)
}
#[cfg(not(any(feature = "std", feature = "collections")))]
fn serialize_struct_variant(self,
_: &'static str,
_: u32,
_: &'static str,
_: usize)
-> Result<Self::SerializeStructVariant, Self::Error> {
fn serialize_struct_variant(
self,
_: &'static str,
_: u32,
_: &'static str,
_: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
// Lack of push-based serialization means we need to buffer the content
// of the struct variant, so it requires std.
Err(self.bad_type(Unsupported::Enum))
}
#[cfg(any(feature = "std", feature = "collections"))]
fn serialize_struct_variant(self,
_: &'static str,
_: u32,
inner_variant: &'static str,
len: usize)
-> Result<Self::SerializeStructVariant, Self::Error> {
fn serialize_struct_variant(
self,
_: &'static str,
_: u32,
inner_variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
let mut map = try!(self.delegate.serialize_map(Some(2)));
try!(map.serialize_entry(self.tag, self.variant_name));
try!(map.serialize_key(inner_variant));
Ok(SerializeStructVariantAsMapValue::new(map, inner_variant, len))
Ok(SerializeStructVariantAsMapValue::new(map, inner_variant, len),)
}
#[cfg(not(any(feature = "std", feature = "collections")))]
fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
where T: Display
where
T: Display,
{
Err(self.bad_type(Unsupported::String))
}
@@ -358,7 +379,8 @@ mod content {
}
impl<M> ser::SerializeTupleVariant for SerializeTupleVariantAsMapValue<M>
where M: ser::SerializeMap
where
M: ser::SerializeMap,
{
type Ok = M::Ok;
type Error = M::Error;
@@ -392,15 +414,17 @@ mod content {
}
impl<M> ser::SerializeStructVariant for SerializeStructVariantAsMapValue<M>
where M: ser::SerializeMap
where
M: ser::SerializeMap,
{
type Ok = M::Ok;
type Error = M::Error;
fn serialize_field<T: ?Sized + Serialize>(&mut self,
key: &'static str,
value: &T)
-> Result<(), M::Error> {
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), M::Error> {
let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push((key, value));
Ok(())
@@ -454,7 +478,8 @@ mod content {
impl Serialize for Content {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
match *self {
Content::Bool(b) => serializer.serialize_bool(b),
@@ -552,7 +577,8 @@ mod content {
}
impl<E> Serializer for ContentSerializer<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
@@ -637,111 +663,141 @@ mod content {
Ok(Content::UnitStruct(name))
}
fn serialize_unit_variant(self,
name: &'static str,
variant_index: u32,
variant: &'static str)
-> Result<Content, E> {
fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
) -> Result<Content, E> {
Ok(Content::UnitVariant(name, variant_index, variant))
}
fn serialize_newtype_struct<T: ?Sized + Serialize>(self,
name: &'static str,
value: &T)
-> Result<Content, E> {
Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self)))))
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
name: &'static str,
value: &T,
) -> Result<Content, E> {
Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self)))),)
}
fn serialize_newtype_variant<T: ?Sized + Serialize>(self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T)
-> Result<Content, E> {
Ok(Content::NewtypeVariant(name,
variant_index,
variant,
Box::new(try!(value.serialize(self)))))
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T,
) -> Result<Content, E> {
Ok(
Content::NewtypeVariant(
name,
variant_index,
variant,
Box::new(try!(value.serialize(self))),
),
)
}
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, E> {
Ok(SerializeSeq {
fixed_size: false,
elements: Vec::with_capacity(len.unwrap_or(0)),
error: PhantomData,
})
Ok(
SerializeSeq {
fixed_size: false,
elements: Vec::with_capacity(len.unwrap_or(0)),
error: PhantomData,
},
)
}
fn serialize_seq_fixed_size(self, size: usize) -> Result<Self::SerializeSeq, E> {
Ok(SerializeSeq {
fixed_size: true,
elements: Vec::with_capacity(size),
error: PhantomData,
})
Ok(
SerializeSeq {
fixed_size: true,
elements: Vec::with_capacity(size),
error: PhantomData,
},
)
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> {
Ok(SerializeTuple {
elements: Vec::with_capacity(len),
error: PhantomData,
})
Ok(
SerializeTuple {
elements: Vec::with_capacity(len),
error: PhantomData,
},
)
}
fn serialize_tuple_struct(self,
name: &'static str,
len: usize)
-> Result<Self::SerializeTupleStruct, E> {
Ok(SerializeTupleStruct {
name: name,
fields: Vec::with_capacity(len),
error: PhantomData,
})
fn serialize_tuple_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeTupleStruct, E> {
Ok(
SerializeTupleStruct {
name: name,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
}
fn serialize_tuple_variant(self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize)
-> Result<Self::SerializeTupleVariant, E> {
Ok(SerializeTupleVariant {
name: name,
variant_index: variant_index,
variant: variant,
fields: Vec::with_capacity(len),
error: PhantomData,
})
fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, E> {
Ok(
SerializeTupleVariant {
name: name,
variant_index: variant_index,
variant: variant,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
}
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, E> {
Ok(SerializeMap {
entries: Vec::with_capacity(len.unwrap_or(0)),
key: None,
error: PhantomData,
})
Ok(
SerializeMap {
entries: Vec::with_capacity(len.unwrap_or(0)),
key: None,
error: PhantomData,
},
)
}
fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, E> {
Ok(SerializeStruct {
name: name,
fields: Vec::with_capacity(len),
error: PhantomData,
})
fn serialize_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, E> {
Ok(
SerializeStruct {
name: name,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
}
fn serialize_struct_variant(self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize)
-> Result<Self::SerializeStructVariant, E> {
Ok(SerializeStructVariant {
name: name,
variant_index: variant_index,
variant: variant,
fields: Vec::with_capacity(len),
error: PhantomData,
})
fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant, E> {
Ok(
SerializeStructVariant {
name: name,
variant_index: variant_index,
variant: variant,
fields: Vec::with_capacity(len),
error: PhantomData,
},
)
}
}
@@ -752,7 +808,8 @@ mod content {
}
impl<E> ser::SerializeSeq for SerializeSeq<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
@@ -764,11 +821,13 @@ mod content {
}
fn end(self) -> Result<Content, E> {
Ok(if self.fixed_size {
Content::SeqFixedSize(self.elements)
} else {
Content::Seq(self.elements)
})
Ok(
if self.fixed_size {
Content::SeqFixedSize(self.elements)
} else {
Content::Seq(self.elements)
},
)
}
}
@@ -778,7 +837,8 @@ mod content {
}
impl<E> ser::SerializeTuple for SerializeTuple<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
@@ -801,7 +861,8 @@ mod content {
}
impl<E> ser::SerializeTupleStruct for SerializeTupleStruct<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
@@ -826,7 +887,8 @@ mod content {
}
impl<E> ser::SerializeTupleVariant for SerializeTupleVariant<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
@@ -838,7 +900,7 @@ mod content {
}
fn end(self) -> Result<Content, E> {
Ok(Content::TupleVariant(self.name, self.variant_index, self.variant, self.fields))
Ok(Content::TupleVariant(self.name, self.variant_index, self.variant, self.fields),)
}
}
@@ -849,7 +911,8 @@ mod content {
}
impl<E> ser::SerializeMap for SerializeMap<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
@@ -861,7 +924,9 @@ mod content {
}
fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
let key = self.key.take().expect("serialize_value called before serialize_key");
let key = self.key
.take()
.expect("serialize_value called before serialize_key");
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.entries.push((key, value));
Ok(())
@@ -871,10 +936,11 @@ mod content {
Ok(Content::Map(self.entries))
}
fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(&mut self,
key: &K,
value: &V)
-> Result<(), E> {
fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(
&mut self,
key: &K,
value: &V,
) -> Result<(), E> {
let key = try!(key.serialize(ContentSerializer::<E>::new()));
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.entries.push((key, value));
@@ -889,15 +955,17 @@ mod content {
}
impl<E> ser::SerializeStruct for SerializeStruct<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self,
key: &'static str,
value: &T)
-> Result<(), E> {
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), E> {
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value));
Ok(())
@@ -917,22 +985,24 @@ mod content {
}
impl<E> ser::SerializeStructVariant for SerializeStructVariant<E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Content;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self,
key: &'static str,
value: &T)
-> Result<(), E> {
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), E> {
let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value));
Ok(())
}
fn end(self) -> Result<Content, E> {
Ok(Content::StructVariant(self.name, self.variant_index, self.variant, self.fields))
Ok(Content::StructVariant(self.name, self.variant_index, self.variant, self.fields),)
}
}
}
serde/src/ser/impls.rs
+101 -60
View File
@@ -40,7 +40,8 @@ impl_visit!(char, serialize_char);
impl Serialize for str {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
serializer.serialize_str(self)
}
@@ -50,7 +51,8 @@ impl Serialize for str {
impl Serialize for String {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(&self[..]).serialize(serializer)
}
@@ -62,7 +64,8 @@ impl Serialize for String {
impl Serialize for CStr {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
serializer.serialize_bytes(self.to_bytes())
}
@@ -72,7 +75,8 @@ impl Serialize for CStr {
impl Serialize for CString {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
serializer.serialize_bytes(self.to_bytes())
}
@@ -81,11 +85,13 @@ impl Serialize for CString {
///////////////////////////////////////////////////////////////////////////////
impl<T> Serialize for Option<T>
where T: Serialize
where
T: Serialize,
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
match *self {
Some(ref value) => serializer.serialize_some(value),
@@ -99,7 +105,8 @@ impl<T> Serialize for Option<T>
impl<T> Serialize for PhantomData<T> {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
serializer.serialize_unit_struct("PhantomData")
}
@@ -111,7 +118,8 @@ impl<T> Serialize for PhantomData<T> {
impl<T> Serialize for [T; 0] {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
try!(serializer.serialize_seq_fixed_size(0)).end()
}
@@ -181,50 +189,57 @@ macro_rules! serialize_seq {
}
impl<T> Serialize for [T]
where T: Serialize
where
T: Serialize,
{
serialize_seq!();
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for BinaryHeap<T>
where T: Serialize + Ord
where
T: Serialize + Ord,
{
serialize_seq!();
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for BTreeSet<T>
where T: Serialize + Ord
where
T: Serialize + Ord,
{
serialize_seq!();
}
#[cfg(feature = "std")]
impl<T, H> Serialize for HashSet<T, H>
where T: Serialize + Eq + Hash,
H: BuildHasher
where
T: Serialize + Eq + Hash,
H: BuildHasher,
{
serialize_seq!();
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for LinkedList<T>
where T: Serialize
where
T: Serialize,
{
serialize_seq!();
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for Vec<T>
where T: Serialize
where
T: Serialize,
{
serialize_seq!();
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for VecDeque<T>
where T: Serialize
where
T: Serialize,
{
serialize_seq!();
}
@@ -234,7 +249,8 @@ impl<T> Serialize for VecDeque<T>
#[cfg(feature = "std")]
impl<Idx: Serialize> Serialize for ops::Range<Idx> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
use super::SerializeStruct;
let mut state = try!(serializer.serialize_struct("Range", 2));
@@ -249,7 +265,8 @@ impl<Idx: Serialize> Serialize for ops::Range<Idx> {
impl Serialize for () {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
serializer.serialize_unit()
}
@@ -468,17 +485,19 @@ macro_rules! serialize_map {
#[cfg(any(feature = "std", feature = "collections"))]
impl<K, V> Serialize for BTreeMap<K, V>
where K: Serialize + Ord,
V: Serialize
where
K: Serialize + Ord,
V: Serialize,
{
serialize_map!();
}
#[cfg(feature = "std")]
impl<K, V, H> Serialize for HashMap<K, V, H>
where K: Serialize + Eq + Hash,
V: Serialize,
H: BuildHasher
where
K: Serialize + Eq + Hash,
V: Serialize,
H: BuildHasher,
{
serialize_map!();
}
@@ -486,22 +505,26 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
///////////////////////////////////////////////////////////////////////////////
impl<'a, T: ?Sized> Serialize for &'a T
where T: Serialize
where
T: Serialize,
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(**self).serialize(serializer)
}
}
impl<'a, T: ?Sized> Serialize for &'a mut T
where T: Serialize
where
T: Serialize,
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(**self).serialize(serializer)
}
@@ -509,11 +532,13 @@ impl<'a, T: ?Sized> Serialize for &'a mut T
#[cfg(any(feature = "std", feature = "alloc"))]
impl<T: ?Sized> Serialize for Box<T>
where T: Serialize
where
T: Serialize,
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(**self).serialize(serializer)
}
@@ -521,11 +546,13 @@ impl<T: ?Sized> Serialize for Box<T>
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
impl<T> Serialize for Rc<T>
where T: Serialize
where
T: Serialize,
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(**self).serialize(serializer)
}
@@ -533,11 +560,13 @@ impl<T> Serialize for Rc<T>
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
impl<T> Serialize for Arc<T>
where T: Serialize
where
T: Serialize,
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(**self).serialize(serializer)
}
@@ -545,11 +574,13 @@ impl<T> Serialize for Arc<T>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'a, T: ?Sized> Serialize for Cow<'a, T>
where T: Serialize + ToOwned
where
T: Serialize + ToOwned,
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(**self).serialize(serializer)
}
@@ -558,11 +589,13 @@ impl<'a, T: ?Sized> Serialize for Cow<'a, T>
///////////////////////////////////////////////////////////////////////////////
impl<T, E> Serialize for Result<T, E>
where T: Serialize,
E: Serialize
where
T: Serialize,
E: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
match *self {
Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value),
@@ -578,7 +611,8 @@ impl<T, E> Serialize for Result<T, E>
#[cfg(feature = "std")]
impl Serialize for Duration {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
use super::SerializeStruct;
let mut state = try!(serializer.serialize_struct("Duration", 2));
@@ -623,7 +657,8 @@ macro_rules! serialize_display_bounded_length {
#[cfg(feature = "std")]
impl Serialize for net::IpAddr {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
match *self {
net::IpAddr::V4(ref a) => a.serialize(serializer),
@@ -635,7 +670,8 @@ impl Serialize for net::IpAddr {
#[cfg(feature = "std")]
impl Serialize for net::Ipv4Addr {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
/// "101.102.103.104".len()
const MAX_LEN: usize = 15;
@@ -646,7 +682,8 @@ impl Serialize for net::Ipv4Addr {
#[cfg(feature = "std")]
impl Serialize for net::Ipv6Addr {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
/// "1000:1002:1003:1004:1005:1006:1007:1008".len()
const MAX_LEN: usize = 39;
@@ -659,7 +696,8 @@ impl Serialize for net::Ipv6Addr {
#[cfg(feature = "std")]
impl Serialize for net::SocketAddr {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
match *self {
net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
@@ -671,7 +709,8 @@ impl Serialize for net::SocketAddr {
#[cfg(feature = "std")]
impl Serialize for net::SocketAddrV4 {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
/// "101.102.103.104:65000".len()
const MAX_LEN: usize = 21;
@@ -682,7 +721,8 @@ impl Serialize for net::SocketAddrV4 {
#[cfg(feature = "std")]
impl Serialize for net::SocketAddrV6 {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
/// "[1000:1002:1003:1004:1005:1006:1007:1008]:65000".len()
const MAX_LEN: usize = 47;
@@ -695,7 +735,8 @@ impl Serialize for net::SocketAddrV6 {
#[cfg(feature = "std")]
impl Serialize for path::Path {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
match self.to_str() {
Some(s) => s.serialize(serializer),
@@ -707,7 +748,8 @@ impl Serialize for path::Path {
#[cfg(feature = "std")]
impl Serialize for path::PathBuf {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
self.as_path().serialize(serializer)
}
@@ -717,24 +759,20 @@ impl Serialize for path::PathBuf {
impl Serialize for OsStr {
#[cfg(unix)]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
use std::os::unix::ffi::OsStrExt;
serializer.serialize_newtype_variant("OsString",
0,
"Unix",
self.as_bytes())
serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes())
}
#[cfg(windows)]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
use std::os::windows::ffi::OsStrExt;
let val = self.encode_wide().collect::<Vec<_>>();
serializer.serialize_newtype_variant("OsString",
1,
"Windows",
&val)
serializer.serialize_newtype_variant("OsString", 1, "Windows", &val)
}
}
@@ -742,7 +780,8 @@ impl Serialize for OsStr {
#[cfg(feature = "std")]
impl Serialize for OsString {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
self.as_os_str().serialize(serializer)
}
@@ -750,10 +789,12 @@ impl Serialize for OsString {
#[cfg(feature = "unstable")]
impl<T> Serialize for NonZero<T>
where T: Serialize + Zeroable
where
T: Serialize + Zeroable,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
(**self).serialize(serializer)
}
serde/src/ser/impossible.rs
+24 -15
View File
@@ -60,7 +60,8 @@ pub struct Impossible<Ok, E> {
enum Void {}
impl<Ok, E> SerializeSeq for Impossible<Ok, E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Ok;
type Error = E;
@@ -75,7 +76,8 @@ impl<Ok, E> SerializeSeq for Impossible<Ok, E>
}
impl<Ok, E> SerializeTuple for Impossible<Ok, E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Ok;
type Error = E;
@@ -90,7 +92,8 @@ impl<Ok, E> SerializeTuple for Impossible<Ok, E>
}
impl<Ok, E> SerializeTupleStruct for Impossible<Ok, E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Ok;
type Error = E;
@@ -105,7 +108,8 @@ impl<Ok, E> SerializeTupleStruct for Impossible<Ok, E>
}
impl<Ok, E> SerializeTupleVariant for Impossible<Ok, E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Ok;
type Error = E;
@@ -120,7 +124,8 @@ impl<Ok, E> SerializeTupleVariant for Impossible<Ok, E>
}
impl<Ok, E> SerializeMap for Impossible<Ok, E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Ok;
type Error = E;
@@ -139,15 +144,17 @@ impl<Ok, E> SerializeMap for Impossible<Ok, E>
}
impl<Ok, E> SerializeStruct for Impossible<Ok, E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Ok;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), E> {
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
_key: &'static str,
_value: &T,
) -> Result<(), E> {
match self.void {}
}
@@ -157,15 +164,17 @@ impl<Ok, E> SerializeStruct for Impossible<Ok, E>
}
impl<Ok, E> SerializeStructVariant for Impossible<Ok, E>
where E: ser::Error
where
E: ser::Error,
{
type Ok = Ok;
type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self,
_key: &'static str,
_value: &T)
-> Result<(), E> {
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
_key: &'static str,
_value: &T,
) -> Result<(), E> {
match self.void {}
}
serde/src/ser/mod.rs
+71 -55
View File
@@ -182,7 +182,9 @@ pub trait Serialize {
/// for more information about how to implement this method.
///
/// [impl-serialize]: https://serde.rs/impl-serialize.html
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer;
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer;
}
///////////////////////////////////////////////////////////////////////////////
@@ -437,11 +439,12 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_unit_variant(self,
name: &'static str,
variant_index: u32,
variant: &'static str)
-> Result<Self::Ok, Self::Error>;
fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
) -> Result<Self::Ok, Self::Error>;
/// Serialize a newtype struct like `struct Millimeters(u8)`.
///
@@ -462,10 +465,11 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_newtype_struct<T: ?Sized + Serialize>(self,
name: &'static str,
value: &T)
-> Result<Self::Ok, Self::Error>;
fn serialize_newtype_struct<T: ?Sized + Serialize>(
self,
name: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>;
/// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
///
@@ -492,12 +496,13 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_newtype_variant<T: ?Sized + Serialize>(self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T)
-> Result<Self::Ok, Self::Error>;
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>;
/// Begin to serialize a dynamically sized sequence. This call must be
/// followed by zero or more calls to `serialize_element`, then a call to
@@ -630,10 +635,11 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_tuple_struct(self,
name: &'static str,
len: usize)
-> Result<Self::SerializeTupleStruct, Self::Error>;
fn serialize_tuple_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error>;
/// Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8)
/// }`. This call must be followed by zero or more calls to
@@ -674,12 +680,13 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_tuple_variant(self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize)
-> Result<Self::SerializeTupleVariant, Self::Error>;
fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error>;
/// Begin to serialize a map. This call must be followed by zero or more
/// calls to `serialize_key` and `serialize_value`, then a call to `end`.
@@ -757,10 +764,11 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_struct(self,
name: &'static str,
len: usize)
-> Result<Self::SerializeStruct, Self::Error>;
fn serialize_struct(
self,
name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error>;
/// Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8,
/// g: u8, b: u8 } }`. This call must be followed by zero or more calls to
@@ -794,12 +802,13 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_struct_variant(self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize)
-> Result<Self::SerializeStructVariant, Self::Error>;
fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error>;
/// Collect an iterator as a sequence.
///
@@ -807,8 +816,9 @@ pub trait Serializer: Sized {
/// using `Self::SerializeSeq`. Implementors should not need to override
/// this method.
fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
where I: IntoIterator,
<I as IntoIterator>::Item: Serialize
where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
{
let iter = iter.into_iter();
let mut serializer = try!(self.serialize_seq(iter.len_hint()));
@@ -824,9 +834,10 @@ pub trait Serializer: Sized {
/// using `Self::SerializeMap`. Implementors should not need to override
/// this method.
fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
where K: Serialize,
V: Serialize,
I: IntoIterator<Item = (K, V)>
where
K: Serialize,
V: Serialize,
I: IntoIterator<Item = (K, V)>,
{
let iter = iter.into_iter();
let mut serializer = try!(self.serialize_map(iter.len_hint()));
@@ -864,7 +875,8 @@ pub trait Serializer: Sized {
/// ```
#[cfg(any(feature = "std", feature = "collections"))]
fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
where T: Display
where
T: Display,
{
use lib::fmt::Write;
let mut string = String::new();
@@ -900,7 +912,8 @@ pub trait Serializer: Sized {
/// ```
#[cfg(not(any(feature = "std", feature = "collections")))]
fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
where T: Display;
where
T: Display;
}
/// Returned from `Serializer::serialize_seq` and
@@ -1174,10 +1187,11 @@ pub trait SerializeMap {
/// `serialize_value`. This is appropriate for serializers that do not care
/// about performance or are not able to optimize `serialize_entry` any
/// better than this.
fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(&mut self,
key: &K,
value: &V)
-> Result<(), Self::Error> {
fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(
&mut self,
key: &K,
value: &V,
) -> Result<(), Self::Error> {
try!(self.serialize_key(key));
self.serialize_value(value)
}
@@ -1218,10 +1232,11 @@ pub trait SerializeStruct {
type Error: Error;
/// Serialize a struct field.
fn serialize_field<T: ?Sized + Serialize>(&mut self,
key: &'static str,
value: &T)
-> Result<(), Self::Error>;
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>;
/// Finish serializing a struct.
fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1261,10 +1276,11 @@ pub trait SerializeStructVariant {
type Error: Error;
/// Serialize a struct variant field.
fn serialize_field<T: ?Sized + Serialize>(&mut self,
key: &'static str,
value: &T)
-> Result<(), Self::Error>;
fn serialize_field<T: ?Sized + Serialize>(
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>;
/// Finish serializing a struct variant.
fn end(self) -> Result<Self::Ok, Self::Error>;