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

feat: ValueDeserializers are generic over the error type

Browse Source 
This makes it possible to remove the `From<de::value::Error>` trait
bound from the `de::Error` trait.

An example for using a `ValueDeserializer` to forward deserializing to
another type's visitor:

```rust
fn visit_u8<E>(&mut self, value: u8) -> Result<Self::Value, E>
    where E: de::Error
{
    try!(Deserialize::deserialize(&mut value.into_deserializer()))
}
```

Please note that there is an regression in serde-rs/json which needs to
be fixed.
This commit is contained in:
Thomas Bahn
2015-10-06 01:10:10 +02:00
parent 0a65153634
commit 7413bbb7bf
1 changed files with 155 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/src/de/value.rs
+155 -111
View File
@@ -12,6 +12,7 @@ use std::collections::{
};
use std::hash::Hash;
use std::vec;
use std::marker::PhantomData;
use de;
use bytes;
@@ -52,9 +53,9 @@ impl de::Error for Error {
///////////////////////////////////////////////////////////////////////////////
/// This trait converts primitive types into a deserializer.
pub trait ValueDeserializer {
pub trait ValueDeserializer<E: de::Error = Error> {
/// The actual deserializer type.
type Deserializer: de::Deserializer<Error=Error>;
type Deserializer: de::Deserializer<Error=E>;
/// Convert this value into a deserializer.
fn into_deserializer(self) -> Self::Deserializer;
@@ -62,27 +63,31 @@ pub trait ValueDeserializer {
///////////////////////////////////////////////////////////////////////////////
impl ValueDeserializer for () {
type Deserializer = UnitDeserializer;
impl<E> ValueDeserializer<E> for ()
where E: de::Error,
{
type Deserializer = UnitDeserializer<E>;
fn into_deserializer(self) -> UnitDeserializer {
UnitDeserializer
fn into_deserializer(self) -> UnitDeserializer<E> {
UnitDeserializer(PhantomData)
}
}
/// A helper deserializer that deserializes a `()`.
pub struct UnitDeserializer;
pub struct UnitDeserializer<E>(PhantomData<E>);
impl de::Deserializer for UnitDeserializer {
type Error = Error;
impl<E> de::Deserializer for UnitDeserializer<E>
where E: de::Error
{
type Error = E;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_unit()
}
fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_none()
@@ -94,20 +99,24 @@ impl de::Deserializer for UnitDeserializer {
macro_rules! primitive_deserializer {
($ty:ty, $name:ident, $method:ident) => {
/// A helper deserializer that deserializes a number.
pub struct $name(Option<$ty>);
pub struct $name<E>(Option<$ty>, PhantomData<E>);
impl ValueDeserializer for $ty {
type Deserializer = $name;
impl<E> ValueDeserializer<E> for $ty
where E: de::Error,
{
type Deserializer = $name<E>;
fn into_deserializer(self) -> $name {
$name(Some(self))
fn into_deserializer(self) -> $name<E> {
$name(Some(self), PhantomData)
}
}
impl de::Deserializer for $name {
type Error = Error;
impl<E> de::Deserializer for $name<E>
where E: de::Error,
{
type Error = E;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
match self.0.take() {
@@ -137,20 +146,24 @@ primitive_deserializer!(char, CharDeserializer, visit_char);
///////////////////////////////////////////////////////////////////////////////
/// A helper deserializer that deserializes a `&str`.
pub struct StrDeserializer<'a>(Option<&'a str>);
pub struct StrDeserializer<'a, E>(Option<&'a str>, PhantomData<E>);
impl<'a> ValueDeserializer for &'a str {
type Deserializer = StrDeserializer<'a>;
impl<'a, E> ValueDeserializer<E> for &'a str
where E: de::Error,
{
type Deserializer = StrDeserializer<'a, E>;
fn into_deserializer(self) -> StrDeserializer<'a> {
StrDeserializer(Some(self))
fn into_deserializer(self) -> StrDeserializer<'a, E> {
StrDeserializer(Some(self), PhantomData)
}
}
impl<'a> de::Deserializer for StrDeserializer<'a> {
type Error = Error;
impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
where E: de::Error,
{
type Error = E;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
match self.0.take() {
@@ -162,23 +175,25 @@ impl<'a> de::Deserializer for StrDeserializer<'a> {
fn visit_enum<V>(&mut self,
_name: &str,
_variants: &'static [&'static str],
mut visitor: V) -> Result<V::Value, Error>
mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::EnumVisitor,
{
visitor.visit(self)
}
}
impl<'a> de::VariantVisitor for StrDeserializer<'a> {
type Error = Error;
impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
where E: de::Error,
{
type Error = E;
fn visit_variant<T>(&mut self) -> Result<T, Error>
fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
where T: de::Deserialize,
{
de::Deserialize::deserialize(self)
}
fn visit_unit(&mut self) -> Result<(), Error> {
fn visit_unit(&mut self) -> Result<(), Self::Error> {
Ok(())
}
}
@@ -186,20 +201,24 @@ impl<'a> de::VariantVisitor for StrDeserializer<'a> {
///////////////////////////////////////////////////////////////////////////////
/// A helper deserializer that deserializes a `String`.
pub struct StringDeserializer(Option<String>);
pub struct StringDeserializer<E>(Option<String>, PhantomData<E>);
impl ValueDeserializer for String {
type Deserializer = StringDeserializer;
impl<E> ValueDeserializer<E> for String
where E: de::Error,
{
type Deserializer = StringDeserializer<E>;
fn into_deserializer(self) -> StringDeserializer {
StringDeserializer(Some(self))
fn into_deserializer(self) -> StringDeserializer<E> {
StringDeserializer(Some(self), PhantomData)
}
}
impl de::Deserializer for StringDeserializer {
type Error = Error;
impl<E> de::Deserializer for StringDeserializer<E>
where E: de::Error,
{
type Error = E;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
match self.0.take() {
@@ -211,23 +230,25 @@ impl de::Deserializer for StringDeserializer {
fn visit_enum<V>(&mut self,
_name: &str,
_variants: &'static [&'static str],
mut visitor: V) -> Result<V::Value, Error>
mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::EnumVisitor,
{
visitor.visit(self)
}
}
impl<'a> de::VariantVisitor for StringDeserializer {
type Error = Error;
impl<'a, E> de::VariantVisitor for StringDeserializer<E>
where E: de::Error,
{
type Error = E;
fn visit_variant<T>(&mut self) -> Result<T, Error>
fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
where T: de::Deserialize,
{
de::Deserialize::deserialize(self)
}
fn visit_unit(&mut self) -> Result<(), Error> {
fn visit_unit(&mut self) -> Result<(), Self::Error> {
Ok(())
}
}
@@ -235,41 +256,47 @@ impl<'a> de::VariantVisitor for StringDeserializer {
///////////////////////////////////////////////////////////////////////////////
/// A helper deserializer that deserializes a sequence.
pub struct SeqDeserializer<I> {
pub struct SeqDeserializer<I, E> {
iter: I,
len: usize,
marker: PhantomData<E>,
}
impl<I> SeqDeserializer<I> {
impl<I, E> SeqDeserializer<I, E>
where E: de::Error,
{
/// Construct a new `SeqDeserializer<I>`.
pub fn new(iter: I, len: usize) -> Self {
SeqDeserializer {
iter: iter,
len: len,
marker: PhantomData,
}
}
}
impl<I, T> de::Deserializer for SeqDeserializer<I>
impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
where I: Iterator<Item=T>,
T: ValueDeserializer,
T: ValueDeserializer<E>,
E: de::Error,
{
type Error = Error;
type Error = E;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_seq(self)
}
}
impl<I, T> de::SeqVisitor for SeqDeserializer<I>
impl<I, T, E> de::SeqVisitor for SeqDeserializer<I, E>
where I: Iterator<Item=T>,
T: ValueDeserializer,
T: ValueDeserializer<E>,
E: de::Error,
{
type Error = Error;
type Error = E;
fn visit<V>(&mut self) -> Result<Option<V>, Error>
fn visit<V>(&mut self) -> Result<Option<V>, Self::Error>
where V: de::Deserialize
{
match self.iter.next() {
@@ -282,7 +309,7 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>
}
}
fn end(&mut self) -> Result<(), Error> {
fn end(&mut self) -> Result<(), Self::Error> {
if self.len == 0 {
Ok(())
} else {
@@ -297,34 +324,37 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>
///////////////////////////////////////////////////////////////////////////////
impl<T> ValueDeserializer for Vec<T>
where T: ValueDeserializer,
impl<T, E> ValueDeserializer<E> for Vec<T>
where T: ValueDeserializer<E>,
E: de::Error,
{
type Deserializer = SeqDeserializer<vec::IntoIter<T>>;
type Deserializer = SeqDeserializer<vec::IntoIter<T>, E>;
fn into_deserializer(self) -> SeqDeserializer<vec::IntoIter<T>> {
fn into_deserializer(self) -> Self::Deserializer {
let len = self.len();
SeqDeserializer::new(self.into_iter(), len)
}
}
impl<T> ValueDeserializer for BTreeSet<T>
where T: ValueDeserializer + Eq + Ord,
impl<T, E> ValueDeserializer<E> for BTreeSet<T>
where T: ValueDeserializer<E> + Eq + Ord,
E: de::Error,
{
type Deserializer = SeqDeserializer<btree_set::IntoIter<T>>;
type Deserializer = SeqDeserializer<btree_set::IntoIter<T>, E>;
fn into_deserializer(self) -> SeqDeserializer<btree_set::IntoIter<T>> {
fn into_deserializer(self) -> Self::Deserializer {
let len = self.len();
SeqDeserializer::new(self.into_iter(), len)
}
}
impl<T> ValueDeserializer for HashSet<T>
where T: ValueDeserializer + Eq + Hash,
impl<T, E> ValueDeserializer<E> for HashSet<T>
where T: ValueDeserializer<E> + Eq + Hash,
E: de::Error,
{
type Deserializer = SeqDeserializer<hash_set::IntoIter<T>>;
type Deserializer = SeqDeserializer<hash_set::IntoIter<T>, E>;
fn into_deserializer(self) -> SeqDeserializer<hash_set::IntoIter<T>> {
fn into_deserializer(self) -> Self::Deserializer {
let len = self.len();
SeqDeserializer::new(self.into_iter(), len)
}
@@ -333,20 +363,23 @@ impl<T> ValueDeserializer for HashSet<T>
///////////////////////////////////////////////////////////////////////////////
/// A helper deserializer that deserializes a map.
pub struct MapDeserializer<I, K, V>
pub struct MapDeserializer<I, K, V, E>
where I: Iterator<Item=(K, V)>,
K: ValueDeserializer,
V: ValueDeserializer,
K: ValueDeserializer<E>,
V: ValueDeserializer<E>,
E: de::Error,
{
iter: I,
value: Option<V>,
len: usize,
marker: PhantomData<E>,
}
impl<I, K, V> MapDeserializer<I, K, V>
impl<I, K, V, E> MapDeserializer<I, K, V, E>
where I: Iterator<Item=(K, V)>,
K: ValueDeserializer,
V: ValueDeserializer,
K: ValueDeserializer<E>,
V: ValueDeserializer<E>,
E: de::Error,
{
/// Construct a new `MapDeserializer<I, K, V>`.
pub fn new(iter: I, len: usize) -> Self {
@@ -354,32 +387,35 @@ impl<I, K, V> MapDeserializer<I, K, V>
iter: iter,
value: None,
len: len,
marker: PhantomData,
}
}
}
impl<I, K, V> de::Deserializer for MapDeserializer<I, K, V>
impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
where I: Iterator<Item=(K, V)>,
K: ValueDeserializer,
V: ValueDeserializer,
K: ValueDeserializer<E>,
V: ValueDeserializer<E>,
E: de::Error,
{
type Error = Error;
type Error = E;
fn visit<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Error>
fn visit<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
where V_: de::Visitor,
{
visitor.visit_map(self)
}
}
impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
where I: Iterator<Item=(K, V)>,
K: ValueDeserializer,
V: ValueDeserializer,
K: ValueDeserializer<E>,
V: ValueDeserializer<E>,
E: de::Error,
{
type Error = Error;
type Error = E;
fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
fn visit_key<T>(&mut self) -> Result<Option<T>, Self::Error>
where T: de::Deserialize,
{
match self.iter.next() {
@@ -393,7 +429,7 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
}
}
fn visit_value<T>(&mut self) -> Result<T, Error>
fn visit_value<T>(&mut self) -> Result<T, Self::Error>
where T: de::Deserialize,
{
match self.value.take() {
@@ -405,7 +441,7 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
}
}
fn end(&mut self) -> Result<(), Error> {
fn end(&mut self) -> Result<(), Self::Error> {
if self.len == 0 {
Ok(())
} else {
@@ -420,25 +456,27 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
///////////////////////////////////////////////////////////////////////////////
impl<K, V> ValueDeserializer for BTreeMap<K, V>
where K: ValueDeserializer + Eq + Ord,
V: ValueDeserializer,
impl<K, V, E> ValueDeserializer<E> for BTreeMap<K, V>
where K: ValueDeserializer<E> + Eq + Ord,
V: ValueDeserializer<E>,
E: de::Error,
{
type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V>;
type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V, E>;
fn into_deserializer(self) -> MapDeserializer<btree_map::IntoIter<K, V>, K, V> {
fn into_deserializer(self) -> Self::Deserializer {
let len = self.len();
MapDeserializer::new(self.into_iter(), len)
}
}
impl<K, V> ValueDeserializer for HashMap<K, V>
where K: ValueDeserializer + Eq + Hash,
V: ValueDeserializer,
impl<K, V, E> ValueDeserializer<E> for HashMap<K, V>
where K: ValueDeserializer<E> + Eq + Hash,
V: ValueDeserializer<E>,
E: de::Error,
{
type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V>;
type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V, E>;
fn into_deserializer(self) -> MapDeserializer<hash_map::IntoIter<K, V>, K, V> {
fn into_deserializer(self) -> Self::Deserializer {
let len = self.len();
MapDeserializer::new(self.into_iter(), len)
}
@@ -446,22 +484,25 @@ impl<K, V> ValueDeserializer for HashMap<K, V>
///////////////////////////////////////////////////////////////////////////////
impl<'a> ValueDeserializer for bytes::Bytes<'a>
impl<'a, E> ValueDeserializer<E> for bytes::Bytes<'a>
where E: de::Error,
{
type Deserializer = BytesDeserializer<'a>;
type Deserializer = BytesDeserializer<'a, E>;
fn into_deserializer(self) -> BytesDeserializer<'a> {
BytesDeserializer(Some(self.into()))
fn into_deserializer(self) -> BytesDeserializer<'a, E> {
BytesDeserializer(Some(self.into()), PhantomData)
}
}
/// A helper deserializer that deserializes a `&[u8]`.
pub struct BytesDeserializer<'a> (Option<&'a [u8]>);
pub struct BytesDeserializer<'a, E> (Option<&'a [u8]>, PhantomData<E>);
impl<'a> de::Deserializer for BytesDeserializer<'a> {
type Error = Error;
impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
where E: de::Error
{
type Error = E;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
match self.0.take() {
@@ -474,22 +515,25 @@ impl<'a> de::Deserializer for BytesDeserializer<'a> {
///////////////////////////////////////////////////////////////////////////////
impl ValueDeserializer for bytes::ByteBuf
impl<E> ValueDeserializer<E> for bytes::ByteBuf
where E: de::Error,
{
type Deserializer = ByteBufDeserializer;
type Deserializer = ByteBufDeserializer<E>;
fn into_deserializer(self) -> Self::Deserializer {
ByteBufDeserializer(Some(self.into()))
ByteBufDeserializer(Some(self.into()), PhantomData)
}
}
/// A helper deserializer that deserializes a `Vec<u8>`.
pub struct ByteBufDeserializer(Option<Vec<u8>>);
pub struct ByteBufDeserializer<E>(Option<Vec<u8>>, PhantomData<E>);
impl de::Deserializer for ByteBufDeserializer {
type Error = Error;
impl<E> de::Deserializer for ByteBufDeserializer<E>
where E: de::Error,
{
type Error = E;
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
match self.0.take() {