asya/toml-rs
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Support serde 1.0.0

Browse source
This commit is contained in:
Alex Crichton 2017-04-20 10:16:00 -07:00
parent 8683f1d22b
commit dc5ff1ef90
6 changed files with 156 additions and 170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
Cargo.toml
View file

@ -19,8 +19,8 @@ categories = ["config", "encoding", "parser-implementations"]
travis-ci = { repository = "alexcrichton/toml-rs" }
[dependencies]
serde = "0.9.6"
serde = "1.0"
[dev-dependencies]
serde_derive = "0.9"
serde_json = "0.9"
serde_derive = "1.0"
serde_json = "1.0"

26
src/datetime.rs
View file

@ -315,13 +315,13 @@ impl ser::Serialize for Datetime {
}
}
impl de::Deserialize for Datetime {
impl<'de> de::Deserialize<'de> for Datetime {
fn deserialize<D>(deserializer: D) -> Result<Datetime, D::Error>
where D: de::Deserializer
where D: de::Deserializer<'de>
{
struct DatetimeVisitor;
impl de::Visitor for DatetimeVisitor {
impl<'de> de::Visitor<'de> for DatetimeVisitor {
type Value = Datetime;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -329,13 +329,13 @@ impl de::Deserialize for Datetime {
}
fn visit_map<V>(self, mut visitor: V) -> Result<Datetime, V::Error>
where V: de::MapVisitor
where V: de::MapAccess<'de>
{
let value = visitor.visit_key::<DatetimeKey>()?;
let value = visitor.next_key::<DatetimeKey>()?;
if value.is_none() {
return Err(de::Error::custom("datetime key not found"))
}
let v: DatetimeFromString = visitor.visit_value()?;
let v: DatetimeFromString = visitor.next_value()?;
Ok(v.value)
}
@ -350,13 +350,13 @@ impl de::Deserialize for Datetime {
struct DatetimeKey;
impl de::Deserialize for DatetimeKey {
impl<'de> de::Deserialize<'de> for DatetimeKey {
fn deserialize<D>(deserializer: D) -> Result<DatetimeKey, D::Error>
where D: de::Deserializer
where D: de::Deserializer<'de>
{
struct FieldVisitor;
impl de::Visitor for FieldVisitor {
impl<'de> de::Visitor<'de> for FieldVisitor {
type Value = ();
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -374,7 +374,7 @@ impl de::Deserialize for DatetimeKey {
}
}
deserializer.deserialize_struct_field(FieldVisitor)?;
deserializer.deserialize_identifier(FieldVisitor)?;
Ok(DatetimeKey)
}
}
@ -383,13 +383,13 @@ pub struct DatetimeFromString {
pub value: Datetime,
}
impl de::Deserialize for DatetimeFromString {
impl<'de> de::Deserialize<'de> for DatetimeFromString {
fn deserialize<D>(deserializer: D) -> Result<DatetimeFromString, D::Error>
where D: de::Deserializer
where D: de::Deserializer<'de>
{
struct Visitor;
impl de::Visitor for Visitor {
impl<'de> de::Visitor<'de> for Visitor {
type Value = DatetimeFromString;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

136
src/de.rs
View file

@ -19,8 +19,8 @@ use datetime::{SERDE_STRUCT_FIELD_NAME, SERDE_STRUCT_NAME};
///
/// This function will attempt to interpret `bytes` as UTF-8 data and then
/// deserialize `T` from the TOML document provided.
pub fn from_slice<T>(bytes: &[u8]) -> Result<T, Error>
where T: de::Deserialize,
pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
where T: de::Deserialize<'de>,
{
match str::from_utf8(bytes) {
Ok(s) => from_str(s),
@ -32,8 +32,8 @@ pub fn from_slice<T>(bytes: &[u8]) -> Result<T, Error>
///
/// This function will attempt to interpret `s` as a TOML document and
/// deserialize `T` from the document.
pub fn from_str<T>(s: &str) -> Result<T, Error>
where T: de::Deserialize,
pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
where T: de::Deserialize<'de>,
{
let mut d = Deserializer::new(s);
let ret = T::deserialize(&mut d)?;
@ -132,11 +132,11 @@ pub struct Deserializer<'a> {
tokens: Tokenizer<'a>,
}
impl<'a, 'b> de::Deserializer for &'b mut Deserializer<'a> {
impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
type Error = Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
{
let mut tables = Vec::new();
let mut cur_table = Table {
@ -192,10 +192,10 @@ impl<'a, 'b> de::Deserializer for &'b mut Deserializer<'a> {
})
}
forward_to_deserialize! {
forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
seq_fixed_size bytes byte_buf map struct unit enum newtype_struct
struct_field ignored_any unit_struct tuple_struct tuple option
bytes byte_buf map struct unit enum newtype_struct
ignored_any unit_struct tuple_struct tuple option identifier
}
}
@ -207,23 +207,23 @@ struct Table<'a> {
}
#[doc(hidden)]
pub struct MapVisitor<'a: 'b, 'b> {
values: vec::IntoIter<(Cow<'a, str>, Value<'a>)>,
next_value: Option<(Cow<'a, str>, Value<'a>)>,
pub struct MapVisitor<'de: 'b, 'b> {
values: vec::IntoIter<(Cow<'de, str>, Value<'de>)>,
next_value: Option<(Cow<'de, str>, Value<'de>)>,
depth: usize,
cur: usize,
cur_parent: usize,
max: usize,
tables: &'b mut [Table<'a>],
tables: &'b mut [Table<'de>],
array: bool,
de: &'b mut Deserializer<'a>,
de: &'b mut Deserializer<'de>,
}
impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
type Error = Error;
fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed,
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed<'de>,
{
if self.cur_parent == self.max || self.cur == self.max {
return Ok(None)
@ -268,11 +268,11 @@ impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
let table = &mut self.tables[pos];
// If we're not yet at the appropriate depth for this table then we
// just visit the next portion of its header and then continue
// just next the next portion of its header and then continue
// decoding.
if self.depth != table.header.len() {
let key = &table.header[self.depth];
let key = seed.deserialize(StrDeserializer::new(key[..].into()))?;
let key = seed.deserialize(StrDeserializer::new(key.clone()))?;
return Ok(Some(key))
}
@ -289,8 +289,8 @@ impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
}
}
fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where V: de::DeserializeSeed,
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where V: de::DeserializeSeed<'de>,
{
if let Some((k, v)) = self.next_value.take() {
match seed.deserialize(ValueDeserializer::new(v)) {
@ -323,11 +323,11 @@ impl<'a, 'b> de::MapVisitor for MapVisitor<'a, 'b> {
}
}
impl<'a, 'b> de::SeqVisitor for MapVisitor<'a, 'b> {
impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
type Error = Error;
fn visit_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed,
fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed<'de>,
{
assert!(self.next_value.is_none());
assert!(self.values.next().is_none());
@ -361,11 +361,11 @@ impl<'a, 'b> de::SeqVisitor for MapVisitor<'a, 'b> {
}
}
impl<'a, 'b> de::Deserializer for MapVisitor<'a, 'b> {
impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
type Error = Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
{
if self.array {
visitor.visit_seq(self)
@ -377,15 +377,15 @@ impl<'a, 'b> de::Deserializer for MapVisitor<'a, 'b> {
// `None` is interpreted as a missing field so be sure to implement `Some`
// as a present field.
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor
where V: de::Visitor<'de>,
{
visitor.visit_some(self)
}
forward_to_deserialize! {
forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
seq_fixed_size bytes byte_buf map struct unit newtype_struct
struct_field ignored_any unit_struct tuple_struct tuple enum
bytes byte_buf map struct unit newtype_struct identifier
ignored_any unit_struct tuple_struct tuple enum
}
}
@ -401,22 +401,22 @@ impl<'a> StrDeserializer<'a> {
}
}
impl<'a> de::Deserializer for StrDeserializer<'a> {
impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
type Error = Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
{
match self.key {
Cow::Borrowed(s) => visitor.visit_str(s),
Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
Cow::Owned(s) => visitor.visit_string(s),
}
}
forward_to_deserialize! {
forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
seq_fixed_size bytes byte_buf map struct option unit newtype_struct
struct_field ignored_any unit_struct tuple_struct tuple enum
bytes byte_buf map struct option unit newtype_struct
ignored_any unit_struct tuple_struct tuple enum identifier
}
}
@ -432,17 +432,17 @@ impl<'a> ValueDeserializer<'a> {
}
}
impl<'a> de::Deserializer for ValueDeserializer<'a> {
impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
type Error = Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
{
match self.value {
Value::Integer(i) => visitor.visit_i64(i),
Value::Boolean(b) => visitor.visit_bool(b),
Value::Float(f) => visitor.visit_f64(f),
Value::String(Cow::Borrowed(s)) => visitor.visit_str(s),
Value::String(Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
Value::String(Cow::Owned(s)) => visitor.visit_string(s),
Value::Datetime(s) => visitor.visit_map(DatetimeDeserializer {
date: s,
@ -467,7 +467,7 @@ impl<'a> de::Deserializer for ValueDeserializer<'a> {
name: &'static str,
fields: &'static [&'static str],
visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
where V: de::Visitor<'de>,
{
if name == SERDE_STRUCT_NAME && fields == &[SERDE_STRUCT_FIELD_NAME] {
if let Value::Datetime(s) = self.value {
@ -478,26 +478,26 @@ impl<'a> de::Deserializer for ValueDeserializer<'a> {
}
}
self.deserialize(visitor)
self.deserialize_any(visitor)
}
// `None` is interpreted as a missing field so be sure to implement `Some`
// as a present field.
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor
where V: de::Visitor<'de>,
{
visitor.visit_some(self)
}
forward_to_deserialize! {
forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
seq_fixed_size bytes byte_buf map unit newtype_struct
struct_field ignored_any unit_struct tuple_struct tuple enum
bytes byte_buf map unit newtype_struct identifier
ignored_any unit_struct tuple_struct tuple enum
}
}
impl<'a> de::value::ValueDeserializer<Error> for Value<'a> {
type Deserializer = ValueDeserializer<'a>;
impl<'de> de::IntoDeserializer<'de, Error> for Value<'de> {
type Deserializer = ValueDeserializer<'de>;
fn into_deserializer(self) -> Self::Deserializer {
ValueDeserializer::new(self)
@ -509,11 +509,11 @@ struct DatetimeDeserializer<'a> {
date: &'a str,
}
impl<'a> de::MapVisitor for DatetimeDeserializer<'a> {
impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
type Error = Error;
fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed,
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed<'de>,
{
if self.visited {
return Ok(None)
@ -522,8 +522,8 @@ impl<'a> de::MapVisitor for DatetimeDeserializer<'a> {
seed.deserialize(DatetimeFieldDeserializer).map(Some)
}
fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where V: de::DeserializeSeed,
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where V: de::DeserializeSeed<'de>,
{
seed.deserialize(StrDeserializer::new(self.date.into()))
}
@ -531,19 +531,19 @@ impl<'a> de::MapVisitor for DatetimeDeserializer<'a> {
struct DatetimeFieldDeserializer;
impl de::Deserializer for DatetimeFieldDeserializer {
impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
type Error = Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
{
visitor.visit_str(SERDE_STRUCT_FIELD_NAME)
visitor.visit_borrowed_str(SERDE_STRUCT_FIELD_NAME)
}
forward_to_deserialize! {
forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
seq_fixed_size bytes byte_buf map struct option unit newtype_struct
struct_field ignored_any unit_struct tuple_struct tuple enum
bytes byte_buf map struct option unit newtype_struct
ignored_any unit_struct tuple_struct tuple enum identifier
}
}
@ -552,11 +552,11 @@ struct InlineTableDeserializer<'a> {
next_value: Option<Value<'a>>,
}
impl<'a> de::MapVisitor for InlineTableDeserializer<'a> {
impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
type Error = Error;
fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed,
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
where K: de::DeserializeSeed<'de>,
{
let (key, value) = match self.values.next() {
Some(pair) => pair,
@ -566,8 +566,8 @@ impl<'a> de::MapVisitor for InlineTableDeserializer<'a> {
seed.deserialize(StrDeserializer::new(key)).map(Some)
}
fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where V: de::DeserializeSeed,
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where V: de::DeserializeSeed<'de>,
{
let value = self.next_value.take().expect("Unable to read table values");
seed.deserialize(ValueDeserializer::new(value))

51
src/ser.rs
View file

@ -420,7 +420,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
fn serialize_unit_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str)
-> Result<(), Self::Error> {
Err(Error::UnsupportedType)
@ -435,7 +435,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
fn serialize_newtype_variant<T: ?Sized>(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_value: &T)
-> Result<(), Self::Error>
@ -454,11 +454,6 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
})
}
fn serialize_seq_fixed_size(self, size: usize)
-> Result<Self::SerializeSeq, Self::Error> {
self.serialize_seq(Some(size))
}
fn serialize_tuple(self, _len: usize)
-> Result<Self::SerializeTuple, Self::Error> {
Err(Error::UnsupportedType)
@ -471,7 +466,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
fn serialize_tuple_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeTupleVariant, Self::Error> {
@ -507,7 +502,7 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> {
fn serialize_struct_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeStructVariant, Self::Error> {
@ -754,7 +749,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
fn serialize_unit_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str)
-> Result<(), Self::Error> {
Err(Error::DateInvalid)
@ -769,7 +764,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
fn serialize_newtype_variant<T: ?Sized>(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_value: &T)
-> Result<(), Self::Error>
@ -783,11 +778,6 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
Err(Error::DateInvalid)
}
fn serialize_seq_fixed_size(self, _size: usize)
-> Result<Self::SerializeSeq, Self::Error> {
Err(Error::DateInvalid)
}
fn serialize_tuple(self, _len: usize)
-> Result<Self::SerializeTuple, Self::Error> {
Err(Error::DateInvalid)
@ -800,7 +790,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
fn serialize_tuple_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeTupleVariant, Self::Error> {
@ -819,7 +809,7 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> {
fn serialize_struct_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeStructVariant, Self::Error> {
@ -918,7 +908,7 @@ impl ser::Serializer for StringExtractor {
fn serialize_unit_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str)
-> Result<String, Self::Error> {
Err(Error::KeyNotString)
@ -933,7 +923,7 @@ impl ser::Serializer for StringExtractor {
fn serialize_newtype_variant<T: ?Sized>(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_value: &T)
-> Result<String, Self::Error>
@ -947,11 +937,6 @@ impl ser::Serializer for StringExtractor {
Err(Error::KeyNotString)
}
fn serialize_seq_fixed_size(self, _size: usize)
-> Result<Self::SerializeSeq, Self::Error> {
Err(Error::KeyNotString)
}
fn serialize_tuple(self, _len: usize)
-> Result<Self::SerializeTuple, Self::Error> {
Err(Error::KeyNotString)
@ -964,7 +949,7 @@ impl ser::Serializer for StringExtractor {
fn serialize_tuple_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeTupleVariant, Self::Error> {
@ -983,7 +968,7 @@ impl ser::Serializer for StringExtractor {
fn serialize_struct_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeStructVariant, Self::Error> {
@ -1175,7 +1160,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
Err(ser::Error::custom("unsupported"))
}
fn serialize_unit_variant(self, _: &'static str, _: usize, _: &'static str) -> Result<Self::Ok, Self::Error> {
fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<Self::Ok, Self::Error> {
Err(ser::Error::custom("unsupported"))
}
@ -1183,7 +1168,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
v.serialize(self)
}
fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self, _: &'static str, _: usize, _: &'static str, _: &T) -> Result<Self::Ok, Self::Error> {
fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self, _: &'static str, _: u32, _: &'static str, _: &T) -> Result<Self::Ok, Self::Error> {
Err(ser::Error::custom("unsupported"))
}
@ -1191,10 +1176,6 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
Ok(self)
}
fn serialize_seq_fixed_size(self, _: usize) -> Result<Self, Self::Error> {
Ok(self)
}
fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
Err(ser::Error::custom("unsupported"))
}
@ -1203,7 +1184,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
Err(ser::Error::custom("unsupported"))
}
fn serialize_tuple_variant(self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
fn serialize_tuple_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
Err(ser::Error::custom("unsupported"))
}
@ -1215,7 +1196,7 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> {
Ok(self)
}
fn serialize_struct_variant(self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
fn serialize_struct_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
Err(ser::Error::custom("unsupported"))
}
}

103
src/value.rs
View file

@ -58,8 +58,8 @@ impl Value {
/// something is wrong with the data, for example required struct fields are
/// missing from the TOML map or some number is too big to fit in the expected
/// primitive type.
pub fn try_into<T>(self) -> Result<T, ::de::Error>
where T: de::Deserialize,
pub fn try_into<'de, T>(self) -> Result<T, ::de::Error>
where T: de::Deserialize<'de>,
{
de::Deserialize::deserialize(self)
}
@ -387,13 +387,13 @@ impl ser::Serialize for Value {
}
}
impl de::Deserialize for Value {
impl<'de> de::Deserialize<'de> for Value {
fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
where D: de::Deserializer
where D: de::Deserializer<'de>,
{
struct ValueVisitor;
impl de::Visitor for ValueVisitor {
impl<'de> de::Visitor<'de> for ValueVisitor {
type Value = Value;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -421,55 +421,58 @@ impl de::Deserialize for Value {
}
fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
where D: de::Deserializer,
where D: de::Deserializer<'de>,
{
de::Deserialize::deserialize(deserializer)
}
fn visit_seq<V>(self, visitor: V) -> Result<Value, V::Error>
where V: de::SeqVisitor
fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
where V: de::SeqAccess<'de>,
{
let values = de::impls::VecVisitor::new().visit_seq(visitor)?;
Ok(Value::Array(values))
let mut vec = Vec::new();
while let Some(elem) = try!(visitor.next_element()) {
vec.push(elem);
}
Ok(Value::Array(vec))
}
fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
where V: de::MapVisitor
where V: de::MapAccess<'de>,
{
let mut key = String::new();
let datetime = visitor.visit_key_seed(DatetimeOrTable {
let datetime = visitor.next_key_seed(DatetimeOrTable {
key: &mut key,
})?;
match datetime {
Some(true) => {
let date: DatetimeFromString = visitor.visit_value()?;
let date: DatetimeFromString = visitor.next_value()?;
return Ok(Value::Datetime(date.value))
}
None => return Ok(Value::Table(BTreeMap::new())),
Some(false) => {}
}
let mut map = BTreeMap::new();
map.insert(key, visitor.visit_value()?);
while let Some(key) = visitor.visit_key()? {
map.insert(key, visitor.next_value()?);
while let Some(key) = visitor.next_key()? {
if map.contains_key(&key) {
let msg = format!("duplicate key: `{}`", key);
return Err(de::Error::custom(msg))
}
map.insert(key, visitor.visit_value()?);
map.insert(key, visitor.next_value()?);
}
Ok(Value::Table(map))
}
}
deserializer.deserialize(ValueVisitor)
deserializer.deserialize_any(ValueVisitor)
}
}
impl de::Deserializer for Value {
impl<'de> de::Deserializer<'de> for Value {
type Error = ::de::Error;
fn deserialize<V>(self, visitor: V) -> Result<V::Value, ::de::Error>
where V: de::Visitor,
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, ::de::Error>
where V: de::Visitor<'de>,
{
match self {
Value::Boolean(v) => visitor.visit_bool(v),
@ -505,15 +508,15 @@ impl de::Deserializer for Value {
// `None` is interpreted as a missing field so be sure to implement `Some`
// as a present field.
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, ::de::Error>
where V: de::Visitor
where V: de::Visitor<'de>,
{
visitor.visit_some(self)
}
forward_to_deserialize! {
forward_to_deserialize_any! {
bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
seq_fixed_size bytes byte_buf map unit_struct tuple_struct struct
struct_field tuple ignored_any enum newtype_struct
bytes byte_buf map unit_struct tuple_struct struct
tuple ignored_any enum newtype_struct identifier
}
}
@ -529,11 +532,12 @@ impl SeqDeserializer {
}
}
impl de::SeqVisitor for SeqDeserializer {
impl<'de> de::SeqAccess<'de> for SeqDeserializer {
type Error = ::de::Error;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
where T: de::DeserializeSeed,
fn next_element_seed<T>(&mut self, seed: T)
-> Result<Option<T::Value>, ::de::Error>
where T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => seed.deserialize(value).map(Some),
@ -541,8 +545,11 @@ impl de::SeqVisitor for SeqDeserializer {
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
fn size_hint(&self) -> Option<usize> {
match self.iter.size_hint() {
(lower, Some(upper)) if lower == upper => Some(upper),
_ => None,
}
}
}
@ -560,11 +567,11 @@ impl MapDeserializer {
}
}
impl de::MapVisitor for MapDeserializer {
impl<'de> de::MapAccess<'de> for MapDeserializer {
type Error = ::de::Error;
fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
where T: de::DeserializeSeed,
fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error>
where T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some((key, value)) => {
@ -575,8 +582,8 @@ impl de::MapVisitor for MapDeserializer {
}
}
fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error>
where T: de::DeserializeSeed,
fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error>
where T: de::DeserializeSeed<'de>,
{
let (key, res) = match self.value.take() {
Some((key, value)) => (key, seed.deserialize(value)),
@ -588,8 +595,11 @@ impl de::MapVisitor for MapDeserializer {
})
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
fn size_hint(&self) -> Option<usize> {
match self.iter.size_hint() {
(lower, Some(upper)) if lower == upper => Some(upper),
_ => None,
}
}
}
@ -681,7 +691,7 @@ impl ser::Serializer for Serializer {
fn serialize_unit_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str)
-> Result<Value, ::ser::Error> {
Err(::ser::Error::UnsupportedType)
@ -698,7 +708,7 @@ impl ser::Serializer for Serializer {
fn serialize_newtype_variant<T: ?Sized>(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_value: &T)
-> Result<Value, ::ser::Error>
@ -725,11 +735,6 @@ impl ser::Serializer for Serializer {
})
}
fn serialize_seq_fixed_size(self, size: usize)
-> Result<Self::SerializeSeq, ::ser::Error> {
self.serialize_seq(Some(size))
}
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, ::ser::Error> {
Err(::ser::Error::UnsupportedType)
}
@ -741,7 +746,7 @@ impl ser::Serializer for Serializer {
fn serialize_tuple_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeTupleVariant, ::ser::Error>
@ -765,7 +770,7 @@ impl ser::Serializer for Serializer {
fn serialize_struct_variant(self,
_name: &'static str,
_variant_index: usize,
_variant_index: u32,
_variant: &'static str,
_len: usize)
-> Result<Self::SerializeStructVariant, ::ser::Error>
@ -851,17 +856,17 @@ struct DatetimeOrTable<'a> {
key: &'a mut String,
}
impl<'a> de::DeserializeSeed for DatetimeOrTable<'a> {
impl<'a, 'de> de::DeserializeSeed<'de> for DatetimeOrTable<'a> {
type Value = bool;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where D: de::Deserializer
where D: de::Deserializer<'de>
{
deserializer.deserialize(self)
deserializer.deserialize_any(self)
}
}
impl<'a> de::Visitor for DatetimeOrTable<'a> {
impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> {
type Value = bool;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

4
tests/serde.rs
View file

@ -130,8 +130,8 @@ fn nested() {
fn application_decode_error() {
#[derive(PartialEq, Debug)]
struct Range10(usize);
impl Deserialize for Range10 {
fn deserialize<D: Deserializer>(d: D) -> Result<Range10, D::Error> {
impl<'de> Deserialize<'de> for Range10 {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Range10, D::Error> {
let x: usize = try!(Deserialize::deserialize(d));
if x > 10 {
Err(serde::de::Error::custom("more than 10"))