pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-26 01:37:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert over to where clauses

Browse Source
This commit is contained in:
Erick Tryzelaar
2015-03-03 19:34:16 -08:00
parent 033b039284
commit ecc19bdbdb
6 changed files with 343 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde2/serde2_macros/src/lib.rs
+11 -6
View File
@@ -1123,9 +1123,12 @@ fn deserialize_enum(
impl ::serde2::de::Visitor for __Visitor { impl ::serde2::de::Visitor for __Visitor {
type Value = $type_ident; type Value = $type_ident;
fn visit_enum< fn visit_enum<__V>(&mut self,
__V: ::serde2::de::EnumVisitor, name: &str,
>(&mut self, name: &str, variant: &str, mut visitor: __V) -> Result<$type_ident, __V::Error> { variant: &str,
mut visitor: __V) -> Result<$type_ident, __V::Error>
where __V: ::serde2::de::EnumVisitor,
{
if name == $type_name { if name == $type_name {
self.visit_variant(variant, visitor) self.visit_variant(variant, visitor)
} else { } else {
@@ -1133,9 +1136,11 @@ fn deserialize_enum(
} }
} }
fn visit_variant< fn visit_variant<__V>(&mut self,
__V: ::serde2::de::EnumVisitor, name: &str,
>(&mut self, name: &str, mut visitor: __V) -> Result<$type_ident, __V::Error> { mut visitor: __V) -> Result<$type_ident, __V::Error>
where __V: ::serde2::de::EnumVisitor
{
match name { match name {
$variant_arms $variant_arms
_ => Err(::serde2::de::Error::syntax_error()), _ => Err(::serde2::de::Error::syntax_error()),
serde2/src/de.rs
+203 -204
View File
@@ -15,17 +15,15 @@ pub trait Error {
} }
pub trait Deserialize { pub trait Deserialize {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
D: Deserializer, where D: Deserializer;
>(deserializer: &mut D) -> Result<Self, D::Error>;
} }
pub trait Deserializer { pub trait Deserializer {
type Error: Error; type Error: Error;
fn visit< fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
V: Visitor, where V: Visitor;
>(&mut self, visitor: V) -> Result<V::Value, Self::Error>;
/// The `visit_option` method allows a `Deserialize` type to inform the /// The `visit_option` method allows a `Deserialize` type to inform the
/// `Deserializer` that it's expecting an optional value. This allows /// `Deserializer` that it's expecting an optional value. This allows
@@ -33,9 +31,9 @@ pub trait Deserializer {
/// convert the null value into a `None`, and a regular value as /// convert the null value into a `None`, and a regular value as
/// `Some(value)`. /// `Some(value)`.
#[inline] #[inline]
fn visit_option< fn visit_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
V: Visitor, where V: Visitor,
>(&mut self, visitor: V) -> Result<V::Value, Self::Error> { {
self.visit(visitor) self.visit(visitor)
} }
} }
@@ -43,169 +41,172 @@ pub trait Deserializer {
pub trait Visitor { pub trait Visitor {
type Value; type Value;
fn visit_bool< fn visit_bool<E>(&mut self, _v: bool) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, _v: bool) -> Result<Self::Value, E> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_isize< fn visit_isize<E>(&mut self, v: isize) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: isize) -> Result<Self::Value, E> { {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
fn visit_i8< fn visit_i8<E>(&mut self, v: i8) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: i8) -> Result<Self::Value, E> { {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
fn visit_i16< fn visit_i16<E>(&mut self, v: i16) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: i16) -> Result<Self::Value, E> { {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
fn visit_i32< fn visit_i32<E>(&mut self, v: i32) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: i32) -> Result<Self::Value, E> { {
self.visit_i64(v as i64) self.visit_i64(v as i64)
} }
fn visit_i64< fn visit_i64<E>(&mut self, _v: i64) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, _v: i64) -> Result<Self::Value, E> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_usize< fn visit_usize<E>(&mut self, v: usize) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: usize) -> Result<Self::Value, E> { {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
fn visit_u8< fn visit_u8<E>(&mut self, v: u8) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: u8) -> Result<Self::Value, E> { {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
fn visit_u16< fn visit_u16<E>(&mut self, v: u16) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: u16) -> Result<Self::Value, E> { {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
fn visit_u32< fn visit_u32<E>(&mut self, v: u32) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: u32) -> Result<Self::Value, E> { {
self.visit_u64(v as u64) self.visit_u64(v as u64)
} }
fn visit_u64< fn visit_u64<E>(&mut self, _v: u64) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, _v: u64) -> Result<Self::Value, E> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_f32< fn visit_f32<E>(&mut self, v: f32) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: f32) -> Result<Self::Value, E> { {
self.visit_f64(v as f64) self.visit_f64(v as f64)
} }
fn visit_f64< fn visit_f64<E>(&mut self, _v: f64) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, _v: f64) -> Result<Self::Value, E> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
#[inline] #[inline]
fn visit_char< fn visit_char<E>(&mut self, v: char) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: char) -> Result<Self::Value, E> { {
// The unwraps in here should be safe. // The unwraps in here should be safe.
let mut s = &mut [0; 4]; let mut s = &mut [0; 4];
let len = v.encode_utf8(s).unwrap(); let len = v.encode_utf8(s).unwrap();
self.visit_str(str::from_utf8(&s[..len]).unwrap()) self.visit_str(str::from_utf8(&s[..len]).unwrap())
} }
fn visit_str< fn visit_str<E>(&mut self, _v: &str) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, _v: &str) -> Result<Self::Value, E> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
#[inline] #[inline]
fn visit_string< fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, v: String) -> Result<Self::Value, E> { {
self.visit_str(&v) self.visit_str(&v)
} }
fn visit_unit< fn visit_unit<E>(&mut self) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self) -> Result<Self::Value, E> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
#[inline] #[inline]
fn visit_named_unit< fn visit_named_unit<E>(&mut self, _name: &str) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self, _name: &str) -> Result<Self::Value, E> { {
self.visit_unit() self.visit_unit()
} }
fn visit_none< fn visit_none<E>(&mut self) -> Result<Self::Value, E>
E: Error, where E: Error,
>(&mut self) -> Result<Self::Value, E> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_some< fn visit_some<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
D: Deserializer, where D: Deserializer,
>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_seq< fn visit_seq<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
V: SeqVisitor, where V: SeqVisitor,
>(&mut self, _visitor: V) -> Result<Self::Value, V::Error> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
#[inline] #[inline]
fn visit_named_seq< fn visit_named_seq<V>(&mut self, _name: &str, visitor: V) -> Result<Self::Value, V::Error>
V: SeqVisitor, where V: SeqVisitor,
>(&mut self, _name: &str, visitor: V) -> Result<Self::Value, V::Error> { {
self.visit_seq(visitor) self.visit_seq(visitor)
} }
fn visit_map< fn visit_map<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
V: MapVisitor, where V: MapVisitor,
>(&mut self, _visitor: V) -> Result<Self::Value, V::Error> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
#[inline] #[inline]
fn visit_named_map< fn visit_named_map<V>(&mut self, _name: &str, visitor: V) -> Result<Self::Value, V::Error>
V: MapVisitor, where V: MapVisitor,
>(&mut self, _name: &str, visitor: V) -> Result<Self::Value, V::Error> { {
self.visit_map(visitor) self.visit_map(visitor)
} }
#[inline] #[inline]
fn visit_enum< fn visit_enum<V>(&mut self,
V: EnumVisitor, _name: &str,
>(&mut self, _name: &str, _variant: &str, _visitor: V) -> Result<Self::Value, V::Error> { _variant: &str,
_visitor: V) -> Result<Self::Value, V::Error>
where V: EnumVisitor,
{
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
#[inline] #[inline]
fn visit_variant< fn visit_variant<V>(&mut self, _name: &str, _visitor: V) -> Result<Self::Value, V::Error>
V: EnumVisitor, where V: EnumVisitor,
>(&mut self, _name: &str, _visitor: V) -> Result<Self::Value, V::Error> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
} }
@@ -262,15 +263,15 @@ pub trait EnumVisitor {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_seq< fn visit_seq<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
V: EnumSeqVisitor, where V: EnumSeqVisitor,
>(&mut self, _visitor: V) -> Result<V::Value, Self::Error> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
fn visit_map< fn visit_map<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
V: EnumMapVisitor, where V: EnumMapVisitor,
>(&mut self, _visitor: V) -> Result<V::Value, Self::Error> { {
Err(Error::syntax_error()) Err(Error::syntax_error())
} }
} }
@@ -278,17 +279,15 @@ pub trait EnumVisitor {
pub trait EnumSeqVisitor { pub trait EnumSeqVisitor {
type Value; type Value;
fn visit< fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
V: SeqVisitor, where V: SeqVisitor;
>(&mut self, visitor: V) -> Result<Self::Value, V::Error>;
} }
pub trait EnumMapVisitor { pub trait EnumMapVisitor {
type Value; type Value;
fn visit< fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
V: MapVisitor, where V: MapVisitor;
>(&mut self, visitor: V) -> Result<Self::Value, V::Error>;
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@@ -298,23 +297,23 @@ struct UnitVisitor;
impl Visitor for UnitVisitor { impl Visitor for UnitVisitor {
type Value = (); type Value = ();
fn visit_unit< fn visit_unit<E>(&mut self) -> Result<(), E>
E: Error, where E: Error,
>(&mut self) -> Result<(), E> { {
Ok(()) Ok(())
} }
fn visit_seq< fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), V::Error>
V: SeqVisitor, where V: SeqVisitor,
>(&mut self, mut visitor: V) -> Result<(), V::Error> { {
visitor.end() visitor.end()
} }
} }
impl Deserialize for () { impl Deserialize for () {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<(), D::Error> { {
deserializer.visit(UnitVisitor) deserializer.visit(UnitVisitor)
} }
} }
@@ -326,17 +325,17 @@ struct BoolVisitor;
impl Visitor for BoolVisitor { impl Visitor for BoolVisitor {
type Value = bool; type Value = bool;
fn visit_bool< fn visit_bool<E>(&mut self, v: bool) -> Result<bool, E>
E: Error, where E: Error,
>(&mut self, v: bool) -> Result<bool, E> { {
Ok(v) Ok(v)
} }
} }
impl Deserialize for bool { impl Deserialize for bool {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<bool, D::Error> { {
deserializer.visit(BoolVisitor) deserializer.visit(BoolVisitor)
} }
} }
@@ -346,9 +345,9 @@ impl Deserialize for bool {
macro_rules! impl_deserialize_num_method { macro_rules! impl_deserialize_num_method {
($src_ty:ty, $method:ident, $from_method:ident) => { ($src_ty:ty, $method:ident, $from_method:ident) => {
#[inline] #[inline]
fn $method< fn $method<E>(&mut self, v: $src_ty) -> Result<T, E>
E: Error, where E: Error,
>(&mut self, v: $src_ty) -> Result<T, E> { {
match FromPrimitive::$from_method(v) { match FromPrimitive::$from_method(v) {
Some(v) => Ok(v), Some(v) => Ok(v),
None => Err(Error::syntax_error()), None => Err(Error::syntax_error()),
@@ -393,9 +392,9 @@ macro_rules! impl_deserialize_num {
($ty:ty) => { ($ty:ty) => {
impl Deserialize for $ty { impl Deserialize for $ty {
#[inline] #[inline]
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<$ty, D::Error> { {
deserializer.visit(PrimitiveVisitor::new()) deserializer.visit(PrimitiveVisitor::new())
} }
} }
@@ -423,16 +422,16 @@ impl Visitor for CharVisitor {
type Value = char; type Value = char;
#[inline] #[inline]
fn visit_char< fn visit_char<E>(&mut self, v: char) -> Result<char, E>
E: Error, where E: Error,
>(&mut self, v: char) -> Result<char, E> { {
Ok(v) Ok(v)
} }
#[inline] #[inline]
fn visit_str< fn visit_str<E>(&mut self, v: &str) -> Result<char, E>
E: Error, where E: Error,
>(&mut self, v: &str) -> Result<char, E> { {
let mut iter = v.chars(); let mut iter = v.chars();
if let Some(v) = iter.next() { if let Some(v) = iter.next() {
if iter.next().is_some() { if iter.next().is_some() {
@@ -448,9 +447,9 @@ impl Visitor for CharVisitor {
impl Deserialize for char { impl Deserialize for char {
#[inline] #[inline]
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<char, D::Error> { {
deserializer.visit(CharVisitor) deserializer.visit(CharVisitor)
} }
} }
@@ -462,23 +461,23 @@ struct StringVisitor;
impl Visitor for StringVisitor { impl Visitor for StringVisitor {
type Value = String; type Value = String;
fn visit_str< fn visit_str<E>(&mut self, v: &str) -> Result<String, E>
E: Error, where E: Error,
>(&mut self, v: &str) -> Result<String, E> { {
Ok(v.to_string()) Ok(v.to_string())
} }
fn visit_string< fn visit_string<E>(&mut self, v: String) -> Result<String, E>
E: Error, where E: Error,
>(&mut self, v: String) -> Result<String, E> { {
Ok(v) Ok(v)
} }
} }
impl Deserialize for String { impl Deserialize for String {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<String, D::Error> { {
deserializer.visit(StringVisitor) deserializer.visit(StringVisitor)
} }
} }
@@ -495,24 +494,24 @@ impl<
type Value = Option<T>; type Value = Option<T>;
#[inline] #[inline]
fn visit_none< fn visit_none<E>(&mut self) -> Result<Option<T>, E>
E: Error, where E: Error,
>(&mut self) -> Result<Option<T>, E> { {
Ok(None) Ok(None)
} }
#[inline] #[inline]
fn visit_some< fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Option<T>, D::Error>
D: Deserializer, where D: Deserializer,
>(&mut self, deserializer: &mut D) -> Result<Option<T>, D::Error> { {
Ok(Some(try!(Deserialize::deserialize(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< fn deserialize<D>(deserializer: &mut D) -> Result<Option<T>, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<Option<T>, D::Error> { {
deserializer.visit_option(OptionVisitor { marker: PhantomData }) deserializer.visit_option(OptionVisitor { marker: PhantomData })
} }
} }
@@ -527,9 +526,9 @@ impl<T> Visitor for VecVisitor<T> where T: Deserialize {
type Value = Vec<T>; type Value = Vec<T>;
#[inline] #[inline]
fn visit_seq< fn visit_seq<V>(&mut self, mut visitor: V) -> Result<Vec<T>, V::Error>
V: SeqVisitor, where V: SeqVisitor,
>(&mut self, mut visitor: V) -> Result<Vec<T>, V::Error> { {
let (len, _) = visitor.size_hint(); let (len, _) = visitor.size_hint();
let mut values = Vec::with_capacity(len); let mut values = Vec::with_capacity(len);
@@ -542,9 +541,9 @@ impl<T> Visitor for VecVisitor<T> where T: Deserialize {
} }
impl<T: Deserialize> Deserialize for Vec<T> { impl<T: Deserialize> Deserialize for Vec<T> {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<Vec<T>, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<Vec<T>, D::Error> { {
deserializer.visit(VecVisitor { marker: PhantomData }) deserializer.visit(VecVisitor { marker: PhantomData })
} }
} }
@@ -566,9 +565,9 @@ macro_rules! tuple_impls {
#[inline] #[inline]
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn visit_seq< fn visit_seq<V>(&mut self, mut visitor: V) -> Result<($($name,)+), V::Error>
V: SeqVisitor, where V: SeqVisitor,
>(&mut self, mut visitor: V) -> Result<($($name,)+), V::Error> { {
$( $(
let $name = match try!(visitor.visit()) { let $name = match try!(visitor.visit()) {
Some(value) => value, Some(value) => value,
@@ -586,9 +585,9 @@ macro_rules! tuple_impls {
$($name: Deserialize),+ $($name: Deserialize),+
> Deserialize for ($($name,)+) { > Deserialize for ($($name,)+) {
#[inline] #[inline]
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<($($name,)+), D::Error> { {
deserializer.visit($visitor { marker: PhantomData }) deserializer.visit($visitor { marker: PhantomData })
} }
} }
@@ -624,9 +623,9 @@ impl<K, V> Visitor for HashMapVisitor<K, V>
type Value = HashMap<K, V>; type Value = HashMap<K, V>;
#[inline] #[inline]
fn visit_map< fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<HashMap<K, V>, V_::Error>
V_: MapVisitor, where V_: MapVisitor,
>(&mut self, mut visitor: V_) -> Result<HashMap<K, V>, V_::Error> { {
let (len, _) = visitor.size_hint(); let (len, _) = visitor.size_hint();
let mut values = HashMap::with_capacity(len); let mut values = HashMap::with_capacity(len);
@@ -642,9 +641,9 @@ impl<K, V> Deserialize for HashMap<K, V>
where K: Deserialize + Eq + Hash, where K: Deserialize + Eq + Hash,
V: Deserialize, V: Deserialize,
{ {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error> { {
deserializer.visit(HashMapVisitor { marker: PhantomData }) deserializer.visit(HashMapVisitor { marker: PhantomData })
} }
} }
@@ -662,9 +661,9 @@ impl<K, V> Visitor for BTreeMapVisitor<K, V>
type Value = BTreeMap<K, V>; type Value = BTreeMap<K, V>;
#[inline] #[inline]
fn visit_map< fn visit_map<Visitor>(&mut self, mut visitor: Visitor) -> Result<BTreeMap<K, V>, Visitor::Error>
Visitor: MapVisitor, where Visitor: MapVisitor,
>(&mut self, mut visitor: Visitor) -> Result<BTreeMap<K, V>, Visitor::Error> { {
let mut values = BTreeMap::new(); let mut values = BTreeMap::new();
while let Some((key, value)) = try!(visitor.visit()) { while let Some((key, value)) = try!(visitor.visit()) {
@@ -679,9 +678,9 @@ impl<
K: Deserialize + Eq + Ord, K: Deserialize + Eq + Ord,
V: Deserialize, V: Deserialize,
> Deserialize for BTreeMap<K, V> { > Deserialize for BTreeMap<K, V> {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error> { {
deserializer.visit(BTreeMapVisitor { marker: PhantomData }) deserializer.visit(BTreeMapVisitor { marker: PhantomData })
} }
} }
@@ -763,9 +762,9 @@ mod tests {
impl<'a> Deserializer for TokenDeserializer<'a> { impl<'a> Deserializer for TokenDeserializer<'a> {
type Error = Error; type Error = Error;
fn visit< fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
V: Visitor, where V: Visitor,
>(&mut self, mut visitor: V) -> Result<V::Value, Error> { {
match self.tokens.next() { match self.tokens.next() {
Some(Token::Bool(v)) => visitor.visit_bool(v), Some(Token::Bool(v)) => visitor.visit_bool(v),
Some(Token::Isize(v)) => visitor.visit_isize(v), Some(Token::Isize(v)) => visitor.visit_isize(v),
@@ -828,9 +827,9 @@ mod tests {
/// Hook into `Option` deserializing so we can treat `Unit` as a /// Hook into `Option` deserializing so we can treat `Unit` as a
/// `None`, or a regular value as `Some(value)`. /// `None`, or a regular value as `Some(value)`.
#[inline] #[inline]
fn visit_option< fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
V: Visitor, where V: Visitor,
>(&mut self, mut visitor: V) -> Result<V::Value, Error> { {
match self.tokens.peek() { match self.tokens.peek() {
Some(&Token::Option(false)) => { Some(&Token::Option(false)) => {
self.tokens.next(); self.tokens.next();
@@ -861,9 +860,9 @@ mod tests {
impl<'a, 'b> super::SeqVisitor for TokenDeserializerSeqVisitor<'a, 'b> { impl<'a, 'b> super::SeqVisitor for TokenDeserializerSeqVisitor<'a, 'b> {
type Error = Error; type Error = Error;
fn visit< fn visit<T>(&mut self) -> Result<Option<T>, Error>
T: Deserialize, where T: Deserialize,
>(&mut self) -> Result<Option<T>, Error> { {
let first = self.first; let first = self.first;
self.first = false; self.first = false;
@@ -904,9 +903,9 @@ mod tests {
impl<'a, 'b> super::MapVisitor for TokenDeserializerMapVisitor<'a, 'b> { impl<'a, 'b> super::MapVisitor for TokenDeserializerMapVisitor<'a, 'b> {
type Error = Error; type Error = Error;
fn visit_key< fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
K: Deserialize, where K: Deserialize,
>(&mut self) -> Result<Option<K>, Error> { {
let first = self.first; let first = self.first;
self.first = false; self.first = false;
@@ -920,9 +919,9 @@ mod tests {
} }
} }
fn visit_value< fn visit_value<V>(&mut self) -> Result<V, Error>
V: Deserialize, where V: Deserialize,
>(&mut self) -> Result<V, Error> { {
Ok(try!(Deserialize::deserialize(self.de))) Ok(try!(Deserialize::deserialize(self.de)))
} }
@@ -1010,9 +1009,9 @@ mod tests {
struct NamedUnit; struct NamedUnit;
impl Deserialize for NamedUnit { impl Deserialize for NamedUnit {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<NamedUnit, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<NamedUnit, D::Error> { {
deserializer.visit(NamedUnitVisitor) deserializer.visit(NamedUnitVisitor)
} }
} }
@@ -1052,9 +1051,9 @@ mod tests {
struct NamedSeq(i32, i32, i32); struct NamedSeq(i32, i32, i32);
impl Deserialize for NamedSeq { impl Deserialize for NamedSeq {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<NamedSeq, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<NamedSeq, D::Error> { {
deserializer.visit(NamedSeqVisitor) deserializer.visit(NamedSeqVisitor)
} }
} }
@@ -1108,9 +1107,9 @@ mod tests {
} }
impl Deserialize for NamedMap { impl Deserialize for NamedMap {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<NamedMap, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<NamedMap, D::Error> { {
deserializer.visit(NamedMapVisitor) deserializer.visit(NamedMapVisitor)
} }
} }
@@ -1159,9 +1158,9 @@ mod tests {
} }
impl Deserialize for NamedMapField { impl Deserialize for NamedMapField {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<NamedMapField, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<NamedMapField, D::Error> { {
deserializer.visit(NamedMapFieldVisitor) deserializer.visit(NamedMapFieldVisitor)
} }
} }
@@ -1193,9 +1192,9 @@ mod tests {
} }
impl Deserialize for Enum { impl Deserialize for Enum {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<Enum, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<Enum, D::Error> { {
deserializer.visit(EnumVisitor) deserializer.visit(EnumVisitor)
} }
} }
@@ -1293,9 +1292,9 @@ mod tests {
} }
impl Deserialize for EnumMapField { impl Deserialize for EnumMapField {
fn deserialize< fn deserialize<D>(deserializer: &mut D) -> Result<EnumMapField, D::Error>
D: Deserializer, where D: Deserializer,
>(deserializer: &mut D) -> Result<EnumMapField, D::Error> { {
deserializer.visit(EnumMapFieldVisitor) deserializer.visit(EnumMapFieldVisitor)
} }
} }
serde2/src/json/de.rs
+18 -18
View File
@@ -81,9 +81,9 @@ impl<Iter: Iterator<Item=u8>> Deserializer<Iter> {
} }
#[inline] #[inline]
fn parse_value< fn parse_value<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
V: de::Visitor, where V: de::Visitor,
>(&mut self, mut visitor: V) -> Result<V::Value, Error> { {
self.parse_whitespace(); self.parse_whitespace();
if self.eof() { if self.eof() {
@@ -140,9 +140,9 @@ impl<Iter: Iterator<Item=u8>> Deserializer<Iter> {
} }
#[inline] #[inline]
fn parse_number< fn parse_number<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
V: de::Visitor, where V: de::Visitor,
>(&mut self, mut visitor: V) -> Result<V::Value, Error> { {
let mut neg = 1; let mut neg = 1;
if self.ch_is(b'-') { if self.ch_is(b'-') {
@@ -387,9 +387,9 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer for Deserializer<Iter> {
type Error = Error; type Error = Error;
#[inline] #[inline]
fn visit< fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Error>
V: de::Visitor, where V: de::Visitor,
>(&mut self, visitor: V) -> Result<V::Value, Error> { {
self.parse_value(visitor) self.parse_value(visitor)
} }
} }
@@ -402,9 +402,9 @@ struct SeqVisitor<'a, Iter: 'a> {
impl<'a, Iter: Iterator<Item=u8>> de::SeqVisitor for SeqVisitor<'a, Iter> { impl<'a, Iter: Iterator<Item=u8>> de::SeqVisitor for SeqVisitor<'a, Iter> {
type Error = Error; type Error = Error;
fn visit< fn visit<T>(&mut self) -> Result<Option<T>, Error>
T: de::Deserialize, where T: de::Deserialize,
>(&mut self) -> Result<Option<T>, Error> { {
self.de.parse_whitespace(); self.de.parse_whitespace();
if self.de.ch_is(b']') { if self.de.ch_is(b']') {
@@ -448,9 +448,9 @@ struct MapVisitor<'a, Iter: 'a> {
impl<'a, Iter: Iterator<Item=u8>> de::MapVisitor for MapVisitor<'a, Iter> { impl<'a, Iter: Iterator<Item=u8>> de::MapVisitor for MapVisitor<'a, Iter> {
type Error = Error; type Error = Error;
fn visit_key< fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
K: de::Deserialize, where K: de::Deserialize,
>(&mut self) -> Result<Option<K>, Error> { {
self.de.parse_whitespace(); self.de.parse_whitespace();
if self.de.ch_is(b'}') { if self.de.ch_is(b'}') {
@@ -482,9 +482,9 @@ impl<'a, Iter: Iterator<Item=u8>> de::MapVisitor for MapVisitor<'a, Iter> {
Ok(Some(try!(de::Deserialize::deserialize(self.de)))) Ok(Some(try!(de::Deserialize::deserialize(self.de))))
} }
fn visit_value< fn visit_value<V>(&mut self) -> Result<V, Error>
V: de::Deserialize, where V: de::Deserialize,
>(&mut self) -> Result<V, Error> { {
self.de.parse_whitespace(); self.de.parse_whitespace();
if self.de.ch_is(b':') { if self.de.ch_is(b':') {
serde2/src/json/ser.rs
+3 -3
View File
@@ -32,9 +32,9 @@ impl<W: io::Write> ser::Serializer for Serializer<W> {
type Error = io::Error; type Error = io::Error;
#[inline] #[inline]
fn visit< fn visit<T>(&mut self, value: &T) -> io::Result<()>
T: ser::Serialize, where T: ser::Serialize,
>(&mut self, value: &T) -> io::Result<()> { {
value.visit(&mut Visitor { writer: &mut self.writer }) value.visit(&mut Visitor { writer: &mut self.writer })
} }
} }
serde2/src/json/value.rs
+15 -15
View File
@@ -21,9 +21,9 @@ pub enum Value {
impl ser::Serialize for Value { impl ser::Serialize for Value {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: ser::Visitor, where V: ser::Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
match *self { match *self {
Value::Null => visitor.visit_unit(), Value::Null => visitor.visit_unit(),
Value::Bool(v) => visitor.visit_bool(v), Value::Bool(v) => visitor.visit_bool(v),
@@ -91,9 +91,9 @@ impl ser::Serializer for Serializer {
type Error = (); type Error = ();
#[inline] #[inline]
fn visit< fn visit<T>(&mut self, value: &T) -> Result<(), ()>
T: ser::Serialize, where T: ser::Serialize,
>(&mut self, value: &T) -> Result<(), ()> { {
try!(value.visit(self)); try!(value.visit(self));
Ok(()) Ok(())
} }
@@ -151,9 +151,9 @@ impl ser::Visitor for Serializer {
} }
#[inline] #[inline]
fn visit_some< fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
V: ser::Serialize, where V: ser::Serialize,
>(&mut self, value: V) -> Result<(), ()> { {
value.visit(self) value.visit(self)
} }
@@ -265,9 +265,9 @@ impl de::Deserializer for Deserializer {
type Error = Error; type Error = Error;
#[inline] #[inline]
fn visit< fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
V: de::Visitor, where V: de::Visitor,
>(&mut self, mut visitor: V) -> Result<V::Value, Error> { {
let value = match self.value.take() { let value = match self.value.take() {
Some(value) => value, Some(value) => value,
None => { return Err(de::Error::end_of_stream_error()); } None => { return Err(de::Error::end_of_stream_error()); }
@@ -300,9 +300,9 @@ impl de::Deserializer for Deserializer {
} }
#[inline] #[inline]
fn visit_option< fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
V: de::Visitor, where V: de::Visitor,
>(&mut self, mut visitor: V) -> Result<V::Value, Error> { {
match self.value { match self.value {
Some(Value::Null) => visitor.visit_none(), Some(Value::Null) => visitor.visit_none(),
Some(_) => visitor.visit_some(self), Some(_) => visitor.visit_some(self),
serde2/src/ser.rs
+93 -97
View File
@@ -171,9 +171,8 @@ pub trait Visitor {
} }
pub trait SeqVisitor { pub trait SeqVisitor {
fn visit< fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
V: Visitor, where V: Visitor;
>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>;
#[inline] #[inline]
fn size_hint(&self) -> (usize, Option<usize>) { fn size_hint(&self) -> (usize, Option<usize>) {
@@ -182,9 +181,8 @@ pub trait SeqVisitor {
} }
pub trait MapVisitor { pub trait MapVisitor {
fn visit< fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
V: Visitor, where V: Visitor;
>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>;
#[inline] #[inline]
fn size_hint(&self) -> (usize, Option<usize>) { fn size_hint(&self) -> (usize, Option<usize>) {
@@ -198,9 +196,9 @@ macro_rules! impl_visit {
($ty:ty, $method:ident) => { ($ty:ty, $method:ident) => {
impl Serialize for $ty { impl Serialize for $ty {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
visitor.$method(*self) visitor.$method(*self)
} }
} }
@@ -226,18 +224,18 @@ impl_visit!(char, visit_char);
impl<'a> Serialize for &'a str { impl<'a> Serialize for &'a str {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
visitor.visit_str(*self) visitor.visit_str(*self)
} }
} }
impl Serialize for String { impl Serialize for String {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
(&self[..]).visit(visitor) (&self[..]).visit(visitor)
} }
} }
@@ -246,9 +244,9 @@ impl Serialize for String {
impl<T> Serialize for Option<T> where T: Serialize { impl<T> Serialize for Option<T> where T: Serialize {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
match *self { match *self {
Some(ref value) => visitor.visit_some(value), Some(ref value) => visitor.visit_some(value),
None => visitor.visit_none(), None => visitor.visit_none(),
@@ -263,7 +261,9 @@ pub struct SeqIteratorVisitor<Iter> {
first: bool, first: bool,
} }
impl<T, Iter: Iterator<Item=T>> SeqIteratorVisitor<Iter> { impl<T, Iter> SeqIteratorVisitor<Iter>
where Iter: Iterator<Item=T>
{
#[inline] #[inline]
pub fn new(iter: Iter) -> SeqIteratorVisitor<Iter> { pub fn new(iter: Iter) -> SeqIteratorVisitor<Iter> {
SeqIteratorVisitor { SeqIteratorVisitor {
@@ -273,14 +273,14 @@ impl<T, Iter: Iterator<Item=T>> SeqIteratorVisitor<Iter> {
} }
} }
impl< impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
T: Serialize, where T: Serialize,
Iter: Iterator<Item=T>, Iter: Iterator<Item=T>,
> SeqVisitor for SeqIteratorVisitor<Iter> { {
#[inline] #[inline]
fn visit< fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
V: Visitor, where V: Visitor,
>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error> { {
let first = self.first; let first = self.first;
self.first = false; self.first = false;
@@ -301,34 +301,31 @@ impl<
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
impl< impl<'a, T> Serialize for &'a [T]
'a, where T: Serialize,
T: Serialize, {
> Serialize for &'a [T] {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
visitor.visit_seq(SeqIteratorVisitor::new(self.iter())) visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
} }
} }
impl< impl<T> Serialize for Vec<T> where T: Serialize {
T: Serialize,
> Serialize for Vec<T> {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
(&self[..]).visit(visitor) (&self[..]).visit(visitor)
} }
} }
impl<T> Serialize for BTreeSet<T> where T: Serialize { impl<T> Serialize for BTreeSet<T> where T: Serialize {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
visitor.visit_seq(SeqIteratorVisitor::new(self.iter())) visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
} }
} }
@@ -347,9 +344,9 @@ impl<T, S> Serialize for HashSet<T, S>
impl Serialize for () { impl Serialize for () {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
visitor.visit_unit() visitor.visit_unit()
} }
} }
@@ -384,13 +381,12 @@ macro_rules! tuple_impls {
} }
} }
impl< impl<'a, $($T),+> SeqVisitor for $TupleVisitor<'a, $($T),+>
'a, where $($T: Serialize),+
$($T: Serialize),+ {
> SeqVisitor for $TupleVisitor<'a, $($T),+> { fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
fn visit< where V: Visitor,
V: Visitor, {
>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error> {
let first = self.first; let first = self.first;
self.first = false; self.first = false;
@@ -412,9 +408,9 @@ macro_rules! tuple_impls {
} }
} }
impl< impl<$($T),+> Serialize for ($($T,)+)
$($T: Serialize),+ where $($T: Serialize),+
> Serialize for ($($T,)+) { {
#[inline] #[inline]
fn visit<V: Visitor>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { fn visit<V: Visitor>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
visitor.visit_seq($TupleVisitor::new(self)) visitor.visit_seq($TupleVisitor::new(self))
@@ -536,7 +532,9 @@ pub struct MapIteratorVisitor<Iter> {
first: bool, first: bool,
} }
impl<K, V, Iter: Iterator<Item=(K, V)>> MapIteratorVisitor<Iter> { impl<K, V, Iter> MapIteratorVisitor<Iter>
where Iter: Iterator<Item=(K, V)>
{
#[inline] #[inline]
pub fn new(iter: Iter) -> MapIteratorVisitor<Iter> { pub fn new(iter: Iter) -> MapIteratorVisitor<Iter> {
MapIteratorVisitor { MapIteratorVisitor {
@@ -552,9 +550,9 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
I: Iterator<Item=(K, V)>, I: Iterator<Item=(K, V)>,
{ {
#[inline] #[inline]
fn visit< fn visit<V_>(&mut self, visitor: &mut V_) -> Result<Option<V_::Value>, V_::Error>
V_: Visitor, where V_: Visitor,
>(&mut self, visitor: &mut V_) -> Result<Option<V_::Value>, V_::Error> { {
let first = self.first; let first = self.first;
self.first = false; self.first = false;
@@ -600,42 +598,40 @@ impl<K, V, S> Serialize for HashMap<K, V, S>
impl<'a, T> Serialize for &'a T where T: Serialize { impl<'a, T> Serialize for &'a T where T: Serialize {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
(**self).visit(visitor) (**self).visit(visitor)
} }
} }
impl<'a, T> Serialize for Box<T> where T: Serialize { impl<'a, T> Serialize for Box<T> where T: Serialize {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
(**self).visit(visitor) (**self).visit(visitor)
} }
} }
impl< impl<'a, T> Serialize for Rc<T>
'a, where T: Serialize,
T: Serialize, {
> Serialize for Rc<T> {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
(**self).visit(visitor) (**self).visit(visitor)
} }
} }
impl< impl<'a, T> Serialize for Arc<T>
'a, where T: Serialize,
T: Serialize, {
> Serialize for Arc<T> {
#[inline] #[inline]
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
(**self).visit(visitor) (**self).visit(visitor)
} }
} }
@@ -923,9 +919,9 @@ mod tests {
struct NamedUnit; struct NamedUnit;
impl Serialize for NamedUnit { impl Serialize for NamedUnit {
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
visitor.visit_named_unit("NamedUnit") visitor.visit_named_unit("NamedUnit")
} }
} }
@@ -933,9 +929,9 @@ mod tests {
struct NamedSeq(i32, i32, i32); struct NamedSeq(i32, i32, i32);
impl Serialize for NamedSeq { impl Serialize for NamedSeq {
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
visitor.visit_named_seq("NamedSeq", NamedSeqVisitor { visitor.visit_named_seq("NamedSeq", NamedSeqVisitor {
tuple: self, tuple: self,
state: 0, state: 0,
@@ -949,9 +945,9 @@ mod tests {
} }
impl<'a> SeqVisitor for NamedSeqVisitor<'a> { impl<'a> SeqVisitor for NamedSeqVisitor<'a> {
fn visit< fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
V: Visitor, where V: Visitor,
>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error> { {
match self.state { match self.state {
0 => { 0 => {
self.state += 1; self.state += 1;
@@ -981,9 +977,9 @@ mod tests {
} }
impl Serialize for Enum { impl Serialize for Enum {
fn visit< fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
V: Visitor, where V: Visitor,
>(&self, visitor: &mut V) -> Result<V::Value, V::Error> { {
match *self { match *self {
Enum::Unit => { Enum::Unit => {
visitor.visit_enum_unit("Enum", "Unit") visitor.visit_enum_unit("Enum", "Unit")
@@ -1013,9 +1009,9 @@ mod tests {
} }
impl<'a> SeqVisitor for EnumSeqVisitor<'a> { impl<'a> SeqVisitor for EnumSeqVisitor<'a> {
fn visit< fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
V: Visitor, where V: Visitor,
>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error> { {
match self.state { match self.state {
0 => { 0 => {
self.state += 1; self.state += 1;
@@ -1043,9 +1039,9 @@ mod tests {
} }
impl<'a> MapVisitor for EnumMapVisitor<'a> { impl<'a> MapVisitor for EnumMapVisitor<'a> {
fn visit< fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
V: Visitor, where V: Visitor,
>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error> { {
match self.state { match self.state {
0 => { 0 => {
self.state += 1; self.state += 1;