1 //! Deserializing TOML into Rust structures.
3 //! This module contains all the Serde support for deserializing TOML documents
4 //! into Rust structures. Note that some top-level functions here are also
5 //! provided at the top of the crate.
15 use serde
::de
::IntoDeserializer
;
16 use serde
::de
::value
::BorrowedStrDeserializer
;
18 use tokens
::{Tokenizer, Token, Error as TokenError, Span}
;
22 /// Deserializes a byte slice into a type.
24 /// This function will attempt to interpret `bytes` as UTF-8 data and then
25 /// deserialize `T` from the TOML document provided.
26 pub fn from_slice
<'de
, T
>(bytes
: &'de
[u8]) -> Result
<T
, Error
>
27 where T
: de
::Deserialize
<'de
>,
29 match str::from_utf8(bytes
) {
31 Err(e
) => Err(Error
::custom(e
.to_string())),
35 /// Deserializes a string into a type.
37 /// This function will attempt to interpret `s` as a TOML document and
38 /// deserialize `T` from the document.
44 /// extern crate serde_derive;
45 /// extern crate toml;
47 /// #[derive(Deserialize)]
53 /// #[derive(Deserialize)]
59 /// let config: Config = toml::from_str(r#"
60 /// title = 'TOML Example'
66 /// assert_eq!(config.title, "TOML Example");
67 /// assert_eq!(config.owner.name, "Lisa");
70 pub fn from_str
<'de
, T
>(s
: &'de
str) -> Result
<T
, Error
>
71 where T
: de
::Deserialize
<'de
>,
73 let mut d
= Deserializer
::new(s
);
74 let ret
= T
::deserialize(&mut d
)?
;
79 /// Errors that can occur when deserializing a type.
80 #[derive(Debug, Clone)]
82 inner
: Box
<ErrorInner
>,
85 #[derive(Debug, Clone)]
94 /// Errors that can occur when deserializing a type.
95 #[derive(Debug, Clone)]
97 /// EOF was reached when looking for a value
100 /// An invalid character not allowed in a string was found
101 InvalidCharInString(char),
103 /// An invalid character was found as an escape
106 /// An invalid character was found in a hex escape
107 InvalidHexEscape(char),
109 /// An invalid escape value was specified in a hex escape in a string.
111 /// Valid values are in the plane of unicode codepoints.
112 InvalidEscapeValue(u32),
114 /// A newline in a string was encountered when one was not allowed.
117 /// An unexpected character was encountered, typically when looking for a
121 /// An unterminated string was found where EOF was found before the ending
125 /// A newline was found in a table key.
128 /// A number failed to parse
131 /// A date or datetime was invalid
134 /// Wanted one sort of token, but found another.
136 /// Expected token type
137 expected
: &'
static str,
138 /// Actually found token type
142 /// An array was decoded but the types inside of it were mixed, which is
143 /// disallowed by TOML.
146 /// A duplicate table definition was found.
147 DuplicateTable(String
),
149 /// A previously defined table was redefined as an array.
152 /// An empty table key was found.
155 /// Multiline strings are not allowed for key
158 /// A custom error which could be generated when deserializing a particular
162 /// A tuple with a certain number of elements was expected but something
164 ExpectedTuple(usize),
166 /// Expected table keys to be in increasing tuple index order, but something
171 /// Key that was specified.
175 /// An empty table was expected but entries were found
178 /// Dotted key attempted to extend something that is not a table.
179 DottedKeyInvalidType
,
181 /// An unexpected key was encountered.
183 /// Used when deserializing a struct with a limited set of fields.
185 /// The unexpected keys.
187 /// Keys that may be specified.
188 available
: &'
static [&'
static str],
195 /// Deserialization implementation for TOML.
196 pub struct Deserializer
<'a
> {
197 require_newline_after_table
: bool
,
199 tokens
: Tokenizer
<'a
>,
202 impl<'de
, 'b
> de
::Deserializer
<'de
> for &'b
mut Deserializer
<'de
> {
205 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
206 where V
: de
::Visitor
<'de
>,
209 let mut tables
= self.tables()?
;
211 visitor
.visit_map(MapVisitor
{
212 values
: Vec
::new().into_iter(),
224 // Called when the type to deserialize is an enum, as opposed to a field in the type.
225 fn deserialize_enum
<V
>(
228 _variants
: &'
static [&'
static str],
230 ) -> Result
<V
::Value
, Error
>
231 where V
: de
::Visitor
<'de
>
233 let (value
, name
) = self.string_or_table()?
;
235 E
::String(val
) => visitor
.visit_enum(val
.into_deserializer()),
236 E
::InlineTable(values
) => {
237 if values
.len() != 1 {
238 Err(Error
::from_kind(ErrorKind
::Wanted
{
239 expected
: "exactly 1 element",
240 found
: if values
.is_empty() {
243 "more than 1 element"
247 visitor
.visit_enum(InlineTableDeserializer
{
248 values
: values
.into_iter(),
253 E
::DottedTable(_
) => visitor
.visit_enum(DottedTableDeserializer
{
254 name
: name
.expect("Expected table header to be passed."),
257 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
258 expected
: "string or table",
259 found
: e
.type_name(),
264 forward_to_deserialize_any
! {
265 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
266 bytes byte_buf map
struct unit newtype_struct
267 ignored_any unit_struct tuple_struct tuple option identifier
273 header
: Vec
<Cow
<'a
, str>>,
274 values
: Option
<Vec
<(Cow
<'a
, str>, Value
<'a
>)>>,
279 pub struct MapVisitor
<'de
: 'b
, 'b
> {
280 values
: vec
::IntoIter
<(Cow
<'de
, str>, Value
<'de
>)>,
281 next_value
: Option
<(Cow
<'de
, str>, Value
<'de
>)>,
286 tables
: &'b
mut [Table
<'de
>],
288 de
: &'b
mut Deserializer
<'de
>,
291 impl<'de
, 'b
> de
::MapAccess
<'de
> for MapVisitor
<'de
, 'b
> {
294 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
295 where K
: de
::DeserializeSeed
<'de
>,
297 if self.cur_parent
== self.max
|| self.cur
== self.max
{
302 assert
!(self.next_value
.is_none());
303 if let Some((key
, value
)) = self.values
.next() {
304 let ret
= seed
.deserialize(StrDeserializer
::new(key
.clone()))?
;
305 self.next_value
= Some((key
, value
));
310 let prefix
= &self.tables
[self.cur_parent
].header
[..self.depth
];
311 self.tables
[self.cur
..self.max
].iter().enumerate().find(|&(_
, t
)| {
312 if t
.values
.is_none() {
315 match t
.header
.get(..self.depth
) {
316 Some(header
) => header
== prefix
,
319 }).map(|(i
, _
)| i
+ self.cur
)
322 let pos
= match next_table
{
324 None
=> return Ok(None
),
328 // Test to see if we're duplicating our parent's table, and if so
329 // then this is an error in the toml format
330 if self.cur_parent
!= pos
&&
331 self.tables
[self.cur_parent
].header
== self.tables
[pos
].header
{
332 let at
= self.tables
[pos
].at
;
333 let name
= self.tables
[pos
].header
.join(".");
334 return Err(self.de
.error(at
, ErrorKind
::DuplicateTable(name
)))
337 let table
= &mut self.tables
[pos
];
339 // If we're not yet at the appropriate depth for this table then we
340 // just next the next portion of its header and then continue
342 if self.depth
!= table
.header
.len() {
343 let key
= &table
.header
[self.depth
];
344 let key
= seed
.deserialize(StrDeserializer
::new(key
.clone()))?
;
348 // Rule out cases like:
353 let kind
= ErrorKind
::RedefineAsArray
;
354 return Err(self.de
.error(table
.at
, kind
))
357 self.values
= table
.values
.take().expect("Unable to read table values").into_iter();
361 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
362 where V
: de
::DeserializeSeed
<'de
>,
364 if let Some((k
, v
)) = self.next_value
.take() {
365 match seed
.deserialize(ValueDeserializer
::new(v
)) {
366 Ok(v
) => return Ok(v
),
368 e
.add_key_context(&k
);
374 let array
= self.tables
[self.cur
].array
&&
375 self.depth
== self.tables
[self.cur
].header
.len() - 1;
377 let res
= seed
.deserialize(MapVisitor
{
378 values
: Vec
::new().into_iter(),
380 depth
: self.depth
+ if array {0}
else {1}
,
381 cur_parent
: self.cur
- 1,
385 tables
: &mut *self.tables
,
388 res
.map_err(|mut e
| {
389 e
.add_key_context(&self.tables
[self.cur
- 1].header
[self.depth
]);
395 impl<'de
, 'b
> de
::SeqAccess
<'de
> for MapVisitor
<'de
, 'b
> {
398 fn next_element_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
399 where K
: de
::DeserializeSeed
<'de
>,
401 assert
!(self.next_value
.is_none());
402 assert
!(self.values
.next().is_none());
404 if self.cur_parent
== self.max
{
408 let next
= self.tables
[..self.max
]
411 .skip(self.cur_parent
+ 1)
412 .find(|&(_
, table
)| {
413 table
.array
&& table
.header
== self.tables
[self.cur_parent
].header
415 .unwrap_or(self.max
);
417 let ret
= seed
.deserialize(MapVisitor
{
418 values
: self.tables
[self.cur_parent
].values
.take().expect("Unable to read table values").into_iter(),
420 depth
: self.depth
+ 1,
421 cur_parent
: self.cur_parent
,
425 tables
: &mut self.tables
,
428 self.cur_parent
= next
;
433 impl<'de
, 'b
> de
::Deserializer
<'de
> for MapVisitor
<'de
, 'b
> {
436 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
437 where V
: de
::Visitor
<'de
>,
440 visitor
.visit_seq(self)
442 visitor
.visit_map(self)
446 // `None` is interpreted as a missing field so be sure to implement `Some`
447 // as a present field.
448 fn deserialize_option
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
449 where V
: de
::Visitor
<'de
>,
451 visitor
.visit_some(self)
454 fn deserialize_newtype_struct
<V
>(
458 ) -> Result
<V
::Value
, Error
>
459 where V
: de
::Visitor
<'de
>
461 visitor
.visit_newtype_struct(self)
464 forward_to_deserialize_any
! {
465 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
466 bytes byte_buf map
struct unit identifier
467 ignored_any unit_struct tuple_struct tuple
enum
471 struct StrDeserializer
<'a
> {
475 impl<'a
> StrDeserializer
<'a
> {
476 fn new(key
: Cow
<'a
, str>) -> StrDeserializer
<'a
> {
483 impl<'de
> de
::Deserializer
<'de
> for StrDeserializer
<'de
> {
486 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
487 where V
: de
::Visitor
<'de
>,
490 Cow
::Borrowed(s
) => visitor
.visit_borrowed_str(s
),
491 Cow
::Owned(s
) => visitor
.visit_string(s
),
495 forward_to_deserialize_any
! {
496 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
497 bytes byte_buf map
struct option unit newtype_struct
498 ignored_any unit_struct tuple_struct tuple
enum identifier
502 struct ValueDeserializer
<'a
> {
504 validate_struct_keys
: bool
,
507 impl<'a
> ValueDeserializer
<'a
> {
508 fn new(value
: Value
<'a
>) -> ValueDeserializer
<'a
> {
511 validate_struct_keys
: false,
515 fn with_struct_key_validation(mut self) -> Self {
516 self.validate_struct_keys
= true;
521 impl<'de
> de
::Deserializer
<'de
> for ValueDeserializer
<'de
> {
524 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
525 where V
: de
::Visitor
<'de
>,
528 E
::Integer(i
) => visitor
.visit_i64(i
),
529 E
::Boolean(b
) => visitor
.visit_bool(b
),
530 E
::Float(f
) => visitor
.visit_f64(f
),
531 E
::String(Cow
::Borrowed(s
)) => visitor
.visit_borrowed_str(s
),
532 E
::String(Cow
::Owned(s
)) => visitor
.visit_string(s
),
533 E
::Datetime(s
) => visitor
.visit_map(DatetimeDeserializer
{
537 E
::Array(values
) => {
538 let mut s
= de
::value
::SeqDeserializer
::new(values
.into_iter());
539 let ret
= visitor
.visit_seq(&mut s
)?
;
543 E
::InlineTable(values
) | E
::DottedTable(values
) => {
544 visitor
.visit_map(InlineTableDeserializer
{
545 values
: values
.into_iter(),
552 fn deserialize_struct
<V
>(self,
554 fields
: &'
static [&'
static str],
555 visitor
: V
) -> Result
<V
::Value
, Error
>
556 where V
: de
::Visitor
<'de
>,
558 if name
== datetime
::NAME
&& fields
== &[datetime
::FIELD
] {
559 if let E
::Datetime(s
) = self.value
.e
{
560 return visitor
.visit_map(DatetimeDeserializer
{
567 if self.validate_struct_keys
{
568 match &self.value
.e
{
569 &E
::InlineTable(ref values
) | &E
::DottedTable(ref values
) => {
570 let extra_fields
= values
.iter()
571 .filter_map(|key_value
| {
572 let (ref key
, ref _val
) = *key_value
;
573 if !fields
.contains(&&(**key
)) {
579 .collect
::<Vec
<Cow
<'de
, str>>>();
581 if !extra_fields
.is_empty() {
582 return Err(Error
::from_kind(ErrorKind
::UnexpectedKeys
{
583 keys
: extra_fields
.iter().map(|k
| k
.to_string()).collect
::<Vec
<_
>>(),
592 if name
== spanned
::NAME
&& fields
== &[spanned
::START
, spanned
::END
, spanned
::VALUE
] {
593 let start
= self.value
.start
;
594 let end
= self.value
.end
;
596 return visitor
.visit_map(SpannedDeserializer
{
598 value
: Some(self.value
),
603 self.deserialize_any(visitor
)
606 // `None` is interpreted as a missing field so be sure to implement `Some`
607 // as a present field.
608 fn deserialize_option
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
609 where V
: de
::Visitor
<'de
>,
611 visitor
.visit_some(self)
614 fn deserialize_enum
<V
>(
617 _variants
: &'
static [&'
static str],
619 ) -> Result
<V
::Value
, Error
>
620 where V
: de
::Visitor
<'de
>
623 E
::String(val
) => visitor
.visit_enum(val
.into_deserializer()),
624 E
::InlineTable(values
) => {
625 if values
.len() != 1 {
626 Err(Error
::from_kind(ErrorKind
::Wanted
{
627 expected
: "exactly 1 element",
628 found
: if values
.is_empty() {
631 "more than 1 element"
635 visitor
.visit_enum(InlineTableDeserializer
{
636 values
: values
.into_iter(),
641 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
642 expected
: "string or inline table",
643 found
: e
.type_name(),
648 fn deserialize_newtype_struct
<V
>(
652 ) -> Result
<V
::Value
, Error
>
653 where V
: de
::Visitor
<'de
>
655 visitor
.visit_newtype_struct(self)
658 forward_to_deserialize_any
! {
659 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
660 bytes byte_buf map unit identifier
661 ignored_any unit_struct tuple_struct tuple
665 impl<'de
> de
::IntoDeserializer
<'de
, Error
> for Value
<'de
> {
666 type Deserializer
= ValueDeserializer
<'de
>;
668 fn into_deserializer(self) -> Self::Deserializer
{
669 ValueDeserializer
::new(self)
673 struct SpannedDeserializer
<'a
> {
674 start
: Option
<usize>,
676 value
: Option
<Value
<'a
>>,
679 impl<'de
> de
::MapAccess
<'de
> for SpannedDeserializer
<'de
> {
682 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
684 K
: de
::DeserializeSeed
<'de
>,
686 if self.start
.is_some() {
687 seed
.deserialize(BorrowedStrDeserializer
::new(spanned
::START
)).map(Some
)
688 } else if self.end
.is_some() {
689 seed
.deserialize(BorrowedStrDeserializer
::new(spanned
::END
)).map(Some
)
690 } else if self.value
.is_some() {
691 seed
.deserialize(BorrowedStrDeserializer
::new(spanned
::VALUE
)).map(Some
)
697 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
699 V
: de
::DeserializeSeed
<'de
>,
701 if let Some(start
) = self.start
.take() {
702 seed
.deserialize(start
.into_deserializer())
703 } else if let Some(end
) = self.end
.take() {
704 seed
.deserialize(end
.into_deserializer())
705 } else if let Some(value
) = self.value
.take() {
706 seed
.deserialize(value
.into_deserializer())
708 panic
!("next_value_seed called before next_key_seed")
713 struct DatetimeDeserializer
<'a
> {
718 impl<'de
> de
::MapAccess
<'de
> for DatetimeDeserializer
<'de
> {
721 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
722 where K
: de
::DeserializeSeed
<'de
>,
728 seed
.deserialize(DatetimeFieldDeserializer
).map(Some
)
731 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
732 where V
: de
::DeserializeSeed
<'de
>,
734 seed
.deserialize(StrDeserializer
::new(self.date
.into()))
738 struct DatetimeFieldDeserializer
;
740 impl<'de
> de
::Deserializer
<'de
> for DatetimeFieldDeserializer
{
743 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
744 where V
: de
::Visitor
<'de
>,
746 visitor
.visit_borrowed_str(datetime
::FIELD
)
749 forward_to_deserialize_any
! {
750 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
751 bytes byte_buf map
struct option unit newtype_struct
752 ignored_any unit_struct tuple_struct tuple
enum identifier
756 struct DottedTableDeserializer
<'a
> {
761 impl<'de
> de
::EnumAccess
<'de
> for DottedTableDeserializer
<'de
> {
763 type Variant
= TableEnumDeserializer
<'de
>;
765 fn variant_seed
<V
>(self, seed
: V
) -> Result
<(V
::Value
, Self::Variant
), Self::Error
>
767 V
: de
::DeserializeSeed
<'de
>,
769 let (name
, value
) = (self.name
, self.value
);
770 seed
.deserialize(StrDeserializer
::new(name
))
771 .map(|val
| (val
, TableEnumDeserializer { value: value }
))
775 struct InlineTableDeserializer
<'a
> {
776 values
: vec
::IntoIter
<(Cow
<'a
, str>, Value
<'a
>)>,
777 next_value
: Option
<Value
<'a
>>,
780 impl<'de
> de
::MapAccess
<'de
> for InlineTableDeserializer
<'de
> {
783 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
784 where K
: de
::DeserializeSeed
<'de
>,
786 let (key
, value
) = match self.values
.next() {
788 None
=> return Ok(None
),
790 self.next_value
= Some(value
);
791 seed
.deserialize(StrDeserializer
::new(key
)).map(Some
)
794 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
795 where V
: de
::DeserializeSeed
<'de
>,
797 let value
= self.next_value
.take().expect("Unable to read table values");
798 seed
.deserialize(ValueDeserializer
::new(value
))
802 impl<'de
> de
::EnumAccess
<'de
> for InlineTableDeserializer
<'de
> {
804 type Variant
= TableEnumDeserializer
<'de
>;
806 fn variant_seed
<V
>(mut self, seed
: V
) -> Result
<(V
::Value
, Self::Variant
), Self::Error
>
808 V
: de
::DeserializeSeed
<'de
>,
810 let (key
, value
) = match self.values
.next() {
813 return Err(Error
::from_kind(ErrorKind
::Wanted
{
814 expected
: "table with exactly 1 entry",
815 found
: "empty table",
820 seed
.deserialize(StrDeserializer
::new(key
))
821 .map(|val
| (val
, TableEnumDeserializer { value: value }
))
825 /// Deserializes table values into enum variants.
826 struct TableEnumDeserializer
<'a
> {
830 impl<'de
> de
::VariantAccess
<'de
> for TableEnumDeserializer
<'de
> {
833 fn unit_variant(self) -> Result
<(), Self::Error
> {
835 E
::InlineTable(values
) | E
::DottedTable(values
) => {
836 if values
.len() == 0 {
839 Err(Error
::from_kind(ErrorKind
::ExpectedEmptyTable
))
842 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
844 found
: e
.type_name(),
849 fn newtype_variant_seed
<T
>(self, seed
: T
) -> Result
<T
::Value
, Self::Error
>
851 T
: de
::DeserializeSeed
<'de
>,
853 seed
.deserialize(ValueDeserializer
::new(self.value
))
856 fn tuple_variant
<V
>(self, len
: usize, visitor
: V
) -> Result
<V
::Value
, Self::Error
>
861 E
::InlineTable(values
) | E
::DottedTable(values
) => {
862 let tuple_values
= values
865 .map(|(index
, (key
, value
))| match key
.parse
::<usize>() {
866 Ok(key_index
) if key_index
== index
=> Ok(value
),
867 Ok(_
) | Err(_
) => Err(Error
::from_kind(ErrorKind
::ExpectedTupleIndex
{
869 found
: key
.to_string(),
872 // Fold all values into a `Vec`, or return the first error.
873 .fold(Ok(Vec
::with_capacity(len
)), |result
, value_result
| {
874 result
.and_then(move |mut tuple_values
| match value_result
{
876 tuple_values
.push(value
);
879 // `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
884 if tuple_values
.len() == len
{
885 de
::Deserializer
::deserialize_seq(
886 ValueDeserializer
::new(Value
{
887 e
: E
::Array(tuple_values
),
888 start
: self.value
.start
,
894 Err(Error
::from_kind(ErrorKind
::ExpectedTuple(len
)))
897 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
899 found
: e
.type_name(),
904 fn struct_variant
<V
>(
906 fields
: &'
static [&'
static str],
908 ) -> Result
<V
::Value
, Self::Error
>
912 de
::Deserializer
::deserialize_struct(
913 ValueDeserializer
::new(self.value
).with_struct_key_validation(),
914 "", // TODO: this should be the variant name
921 impl<'a
> Deserializer
<'a
> {
922 /// Creates a new deserializer which will be deserializing the string
924 pub fn new(input
: &'a
str) -> Deserializer
<'a
> {
926 tokens
: Tokenizer
::new(input
),
928 require_newline_after_table
: true,
932 /// The `Deserializer::end` method should be called after a value has been
933 /// fully deserialized. This allows the `Deserializer` to validate that the
934 /// input stream is at the end or that it only has trailing
935 /// whitespace/comments.
936 pub fn end(&mut self) -> Result
<(), Error
> {
940 /// Historical versions of toml-rs accidentally allowed a newline after a
941 /// table definition, but the TOML spec requires a newline after a table
942 /// definition header.
944 /// This option can be set to `false` (the default is `true`) to emulate
945 /// this behavior for backwards compatibility with older toml-rs versions.
946 pub fn set_require_newline_after_table(&mut self, require
: bool
) {
947 self.require_newline_after_table
= require
;
950 fn tables(&mut self) -> Result
<Vec
<Table
<'a
>>, Error
> {
951 let mut tables
= Vec
::new();
952 let mut cur_table
= Table
{
959 while let Some(line
) = self.line()?
{
966 if !cur_table
.header
.is_empty() || cur_table
.values
.is_some() {
967 tables
.push(cur_table
);
972 values
: Some(Vec
::new()),
976 let part
= header
.next().map_err(|e
| self.token_error(e
));
978 Some(part
) => cur_table
.header
.push(part
),
983 Line
::KeyValue(key
, value
) => {
984 if cur_table
.values
.is_none() {
985 cur_table
.values
= Some(Vec
::new());
987 self.add_dotted_key(key
, value
, cur_table
.values
.as_mut().unwrap())?
;
991 if !cur_table
.header
.is_empty() || cur_table
.values
.is_some() {
992 tables
.push(cur_table
);
997 fn line(&mut self) -> Result
<Option
<Line
<'a
>>, Error
> {
999 self.eat_whitespace()?
;
1000 if self.eat_comment()?
{
1003 if self.eat(Token
::Newline
)?
{
1009 match self.peek()?
{
1010 Some((_
, Token
::LeftBracket
)) => self.table_header().map(Some
),
1011 Some(_
) => self.key_value().map(Some
),
1016 fn table_header(&mut self) -> Result
<Line
<'a
>, Error
> {
1017 let start
= self.tokens
.current();
1018 self.expect(Token
::LeftBracket
)?
;
1019 let array
= self.eat(Token
::LeftBracket
)?
;
1020 let ret
= Header
::new(self.tokens
.clone(),
1022 self.require_newline_after_table
);
1023 if self.require_newline_after_table
{
1024 self.tokens
.skip_to_newline();
1027 match self.next()?
{
1028 Some((_
, Token
::RightBracket
)) => {
1030 self.eat(Token
::RightBracket
)?
;
1034 Some((_
, Token
::Newline
)) |
1039 self.eat_whitespace()?
;
1041 Ok(Line
::Table { at: start, header: ret, array: array }
)
1044 fn key_value(&mut self) -> Result
<Line
<'a
>, Error
> {
1045 let key
= self.dotted_key()?
;
1046 self.eat_whitespace()?
;
1047 self.expect(Token
::Equals
)?
;
1048 self.eat_whitespace()?
;
1050 let value
= self.value()?
;
1051 self.eat_whitespace()?
;
1052 if !self.eat_comment()?
{
1053 self.eat_newline_or_eof()?
;
1056 Ok(Line
::KeyValue(key
, value
))
1059 fn value(&mut self) -> Result
<Value
<'a
>, Error
> {
1060 let at
= self.tokens
.current();
1061 let value
= match self.next()?
{
1062 Some((Span { start, end }
, Token
::String { val, .. }
)) => {
1063 Value { e: E::String(val), start: start, end: end }
1065 Some((Span { start, end }
, Token
::Keylike("true"))) => {
1066 Value { e: E::Boolean(true), start: start, end: end }
1068 Some((Span { start, end }
, Token
::Keylike("false"))) => {
1069 Value { e: E::Boolean(false), start: start, end: end }
1071 Some((span
, Token
::Keylike(key
))) => self.number_or_date(span
, key
)?
,
1072 Some((span
, Token
::Plus
)) => self.number_leading_plus(span
)?
,
1073 Some((Span { start, .. }
, Token
::LeftBrace
)) => {
1074 self.inline_table().map(|(Span { end, .. }
, table
)| Value
{
1075 e
: E
::InlineTable(table
),
1080 Some((Span { start, .. }
, Token
::LeftBracket
)) => {
1081 self.array().map(|(Span { end, .. }
, array
)| Value
{
1088 return Err(self.error(at
, ErrorKind
::Wanted
{
1089 expected
: "a value",
1090 found
: token
.1.describe(),
1093 None
=> return Err(self.eof()),
1098 fn number_or_date(&mut self, span
: Span
, s
: &'a
str)
1099 -> Result
<Value
<'a
>, Error
>
1101 if s
.contains('T'
) || (s
.len() > 1 && s
[1..].contains('
-'
)) &&
1103 self.datetime(span
, s
, false).map(|(Span { start, end }
, d
)| Value
{
1108 } else if self.eat(Token
::Colon
)?
{
1109 self.datetime(span
, s
, true).map(|(Span { start, end }
, d
)| Value
{
1115 self.number(span
, s
)
1119 /// Returns a string or table value type.
1121 /// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
1122 /// structures (tuple, newtype, struct) must be represented as a table.
1123 fn string_or_table(&mut self) -> Result
<(Value
<'a
>, Option
<Cow
<'a
, str>>), Error
> {
1124 match self.peek()?
{
1125 Some((_
, Token
::LeftBracket
)) => {
1126 let tables
= self.tables()?
;
1127 if tables
.len() != 1 {
1128 return Err(Error
::from_kind(ErrorKind
::Wanted
{
1129 expected
: "exactly 1 table",
1130 found
: if tables
.is_empty() {
1141 .expect("Expected exactly one table");
1145 .expect("Expected at least one header value for table.");
1147 let start
= table
.at
;
1151 .and_then(|values
| values
.last())
1152 .map(|&(_
, ref val
)| val
.end
)
1153 .unwrap_or_else(|| header
.len());
1156 e
: E
::DottedTable(table
.values
.unwrap_or_else(Vec
::new
)),
1160 Some(header
.clone()),
1163 Some(_
) => self.value().map(|val
| (val
, None
)),
1164 None
=> Err(self.eof()),
1168 fn number(&mut self, Span { start, end }
: Span
, s
: &'a
str) -> Result
<Value
<'a
>, Error
> {
1169 let to_integer
= |f
| Value { e: E::Integer(f), start: start, end: end }
;
1170 if s
.starts_with("0x") {
1171 self.integer(&s
[2..], 16).map(to_integer
)
1172 } else if s
.starts_with("0o") {
1173 self.integer(&s
[2..], 8).map(to_integer
)
1174 } else if s
.starts_with("0b") {
1175 self.integer(&s
[2..], 2).map(to_integer
)
1176 } else if s
.contains('e'
) || s
.contains('E'
) {
1177 self.float(s
, None
).map(|f
| Value { e: E::Float(f), start: start, end: end }
)
1178 } else if self.eat(Token
::Period
)?
{
1179 let at
= self.tokens
.current();
1180 match self.next()?
{
1181 Some((Span { start, end }
, Token
::Keylike(after
))) => {
1182 self.float(s
, Some(after
)).map(|f
| Value
{
1183 e
: E
::Float(f
), start
: start
, end
: end
1186 _
=> Err(self.error(at
, ErrorKind
::NumberInvalid
)),
1188 } else if s
== "inf" {
1189 Ok(Value { e: E::Float(f64::INFINITY), start: start, end: end }
)
1190 } else if s
== "-inf" {
1191 Ok(Value { e: E::Float(f64::NEG_INFINITY), start: start, end: end }
)
1192 } else if s
== "nan" {
1193 Ok(Value { e: E::Float(f64::NAN), start: start, end: end }
)
1194 } else if s
== "-nan" {
1195 Ok(Value { e: E::Float(-f64::NAN), start: start, end: end }
)
1197 self.integer(s
, 10).map(to_integer
)
1201 fn number_leading_plus(&mut self, Span { start, .. }
: Span
) -> Result
<Value
<'a
>, Error
> {
1202 let start_token
= self.tokens
.current();
1203 match self.next()?
{
1204 Some((Span { end, .. }
, Token
::Keylike(s
))) => {
1205 self.number(Span { start: start, end: end }
, s
)
1207 _
=> Err(self.error(start_token
, ErrorKind
::NumberInvalid
)),
1211 fn integer(&self, s
: &'a
str, radix
: u32) -> Result
<i64, Error
> {
1212 let allow_sign
= radix
== 10;
1213 let allow_leading_zeros
= radix
!= 10;
1214 let (prefix
, suffix
) = self.parse_integer(s
, allow_sign
, allow_leading_zeros
, radix
)?
;
1215 let start
= self.tokens
.substr_offset(s
);
1217 return Err(self.error(start
, ErrorKind
::NumberInvalid
))
1219 i64::from_str_radix(&prefix
.replace("_", "").trim_left_matches('
+'
), radix
)
1220 .map_err(|_e
| self.error(start
, ErrorKind
::NumberInvalid
))
1227 allow_leading_zeros
: bool
,
1229 ) -> Result
<(&'a
str, &'a
str), Error
> {
1230 let start
= self.tokens
.substr_offset(s
);
1232 let mut first
= true;
1233 let mut first_zero
= false;
1234 let mut underscore
= false;
1235 let mut end
= s
.len();
1236 for (i
, c
) in s
.char_indices() {
1238 if i
== 0 && (c
== '
+'
|| c
== '
-'
) && allow_sign
{
1242 if c
== '
0'
&& first
{
1244 } else if c
.to_digit(radix
).is_some() {
1245 if !first
&& first_zero
&& !allow_leading_zeros
{
1246 return Err(self.error(at
, ErrorKind
::NumberInvalid
));
1249 } else if c
== '_'
&& first
{
1250 return Err(self.error(at
, ErrorKind
::NumberInvalid
));
1251 } else if c
== '_'
&& !underscore
{
1259 if first
|| underscore
{
1260 return Err(self.error(start
, ErrorKind
::NumberInvalid
))
1262 Ok((&s
[..end
], &s
[end
..]))
1265 fn float(&mut self, s
: &'a
str, after_decimal
: Option
<&'a
str>)
1266 -> Result
<f64, Error
> {
1267 let (integral
, mut suffix
) = self.parse_integer(s
, true, false, 10)?
;
1268 let start
= self.tokens
.substr_offset(integral
);
1270 let mut fraction
= None
;
1271 if let Some(after
) = after_decimal
{
1273 return Err(self.error(start
, ErrorKind
::NumberInvalid
))
1275 let (a
, b
) = self.parse_integer(after
, false, true, 10)?
;
1280 let mut exponent
= None
;
1281 if suffix
.starts_with('e'
) || suffix
.starts_with('E'
) {
1282 let (a
, b
) = if suffix
.len() == 1 {
1283 self.eat(Token
::Plus
)?
;
1284 match self.next()?
{
1285 Some((_
, Token
::Keylike(s
))) => {
1286 self.parse_integer(s
, false, false, 10)?
1288 _
=> return Err(self.error(start
, ErrorKind
::NumberInvalid
)),
1291 self.parse_integer(&suffix
[1..], true, false, 10)?
1294 return Err(self.error(start
, ErrorKind
::NumberInvalid
))
1299 let mut number
= integral
.trim_left_matches('
+'
)
1301 .filter(|c
| *c
!= '_'
)
1302 .collect
::<String
>();
1303 if let Some(fraction
) = fraction
{
1304 number
.push_str(".");
1305 number
.extend(fraction
.chars().filter(|c
| *c
!= '_'
));
1307 if let Some(exponent
) = exponent
{
1308 number
.push_str("E");
1309 number
.extend(exponent
.chars().filter(|c
| *c
!= '_'
));
1311 number
.parse().map_err(|_e
| {
1312 self.error(start
, ErrorKind
::NumberInvalid
)
1313 }).and_then(|n
: f64| {
1317 Err(self.error(start
, ErrorKind
::NumberInvalid
))
1322 fn datetime(&mut self, mut span
: Span
, date
: &'a
str, colon_eaten
: bool
)
1323 -> Result
<(Span
, &'a
str), Error
> {
1324 let start
= self.tokens
.substr_offset(date
);
1326 // Check for space separated date and time.
1327 let mut lookahead
= self.tokens
.clone();
1328 if let Ok(Some((_
, Token
::Whitespace(" ")))) = lookahead
.next() {
1329 // Check if hour follows.
1330 if let Ok(Some((_
, Token
::Keylike(_
)))) = lookahead
.next() {
1331 self.next()?
; // skip space
1332 self.next()?
; // skip keylike hour
1336 if colon_eaten
|| self.eat(Token
::Colon
)?
{
1338 match self.next()?
{
1339 Some((_
, Token
::Keylike(_
))) => {}
1340 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1343 self.expect(Token
::Colon
)?
;
1344 match self.next()?
{
1345 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1348 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1350 // Fractional seconds
1351 if self.eat(Token
::Period
)?
{
1352 match self.next()?
{
1353 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1356 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1361 if self.eat(Token
::Plus
)?
{
1362 match self.next()?
{
1363 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1366 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1369 if self.eat(Token
::Colon
)?
{
1370 match self.next()?
{
1371 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1374 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1379 let end
= self.tokens
.current();
1380 Ok((span
, &self.tokens
.input()[start
..end
]))
1383 // TODO(#140): shouldn't buffer up this entire table in memory, it'd be
1384 // great to defer parsing everything until later.
1385 fn inline_table(&mut self) -> Result
<(Span
, Vec
<(Cow
<'a
, str>, Value
<'a
>)>), Error
> {
1386 let mut ret
= Vec
::new();
1387 self.eat_whitespace()?
;
1388 if let Some(span
) = self.eat_spanned(Token
::RightBrace
)?
{
1389 return Ok((span
, ret
))
1392 let key
= self.dotted_key()?
;
1393 self.eat_whitespace()?
;
1394 self.expect(Token
::Equals
)?
;
1395 self.eat_whitespace()?
;
1396 let value
= self.value()?
;
1397 self.add_dotted_key(key
, value
, &mut ret
)?
;
1399 self.eat_whitespace()?
;
1400 if let Some(span
) = self.eat_spanned(Token
::RightBrace
)?
{
1401 return Ok((span
, ret
))
1403 self.expect(Token
::Comma
)?
;
1404 self.eat_whitespace()?
;
1408 // TODO(#140): shouldn't buffer up this entire array in memory, it'd be
1409 // great to defer parsing everything until later.
1410 fn array(&mut self) -> Result
<(Span
, Vec
<Value
<'a
>>), Error
> {
1411 let mut ret
= Vec
::new();
1413 let intermediate
= |me
: &mut Deserializer
| {
1415 me
.eat_whitespace()?
;
1416 if !me
.eat(Token
::Newline
)?
&& !me
.eat_comment()?
{
1424 intermediate(self)?
;
1425 if let Some(span
) = self.eat_spanned(Token
::RightBracket
)?
{
1426 return Ok((span
, ret
))
1428 let at
= self.tokens
.current();
1429 let value
= self.value()?
;
1430 if let Some(last
) = ret
.last() {
1431 if !value
.same_type(last
) {
1432 return Err(self.error(at
, ErrorKind
::MixedArrayType
))
1436 intermediate(self)?
;
1437 if !self.eat(Token
::Comma
)?
{
1441 intermediate(self)?
;
1442 let span
= self.expect_spanned(Token
::RightBracket
)?
;
1446 fn table_key(&mut self) -> Result
<Cow
<'a
, str>, Error
> {
1447 self.tokens
.table_key().map(|t
| t
.1).map_err(|e
| self.token_error(e
))
1450 fn dotted_key(&mut self) -> Result
<Vec
<Cow
<'a
, str>>, Error
> {
1451 let mut result
= Vec
::new();
1452 result
.push(self.table_key()?
);
1453 self.eat_whitespace()?
;
1454 while self.eat(Token
::Period
)?
{
1455 self.eat_whitespace()?
;
1456 result
.push(self.table_key()?
);
1457 self.eat_whitespace()?
;
1462 /// Stores a value in the appropriate hierachical structure positioned based on the dotted key.
1464 /// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
1465 /// intermediate parts which are mapped to the relevant fields in the deserialized type's data
1470 /// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
1471 /// `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
1472 /// * `value`: The parsed value.
1473 /// * `values`: The `Vec` to store the value in.
1476 mut key_parts
: Vec
<Cow
<'a
, str>>,
1478 values
: &mut Vec
<(Cow
<'a
, str>, Value
<'a
>)>,
1479 ) -> Result
<(), Error
> {
1480 let key
= key_parts
.remove(0);
1481 if key_parts
.is_empty() {
1482 values
.push((key
, value
));
1485 match values
.iter_mut().find(|&&mut (ref k
, _
)| *k
== key
) {
1486 Some(&mut (_
, Value { e: E::DottedTable(ref mut v), .. }
)) => {
1487 return self.add_dotted_key(key_parts
, value
, v
);
1489 Some(&mut (_
, Value { start, .. }
)) => {
1490 return Err(self.error(start
, ErrorKind
::DottedKeyInvalidType
));
1494 // The start/end value is somewhat misleading here.
1495 let table_values
= Value
{
1496 e
: E
::DottedTable(Vec
::new()),
1500 values
.push((key
, table_values
));
1501 let last_i
= values
.len() - 1;
1502 if let (_
, Value { e: E::DottedTable(ref mut v), .. }
) = values
[last_i
] {
1503 self.add_dotted_key(key_parts
, value
, v
)?
;
1508 fn eat_whitespace(&mut self) -> Result
<(), Error
> {
1509 self.tokens
.eat_whitespace().map_err(|e
| self.token_error(e
))
1512 fn eat_comment(&mut self) -> Result
<bool
, Error
> {
1513 self.tokens
.eat_comment().map_err(|e
| self.token_error(e
))
1516 fn eat_newline_or_eof(&mut self) -> Result
<(), Error
> {
1517 self.tokens
.eat_newline_or_eof().map_err(|e
| self.token_error(e
))
1520 fn eat(&mut self, expected
: Token
<'a
>) -> Result
<bool
, Error
> {
1521 self.tokens
.eat(expected
).map_err(|e
| self.token_error(e
))
1524 fn eat_spanned(&mut self, expected
: Token
<'a
>) -> Result
<Option
<Span
>, Error
> {
1525 self.tokens
.eat_spanned(expected
).map_err(|e
| self.token_error(e
))
1528 fn expect(&mut self, expected
: Token
<'a
>) -> Result
<(), Error
> {
1529 self.tokens
.expect(expected
).map_err(|e
| self.token_error(e
))
1532 fn expect_spanned(&mut self, expected
: Token
<'a
>) -> Result
<Span
, Error
> {
1533 self.tokens
.expect_spanned(expected
).map_err(|e
| self.token_error(e
))
1536 fn next(&mut self) -> Result
<Option
<(Span
, Token
<'a
>)>, Error
> {
1537 self.tokens
.next().map_err(|e
| self.token_error(e
))
1540 fn peek(&mut self) -> Result
<Option
<(Span
, Token
<'a
>)>, Error
> {
1541 self.tokens
.peek().map_err(|e
| self.token_error(e
))
1544 fn eof(&self) -> Error
{
1545 self.error(self.input
.len(), ErrorKind
::UnexpectedEof
)
1548 fn token_error(&self, error
: TokenError
) -> Error
{
1550 TokenError
::InvalidCharInString(at
, ch
) => {
1551 self.error(at
, ErrorKind
::InvalidCharInString(ch
))
1553 TokenError
::InvalidEscape(at
, ch
) => {
1554 self.error(at
, ErrorKind
::InvalidEscape(ch
))
1556 TokenError
::InvalidEscapeValue(at
, v
) => {
1557 self.error(at
, ErrorKind
::InvalidEscapeValue(v
))
1559 TokenError
::InvalidHexEscape(at
, ch
) => {
1560 self.error(at
, ErrorKind
::InvalidHexEscape(ch
))
1562 TokenError
::NewlineInString(at
) => {
1563 self.error(at
, ErrorKind
::NewlineInString
)
1565 TokenError
::Unexpected(at
, ch
) => {
1566 self.error(at
, ErrorKind
::Unexpected(ch
))
1568 TokenError
::UnterminatedString(at
) => {
1569 self.error(at
, ErrorKind
::UnterminatedString
)
1571 TokenError
::NewlineInTableKey(at
) => {
1572 self.error(at
, ErrorKind
::NewlineInTableKey
)
1574 TokenError
::Wanted { at, expected, found }
=> {
1575 self.error(at
, ErrorKind
::Wanted { expected: expected, found: found }
)
1577 TokenError
::EmptyTableKey(at
) => {
1578 self.error(at
, ErrorKind
::EmptyTableKey
)
1580 TokenError
::MultilineStringKey(at
) => {
1581 self.error(at
, ErrorKind
::MultilineStringKey
)
1586 fn error(&self, at
: usize, kind
: ErrorKind
) -> Error
{
1587 let mut err
= Error
::from_kind(kind
);
1588 let (line
, col
) = self.to_linecol(at
);
1589 err
.inner
.line
= Some(line
);
1590 err
.inner
.col
= col
;
1594 /// Converts a byte offset from an error message to a (line, column) pair
1596 /// All indexes are 0-based.
1597 fn to_linecol(&self, offset
: usize) -> (usize, usize) {
1599 for (i
, line
) in self.input
.lines().enumerate() {
1600 if cur
+ line
.len() + 1 > offset
{
1601 return (i
, offset
- cur
)
1603 cur
+= line
.len() + 1;
1605 (self.input
.lines().count(), 0)
1610 /// Produces a (line, column) pair of the position of the error if available
1612 /// All indexes are 0-based.
1613 pub fn line_col(&self) -> Option
<(usize, usize)> {
1614 self.inner
.line
.map(|line
| (line
, self.inner
.col
))
1617 fn from_kind(kind
: ErrorKind
) -> Error
{
1619 inner
: Box
::new(ErrorInner
{
1623 message
: String
::new(),
1629 fn custom(s
: String
) -> Error
{
1631 inner
: Box
::new(ErrorInner
{
1632 kind
: ErrorKind
::Custom
,
1641 /// Do not call this method, it may be removed at any time, it's just an
1642 /// internal implementation detail.
1644 pub fn add_key_context(&mut self, key
: &str) {
1645 self.inner
.key
.insert(0, key
.to_string());
1649 impl fmt
::Display
for Error
{
1650 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
1651 match self.inner
.kind
{
1652 ErrorKind
::UnexpectedEof
=> "unexpected eof encountered".fmt(f
)?
,
1653 ErrorKind
::InvalidCharInString(c
) => {
1654 write
!(f
, "invalid character in string: `{}`",
1655 c
.escape_default().collect
::<String
>())?
1657 ErrorKind
::InvalidEscape(c
) => {
1658 write
!(f
, "invalid escape character in string: `{}`",
1659 c
.escape_default().collect
::<String
>())?
1661 ErrorKind
::InvalidHexEscape(c
) => {
1662 write
!(f
, "invalid hex escape character in string: `{}`",
1663 c
.escape_default().collect
::<String
>())?
1665 ErrorKind
::InvalidEscapeValue(c
) => {
1666 write
!(f
, "invalid escape value: `{}`", c
)?
1668 ErrorKind
::NewlineInString
=> "newline in string found".fmt(f
)?
,
1669 ErrorKind
::Unexpected(ch
) => {
1670 write
!(f
, "unexpected character found: `{}`",
1671 ch
.escape_default().collect
::<String
>())?
1673 ErrorKind
::UnterminatedString
=> "unterminated string".fmt(f
)?
,
1674 ErrorKind
::NewlineInTableKey
=> "found newline in table key".fmt(f
)?
,
1675 ErrorKind
::Wanted { expected, found }
=> {
1676 write
!(f
, "expected {}, found {}", expected
, found
)?
1678 ErrorKind
::NumberInvalid
=> "invalid number".fmt(f
)?
,
1679 ErrorKind
::DateInvalid
=> "invalid date".fmt(f
)?
,
1680 ErrorKind
::MixedArrayType
=> "mixed types in an array".fmt(f
)?
,
1681 ErrorKind
::DuplicateTable(ref s
) => {
1682 write
!(f
, "redefinition of table `{}`", s
)?
;
1684 ErrorKind
::RedefineAsArray
=> "table redefined as array".fmt(f
)?
,
1685 ErrorKind
::EmptyTableKey
=> "empty table key found".fmt(f
)?
,
1686 ErrorKind
::MultilineStringKey
=> "multiline strings are not allowed for key".fmt(f
)?
,
1687 ErrorKind
::Custom
=> self.inner
.message
.fmt(f
)?
,
1688 ErrorKind
::ExpectedTuple(l
) => write
!(f
, "expected table with length {}", l
)?
,
1689 ErrorKind
::ExpectedTupleIndex
{
1692 } => write
!(f
, "expected table key `{}`, but was `{}`", expected
, found
)?
,
1693 ErrorKind
::ExpectedEmptyTable
=> "expected empty table".fmt(f
)?
,
1694 ErrorKind
::DottedKeyInvalidType
=> {
1695 "dotted key attempted to extend non-table type".fmt(f
)?
1697 ErrorKind
::UnexpectedKeys { ref keys, available }
=> {
1700 "unexpected keys in table: `{:?}`, available keys: `{:?}`",
1705 ErrorKind
::__Nonexhaustive
=> panic
!(),
1708 if !self.inner
.key
.is_empty() {
1709 write
!(f
, " for key `")?
;
1710 for (i
, k
) in self.inner
.key
.iter().enumerate() {
1714 write
!(f
, "{}", k
)?
;
1719 if let Some(line
) = self.inner
.line
{
1720 write
!(f
, " at line {}", line
+ 1)?
;
1727 impl error
::Error
for Error
{
1728 fn description(&self) -> &str {
1729 match self.inner
.kind
{
1730 ErrorKind
::UnexpectedEof
=> "unexpected eof encountered",
1731 ErrorKind
::InvalidCharInString(_
) => "invalid char in string",
1732 ErrorKind
::InvalidEscape(_
) => "invalid escape in string",
1733 ErrorKind
::InvalidHexEscape(_
) => "invalid hex escape in string",
1734 ErrorKind
::InvalidEscapeValue(_
) => "invalid escape value in string",
1735 ErrorKind
::NewlineInString
=> "newline in string found",
1736 ErrorKind
::Unexpected(_
) => "unexpected or invalid character",
1737 ErrorKind
::UnterminatedString
=> "unterminated string",
1738 ErrorKind
::NewlineInTableKey
=> "found newline in table key",
1739 ErrorKind
::Wanted { .. }
=> "expected a token but found another",
1740 ErrorKind
::NumberInvalid
=> "invalid number",
1741 ErrorKind
::DateInvalid
=> "invalid date",
1742 ErrorKind
::MixedArrayType
=> "mixed types in an array",
1743 ErrorKind
::DuplicateTable(_
) => "duplicate table",
1744 ErrorKind
::RedefineAsArray
=> "table redefined as array",
1745 ErrorKind
::EmptyTableKey
=> "empty table key found",
1746 ErrorKind
::MultilineStringKey
=> "invalid multiline string for key",
1747 ErrorKind
::Custom
=> "a custom error",
1748 ErrorKind
::ExpectedTuple(_
) => "expected table length",
1749 ErrorKind
::ExpectedTupleIndex { .. }
=> "expected table key",
1750 ErrorKind
::ExpectedEmptyTable
=> "expected empty table",
1751 ErrorKind
::DottedKeyInvalidType
=> "dotted key invalid type",
1752 ErrorKind
::UnexpectedKeys { .. }
=> "unexpected keys in table",
1753 ErrorKind
::__Nonexhaustive
=> panic
!(),
1758 impl de
::Error
for Error
{
1759 fn custom
<T
: fmt
::Display
>(msg
: T
) -> Error
{
1760 Error
::custom(msg
.to_string())
1765 Table { at: usize, header: Header<'a>, array: bool }
,
1766 KeyValue(Vec
<Cow
<'a
, str>>, Value
<'a
>),
1772 require_newline_after_table
: bool
,
1773 tokens
: Tokenizer
<'a
>,
1776 impl<'a
> Header
<'a
> {
1777 fn new(tokens
: Tokenizer
<'a
>,
1779 require_newline_after_table
: bool
) -> Header
<'a
> {
1784 require_newline_after_table
: require_newline_after_table
,
1788 fn next(&mut self) -> Result
<Option
<Cow
<'a
, str>>, TokenError
> {
1789 self.tokens
.eat_whitespace()?
;
1791 if self.first
|| self.tokens
.eat(Token
::Period
)?
{
1793 self.tokens
.eat_whitespace()?
;
1794 self.tokens
.table_key().map(|t
| t
.1).map(Some
)
1796 self.tokens
.expect(Token
::RightBracket
)?
;
1798 self.tokens
.expect(Token
::RightBracket
)?
;
1801 self.tokens
.eat_whitespace()?
;
1802 if self.require_newline_after_table
{
1803 if !self.tokens
.eat_comment()?
{
1804 self.tokens
.eat_newline_or_eof()?
;
1824 String(Cow
<'a
, str>),
1826 Array(Vec
<Value
<'a
>>),
1827 InlineTable(Vec
<(Cow
<'a
, str>, Value
<'a
>)>),
1828 DottedTable(Vec
<(Cow
<'a
, str>, Value
<'a
>)>),
1832 fn type_name(&self) -> &'
static str {
1834 E
::String(..) => "string",
1835 E
::Integer(..) => "integer",
1836 E
::Float(..) => "float",
1837 E
::Boolean(..) => "boolean",
1838 E
::Datetime(..) => "datetime",
1839 E
::Array(..) => "array",
1840 E
::InlineTable(..) => "inline table",
1841 E
::DottedTable(..) => "dotted table",
1846 impl<'a
> Value
<'a
> {
1847 fn same_type(&self, other
: &Value
<'a
>) -> bool
{
1848 match (&self.e
, &other
.e
) {
1849 (&E
::String(..), &E
::String(..)) |
1850 (&E
::Integer(..), &E
::Integer(..)) |
1851 (&E
::Float(..), &E
::Float(..)) |
1852 (&E
::Boolean(..), &E
::Boolean(..)) |
1853 (&E
::Datetime(..), &E
::Datetime(..)) |
1854 (&E
::Array(..), &E
::Array(..)) |
1855 (&E
::InlineTable(..), &E
::InlineTable(..)) => true,
1856 (&E
::DottedTable(..), &E
::DottedTable(..)) => true,