aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/datetime.rs26
-rw-r--r--src/de.rs136
-rw-r--r--src/ser.rs51
-rw-r--r--src/value.rs103
4 files changed, 151 insertions, 165 deletions
diff --git a/src/datetime.rs b/src/datetime.rs
index b3c82d6..7917cad 100644
--- a/src/datetime.rs
+++ b/src/datetime.rs
@@ -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 {
diff --git a/src/de.rs b/src/de.rs
index 13a3d90..4578c9a 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -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))
diff --git a/src/ser.rs b/src/ser.rs
index 8fcf0eb..e4b62f7 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -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"))
}
}
diff --git a/src/value.rs b/src/value.rs
index 5c59437..7c2b3eb 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -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 {