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

Rustfmt

Browse Source
This commit is contained in:
David Tolnay
2017-02-12 21:59:04 -08:00
parent 964a2dd4d1
commit e8651a52e7
24 changed files with 1220 additions and 1443 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/src/bytes.rs
+20 -16
View File
@@ -60,9 +60,7 @@ pub struct Bytes<'a> {
impl<'a> Bytes<'a> {
/// Wrap an existing `&[u8]`.
pub fn new(bytes: &'a [u8]) -> Self {
Bytes {
bytes: bytes,
}
Bytes { bytes: bytes }
}
}
@@ -98,7 +96,9 @@ impl<'a> Into<&'a [u8]> for Bytes<'a> {
impl<'a> ops::Deref for Bytes<'a> {
type Target = [u8];
fn deref(&self) -> &[u8] { self.bytes }
fn deref(&self) -> &[u8] {
self.bytes
}
}
impl<'a> ser::Serialize for Bytes<'a> {
@@ -161,9 +161,7 @@ mod bytebuf {
/// Wrap existing bytes in a `ByteBuf`.
pub fn from<T: Into<Vec<u8>>>(bytes: T) -> Self {
ByteBuf {
bytes: bytes.into(),
}
ByteBuf { bytes: bytes.into() }
}
}
@@ -216,11 +214,15 @@ mod bytebuf {
impl ops::Deref for ByteBuf {
type Target = [u8];
fn deref(&self) -> &[u8] { &self.bytes[..] }
fn deref(&self) -> &[u8] {
&self.bytes[..]
}
}
impl ops::DerefMut for ByteBuf {
fn deref_mut(&mut self) -> &mut [u8] { &mut self.bytes[..] }
fn deref_mut(&mut self) -> &mut [u8] {
&mut self.bytes[..]
}
}
impl ser::Serialize for ByteBuf {
@@ -243,14 +245,14 @@ mod bytebuf {
#[inline]
fn visit_unit<E>(self) -> Result<ByteBuf, E>
where E: de::Error,
where E: de::Error
{
Ok(ByteBuf::new())
}
#[inline]
fn visit_seq<V>(self, mut visitor: V) -> Result<ByteBuf, V::Error>
where V: de::SeqVisitor,
where V: de::SeqVisitor
{
let (len, _) = visitor.size_hint();
let mut values = Vec::with_capacity(len);
@@ -264,26 +266,26 @@ mod bytebuf {
#[inline]
fn visit_bytes<E>(self, v: &[u8]) -> Result<ByteBuf, E>
where E: de::Error,
where E: de::Error
{
Ok(ByteBuf::from(v))
}
#[inline]
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<ByteBuf, E>
where E: de::Error,
where E: de::Error
{
Ok(ByteBuf::from(v))
}
fn visit_str<E>(self, v: &str) -> Result<ByteBuf, E>
where E: de::Error,
where E: de::Error
{
Ok(ByteBuf::from(v))
}
fn visit_string<E>(self, v: String) -> Result<ByteBuf, E>
where E: de::Error,
where E: de::Error
{
Ok(ByteBuf::from(v))
}
@@ -302,7 +304,9 @@ mod bytebuf {
///////////////////////////////////////////////////////////////////////////////
#[inline]
fn escape_bytestring<'a>(bytes: &'a [u8]) -> iter::FlatMap<slice::Iter<'a, u8>, char::EscapeDefault, fn(&u8) -> char::EscapeDefault> {
fn escape_bytestring<'a>
(bytes: &'a [u8])
-> iter::FlatMap<slice::Iter<'a, u8>, char::EscapeDefault, fn(&u8) -> char::EscapeDefault> {
fn f(b: &u8) -> char::EscapeDefault {
char::from_u32(*b as u32).unwrap().escape_default()
}
serde/src/de/content.rs
+15 -24
View File
@@ -19,16 +19,8 @@ use collections::{String, Vec};
#[cfg(all(feature = "alloc", not(feature = "std")))]
use alloc::boxed::Box;
use de::{
self,
Deserialize,
DeserializeSeed,
Deserializer,
Visitor,
SeqVisitor,
MapVisitor,
EnumVisitor,
};
use de::{self, Deserialize, DeserializeSeed, Deserializer, Visitor, SeqVisitor, MapVisitor,
EnumVisitor};
/// Used from generated code to buffer the contents of the Deserializer when
/// deserializing untagged enums and internally tagged enums.
@@ -243,9 +235,7 @@ struct TagOrContentVisitor {
impl TagOrContentVisitor {
fn new(name: &'static str) -> Self {
TagOrContentVisitor {
name: name,
}
TagOrContentVisitor { name: name }
}
}
@@ -491,9 +481,7 @@ impl<T> Visitor for TaggedContentVisitor<T>
}
}
match tag {
None => {
Err(de::Error::missing_field(self.tag_name))
}
None => Err(de::Error::missing_field(self.tag_name)),
Some(tag) => {
Ok(TaggedContent {
tag: tag,
@@ -544,14 +532,15 @@ impl<E> Deserializer for ContentDeserializer<E>
let value = try!(visitor.visit_seq(&mut seq_visitor));
try!(seq_visitor.end());
Ok(value)
},
}
Content::Map(v) => {
let map = v.into_iter().map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
let map = v.into_iter()
.map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
let mut map_visitor = de::value::MapDeserializer::new(map);
let value = try!(visitor.visit_map(&mut map_visitor));
try!(map_visitor.end());
Ok(value)
},
}
Content::Bytes(v) => visitor.visit_byte_buf(v),
}
}
@@ -563,7 +552,7 @@ impl<E> Deserializer for ContentDeserializer<E>
Content::None => visitor.visit_none(),
Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
Content::Unit => visitor.visit_unit(),
_ => visitor.visit_some(self)
_ => visitor.visit_some(self),
}
}
@@ -630,14 +619,16 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
let value = try!(visitor.visit_seq(&mut seq_visitor));
try!(seq_visitor.end());
Ok(value)
},
}
Content::Map(ref v) => {
let map = v.into_iter().map(|&(ref k, ref v)| (ContentRefDeserializer::new(k), ContentRefDeserializer::new(v)));
let map = v.into_iter().map(|&(ref k, ref v)| {
(ContentRefDeserializer::new(k), ContentRefDeserializer::new(v))
});
let mut map_visitor = de::value::MapDeserializer::new(map);
let value = try!(visitor.visit_map(&mut map_visitor));
try!(map_visitor.end());
Ok(value)
},
}
Content::Bytes(ref v) => visitor.visit_bytes(v),
}
}
@@ -649,7 +640,7 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
Content::None => visitor.visit_none(),
Content::Some(ref v) => visitor.visit_some(ContentRefDeserializer::new(v)),
Content::Unit => visitor.visit_unit(),
_ => visitor.visit_some(self)
_ => visitor.visit_some(self),
}
}
serde/src/de/impls.rs
+100 -103
View File
@@ -6,26 +6,10 @@ use std::borrow::Cow;
use collections::borrow::Cow;
#[cfg(all(feature = "collections", not(feature = "std")))]
use collections::{
BinaryHeap,
BTreeMap,
BTreeSet,
LinkedList,
VecDeque,
Vec,
String,
};
use collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque, Vec, String};
#[cfg(feature = "std")]
use std::collections::{
HashMap,
HashSet,
BinaryHeap,
BTreeMap,
BTreeSet,
LinkedList,
VecDeque,
};
use std::collections::{HashMap, HashSet, BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque};
#[cfg(feature = "collections")]
use collections::borrow::ToOwned;
@@ -63,17 +47,8 @@ use core::nonzero::{NonZero, Zeroable};
#[allow(deprecated)] // required for impl Deserialize for NonZero<T>
use core::num::Zero;
use de::{
Deserialize,
Deserializer,
EnumVisitor,
Error,
MapVisitor,
SeqVisitor,
Unexpected,
VariantVisitor,
Visitor,
};
use de::{Deserialize, Deserializer, EnumVisitor, Error, MapVisitor, SeqVisitor, Unexpected,
VariantVisitor, Visitor};
use de::from_primitive::FromPrimitive;
///////////////////////////////////////////////////////////////////////////////
@@ -89,13 +64,13 @@ impl Visitor for UnitVisitor {
}
fn visit_unit<E>(self) -> Result<(), E>
where E: Error,
where E: Error
{
Ok(())
}
fn visit_seq<V>(self, _: V) -> Result<(), V::Error>
where V: SeqVisitor,
where V: SeqVisitor
{
Ok(())
}
@@ -103,7 +78,7 @@ impl Visitor for UnitVisitor {
impl Deserialize for () {
fn deserialize<D>(deserializer: D) -> Result<(), D::Error>
where D: Deserializer,
where D: Deserializer
{
deserializer.deserialize_unit(UnitVisitor)
}
@@ -122,13 +97,13 @@ impl Visitor for BoolVisitor {
}
fn visit_bool<E>(self, v: bool) -> Result<bool, E>
where E: Error,
where E: Error
{
Ok(v)
}
fn visit_str<E>(self, s: &str) -> Result<bool, E>
where E: Error,
where E: Error
{
match s.trim_matches(::utils::Pattern_White_Space) {
"true" => Ok(true),
@@ -140,7 +115,7 @@ impl Visitor for BoolVisitor {
impl Deserialize for bool {
fn deserialize<D>(deserializer: D) -> Result<bool, D::Error>
where D: Deserializer,
where D: Deserializer
{
deserializer.deserialize_bool(BoolVisitor)
}
@@ -231,14 +206,14 @@ impl Visitor 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()) {
@@ -251,7 +226,7 @@ impl Visitor for CharVisitor {
impl Deserialize for char {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<char, D::Error>
where D: Deserializer,
where D: Deserializer
{
deserializer.deserialize_char(CharVisitor)
}
@@ -271,25 +246,25 @@ impl Visitor 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_unit<E>(self) -> Result<String, E>
where E: Error,
where E: Error
{
Ok(String::new())
}
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()),
@@ -298,7 +273,7 @@ impl Visitor 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),
@@ -310,7 +285,7 @@ impl Visitor for StringVisitor {
#[cfg(any(feature = "std", feature = "collections"))]
impl Deserialize for String {
fn deserialize<D>(deserializer: D) -> Result<String, D::Error>
where D: Deserializer,
where D: Deserializer
{
deserializer.deserialize_string(StringVisitor)
}
@@ -322,9 +297,7 @@ struct OptionVisitor<T> {
marker: PhantomData<T>,
}
impl<
T: Deserialize,
> Visitor for OptionVisitor<T> {
impl<T: Deserialize> Visitor for OptionVisitor<T> {
type Value = Option<T>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -333,29 +306,31 @@ impl<
#[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,
where D: Deserializer
{
Ok(Some(try!(Deserialize::deserialize(deserializer))))
}
}
impl<T> Deserialize for Option<T> where T: Deserialize {
impl<T> Deserialize for Option<T>
where T: Deserialize
{
fn deserialize<D>(deserializer: D) -> Result<Option<T>, D::Error>
where D: Deserializer,
where D: Deserializer
{
deserializer.deserialize_option(OptionVisitor { marker: PhantomData })
}
@@ -377,7 +352,7 @@ impl<T> Visitor for PhantomDataVisitor<T> {
#[inline]
fn visit_unit<E>(self) -> Result<PhantomData<T>, E>
where E: Error,
where E: Error
{
Ok(PhantomData)
}
@@ -385,7 +360,7 @@ impl<T> Visitor for PhantomDataVisitor<T> {
impl<T> Deserialize for PhantomData<T> {
fn deserialize<D>(deserializer: D) -> Result<PhantomData<T>, D::Error>
where D: Deserializer,
where D: Deserializer
{
let visitor = PhantomDataVisitor { marker: PhantomData };
deserializer.deserialize_unit_struct("PhantomData", visitor)
@@ -524,13 +499,13 @@ struct ArrayVisitor<A> {
impl<A> ArrayVisitor<A> {
pub fn new() -> Self {
ArrayVisitor {
marker: PhantomData,
}
ArrayVisitor { marker: PhantomData }
}
}
impl<T> Visitor for ArrayVisitor<[T; 0]> where T: Deserialize {
impl<T> Visitor for ArrayVisitor<[T; 0]>
where T: Deserialize
{
type Value = [T; 0];
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -539,14 +514,14 @@ impl<T> Visitor for ArrayVisitor<[T; 0]> where T: Deserialize {
#[inline]
fn visit_unit<E>(self) -> Result<[T; 0], E>
where E: Error,
where E: Error
{
Ok([])
}
#[inline]
fn visit_seq<V>(self, _: V) -> Result<[T; 0], V::Error>
where V: SeqVisitor,
where V: SeqVisitor
{
Ok([])
}
@@ -556,7 +531,7 @@ impl<T> Deserialize for [T; 0]
where T: Deserialize
{
fn deserialize<D>(deserializer: D) -> Result<[T; 0], D::Error>
where D: Deserializer,
where D: Deserializer
{
deserializer.deserialize_seq_fixed_size(0, ArrayVisitor::<[T; 0]>::new())
}
@@ -798,7 +773,7 @@ map_impl!(
#[cfg(feature = "std")]
impl Deserialize for net::IpAddr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer,
where D: Deserializer
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -811,7 +786,7 @@ impl Deserialize for net::IpAddr {
#[cfg(feature = "std")]
impl Deserialize for net::Ipv4Addr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer,
where D: Deserializer
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -824,7 +799,7 @@ impl Deserialize for net::Ipv4Addr {
#[cfg(feature = "std")]
impl Deserialize for net::Ipv6Addr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer,
where D: Deserializer
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -839,7 +814,7 @@ impl Deserialize for net::Ipv6Addr {
#[cfg(feature = "std")]
impl Deserialize for net::SocketAddr {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer,
where D: Deserializer
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -852,7 +827,7 @@ impl Deserialize for net::SocketAddr {
#[cfg(feature = "std")]
impl Deserialize for net::SocketAddrV4 {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer,
where D: Deserializer
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -865,7 +840,7 @@ impl Deserialize for net::SocketAddrV4 {
#[cfg(feature = "std")]
impl Deserialize for net::SocketAddrV6 {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer,
where D: Deserializer
{
let s = try!(String::deserialize(deserializer));
match s.parse() {
@@ -889,13 +864,13 @@ impl Visitor 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))
}
@@ -904,7 +879,7 @@ impl Visitor for PathBufVisitor {
#[cfg(feature = "std")]
impl Deserialize for path::PathBuf {
fn deserialize<D>(deserializer: D) -> Result<path::PathBuf, D::Error>
where D: Deserializer,
where D: Deserializer
{
deserializer.deserialize_string(PathBufVisitor)
}
@@ -915,7 +890,7 @@ impl Deserialize for path::PathBuf {
#[cfg(any(feature = "std", feature = "alloc"))]
impl<T: Deserialize> Deserialize for Box<T> {
fn deserialize<D>(deserializer: D) -> Result<Box<T>, D::Error>
where D: Deserializer,
where D: Deserializer
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Box::new(val))
@@ -925,7 +900,7 @@ impl<T: Deserialize> Deserialize for Box<T> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<T: Deserialize> Deserialize for Box<[T]> {
fn deserialize<D>(deserializer: D) -> Result<Box<[T]>, D::Error>
where D: Deserializer,
where D: Deserializer
{
let v: Vec<T> = try!(Deserialize::deserialize(deserializer));
Ok(v.into_boxed_slice())
@@ -945,7 +920,7 @@ impl Deserialize for Box<str> {
#[cfg(any(feature = "std", feature = "alloc"))]
impl<T: Deserialize> Deserialize for Arc<T> {
fn deserialize<D>(deserializer: D) -> Result<Arc<T>, D::Error>
where D: Deserializer,
where D: Deserializer
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Arc::new(val))
@@ -955,7 +930,7 @@ impl<T: Deserialize> Deserialize for Arc<T> {
#[cfg(any(feature = "std", feature = "alloc"))]
impl<T: Deserialize> Deserialize for Rc<T> {
fn deserialize<D>(deserializer: D) -> Result<Rc<T>, D::Error>
where D: Deserializer,
where D: Deserializer
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Rc::new(val))
@@ -963,10 +938,13 @@ impl<T: Deserialize> Deserialize for Rc<T> {
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where T: ToOwned, T::Owned: Deserialize, {
impl<'a, T: ?Sized> Deserialize for Cow<'a, T>
where T: ToOwned,
T::Owned: Deserialize
{
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Cow<'a, T>, D::Error>
where D: Deserializer,
where D: Deserializer
{
let val = try!(Deserialize::deserialize(deserializer));
Ok(Cow::Owned(val))
@@ -986,13 +964,16 @@ impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where T: ToOwned, T::Owned: Deser
#[cfg(feature = "std")]
impl Deserialize for Duration {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer,
where D: Deserializer
{
enum Field { Secs, Nanos };
enum Field {
Secs,
Nanos,
};
impl Deserialize for Field {
fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
where D: Deserializer,
where D: Deserializer
{
struct FieldVisitor;
@@ -1004,7 +985,7 @@ impl Deserialize for Duration {
}
fn visit_str<E>(self, value: &str) -> Result<Field, E>
where E: Error,
where E: Error
{
match value {
"secs" => Ok(Field::Secs),
@@ -1014,7 +995,7 @@ impl Deserialize 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),
@@ -1041,7 +1022,7 @@ impl Deserialize for Duration {
}
fn visit_seq<V>(self, mut visitor: V) -> Result<Duration, V::Error>
where V: SeqVisitor,
where V: SeqVisitor
{
let secs: u64 = match try!(visitor.visit()) {
Some(value) => value,
@@ -1059,7 +1040,7 @@ impl Deserialize for Duration {
}
fn visit_map<V>(self, mut visitor: V) -> Result<Duration, V::Error>
where V: MapVisitor,
where V: MapVisitor
{
let mut secs: Option<u64> = None;
let mut nanos: Option<u32> = None;
@@ -1100,24 +1081,30 @@ impl Deserialize for Duration {
#[cfg(feature = "unstable")]
#[allow(deprecated)] // num::Zero is deprecated but there is no replacement
impl<T> Deserialize for NonZero<T> where T: Deserialize + PartialEq + Zeroable + Zero {
fn deserialize<D>(deserializer: D) -> Result<NonZero<T>, D::Error> where D: Deserializer {
impl<T> Deserialize for NonZero<T>
where T: Deserialize + PartialEq + Zeroable + Zero
{
fn deserialize<D>(deserializer: D) -> Result<NonZero<T>, D::Error>
where D: Deserializer
{
let value = try!(Deserialize::deserialize(deserializer));
if value == Zero::zero() {
return Err(Error::custom("expected a non-zero value"))
}
unsafe {
Ok(NonZero::new(value))
return Err(Error::custom("expected a non-zero value"));
}
unsafe { Ok(NonZero::new(value)) }
}
}
///////////////////////////////////////////////////////////////////////////////
impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
impl<T, E> Deserialize for Result<T, E>
where T: Deserialize,
E: Deserialize
{
fn deserialize<D>(deserializer: D) -> Result<Result<T, E>, D::Error>
where D: Deserializer {
where D: Deserializer
{
enum Field {
Ok,
Err,
@@ -1137,15 +1124,21 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
formatter.write_str("`Ok` or `Err`")
}
fn visit_u32<E>(self, value: u32) -> Result<Field, E> where E: Error {
fn visit_u32<E>(self, value: u32) -> Result<Field, E>
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 {
fn visit_str<E>(self, value: &str) -> Result<Field, E>
where E: Error
{
match value {
"Ok" => Ok(Field::Ok),
"Err" => Ok(Field::Err),
@@ -1153,14 +1146,18 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
}
}
fn visit_bytes<E>(self, value: &[u8]) -> Result<Field, E> where E: Error {
fn visit_bytes<E>(self, value: &[u8]) -> Result<Field, E>
where E: Error
{
match value {
b"Ok" => Ok(Field::Ok),
b"Err" => Ok(Field::Err),
_ => {
match str::from_utf8(value) {
Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
Err(_) => {
Err(Error::invalid_value(Unexpected::Bytes(value), &self))
}
}
}
}
@@ -1208,7 +1205,7 @@ pub struct IgnoredAny;
impl Deserialize for IgnoredAny {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
where D: Deserializer,
where D: Deserializer
{
struct IgnoredAnyVisitor;
@@ -1241,7 +1238,7 @@ impl Deserialize for IgnoredAny {
#[inline]
fn visit_str<E>(self, _: &str) -> Result<IgnoredAny, E>
where E: Error,
where E: Error
{
Ok(IgnoredAny)
}
@@ -1253,14 +1250,14 @@ impl Deserialize for IgnoredAny {
#[inline]
fn visit_some<D>(self, _: D) -> Result<IgnoredAny, D::Error>
where D: Deserializer,
where D: Deserializer
{
Ok(IgnoredAny)
}
#[inline]
fn visit_newtype_struct<D>(self, _: D) -> Result<IgnoredAny, D::Error>
where D: Deserializer,
where D: Deserializer
{
Ok(IgnoredAny)
}
@@ -1272,7 +1269,7 @@ impl Deserialize for IgnoredAny {
#[inline]
fn visit_seq<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
where V: SeqVisitor,
where V: SeqVisitor
{
while let Some(_) = try!(visitor.visit::<IgnoredAny>()) {
// Gobble
@@ -1282,7 +1279,7 @@ impl Deserialize for IgnoredAny {
#[inline]
fn visit_map<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
where V: MapVisitor,
where V: MapVisitor
{
while let Some((_, _)) = try!(visitor.visit::<IgnoredAny, IgnoredAny>()) {
// Gobble
@@ -1292,7 +1289,7 @@ impl Deserialize for IgnoredAny {
#[inline]
fn visit_bytes<E>(self, _: &[u8]) -> Result<IgnoredAny, E>
where E: Error,
where E: Error
{
Ok(IgnoredAny)
}
serde/src/de/mod.rs
+102 -93
View File
@@ -181,7 +181,10 @@ pub trait Error: Sized + error::Error {
write!(formatter, "invalid type: {}, expected {}", self.unexp, self.exp)
}
}
Error::custom(InvalidType { unexp: unexp, exp: exp })
Error::custom(InvalidType {
unexp: unexp,
exp: exp,
})
}
/// Raised when a `Deserialize` receives a value of the right type but that
@@ -207,7 +210,10 @@ pub trait Error: Sized + error::Error {
write!(formatter, "invalid value: {}, expected {}", self.unexp, self.exp)
}
}
Error::custom(InvalidValue { unexp: unexp, exp: exp })
Error::custom(InvalidValue {
unexp: unexp,
exp: exp,
})
}
/// Raised when deserializing a sequence or map and the input data contains
@@ -229,7 +235,10 @@ pub trait Error: Sized + error::Error {
write!(formatter, "invalid length {}, expected {}", self.len, self.exp)
}
}
Error::custom(InvalidLength { len: len, exp: exp })
Error::custom(InvalidLength {
len: len,
exp: exp,
})
}
/// Raised when a `Deserialize` enum type received a variant with an
@@ -253,7 +262,10 @@ pub trait Error: Sized + error::Error {
}
}
}
Error::custom(UnknownVariant { variant: variant, expected: expected })
Error::custom(UnknownVariant {
variant: variant,
expected: expected,
})
}
/// Raised when a `Deserialize` struct type received a field with an
@@ -277,7 +289,10 @@ pub trait Error: Sized + error::Error {
}
}
}
Error::custom(UnknownField { field: field, expected: expected })
Error::custom(UnknownField {
field: field,
expected: expected,
})
}
/// Raised when a `Deserialize` struct type expected to receive a required
@@ -470,7 +485,9 @@ pub trait Expected {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
}
impl<T> Expected for T where T: Visitor {
impl<T> Expected for T
where T: Visitor
{
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
self.expecting(formatter)
}
@@ -521,8 +538,7 @@ pub trait Deserialize: Sized {
/// manual for more information about how to implement this method.
///
/// [impl-deserialize]: https://serde.rs/impl-deserialize.html
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer;
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer;
}
/// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you
@@ -670,8 +686,7 @@ pub trait DeserializeSeed: 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;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer;
}
impl<T> DeserializeSeed for PhantomData<T>
@@ -784,56 +799,43 @@ pub trait Deserializer: 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;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// Hint that the `Deserialize` type is expecting a string value and does
/// not benefit from taking ownership of buffered data owned by the
@@ -842,8 +844,7 @@ pub trait Deserializer: 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;
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// Hint that the `Deserialize` type is expecting a string value and would
/// benefit from taking ownership of buffered data owned by the
@@ -852,8 +853,7 @@ pub trait Deserializer: 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;
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// Hint that the `Deserialize` type is expecting a byte array and does not
/// benefit from taking ownership of buffered data owned by the
@@ -862,8 +862,7 @@ pub trait Deserializer: 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;
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// Hint that the `Deserialize` type is expecting a byte array and would
/// benefit from taking ownership of buffered data owned by the
@@ -872,44 +871,43 @@ pub trait Deserializer: 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;
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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;
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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>
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor;
/// 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>
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor;
/// 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;
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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>
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor;
/// Hint that the `Deserialize` type is expecting a tuple value with a
@@ -922,19 +920,20 @@ pub trait Deserializer: Sized {
fn deserialize_tuple_struct<V>(self,
name: &'static str,
len: usize,
visitor: V) -> Result<V::Value, Self::Error>
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor;
/// 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;
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor;
/// 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>
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor;
/// Hint that the `Deserialize` type is expecting the name of a struct
@@ -947,7 +946,8 @@ pub trait Deserializer: Sized {
fn deserialize_enum<V>(self,
name: &'static str,
variants: &'static [&'static str],
visitor: V) -> Result<V::Value, Self::Error>
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor;
/// Hint that the `Deserialize` type needs to deserialize a value whose type
@@ -1016,77 +1016,77 @@ pub trait Visitor: 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))
}
@@ -1094,7 +1094,7 @@ pub trait Visitor: 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(::utils::encode_utf8(v).as_str())
}
@@ -1110,7 +1110,7 @@ pub trait Visitor: 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))
}
@@ -1132,28 +1132,28 @@ pub trait Visitor: 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,
where D: Deserializer
{
let _ = deserializer;
Err(Error::invalid_type(Unexpected::Option, &self))
@@ -1161,7 +1161,7 @@ pub trait Visitor: Sized {
/// Deserialize `Value` as a newtype struct.
fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where D: Deserializer,
where D: Deserializer
{
let _ = deserializer;
Err(Error::invalid_type(Unexpected::NewtypeStruct, &self))
@@ -1169,7 +1169,7 @@ pub trait Visitor: Sized {
/// Deserialize `Value` as a sequence of elements.
fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
where V: SeqVisitor,
where V: SeqVisitor
{
let _ = visitor;
Err(Error::invalid_type(Unexpected::Seq, &self))
@@ -1177,7 +1177,7 @@ pub trait Visitor: Sized {
/// Deserialize `Value` as a key-value map.
fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
where V: MapVisitor,
where V: MapVisitor
{
let _ = visitor;
Err(Error::invalid_type(Unexpected::Map, &self))
@@ -1185,7 +1185,7 @@ pub trait Visitor: Sized {
/// Deserialize `Value` as an enum.
fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
where V: EnumVisitor,
where V: EnumVisitor
{
let _ = visitor;
Err(Error::invalid_type(Unexpected::Enum, &self))
@@ -1202,7 +1202,7 @@ pub trait Visitor: 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))
@@ -1225,7 +1225,7 @@ pub trait Visitor: 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)
}
@@ -1269,7 +1269,9 @@ pub trait SeqVisitor {
}
}
impl<'a, V> SeqVisitor for &'a mut V where V: SeqVisitor {
impl<'a, V> SeqVisitor for &'a mut V
where V: SeqVisitor
{
type Error = V::Error;
#[inline]
@@ -1326,7 +1328,10 @@ pub trait MapVisitor {
/// `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>
fn visit_seed<K, V>(&mut self,
kseed: K,
vseed: V)
-> Result<Option<(K::Value, V::Value)>, Self::Error>
where K: DeserializeSeed,
V: DeserializeSeed
{
@@ -1335,7 +1340,7 @@ pub trait MapVisitor {
let value = try!(self.visit_value_seed(vseed));
Ok(Some((key, value)))
}
None => Ok(None)
None => Ok(None),
}
}
@@ -1370,7 +1375,7 @@ pub trait MapVisitor {
#[inline]
fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
where K: Deserialize,
V: Deserialize,
V: Deserialize
{
self.visit_seed(PhantomData, PhantomData)
}
@@ -1382,7 +1387,9 @@ pub trait MapVisitor {
}
}
impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
impl<'a, V_> MapVisitor for &'a mut V_
where V_: MapVisitor
{
type Error = V_::Error;
#[inline]
@@ -1400,7 +1407,10 @@ impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
}
#[inline]
fn visit_seed<K, V>(&mut self, kseed: K, vseed: V) -> Result<Option<(K::Value, V::Value)>, Self::Error>
fn visit_seed<K, V>(&mut self,
kseed: K,
vseed: V)
-> Result<Option<(K::Value, V::Value)>, Self::Error>
where K: DeserializeSeed,
V: DeserializeSeed
{
@@ -1410,7 +1420,7 @@ impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
#[inline]
fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, V_::Error>
where K: Deserialize,
V: Deserialize,
V: Deserialize
{
(**self).visit()
}
@@ -1446,7 +1456,7 @@ pub trait EnumVisitor: Sized {
type Error: Error;
/// The `Visitor` that will be used to deserialize the content of the enum
/// variant.
type Variant: VariantVisitor<Error=Self::Error>;
type Variant: VariantVisitor<Error = Self::Error>;
/// `visit_variant` is called to identify which variant to deserialize.
///
@@ -1539,9 +1549,7 @@ pub trait VariantVisitor: Sized {
/// Err(Error::invalid_type(unexp, &"tuple variant"))
/// }
/// ```
fn visit_tuple<V>(self,
len: usize,
visitor: V) -> Result<V::Value, Self::Error>
fn visit_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor;
/// Called when deserializing a struct-like variant.
@@ -1564,7 +1572,8 @@ pub trait VariantVisitor: Sized {
/// ```
fn visit_struct<V>(self,
fields: &'static [&'static str],
visitor: V) -> Result<V::Value, Self::Error>
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor;
}
serde/src/de/private.rs
+2 -8
View File
@@ -3,14 +3,8 @@ use core::marker::PhantomData;
use de::{Deserialize, Deserializer, Error, Visitor};
#[cfg(any(feature = "std", feature = "collections"))]
pub use de::content::{
Content,
ContentRefDeserializer,
ContentDeserializer,
TaggedContentVisitor,
InternallyTaggedUnitVisitor,
UntaggedUnitVisitor,
};
pub use de::content::{Content, ContentRefDeserializer, ContentDeserializer, TaggedContentVisitor,
InternallyTaggedUnitVisitor, UntaggedUnitVisitor};
/// If the missing field is of type `Option<T>` then treat is as `None`,
/// otherwise it is an error.
serde/src/de/value.rs
+100 -110
View File
@@ -1,31 +1,15 @@
//! This module supports deserializing from primitives with the `ValueDeserializer` trait.
#[cfg(feature = "std")]
use std::collections::{
BTreeMap,
BTreeSet,
HashMap,
HashSet,
btree_map,
btree_set,
hash_map,
hash_set,
};
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, btree_map, btree_set, hash_map,
hash_set};
#[cfg(feature = "std")]
use std::borrow::Cow;
#[cfg(feature = "std")]
use std::vec;
#[cfg(all(feature = "collections", not(feature = "std")))]
use collections::{
BTreeMap,
BTreeSet,
Vec,
String,
btree_map,
btree_set,
vec,
};
use collections::{BTreeMap, BTreeSet, Vec, String, btree_map, btree_set, vec};
#[cfg(all(feature = "collections", not(feature = "std")))]
use collections::borrow::Cow;
#[cfg(all(feature = "collections", not(feature = "std")))]
@@ -41,7 +25,7 @@ use std::error;
use error;
use core::fmt::{self, Display};
use core::iter::{self, Iterator};
use core::iter::{self, Iterator};
use core::marker::PhantomData;
use de::{self, Expected, SeqVisitor};
@@ -63,16 +47,12 @@ type ErrorImpl = ();
impl de::Error for Error {
#[cfg(any(feature = "std", feature = "collections"))]
fn custom<T: Display>(msg: T) -> Self {
Error {
err: msg.to_string().into_boxed_str(),
}
Error { err: msg.to_string().into_boxed_str() }
}
#[cfg(not(any(feature = "std", feature = "collections")))]
fn custom<T: Display>(_msg: T) -> Self {
Error {
err: (),
}
Error { err: () }
}
}
@@ -105,7 +85,7 @@ impl error::Error for Error {
/// This trait converts primitive types into a deserializer.
pub trait ValueDeserializer<E: de::Error = Error> {
/// The actual deserializer type.
type Deserializer: de::Deserializer<Error=E>;
type Deserializer: de::Deserializer<Error = E>;
/// Convert this value into a deserializer.
fn into_deserializer(self) -> Self::Deserializer;
@@ -114,14 +94,12 @@ pub trait ValueDeserializer<E: de::Error = Error> {
///////////////////////////////////////////////////////////////////////////////
impl<E> ValueDeserializer<E> for ()
where E: de::Error,
where E: de::Error
{
type Deserializer = UnitDeserializer<E>;
fn into_deserializer(self) -> UnitDeserializer<E> {
UnitDeserializer {
marker: PhantomData,
}
UnitDeserializer { marker: PhantomData }
}
}
@@ -142,13 +120,13 @@ impl<E> de::Deserializer for UnitDeserializer<E>
}
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
where V: de::Visitor
{
visitor.visit_unit()
}
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
where V: de::Visitor
{
visitor.visit_none()
}
@@ -221,7 +199,7 @@ pub struct StrDeserializer<'a, E> {
}
impl<'a, E> ValueDeserializer<E> for &'a str
where E: de::Error,
where E: de::Error
{
type Deserializer = StrDeserializer<'a, E>;
@@ -234,21 +212,22 @@ impl<'a, E> ValueDeserializer<E> for &'a str
}
impl<'a, E> de::Deserializer 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,
where V: de::Visitor
{
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,
_name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor
{
visitor.visit_enum(self)
}
@@ -261,13 +240,13 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
}
impl<'a, E> de::EnumVisitor 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,
where T: de::DeserializeSeed
{
seed.deserialize(self).map(private::unit_only)
}
@@ -284,7 +263,7 @@ pub struct StringDeserializer<E> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<E> ValueDeserializer<E> for String
where E: de::Error,
where E: de::Error
{
type Deserializer = StringDeserializer<E>;
@@ -298,21 +277,22 @@ impl<E> ValueDeserializer<E> for String
#[cfg(any(feature = "std", feature = "collections"))]
impl<E> de::Deserializer 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,
where V: de::Visitor
{
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,
_name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor
{
visitor.visit_enum(self)
}
@@ -326,13 +306,13 @@ impl<E> de::Deserializer for StringDeserializer<E>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'a, E> de::EnumVisitor 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,
where T: de::DeserializeSeed
{
seed.deserialize(self).map(private::unit_only)
}
@@ -349,7 +329,7 @@ pub struct CowStrDeserializer<'a, E> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<'a, E> ValueDeserializer<E> for Cow<'a, str>
where E: de::Error,
where E: de::Error
{
type Deserializer = CowStrDeserializer<'a, E>;
@@ -363,12 +343,12 @@ impl<'a, E> ValueDeserializer<E> for Cow<'a, str>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'a, E> de::Deserializer 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,
where V: de::Visitor
{
match self.value {
Cow::Borrowed(string) => visitor.visit_str(string),
@@ -377,10 +357,11 @@ impl<'a, E> de::Deserializer 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,
_name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor
{
visitor.visit_enum(self)
}
@@ -394,13 +375,13 @@ impl<'a, E> de::Deserializer for CowStrDeserializer<'a, E>
#[cfg(any(feature = "std", feature = "collections"))]
impl<'a, E> de::EnumVisitor 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,
where T: de::DeserializeSeed
{
seed.deserialize(self).map(private::unit_only)
}
@@ -417,7 +398,7 @@ pub struct SeqDeserializer<I, E> {
impl<I, E> SeqDeserializer<I, E>
where I: Iterator,
E: de::Error,
E: de::Error
{
/// Construct a new `SeqDeserializer<I>`.
pub fn new(iter: I) -> Self {
@@ -446,14 +427,14 @@ impl<I, E> SeqDeserializer<I, E>
}
impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
where I: Iterator<Item=T>,
where I: Iterator<Item = T>,
T: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Error = E;
fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
where V: de::Visitor
{
let v = try!(visitor.visit_seq(&mut self));
try!(self.end());
@@ -468,9 +449,9 @@ impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
}
impl<I, T, E> de::SeqVisitor for SeqDeserializer<I, E>
where I: Iterator<Item=T>,
where I: Iterator<Item = T>,
T: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Error = E;
@@ -508,7 +489,7 @@ impl Expected for ExpectedInSeq {
#[cfg(any(feature = "std", feature = "collections"))]
impl<T, E> ValueDeserializer<E> for Vec<T>
where T: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Deserializer = SeqDeserializer<vec::IntoIter<T>, E>;
@@ -520,7 +501,7 @@ impl<T, E> ValueDeserializer<E> for Vec<T>
#[cfg(any(feature = "std", feature = "collections"))]
impl<T, E> ValueDeserializer<E> for BTreeSet<T>
where T: ValueDeserializer<E> + Eq + Ord,
E: de::Error,
E: de::Error
{
type Deserializer = SeqDeserializer<btree_set::IntoIter<T>, E>;
@@ -532,7 +513,7 @@ impl<T, E> ValueDeserializer<E> for BTreeSet<T>
#[cfg(feature = "std")]
impl<T, E> ValueDeserializer<E> for HashSet<T>
where T: ValueDeserializer<E> + Eq + Hash,
E: de::Error,
E: de::Error
{
type Deserializer = SeqDeserializer<hash_set::IntoIter<T>, E>;
@@ -551,20 +532,20 @@ pub struct SeqVisitorDeserializer<V_, E> {
impl<V_, E> SeqVisitorDeserializer<V_, E>
where V_: de::SeqVisitor<Error = E>,
E: de::Error,
E: de::Error
{
/// Construct a new `SeqVisitorDeserializer<V_, E>`.
pub fn new(visitor: V_) -> Self {
SeqVisitorDeserializer{
SeqVisitorDeserializer {
visitor: visitor,
marker: PhantomData
marker: PhantomData,
}
}
}
impl<V_, E> de::Deserializer for SeqVisitorDeserializer<V_, E>
where V_: de::SeqVisitor<Error = E>,
E: de::Error,
E: de::Error
{
type Error = E;
@@ -587,7 +568,7 @@ pub struct MapDeserializer<I, E>
I::Item: private::Pair,
<I::Item as private::Pair>::First: ValueDeserializer<E>,
<I::Item as private::Pair>::Second: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
iter: iter::Fuse<I>,
value: Option<<I::Item as private::Pair>::Second>,
@@ -600,7 +581,7 @@ impl<I, E> MapDeserializer<I, E>
I::Item: private::Pair,
<I::Item as private::Pair>::First: ValueDeserializer<E>,
<I::Item as private::Pair>::Second: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
/// Construct a new `MapDeserializer<I, K, V, E>`.
pub fn new(iter: I) -> Self {
@@ -628,7 +609,9 @@ impl<I, E> MapDeserializer<I, E>
}
}
fn next_pair(&mut self) -> Option<(<I::Item as private::Pair>::First, <I::Item as private::Pair>::Second)> {
fn next_pair
(&mut self)
-> Option<(<I::Item as private::Pair>::First, <I::Item as private::Pair>::Second)> {
match self.iter.next() {
Some(kv) => {
self.count += 1;
@@ -644,12 +627,12 @@ impl<I, E> de::Deserializer for MapDeserializer<I, E>
I::Item: private::Pair,
<I::Item as private::Pair>::First: ValueDeserializer<E>,
<I::Item as private::Pair>::Second: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Error = E;
fn deserialize<V_>(mut self, visitor: V_) -> Result<V_::Value, Self::Error>
where V_: de::Visitor,
where V_: de::Visitor
{
let value = try!(visitor.visit_map(&mut self));
try!(self.end());
@@ -657,15 +640,18 @@ impl<I, E> de::Deserializer for MapDeserializer<I, E>
}
fn deserialize_seq<V_>(mut self, visitor: V_) -> Result<V_::Value, Self::Error>
where V_: de::Visitor,
where V_: de::Visitor
{
let value = try!(visitor.visit_seq(&mut self));
try!(self.end());
Ok(value)
}
fn deserialize_seq_fixed_size<V_>(self, _len: usize, visitor: V_) -> Result<V_::Value, Self::Error>
where V_: de::Visitor,
fn deserialize_seq_fixed_size<V_>(self,
_len: usize,
visitor: V_)
-> Result<V_::Value, Self::Error>
where V_: de::Visitor
{
self.deserialize_seq(visitor)
}
@@ -682,12 +668,12 @@ impl<I, E> de::MapVisitor for MapDeserializer<I, E>
I::Item: private::Pair,
<I::Item as private::Pair>::First: ValueDeserializer<E>,
<I::Item as private::Pair>::Second: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Error = E;
fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed,
where T: de::DeserializeSeed
{
match self.next_pair() {
Some((key, value)) => {
@@ -699,7 +685,7 @@ impl<I, E> de::MapVisitor for MapDeserializer<I, E>
}
fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
where T: de::DeserializeSeed,
where T: de::DeserializeSeed
{
let value = self.value.take();
// Panic because this indicates a bug in the program rather than an
@@ -708,7 +694,10 @@ impl<I, E> de::MapVisitor for MapDeserializer<I, E>
seed.deserialize(value.into_deserializer())
}
fn visit_seed<TK, TV>(&mut self, kseed: TK, vseed: TV) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
fn visit_seed<TK, TV>(&mut self,
kseed: TK,
vseed: TV)
-> Result<Option<(TK::Value, TV::Value)>, Self::Error>
where TK: de::DeserializeSeed,
TV: de::DeserializeSeed
{
@@ -718,7 +707,7 @@ impl<I, E> de::MapVisitor for MapDeserializer<I, E>
let value = try!(vseed.deserialize(value.into_deserializer()));
Ok(Some((key, value)))
}
None => Ok(None)
None => Ok(None),
}
}
@@ -732,12 +721,12 @@ impl<I, E> de::SeqVisitor for MapDeserializer<I, E>
I::Item: private::Pair,
<I::Item as private::Pair>::First: ValueDeserializer<E>,
<I::Item as private::Pair>::Second: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Error = E;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed,
where T: de::DeserializeSeed
{
match self.next_pair() {
Some((k, v)) => {
@@ -771,13 +760,13 @@ impl<A, B, E> de::Deserializer for PairDeserializer<A, B, E>
}
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
where V: de::Visitor
{
self.deserialize_seq(visitor)
}
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
where V: de::Visitor
{
let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData);
let pair = try!(visitor.visit_seq(&mut pair_visitor));
@@ -792,7 +781,7 @@ impl<A, B, E> de::Deserializer 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,
where V: de::Visitor
{
if len == 2 {
self.deserialize_seq(visitor)
@@ -809,12 +798,12 @@ struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
impl<A, B, E> de::SeqVisitor for PairVisitor<A, B, E>
where A: ValueDeserializer<E>,
B: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Error = E;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed,
where T: de::DeserializeSeed
{
if let Some(k) = self.0.take() {
seed.deserialize(k.into_deserializer()).map(Some)
@@ -855,7 +844,7 @@ impl Expected for ExpectedInMap {
impl<K, V, E> ValueDeserializer<E> for BTreeMap<K, V>
where K: ValueDeserializer<E> + Eq + Ord,
V: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, E>;
@@ -868,7 +857,7 @@ impl<K, V, E> ValueDeserializer<E> for BTreeMap<K, V>
impl<K, V, E> ValueDeserializer<E> for HashMap<K, V>
where K: ValueDeserializer<E> + Eq + Hash,
V: ValueDeserializer<E>,
E: de::Error,
E: de::Error
{
type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, E>;
@@ -887,20 +876,20 @@ pub struct MapVisitorDeserializer<V_, E> {
impl<V_, E> MapVisitorDeserializer<V_, E>
where V_: de::MapVisitor<Error = E>,
E: de::Error,
E: de::Error
{
/// Construct a new `MapVisitorDeserializer<V_, E>`.
pub fn new(visitor: V_) -> Self {
MapVisitorDeserializer{
MapVisitorDeserializer {
visitor: visitor,
marker: PhantomData
marker: PhantomData,
}
}
}
impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
where V_: de::MapVisitor<Error = E>,
E: de::Error,
E: de::Error
{
type Error = E;
@@ -918,7 +907,7 @@ impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
///////////////////////////////////////////////////////////////////////////////
impl<'a, E> ValueDeserializer<E> for bytes::Bytes<'a>
where E: de::Error,
where E: de::Error
{
type Deserializer = BytesDeserializer<'a, E>;
@@ -942,7 +931,7 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
type Error = E;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
where V: de::Visitor
{
visitor.visit_bytes(self.value)
}
@@ -958,7 +947,7 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
#[cfg(any(feature = "std", feature = "collections"))]
impl<E> ValueDeserializer<E> for bytes::ByteBuf
where E: de::Error,
where E: de::Error
{
type Deserializer = ByteBufDeserializer<E>;
@@ -979,12 +968,12 @@ pub struct ByteBufDeserializer<E> {
#[cfg(any(feature = "std", feature = "collections"))]
impl<E> de::Deserializer for ByteBufDeserializer<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,
where V: de::Visitor
{
visitor.visit_byte_buf(self.value)
}
@@ -1020,14 +1009,12 @@ mod private {
}
fn visit_newtype_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
where T: de::DeserializeSeed,
where T: de::DeserializeSeed
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"))
}
fn visit_tuple<V>(self,
_len: usize,
_visitor: V) -> Result<V::Value, Self::Error>
fn visit_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
@@ -1035,7 +1022,8 @@ mod private {
fn visit_struct<V>(self,
_fields: &'static [&'static str],
_visitor: V) -> Result<V::Value, Self::Error>
_visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
@@ -1053,6 +1041,8 @@ mod private {
impl<A, B> Pair for (A, B) {
type First = A;
type Second = B;
fn split(self) -> (A, B) { self }
fn split(self) -> (A, B) {
self
}
}
}
serde/src/error.rs
+3 -1
View File
@@ -11,5 +11,7 @@ pub trait Error: Debug + Display {
fn description(&self) -> &str;
/// The lower-level cause of this error, if any.
fn cause(&self) -> Option<&Error> { None }
fn cause(&self) -> Option<&Error> {
None
}
}
serde/src/iter.rs
+24 -12
View File
@@ -4,13 +4,13 @@ use std::io;
use std::iter::Peekable;
/// Iterator over a byte stream that tracks the current position's line and column.
pub struct LineColIterator<Iter: Iterator<Item=io::Result<u8>>> {
pub struct LineColIterator<Iter: Iterator<Item = io::Result<u8>>> {
iter: Iter,
line: usize,
col: usize,
}
impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Iter> {
impl<Iter: Iterator<Item = io::Result<u8>>> LineColIterator<Iter> {
/// Construct a new `LineColIterator<Iter>`.
pub fn new(iter: Iter) -> LineColIterator<Iter> {
LineColIterator {
@@ -21,27 +21,39 @@ impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Iter> {
}
/// Report the current line inside the iterator.
pub fn line(&self) -> usize { self.line }
pub fn line(&self) -> usize {
self.line
}
/// Report the current column inside the iterator.
pub fn col(&self) -> usize { self.col }
pub fn col(&self) -> usize {
self.col
}
/// Gets a reference to the underlying iterator.
pub fn get_ref(&self) -> &Iter { &self.iter }
pub fn get_ref(&self) -> &Iter {
&self.iter
}
/// Gets a mutable reference to the underlying iterator.
pub fn get_mut(&mut self) -> &mut Iter { &mut self.iter }
pub fn get_mut(&mut self) -> &mut Iter {
&mut self.iter
}
/// Unwraps this `LineColIterator`, returning the underlying iterator.
pub fn into_inner(self) -> Iter { self.iter }
pub fn into_inner(self) -> Iter {
self.iter
}
}
impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Peekable<Iter>> {
impl<Iter: Iterator<Item = io::Result<u8>>> LineColIterator<Peekable<Iter>> {
/// peeks at the next value
pub fn peek(&mut self) -> Option<&io::Result<u8>> { self.iter.peek() }
pub fn peek(&mut self) -> Option<&io::Result<u8>> {
self.iter.peek()
}
}
impl<Iter: Iterator<Item=io::Result<u8>>> Iterator for LineColIterator<Iter> {
impl<Iter: Iterator<Item = io::Result<u8>>> Iterator for LineColIterator<Iter> {
type Item = io::Result<u8>;
fn next(&mut self) -> Option<io::Result<u8>> {
match self.iter.next() {
@@ -50,11 +62,11 @@ impl<Iter: Iterator<Item=io::Result<u8>>> Iterator for LineColIterator<Iter> {
self.line += 1;
self.col = 0;
Some(Ok(b'\n'))
},
}
Some(Ok(c)) => {
self.col += 1;
Some(Ok(c))
},
}
Some(Err(e)) => Some(Err(e)),
}
}
serde/src/lib.rs
+1 -1
View File
@@ -79,7 +79,7 @@ extern crate core as actual_core;
#[cfg(feature = "std")]
mod core {
pub use std::{ops, hash, fmt, cmp, marker, mem, i8, i16, i32, i64, u8, u16, u32, u64, isize,
usize, f32, f64, char, str, num, slice, iter, cell, default, result, option};
usize, f32, f64, char, str, num, slice, iter, cell, default, result, option};
#[cfg(feature = "unstable")]
pub use actual_core::nonzero;
}
serde/src/ser/impls.rs
+40 -59
View File
@@ -4,25 +4,9 @@ use std::borrow::Cow;
use collections::borrow::Cow;
#[cfg(feature = "std")]
use std::collections::{
BinaryHeap,
BTreeMap,
BTreeSet,
LinkedList,
HashMap,
HashSet,
VecDeque,
};
use std::collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, HashMap, HashSet, VecDeque};
#[cfg(all(feature = "collections", not(feature = "std")))]
use collections::{
BinaryHeap,
BTreeMap,
BTreeSet,
LinkedList,
VecDeque,
String,
Vec,
};
use collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque, String, Vec};
#[cfg(feature = "collections")]
use collections::borrow::ToOwned;
@@ -57,12 +41,7 @@ use core::marker::PhantomData;
#[cfg(feature = "unstable")]
use core::nonzero::{NonZero, Zeroable};
use super::{
Serialize,
SerializeSeq,
SerializeTuple,
Serializer,
};
use super::{Serialize, SerializeSeq, SerializeTuple, Serializer};
#[cfg(feature = "std")]
use super::Error;
@@ -101,7 +80,7 @@ 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)
}
@@ -111,7 +90,7 @@ 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)
}
@@ -124,7 +103,7 @@ impl<T> Serialize for Option<T>
{
#[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),
@@ -138,7 +117,7 @@ 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")
}
@@ -211,7 +190,7 @@ macro_rules! serialize_seq {
}
impl<T> Serialize for [T]
where T: Serialize,
where T: Serialize
{
serialize_seq!();
}
@@ -225,7 +204,7 @@ impl<T> Serialize for BinaryHeap<T>
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for BTreeSet<T>
where T: Serialize + Ord,
where T: Serialize + Ord
{
serialize_seq!();
}
@@ -233,14 +212,14 @@ impl<T> Serialize for BTreeSet<T>
#[cfg(feature = "std")]
impl<T, H> Serialize for HashSet<T, H>
where T: Serialize + Eq + Hash,
H: BuildHasher,
H: BuildHasher
{
serialize_seq!();
}
#[cfg(any(feature = "std", feature = "collections"))]
impl<T> Serialize for LinkedList<T>
where T: Serialize,
where T: Serialize
{
serialize_seq!();
}
@@ -262,11 +241,11 @@ impl<T> Serialize for VecDeque<T>
#[cfg(feature = "unstable")]
impl<A> Serialize for ops::Range<A>
where ops::Range<A>: ExactSizeIterator + iter::Iterator<Item = A> + Clone,
A: Serialize,
A: Serialize
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
let mut seq = try!(serializer.serialize_seq(Some(self.len())));
for e in self.clone() {
@@ -279,11 +258,11 @@ impl<A> Serialize for ops::Range<A>
#[cfg(feature = "unstable")]
impl<A> Serialize for ops::RangeInclusive<A>
where ops::RangeInclusive<A>: ExactSizeIterator + iter::Iterator<Item = A> + Clone,
A: Serialize,
A: Serialize
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
let mut seq = try!(serializer.serialize_seq(Some(self.len())));
for e in self.clone() {
@@ -298,7 +277,7 @@ impl<A> Serialize for ops::RangeInclusive<A>
impl Serialize for () {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
serializer.serialize_unit()
}
@@ -518,7 +497,7 @@ macro_rules! serialize_map {
#[cfg(any(feature = "std", feature = "collections"))]
impl<K, V> Serialize for BTreeMap<K, V>
where K: Serialize + Ord,
V: Serialize,
V: Serialize
{
serialize_map!();
}
@@ -527,26 +506,30 @@ impl<K, V> Serialize for BTreeMap<K, V>
impl<K, V, H> Serialize for HashMap<K, V, H>
where K: Serialize + Eq + Hash,
V: Serialize,
H: BuildHasher,
H: BuildHasher
{
serialize_map!();
}
///////////////////////////////////////////////////////////////////////////////
impl<'a, T: ?Sized> Serialize for &'a T where T: Serialize {
impl<'a, T: ?Sized> Serialize for &'a T
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 {
impl<'a, T: ?Sized> Serialize for &'a mut T
where T: Serialize
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
(**self).serialize(serializer)
}
@@ -558,7 +541,7 @@ impl<T: ?Sized> Serialize for Box<T>
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
(**self).serialize(serializer)
}
@@ -570,7 +553,7 @@ impl<T> Serialize for Rc<T>
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
(**self).serialize(serializer)
}
@@ -582,7 +565,7 @@ impl<T> Serialize for Arc<T>
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
(**self).serialize(serializer)
}
@@ -594,7 +577,7 @@ impl<'a, T: ?Sized> Serialize for Cow<'a, T>
{
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,
where S: Serializer
{
(**self).serialize(serializer)
}
@@ -610,9 +593,7 @@ impl<T, E> Serialize for Result<T, E>
where S: Serializer
{
match *self {
Result::Ok(ref value) => {
serializer.serialize_newtype_variant("Result", 0, "Ok", value)
}
Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value),
Result::Err(ref value) => {
serializer.serialize_newtype_variant("Result", 1, "Err", value)
}
@@ -625,7 +606,7 @@ 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));
@@ -640,7 +621,7 @@ impl Serialize for Duration {
#[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
{
self.to_string().serialize(serializer)
}
@@ -649,7 +630,7 @@ 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
{
self.to_string().serialize(serializer)
}
@@ -658,7 +639,7 @@ 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
{
self.to_string().serialize(serializer)
}
@@ -669,7 +650,7 @@ 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),
@@ -681,7 +662,7 @@ 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
{
self.to_string().serialize(serializer)
}
@@ -690,7 +671,7 @@ 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
{
self.to_string().serialize(serializer)
}
@@ -701,7 +682,7 @@ 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),
@@ -713,7 +694,7 @@ 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)
}
serde/src/ser/impossible.rs
+17 -38
View File
@@ -2,17 +2,8 @@
use core::marker::PhantomData;
use ser::{
self,
Serialize,
SerializeSeq,
SerializeTuple,
SerializeTupleStruct,
SerializeTupleVariant,
SerializeMap,
SerializeStruct,
SerializeStructVariant,
};
use ser::{self, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
SerializeTupleVariant, SerializeMap, SerializeStruct, SerializeStructVariant};
/// Helper type for implementing a `Serializer` that does not support
/// serializing one of the compound types.
@@ -50,14 +41,12 @@ 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;
fn serialize_element<T: ?Sized + Serialize>(&mut self,
_value: &T)
-> Result<(), E> {
fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
match self.void {}
}
@@ -67,14 +56,12 @@ 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;
fn serialize_element<T: ?Sized + Serialize>(&mut self,
_value: &T)
-> Result<(), E> {
fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
match self.void {}
}
@@ -84,14 +71,12 @@ 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;
fn serialize_field<T: ?Sized + Serialize>(&mut self,
_value: &T)
-> Result<(), E> {
fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
match self.void {}
}
@@ -101,14 +86,12 @@ 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;
fn serialize_field<T: ?Sized + Serialize>(&mut self,
_value: &T)
-> Result<(), E> {
fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
match self.void {}
}
@@ -118,20 +101,16 @@ 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;
fn serialize_key<T: ?Sized + Serialize>(&mut self,
_key: &T)
-> Result<(), E> {
fn serialize_key<T: ?Sized + Serialize>(&mut self, _key: &T) -> Result<(), E> {
match self.void {}
}
fn serialize_value<T: ?Sized + Serialize>(&mut self,
_value: &T)
-> Result<(), E> {
fn serialize_value<T: ?Sized + Serialize>(&mut self, _value: &T) -> Result<(), E> {
match self.void {}
}
@@ -141,13 +120,13 @@ 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,
_key: &'static str,
_value: &T)
-> Result<(), E> {
match self.void {}
@@ -159,13 +138,13 @@ 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,
_key: &'static str,
_value: &T)
-> Result<(), E> {
match self.void {}
serde/src/ser/mod.rs
+63 -84
View File
@@ -174,8 +174,7 @@ 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;
}
///////////////////////////////////////////////////////////////////////////////
@@ -254,31 +253,31 @@ pub trait Serializer: Sized {
/// Type returned from `serialize_seq` and `serialize_seq_fixed_size` for
/// serializing the content of the sequence.
type SerializeSeq: SerializeSeq<Ok=Self::Ok, Error=Self::Error>;
type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>;
/// Type returned from `serialize_tuple` for serializing the content of the
/// tuple.
type SerializeTuple: SerializeTuple<Ok=Self::Ok, Error=Self::Error>;
type SerializeTuple: SerializeTuple<Ok = Self::Ok, Error = Self::Error>;
/// Type returned from `serialize_tuple_struct` for serializing the content
/// of the tuple struct.
type SerializeTupleStruct: SerializeTupleStruct<Ok=Self::Ok, Error=Self::Error>;
type SerializeTupleStruct: SerializeTupleStruct<Ok = Self::Ok, Error = Self::Error>;
/// Type returned from `serialize_tuple_variant` for serializing the content
/// of the tuple variant.
type SerializeTupleVariant: SerializeTupleVariant<Ok=Self::Ok, Error=Self::Error>;
type SerializeTupleVariant: SerializeTupleVariant<Ok = Self::Ok, Error = Self::Error>;
/// Type returned from `serialize_map` for serializing the content of the
/// map.
type SerializeMap: SerializeMap<Ok=Self::Ok, Error=Self::Error>;
type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
/// Type returned from `serialize_struct` for serializing the content of the
/// struct.
type SerializeStruct: SerializeStruct<Ok=Self::Ok, Error=Self::Error>;
type SerializeStruct: SerializeStruct<Ok = Self::Ok, Error = Self::Error>;
/// Type returned from `serialize_struct_variant` for serializing the
/// content of the struct variant.
type SerializeStructVariant: SerializeStructVariant<Ok=Self::Ok, Error=Self::Error>;
type SerializeStructVariant: SerializeStructVariant<Ok = Self::Ok, Error = Self::Error>;
/// Serialize a `bool` value.
fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
@@ -371,10 +370,7 @@ pub trait Serializer: Sized {
fn serialize_none(self) -> Result<Self::Ok, Self::Error>;
/// Serialize a `Some(T)` value.
fn serialize_some<T: ?Sized + Serialize>(
self,
value: &T,
) -> Result<Self::Ok, Self::Error>;
fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error>;
/// Serialize a `()` value.
fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;
@@ -382,10 +378,7 @@ pub trait Serializer: Sized {
/// Serialize a unit struct like `struct Unit` or `PhantomData<T>`.
///
/// A reasonable implementation would be to forward to `serialize_unit`.
fn serialize_unit_struct(
self,
name: &'static str,
) -> Result<Self::Ok, Self::Error>;
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error>;
/// Serialize a unit variant like `E::A` in `enum E { A, B }`.
///
@@ -401,12 +394,11 @@ pub trait Serializer: Sized {
/// E::B => serializer.serialize_unit_variant("E", 1, "B"),
/// }
/// ```
fn serialize_unit_variant(
self,
name: &'static str,
variant_index: usize,
variant: &'static str,
) -> Result<Self::Ok, Self::Error>;
fn serialize_unit_variant(self,
name: &'static str,
variant_index: usize,
variant: &'static str)
-> Result<Self::Ok, Self::Error>;
/// Serialize a newtype struct like `struct Millimeters(u8)`.
///
@@ -417,11 +409,10 @@ pub trait Serializer: Sized {
/// ```rust,ignore
/// serializer.serialize_newtype_struct("Millimeters", &self.0)
/// ```
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) }`.
///
@@ -434,13 +425,12 @@ pub trait Serializer: Sized {
/// E::N(ref n) => serializer.serialize_newtype_variant("E", 0, "N", n),
/// }
/// ```
fn serialize_newtype_variant<T: ?Sized + Serialize>(
self,
name: &'static str,
variant_index: usize,
variant: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>;
fn serialize_newtype_variant<T: ?Sized + Serialize>(self,
name: &'static str,
variant_index: usize,
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
@@ -457,10 +447,7 @@ pub trait Serializer: Sized {
/// }
/// seq.end()
/// ```
fn serialize_seq(
self,
len: Option<usize>,
) -> Result<Self::SerializeSeq, Self::Error>;
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error>;
/// Begin to serialize a statically sized sequence whose length will be
/// known at deserialization time without looking at the serialized data.
@@ -474,10 +461,7 @@ pub trait Serializer: Sized {
/// }
/// seq.end()
/// ```
fn serialize_seq_fixed_size(
self,
size: usize,
) -> Result<Self::SerializeSeq, Self::Error>;
fn serialize_seq_fixed_size(self, size: usize) -> Result<Self::SerializeSeq, Self::Error>;
/// Begin to serialize a tuple. This call must be followed by zero or more
/// calls to `serialize_field`, then a call to `end`.
@@ -489,10 +473,7 @@ pub trait Serializer: Sized {
/// tup.serialize_field(&self.2)?;
/// tup.end()
/// ```
fn serialize_tuple(
self,
len: usize,
) -> Result<Self::SerializeTuple, Self::Error>;
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error>;
/// Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This
/// call must be followed by zero or more calls to `serialize_field`, then a
@@ -508,11 +489,10 @@ pub trait Serializer: Sized {
/// ts.serialize_field(&self.2)?;
/// ts.end()
/// ```
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
@@ -532,13 +512,12 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: usize,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error>;
fn serialize_tuple_variant(self,
name: &'static str,
variant_index: usize,
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`.
@@ -554,10 +533,7 @@ pub trait Serializer: Sized {
/// }
/// map.end()
/// ```
fn serialize_map(
self,
len: Option<usize>,
) -> Result<Self::SerializeMap, Self::Error>;
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error>;
/// Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`.
/// This call must be followed by zero or more calls to `serialize_field`,
@@ -573,11 +549,10 @@ pub trait Serializer: Sized {
/// struc.serialize_field("b", &self.b)?;
/// struc.end()
/// ```
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
@@ -598,13 +573,12 @@ pub trait Serializer: Sized {
/// }
/// }
/// ```
fn serialize_struct_variant(
self,
name: &'static str,
variant_index: usize,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error>;
fn serialize_struct_variant(self,
name: &'static str,
variant_index: usize,
variant: &'static str,
len: usize)
-> Result<Self::SerializeStructVariant, Self::Error>;
/// Collect an iterator as a sequence.
///
@@ -613,7 +587,7 @@ pub trait Serializer: Sized {
/// this method.
fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
where I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
<I as IntoIterator>::Item: Serialize
{
let iter = iter.into_iter();
let mut serializer = try!(self.serialize_seq(iter.len_hint()));
@@ -631,7 +605,7 @@ pub trait Serializer: Sized {
fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
where K: Serialize,
V: Serialize,
I: IntoIterator<Item = (K, V)>,
I: IntoIterator<Item = (K, V)>
{
let iter = iter.into_iter();
let mut serializer = try!(self.serialize_map(iter.len_hint()));
@@ -773,11 +747,10 @@ 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)
}
@@ -803,7 +776,10 @@ 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>;
@@ -830,7 +806,10 @@ 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>;
serde/src/ser/private.rs
+42 -15
View File
@@ -3,14 +3,13 @@ use core::fmt::{self, Display};
use ser::{self, Serialize, Serializer, SerializeMap, SerializeStruct};
/// 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>
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
{
@@ -181,17 +180,29 @@ impl<S> Serializer for TaggedSerializer<S>
Err(self.bad_type(Unsupported::UnitStruct))
}
fn serialize_unit_variant(self, _: &'static str, _: usize, _: &'static str) -> Result<Self::Ok, Self::Error> {
fn serialize_unit_variant(self,
_: &'static str,
_: usize,
_: &'static str)
-> Result<Self::Ok, Self::Error> {
Err(self.bad_type(Unsupported::Enum))
}
fn serialize_newtype_struct<T: ?Sized>(self, _: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
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, _: usize, _: &'static str, _: &T) -> Result<Self::Ok, Self::Error>
fn serialize_newtype_variant<T: ?Sized>(self,
_: &'static str,
_: usize,
_: &'static str,
_: &T)
-> Result<Self::Ok, Self::Error>
where T: Serialize
{
Err(self.bad_type(Unsupported::Enum))
@@ -209,11 +220,19 @@ 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))
}
fn serialize_tuple_variant(self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
fn serialize_tuple_variant(self,
_: &'static str,
_: usize,
_: &'static str,
_: usize)
-> Result<Self::SerializeTupleVariant, Self::Error> {
Err(self.bad_type(Unsupported::Enum))
}
@@ -223,13 +242,21 @@ 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)
}
fn serialize_struct_variant(self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
fn serialize_struct_variant(self,
_: &'static str,
_: usize,
_: &'static str,
_: usize)
-> Result<Self::SerializeStructVariant, Self::Error> {
Err(self.bad_type(Unsupported::Enum))
}
}
serde/src/utils.rs
+20 -18
View File
@@ -1,12 +1,12 @@
//! Private utility functions
const TAG_CONT: u8 = 0b1000_0000;
const TAG_TWO_B: u8 = 0b1100_0000;
const TAG_CONT: u8 = 0b1000_0000;
const TAG_TWO_B: u8 = 0b1100_0000;
const TAG_THREE_B: u8 = 0b1110_0000;
const TAG_FOUR_B: u8 = 0b1111_0000;
const MAX_ONE_B: u32 = 0x80;
const MAX_TWO_B: u32 = 0x800;
const MAX_THREE_B: u32 = 0x10000;
const TAG_FOUR_B: u8 = 0b1111_0000;
const MAX_ONE_B: u32 = 0x80;
const MAX_TWO_B: u32 = 0x800;
const MAX_THREE_B: u32 = 0x10000;
#[inline]
pub fn encode_utf8(c: char) -> EncodeUtf8 {
@@ -21,17 +21,20 @@ pub fn encode_utf8(c: char) -> EncodeUtf8 {
2
} else if code < MAX_THREE_B {
buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
buf[3] = (code & 0x3F) as u8 | TAG_CONT;
1
} else {
buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
buf[3] = (code & 0x3F) as u8 | TAG_CONT;
0
};
EncodeUtf8 { buf: buf, pos: pos }
EncodeUtf8 {
buf: buf,
pos: pos,
}
}
pub struct EncodeUtf8 {
@@ -47,23 +50,22 @@ impl EncodeUtf8 {
}
#[allow(non_upper_case_globals)]
const Pattern_White_Space_table: &'static [(char, char)] = &[
('\u{9}', '\u{d}'), ('\u{20}', '\u{20}'), ('\u{85}', '\u{85}'), ('\u{200e}', '\u{200f}'),
('\u{2028}', '\u{2029}')
];
const Pattern_White_Space_table: &'static [(char, char)] = &[('\u{9}', '\u{d}'),
('\u{20}', '\u{20}'),
('\u{85}', '\u{85}'),
('\u{200e}', '\u{200f}'),
('\u{2028}', '\u{2029}')];
fn bsearch_range_table(c: char, r: &'static [(char, char)]) -> bool {
use core::cmp::Ordering::{Equal, Less, Greater};
r.binary_search_by(|&(lo, hi)| {
if c < lo {
r.binary_search_by(|&(lo, hi)| if c < lo {
Greater
} else if hi < c {
Less
} else {
Equal
}
})
.is_ok()
})
.is_ok()
}
#[allow(non_snake_case)]