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
::value
::BorrowedStrDeserializer
;
16 use serde
::de
::IntoDeserializer
;
20 use crate::tokens
::{Error as TokenError, Span, Token, Tokenizer}
;
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
>
28 T
: de
::Deserialize
<'de
>,
30 match str::from_utf8(bytes
) {
32 Err(e
) => Err(Error
::custom(e
.to_string())),
36 /// Deserializes a string into a type.
38 /// This function will attempt to interpret `s` as a TOML document and
39 /// deserialize `T` from the document.
44 /// use serde_derive::Deserialize;
46 /// #[derive(Deserialize)]
52 /// #[derive(Deserialize)]
58 /// let config: Config = toml::from_str(r#"
59 /// title = 'TOML Example'
65 /// assert_eq!(config.title, "TOML Example");
66 /// assert_eq!(config.owner.name, "Lisa");
69 pub fn from_str
<'de
, T
>(s
: &'de
str) -> Result
<T
, Error
>
71 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, PartialEq, Clone)]
82 inner
: Box
<ErrorInner
>,
85 #[derive(Debug, PartialEq, Clone)]
94 /// Errors that can occur when deserializing a type.
95 #[derive(Debug, PartialEq, 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
,
198 allow_duplciate_after_longer_table
: bool
,
200 tokens
: Tokenizer
<'a
>,
203 impl<'de
, 'b
> de
::Deserializer
<'de
> for &'b
mut Deserializer
<'de
> {
206 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
210 let mut tables
= self.tables()?
;
212 visitor
.visit_map(MapVisitor
{
213 values
: Vec
::new().into_iter(),
225 // Called when the type to deserialize is an enum, as opposed to a field in the type.
226 fn deserialize_enum
<V
>(
229 _variants
: &'
static [&'
static str],
231 ) -> Result
<V
::Value
, Error
>
235 let (value
, name
) = self.string_or_table()?
;
237 E
::String(val
) => visitor
.visit_enum(val
.into_deserializer()),
238 E
::InlineTable(values
) => {
239 if values
.len() != 1 {
240 Err(Error
::from_kind(ErrorKind
::Wanted
{
241 expected
: "exactly 1 element",
242 found
: if values
.is_empty() {
245 "more than 1 element"
249 visitor
.visit_enum(InlineTableDeserializer
{
250 values
: values
.into_iter(),
255 E
::DottedTable(_
) => visitor
.visit_enum(DottedTableDeserializer
{
256 name
: name
.expect("Expected table header to be passed."),
259 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
260 expected
: "string or table",
261 found
: e
.type_name(),
266 serde
::forward_to_deserialize_any
! {
267 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
268 bytes byte_buf map
struct unit newtype_struct
269 ignored_any unit_struct tuple_struct tuple option identifier
275 header
: Vec
<Cow
<'a
, str>>,
276 values
: Option
<Vec
<(Cow
<'a
, str>, Value
<'a
>)>>,
281 pub struct MapVisitor
<'de
: 'b
, 'b
> {
282 values
: vec
::IntoIter
<(Cow
<'de
, str>, Value
<'de
>)>,
283 next_value
: Option
<(Cow
<'de
, str>, Value
<'de
>)>,
288 tables
: &'b
mut [Table
<'de
>],
290 de
: &'b
mut Deserializer
<'de
>,
293 impl<'de
, 'b
> de
::MapAccess
<'de
> for MapVisitor
<'de
, 'b
> {
296 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
298 K
: de
::DeserializeSeed
<'de
>,
300 if self.cur_parent
== self.max
|| self.cur
== self.max
{
305 assert
!(self.next_value
.is_none());
306 if let Some((key
, value
)) = self.values
.next() {
307 let ret
= seed
.deserialize(StrDeserializer
::new(key
.clone()))?
;
308 self.next_value
= Some((key
, value
));
309 return Ok(Some(ret
));
313 let prefix
= &self.tables
[self.cur_parent
].header
[..self.depth
];
314 self.tables
[self.cur
..self.max
]
318 if t
.values
.is_none() {
321 match t
.header
.get(..self.depth
) {
322 Some(header
) => header
== prefix
,
326 .map(|(i
, _
)| i
+ self.cur
)
329 let pos
= match next_table
{
331 None
=> return Ok(None
),
335 // Test to see if we're duplicating our parent's table, and if so
336 // then this is an error in the toml format
337 if self.cur_parent
!= pos
{
338 if self.tables
[self.cur_parent
].header
== self.tables
[pos
].header
{
339 let at
= self.tables
[pos
].at
;
340 let name
= self.tables
[pos
].header
.join(".");
341 return Err(self.de
.error(at
, ErrorKind
::DuplicateTable(name
)));
344 // If we're here we know we should share the same prefix, and if
345 // the longer table was defined first then we want to narrow
346 // down our parent's length if possible to ensure that we catch
347 // duplicate tables defined afterwards.
348 if !self.de
.allow_duplciate_after_longer_table
{
349 let parent_len
= self.tables
[self.cur_parent
].header
.len();
350 let cur_len
= self.tables
[pos
].header
.len();
351 if cur_len
< parent_len
{
352 self.cur_parent
= pos
;
357 let table
= &mut self.tables
[pos
];
359 // If we're not yet at the appropriate depth for this table then we
360 // just next the next portion of its header and then continue
362 if self.depth
!= table
.header
.len() {
363 let key
= &table
.header
[self.depth
];
364 let key
= seed
.deserialize(StrDeserializer
::new(key
.clone()))?
;
365 return Ok(Some(key
));
368 // Rule out cases like:
373 let kind
= ErrorKind
::RedefineAsArray
;
374 return Err(self.de
.error(table
.at
, kind
));
380 .expect("Unable to read table values")
385 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
387 V
: de
::DeserializeSeed
<'de
>,
389 if let Some((k
, v
)) = self.next_value
.take() {
390 match seed
.deserialize(ValueDeserializer
::new(v
)) {
391 Ok(v
) => return Ok(v
),
393 e
.add_key_context(&k
);
400 self.tables
[self.cur
].array
&& self.depth
== self.tables
[self.cur
].header
.len() - 1;
402 let res
= seed
.deserialize(MapVisitor
{
403 values
: Vec
::new().into_iter(),
405 depth
: self.depth
+ if array { 0 }
else { 1 }
,
406 cur_parent
: self.cur
- 1,
410 tables
: &mut *self.tables
,
413 res
.map_err(|mut e
| {
414 e
.add_key_context(&self.tables
[self.cur
- 1].header
[self.depth
]);
420 impl<'de
, 'b
> de
::SeqAccess
<'de
> for MapVisitor
<'de
, 'b
> {
423 fn next_element_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
425 K
: de
::DeserializeSeed
<'de
>,
427 assert
!(self.next_value
.is_none());
428 assert
!(self.values
.next().is_none());
430 if self.cur_parent
== self.max
{
434 let next
= self.tables
[..self.max
]
437 .skip(self.cur_parent
+ 1)
438 .find(|&(_
, table
)| table
.array
&& table
.header
== self.tables
[self.cur_parent
].header
)
440 .unwrap_or(self.max
);
442 let ret
= seed
.deserialize(MapVisitor
{
443 values
: self.tables
[self.cur_parent
]
446 .expect("Unable to read table values")
449 depth
: self.depth
+ 1,
450 cur_parent
: self.cur_parent
,
454 tables
: &mut self.tables
,
457 self.cur_parent
= next
;
462 impl<'de
, 'b
> de
::Deserializer
<'de
> for MapVisitor
<'de
, 'b
> {
465 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
470 visitor
.visit_seq(self)
472 visitor
.visit_map(self)
476 // `None` is interpreted as a missing field so be sure to implement `Some`
477 // as a present field.
478 fn deserialize_option
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
482 visitor
.visit_some(self)
485 fn deserialize_newtype_struct
<V
>(
489 ) -> Result
<V
::Value
, Error
>
493 visitor
.visit_newtype_struct(self)
496 serde
::forward_to_deserialize_any
! {
497 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
498 bytes byte_buf map
struct unit identifier
499 ignored_any unit_struct tuple_struct tuple
enum
503 struct StrDeserializer
<'a
> {
507 impl<'a
> StrDeserializer
<'a
> {
508 fn new(key
: Cow
<'a
, str>) -> StrDeserializer
<'a
> {
509 StrDeserializer { key: key }
513 impl<'de
> de
::Deserializer
<'de
> for StrDeserializer
<'de
> {
516 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
521 Cow
::Borrowed(s
) => visitor
.visit_borrowed_str(s
),
522 Cow
::Owned(s
) => visitor
.visit_string(s
),
526 serde
::forward_to_deserialize_any
! {
527 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
528 bytes byte_buf map
struct option unit newtype_struct
529 ignored_any unit_struct tuple_struct tuple
enum identifier
533 struct ValueDeserializer
<'a
> {
535 validate_struct_keys
: bool
,
538 impl<'a
> ValueDeserializer
<'a
> {
539 fn new(value
: Value
<'a
>) -> ValueDeserializer
<'a
> {
542 validate_struct_keys
: false,
546 fn with_struct_key_validation(mut self) -> Self {
547 self.validate_struct_keys
= true;
552 impl<'de
> de
::Deserializer
<'de
> for ValueDeserializer
<'de
> {
555 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
560 E
::Integer(i
) => visitor
.visit_i64(i
),
561 E
::Boolean(b
) => visitor
.visit_bool(b
),
562 E
::Float(f
) => visitor
.visit_f64(f
),
563 E
::String(Cow
::Borrowed(s
)) => visitor
.visit_borrowed_str(s
),
564 E
::String(Cow
::Owned(s
)) => visitor
.visit_string(s
),
565 E
::Datetime(s
) => visitor
.visit_map(DatetimeDeserializer
{
569 E
::Array(values
) => {
570 let mut s
= de
::value
::SeqDeserializer
::new(values
.into_iter());
571 let ret
= visitor
.visit_seq(&mut s
)?
;
575 E
::InlineTable(values
) | E
::DottedTable(values
) => {
576 visitor
.visit_map(InlineTableDeserializer
{
577 values
: values
.into_iter(),
584 fn deserialize_struct
<V
>(
587 fields
: &'
static [&'
static str],
589 ) -> Result
<V
::Value
, Error
>
593 if name
== datetime
::NAME
&& fields
== &[datetime
::FIELD
] {
594 if let E
::Datetime(s
) = self.value
.e
{
595 return visitor
.visit_map(DatetimeDeserializer
{
602 if self.validate_struct_keys
{
603 match &self.value
.e
{
604 &E
::InlineTable(ref values
) | &E
::DottedTable(ref values
) => {
605 let extra_fields
= values
607 .filter_map(|key_value
| {
608 let (ref key
, ref _val
) = *key_value
;
609 if !fields
.contains(&&(**key
)) {
615 .collect
::<Vec
<Cow
<'de
, str>>>();
617 if !extra_fields
.is_empty() {
618 return Err(Error
::from_kind(ErrorKind
::UnexpectedKeys
{
621 .map(|k
| k
.to_string())
622 .collect
::<Vec
<_
>>(),
631 if name
== spanned
::NAME
&& fields
== &[spanned
::START
, spanned
::END
, spanned
::VALUE
] {
632 let start
= self.value
.start
;
633 let end
= self.value
.end
;
635 return visitor
.visit_map(SpannedDeserializer
{
637 value
: Some(self.value
),
642 self.deserialize_any(visitor
)
645 // `None` is interpreted as a missing field so be sure to implement `Some`
646 // as a present field.
647 fn deserialize_option
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
651 visitor
.visit_some(self)
654 fn deserialize_enum
<V
>(
657 _variants
: &'
static [&'
static str],
659 ) -> Result
<V
::Value
, Error
>
664 E
::String(val
) => visitor
.visit_enum(val
.into_deserializer()),
665 E
::InlineTable(values
) => {
666 if values
.len() != 1 {
667 Err(Error
::from_kind(ErrorKind
::Wanted
{
668 expected
: "exactly 1 element",
669 found
: if values
.is_empty() {
672 "more than 1 element"
676 visitor
.visit_enum(InlineTableDeserializer
{
677 values
: values
.into_iter(),
682 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
683 expected
: "string or inline table",
684 found
: e
.type_name(),
689 fn deserialize_newtype_struct
<V
>(
693 ) -> Result
<V
::Value
, Error
>
697 visitor
.visit_newtype_struct(self)
700 serde
::forward_to_deserialize_any
! {
701 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
702 bytes byte_buf map unit identifier
703 ignored_any unit_struct tuple_struct tuple
707 impl<'de
> de
::IntoDeserializer
<'de
, Error
> for Value
<'de
> {
708 type Deserializer
= ValueDeserializer
<'de
>;
710 fn into_deserializer(self) -> Self::Deserializer
{
711 ValueDeserializer
::new(self)
715 struct SpannedDeserializer
<'a
> {
716 start
: Option
<usize>,
718 value
: Option
<Value
<'a
>>,
721 impl<'de
> de
::MapAccess
<'de
> for SpannedDeserializer
<'de
> {
724 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
726 K
: de
::DeserializeSeed
<'de
>,
728 if self.start
.is_some() {
729 seed
.deserialize(BorrowedStrDeserializer
::new(spanned
::START
))
731 } else if self.end
.is_some() {
732 seed
.deserialize(BorrowedStrDeserializer
::new(spanned
::END
))
734 } else if self.value
.is_some() {
735 seed
.deserialize(BorrowedStrDeserializer
::new(spanned
::VALUE
))
742 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
744 V
: de
::DeserializeSeed
<'de
>,
746 if let Some(start
) = self.start
.take() {
747 seed
.deserialize(start
.into_deserializer())
748 } else if let Some(end
) = self.end
.take() {
749 seed
.deserialize(end
.into_deserializer())
750 } else if let Some(value
) = self.value
.take() {
751 seed
.deserialize(value
.into_deserializer())
753 panic
!("next_value_seed called before next_key_seed")
758 struct DatetimeDeserializer
<'a
> {
763 impl<'de
> de
::MapAccess
<'de
> for DatetimeDeserializer
<'de
> {
766 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
768 K
: de
::DeserializeSeed
<'de
>,
774 seed
.deserialize(DatetimeFieldDeserializer
).map(Some
)
777 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
779 V
: de
::DeserializeSeed
<'de
>,
781 seed
.deserialize(StrDeserializer
::new(self.date
.into()))
785 struct DatetimeFieldDeserializer
;
787 impl<'de
> de
::Deserializer
<'de
> for DatetimeFieldDeserializer
{
790 fn deserialize_any
<V
>(self, visitor
: V
) -> Result
<V
::Value
, Error
>
794 visitor
.visit_borrowed_str(datetime
::FIELD
)
797 serde
::forward_to_deserialize_any
! {
798 bool
u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
799 bytes byte_buf map
struct option unit newtype_struct
800 ignored_any unit_struct tuple_struct tuple
enum identifier
804 struct DottedTableDeserializer
<'a
> {
809 impl<'de
> de
::EnumAccess
<'de
> for DottedTableDeserializer
<'de
> {
811 type Variant
= TableEnumDeserializer
<'de
>;
813 fn variant_seed
<V
>(self, seed
: V
) -> Result
<(V
::Value
, Self::Variant
), Self::Error
>
815 V
: de
::DeserializeSeed
<'de
>,
817 let (name
, value
) = (self.name
, self.value
);
818 seed
.deserialize(StrDeserializer
::new(name
))
819 .map(|val
| (val
, TableEnumDeserializer { value: value }
))
823 struct InlineTableDeserializer
<'a
> {
824 values
: vec
::IntoIter
<(Cow
<'a
, str>, Value
<'a
>)>,
825 next_value
: Option
<Value
<'a
>>,
828 impl<'de
> de
::MapAccess
<'de
> for InlineTableDeserializer
<'de
> {
831 fn next_key_seed
<K
>(&mut self, seed
: K
) -> Result
<Option
<K
::Value
>, Error
>
833 K
: de
::DeserializeSeed
<'de
>,
835 let (key
, value
) = match self.values
.next() {
837 None
=> return Ok(None
),
839 self.next_value
= Some(value
);
840 seed
.deserialize(StrDeserializer
::new(key
)).map(Some
)
843 fn next_value_seed
<V
>(&mut self, seed
: V
) -> Result
<V
::Value
, Error
>
845 V
: de
::DeserializeSeed
<'de
>,
847 let value
= self.next_value
.take().expect("Unable to read table values");
848 seed
.deserialize(ValueDeserializer
::new(value
))
852 impl<'de
> de
::EnumAccess
<'de
> for InlineTableDeserializer
<'de
> {
854 type Variant
= TableEnumDeserializer
<'de
>;
856 fn variant_seed
<V
>(mut self, seed
: V
) -> Result
<(V
::Value
, Self::Variant
), Self::Error
>
858 V
: de
::DeserializeSeed
<'de
>,
860 let (key
, value
) = match self.values
.next() {
863 return Err(Error
::from_kind(ErrorKind
::Wanted
{
864 expected
: "table with exactly 1 entry",
865 found
: "empty table",
870 seed
.deserialize(StrDeserializer
::new(key
))
871 .map(|val
| (val
, TableEnumDeserializer { value: value }
))
875 /// Deserializes table values into enum variants.
876 struct TableEnumDeserializer
<'a
> {
880 impl<'de
> de
::VariantAccess
<'de
> for TableEnumDeserializer
<'de
> {
883 fn unit_variant(self) -> Result
<(), Self::Error
> {
885 E
::InlineTable(values
) | E
::DottedTable(values
) => {
886 if values
.len() == 0 {
889 Err(Error
::from_kind(ErrorKind
::ExpectedEmptyTable
))
892 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
894 found
: e
.type_name(),
899 fn newtype_variant_seed
<T
>(self, seed
: T
) -> Result
<T
::Value
, Self::Error
>
901 T
: de
::DeserializeSeed
<'de
>,
903 seed
.deserialize(ValueDeserializer
::new(self.value
))
906 fn tuple_variant
<V
>(self, len
: usize, visitor
: V
) -> Result
<V
::Value
, Self::Error
>
911 E
::InlineTable(values
) | E
::DottedTable(values
) => {
912 let tuple_values
= values
915 .map(|(index
, (key
, value
))| match key
.parse
::<usize>() {
916 Ok(key_index
) if key_index
== index
=> Ok(value
),
917 Ok(_
) | Err(_
) => Err(Error
::from_kind(ErrorKind
::ExpectedTupleIndex
{
919 found
: key
.to_string(),
922 // Fold all values into a `Vec`, or return the first error.
923 .fold(Ok(Vec
::with_capacity(len
)), |result
, value_result
| {
924 result
.and_then(move |mut tuple_values
| match value_result
{
926 tuple_values
.push(value
);
929 // `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
934 if tuple_values
.len() == len
{
935 de
::Deserializer
::deserialize_seq(
936 ValueDeserializer
::new(Value
{
937 e
: E
::Array(tuple_values
),
938 start
: self.value
.start
,
944 Err(Error
::from_kind(ErrorKind
::ExpectedTuple(len
)))
947 e @ _
=> Err(Error
::from_kind(ErrorKind
::Wanted
{
949 found
: e
.type_name(),
954 fn struct_variant
<V
>(
956 fields
: &'
static [&'
static str],
958 ) -> Result
<V
::Value
, Self::Error
>
962 de
::Deserializer
::deserialize_struct(
963 ValueDeserializer
::new(self.value
).with_struct_key_validation(),
964 "", // TODO: this should be the variant name
971 impl<'a
> Deserializer
<'a
> {
972 /// Creates a new deserializer which will be deserializing the string
974 pub fn new(input
: &'a
str) -> Deserializer
<'a
> {
976 tokens
: Tokenizer
::new(input
),
978 require_newline_after_table
: true,
979 allow_duplciate_after_longer_table
: false,
983 /// The `Deserializer::end` method should be called after a value has been
984 /// fully deserialized. This allows the `Deserializer` to validate that the
985 /// input stream is at the end or that it only has trailing
986 /// whitespace/comments.
987 pub fn end(&mut self) -> Result
<(), Error
> {
991 /// Historical versions of toml-rs accidentally allowed a newline after a
992 /// table definition, but the TOML spec requires a newline after a table
993 /// definition header.
995 /// This option can be set to `false` (the default is `true`) to emulate
996 /// this behavior for backwards compatibility with older toml-rs versions.
997 pub fn set_require_newline_after_table(&mut self, require
: bool
) {
998 self.require_newline_after_table
= require
;
1001 /// Historical versions of toml-rs accidentally allowed a duplicate table
1002 /// header after a longer table header was previously defined. This is
1003 /// invalid according to the TOML spec, however.
1005 /// This option can be set to `true` (the default is `false`) to emulate
1006 /// this behavior for backwards compatibility with older toml-rs versions.
1007 pub fn set_allow_duplicate_after_longer_table(&mut self, allow
: bool
) {
1008 self.allow_duplciate_after_longer_table
= allow
;
1011 fn tables(&mut self) -> Result
<Vec
<Table
<'a
>>, Error
> {
1012 let mut tables
= Vec
::new();
1013 let mut cur_table
= Table
{
1020 while let Some(line
) = self.line()?
{
1027 if !cur_table
.header
.is_empty() || cur_table
.values
.is_some() {
1028 tables
.push(cur_table
);
1033 values
: Some(Vec
::new()),
1037 let part
= header
.next().map_err(|e
| self.token_error(e
));
1039 Some(part
) => cur_table
.header
.push(part
),
1044 Line
::KeyValue(key
, value
) => {
1045 if cur_table
.values
.is_none() {
1046 cur_table
.values
= Some(Vec
::new());
1048 self.add_dotted_key(key
, value
, cur_table
.values
.as_mut().unwrap())?
;
1052 if !cur_table
.header
.is_empty() || cur_table
.values
.is_some() {
1053 tables
.push(cur_table
);
1058 fn line(&mut self) -> Result
<Option
<Line
<'a
>>, Error
> {
1060 self.eat_whitespace()?
;
1061 if self.eat_comment()?
{
1064 if self.eat(Token
::Newline
)?
{
1070 match self.peek()?
{
1071 Some((_
, Token
::LeftBracket
)) => self.table_header().map(Some
),
1072 Some(_
) => self.key_value().map(Some
),
1077 fn table_header(&mut self) -> Result
<Line
<'a
>, Error
> {
1078 let start
= self.tokens
.current();
1079 self.expect(Token
::LeftBracket
)?
;
1080 let array
= self.eat(Token
::LeftBracket
)?
;
1081 let ret
= Header
::new(self.tokens
.clone(), array
, self.require_newline_after_table
);
1082 if self.require_newline_after_table
{
1083 self.tokens
.skip_to_newline();
1086 match self.next()?
{
1087 Some((_
, Token
::RightBracket
)) => {
1089 self.eat(Token
::RightBracket
)?
;
1093 Some((_
, Token
::Newline
)) | None
=> break,
1097 self.eat_whitespace()?
;
1106 fn key_value(&mut self) -> Result
<Line
<'a
>, Error
> {
1107 let key
= self.dotted_key()?
;
1108 self.eat_whitespace()?
;
1109 self.expect(Token
::Equals
)?
;
1110 self.eat_whitespace()?
;
1112 let value
= self.value()?
;
1113 self.eat_whitespace()?
;
1114 if !self.eat_comment()?
{
1115 self.eat_newline_or_eof()?
;
1118 Ok(Line
::KeyValue(key
, value
))
1121 fn value(&mut self) -> Result
<Value
<'a
>, Error
> {
1122 let at
= self.tokens
.current();
1123 let value
= match self.next()?
{
1124 Some((Span { start, end }
, Token
::String { val, .. }
)) => Value
{
1129 Some((Span { start, end }
, Token
::Keylike("true"))) => Value
{
1130 e
: E
::Boolean(true),
1134 Some((Span { start, end }
, Token
::Keylike("false"))) => Value
{
1135 e
: E
::Boolean(false),
1139 Some((span
, Token
::Keylike(key
))) => self.number_or_date(span
, key
)?
,
1140 Some((span
, Token
::Plus
)) => self.number_leading_plus(span
)?
,
1141 Some((Span { start, .. }
, Token
::LeftBrace
)) => {
1142 self.inline_table().map(|(Span { end, .. }
, table
)| Value
{
1143 e
: E
::InlineTable(table
),
1148 Some((Span { start, .. }
, Token
::LeftBracket
)) => {
1149 self.array().map(|(Span { end, .. }
, array
)| Value
{
1156 return Err(self.error(
1159 expected
: "a value",
1160 found
: token
.1.describe(),
1164 None
=> return Err(self.eof()),
1169 fn number_or_date(&mut self, span
: Span
, s
: &'a
str) -> Result
<Value
<'a
>, Error
> {
1172 || (s
.len() > 1 && s
[1..].contains('
-'
) && !s
.contains("e-") && !s
.contains("E-"))
1174 self.datetime(span
, s
, false)
1175 .map(|(Span { start, end }
, d
)| Value
{
1180 } else if self.eat(Token
::Colon
)?
{
1181 self.datetime(span
, s
, true)
1182 .map(|(Span { start, end }
, d
)| Value
{
1188 self.number(span
, s
)
1192 /// Returns a string or table value type.
1194 /// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
1195 /// structures (tuple, newtype, struct) must be represented as a table.
1196 fn string_or_table(&mut self) -> Result
<(Value
<'a
>, Option
<Cow
<'a
, str>>), Error
> {
1197 match self.peek()?
{
1198 Some((_
, Token
::LeftBracket
)) => {
1199 let tables
= self.tables()?
;
1200 if tables
.len() != 1 {
1201 return Err(Error
::from_kind(ErrorKind
::Wanted
{
1202 expected
: "exactly 1 table",
1203 found
: if tables
.is_empty() {
1214 .expect("Expected exactly one table");
1218 .expect("Expected at least one header value for table.");
1220 let start
= table
.at
;
1224 .and_then(|values
| values
.last())
1225 .map(|&(_
, ref val
)| val
.end
)
1226 .unwrap_or_else(|| header
.len());
1229 e
: E
::DottedTable(table
.values
.unwrap_or_else(Vec
::new
)),
1233 Some(header
.clone()),
1236 Some(_
) => self.value().map(|val
| (val
, None
)),
1237 None
=> Err(self.eof()),
1241 fn number(&mut self, Span { start, end }
: Span
, s
: &'a
str) -> Result
<Value
<'a
>, Error
> {
1242 let to_integer
= |f
| Value
{
1247 if s
.starts_with("0x") {
1248 self.integer(&s
[2..], 16).map(to_integer
)
1249 } else if s
.starts_with("0o") {
1250 self.integer(&s
[2..], 8).map(to_integer
)
1251 } else if s
.starts_with("0b") {
1252 self.integer(&s
[2..], 2).map(to_integer
)
1253 } else if s
.contains('e'
) || s
.contains('E'
) {
1254 self.float(s
, None
).map(|f
| Value
{
1259 } else if self.eat(Token
::Period
)?
{
1260 let at
= self.tokens
.current();
1261 match self.next()?
{
1262 Some((Span { start, end }
, Token
::Keylike(after
))) => {
1263 self.float(s
, Some(after
)).map(|f
| Value
{
1269 _
=> Err(self.error(at
, ErrorKind
::NumberInvalid
)),
1271 } else if s
== "inf" {
1273 e
: E
::Float(f64::INFINITY
),
1277 } else if s
== "-inf" {
1279 e
: E
::Float(f64::NEG_INFINITY
),
1283 } else if s
== "nan" {
1285 e
: E
::Float(f64::NAN
),
1289 } else if s
== "-nan" {
1291 e
: E
::Float(-f64::NAN
),
1296 self.integer(s
, 10).map(to_integer
)
1300 fn number_leading_plus(&mut self, Span { start, .. }
: Span
) -> Result
<Value
<'a
>, Error
> {
1301 let start_token
= self.tokens
.current();
1302 match self.next()?
{
1303 Some((Span { end, .. }
, Token
::Keylike(s
))) => self.number(
1310 _
=> Err(self.error(start_token
, ErrorKind
::NumberInvalid
)),
1314 fn integer(&self, s
: &'a
str, radix
: u32) -> Result
<i64, Error
> {
1315 let allow_sign
= radix
== 10;
1316 let allow_leading_zeros
= radix
!= 10;
1317 let (prefix
, suffix
) = self.parse_integer(s
, allow_sign
, allow_leading_zeros
, radix
)?
;
1318 let start
= self.tokens
.substr_offset(s
);
1320 return Err(self.error(start
, ErrorKind
::NumberInvalid
));
1322 i64::from_str_radix(&prefix
.replace("_", "").trim_start_matches('
+'
), radix
)
1323 .map_err(|_e
| self.error(start
, ErrorKind
::NumberInvalid
))
1330 allow_leading_zeros
: bool
,
1332 ) -> Result
<(&'a
str, &'a
str), Error
> {
1333 let start
= self.tokens
.substr_offset(s
);
1335 let mut first
= true;
1336 let mut first_zero
= false;
1337 let mut underscore
= false;
1338 let mut end
= s
.len();
1339 for (i
, c
) in s
.char_indices() {
1341 if i
== 0 && (c
== '
+'
|| c
== '
-'
) && allow_sign
{
1345 if c
== '
0'
&& first
{
1347 } else if c
.to_digit(radix
).is_some() {
1348 if !first
&& first_zero
&& !allow_leading_zeros
{
1349 return Err(self.error(at
, ErrorKind
::NumberInvalid
));
1352 } else if c
== '_'
&& first
{
1353 return Err(self.error(at
, ErrorKind
::NumberInvalid
));
1354 } else if c
== '_'
&& !underscore
{
1362 if first
|| underscore
{
1363 return Err(self.error(start
, ErrorKind
::NumberInvalid
));
1365 Ok((&s
[..end
], &s
[end
..]))
1368 fn float(&mut self, s
: &'a
str, after_decimal
: Option
<&'a
str>) -> Result
<f64, Error
> {
1369 let (integral
, mut suffix
) = self.parse_integer(s
, true, false, 10)?
;
1370 let start
= self.tokens
.substr_offset(integral
);
1372 let mut fraction
= None
;
1373 if let Some(after
) = after_decimal
{
1375 return Err(self.error(start
, ErrorKind
::NumberInvalid
));
1377 let (a
, b
) = self.parse_integer(after
, false, true, 10)?
;
1382 let mut exponent
= None
;
1383 if suffix
.starts_with('e'
) || suffix
.starts_with('E'
) {
1384 let (a
, b
) = if suffix
.len() == 1 {
1385 self.eat(Token
::Plus
)?
;
1386 match self.next()?
{
1387 Some((_
, Token
::Keylike(s
))) => self.parse_integer(s
, false, false, 10)?
,
1388 _
=> return Err(self.error(start
, ErrorKind
::NumberInvalid
)),
1391 self.parse_integer(&suffix
[1..], true, false, 10)?
1394 return Err(self.error(start
, ErrorKind
::NumberInvalid
));
1397 } else if !suffix
.is_empty() {
1398 return Err(self.error(start
, ErrorKind
::NumberInvalid
));
1401 let mut number
= integral
1402 .trim_start_matches('
+'
)
1404 .filter(|c
| *c
!= '_'
)
1405 .collect
::<String
>();
1406 if let Some(fraction
) = fraction
{
1407 number
.push_str(".");
1408 number
.extend(fraction
.chars().filter(|c
| *c
!= '_'
));
1410 if let Some(exponent
) = exponent
{
1411 number
.push_str("E");
1412 number
.extend(exponent
.chars().filter(|c
| *c
!= '_'
));
1416 .map_err(|_e
| self.error(start
, ErrorKind
::NumberInvalid
))
1417 .and_then(|n
: f64| {
1421 Err(self.error(start
, ErrorKind
::NumberInvalid
))
1431 ) -> Result
<(Span
, &'a
str), Error
> {
1432 let start
= self.tokens
.substr_offset(date
);
1434 // Check for space separated date and time.
1435 let mut lookahead
= self.tokens
.clone();
1436 if let Ok(Some((_
, Token
::Whitespace(" ")))) = lookahead
.next() {
1437 // Check if hour follows.
1438 if let Ok(Some((_
, Token
::Keylike(_
)))) = lookahead
.next() {
1439 self.next()?
; // skip space
1440 self.next()?
; // skip keylike hour
1444 if colon_eaten
|| self.eat(Token
::Colon
)?
{
1446 match self.next()?
{
1447 Some((_
, Token
::Keylike(_
))) => {}
1448 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1451 self.expect(Token
::Colon
)?
;
1452 match self.next()?
{
1453 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1456 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1458 // Fractional seconds
1459 if self.eat(Token
::Period
)?
{
1460 match self.next()?
{
1461 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1464 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1469 if self.eat(Token
::Plus
)?
{
1470 match self.next()?
{
1471 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1474 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1477 if self.eat(Token
::Colon
)?
{
1478 match self.next()?
{
1479 Some((Span { end, .. }
, Token
::Keylike(_
))) => {
1482 _
=> return Err(self.error(start
, ErrorKind
::DateInvalid
)),
1487 let end
= self.tokens
.current();
1488 Ok((span
, &self.tokens
.input()[start
..end
]))
1491 // TODO(#140): shouldn't buffer up this entire table in memory, it'd be
1492 // great to defer parsing everything until later.
1493 fn inline_table(&mut self) -> Result
<(Span
, Vec
<(Cow
<'a
, str>, Value
<'a
>)>), Error
> {
1494 let mut ret
= Vec
::new();
1495 self.eat_whitespace()?
;
1496 if let Some(span
) = self.eat_spanned(Token
::RightBrace
)?
{
1497 return Ok((span
, ret
));
1500 let key
= self.dotted_key()?
;
1501 self.eat_whitespace()?
;
1502 self.expect(Token
::Equals
)?
;
1503 self.eat_whitespace()?
;
1504 let value
= self.value()?
;
1505 self.add_dotted_key(key
, value
, &mut ret
)?
;
1507 self.eat_whitespace()?
;
1508 if let Some(span
) = self.eat_spanned(Token
::RightBrace
)?
{
1509 return Ok((span
, ret
));
1511 self.expect(Token
::Comma
)?
;
1512 self.eat_whitespace()?
;
1516 // TODO(#140): shouldn't buffer up this entire array in memory, it'd be
1517 // great to defer parsing everything until later.
1518 fn array(&mut self) -> Result
<(Span
, Vec
<Value
<'a
>>), Error
> {
1519 let mut ret
= Vec
::new();
1521 let intermediate
= |me
: &mut Deserializer
<'_
>| {
1523 me
.eat_whitespace()?
;
1524 if !me
.eat(Token
::Newline
)?
&& !me
.eat_comment()?
{
1532 intermediate(self)?
;
1533 if let Some(span
) = self.eat_spanned(Token
::RightBracket
)?
{
1534 return Ok((span
, ret
));
1536 let at
= self.tokens
.current();
1537 let value
= self.value()?
;
1538 if let Some(last
) = ret
.last() {
1539 if !value
.same_type(last
) {
1540 return Err(self.error(at
, ErrorKind
::MixedArrayType
));
1544 intermediate(self)?
;
1545 if !self.eat(Token
::Comma
)?
{
1549 intermediate(self)?
;
1550 let span
= self.expect_spanned(Token
::RightBracket
)?
;
1554 fn table_key(&mut self) -> Result
<Cow
<'a
, str>, Error
> {
1558 .map_err(|e
| self.token_error(e
))
1561 fn dotted_key(&mut self) -> Result
<Vec
<Cow
<'a
, str>>, Error
> {
1562 let mut result
= Vec
::new();
1563 result
.push(self.table_key()?
);
1564 self.eat_whitespace()?
;
1565 while self.eat(Token
::Period
)?
{
1566 self.eat_whitespace()?
;
1567 result
.push(self.table_key()?
);
1568 self.eat_whitespace()?
;
1573 /// Stores a value in the appropriate hierachical structure positioned based on the dotted key.
1575 /// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
1576 /// intermediate parts which are mapped to the relevant fields in the deserialized type's data
1581 /// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
1582 /// `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
1583 /// * `value`: The parsed value.
1584 /// * `values`: The `Vec` to store the value in.
1587 mut key_parts
: Vec
<Cow
<'a
, str>>,
1589 values
: &mut Vec
<(Cow
<'a
, str>, Value
<'a
>)>,
1590 ) -> Result
<(), Error
> {
1591 let key
= key_parts
.remove(0);
1592 if key_parts
.is_empty() {
1593 values
.push((key
, value
));
1596 match values
.iter_mut().find(|&&mut (ref k
, _
)| *k
== key
) {
1600 e
: E
::DottedTable(ref mut v
),
1604 return self.add_dotted_key(key_parts
, value
, v
);
1606 Some(&mut (_
, Value { start, .. }
)) => {
1607 return Err(self.error(start
, ErrorKind
::DottedKeyInvalidType
));
1611 // The start/end value is somewhat misleading here.
1612 let table_values
= Value
{
1613 e
: E
::DottedTable(Vec
::new()),
1617 values
.push((key
, table_values
));
1618 let last_i
= values
.len() - 1;
1622 e
: E
::DottedTable(ref mut v
),
1627 self.add_dotted_key(key_parts
, value
, v
)?
;
1632 fn eat_whitespace(&mut self) -> Result
<(), Error
> {
1635 .map_err(|e
| self.token_error(e
))
1638 fn eat_comment(&mut self) -> Result
<bool
, Error
> {
1639 self.tokens
.eat_comment().map_err(|e
| self.token_error(e
))
1642 fn eat_newline_or_eof(&mut self) -> Result
<(), Error
> {
1644 .eat_newline_or_eof()
1645 .map_err(|e
| self.token_error(e
))
1648 fn eat(&mut self, expected
: Token
<'a
>) -> Result
<bool
, Error
> {
1649 self.tokens
.eat(expected
).map_err(|e
| self.token_error(e
))
1652 fn eat_spanned(&mut self, expected
: Token
<'a
>) -> Result
<Option
<Span
>, Error
> {
1654 .eat_spanned(expected
)
1655 .map_err(|e
| self.token_error(e
))
1658 fn expect(&mut self, expected
: Token
<'a
>) -> Result
<(), Error
> {
1661 .map_err(|e
| self.token_error(e
))
1664 fn expect_spanned(&mut self, expected
: Token
<'a
>) -> Result
<Span
, Error
> {
1666 .expect_spanned(expected
)
1667 .map_err(|e
| self.token_error(e
))
1670 fn next(&mut self) -> Result
<Option
<(Span
, Token
<'a
>)>, Error
> {
1671 self.tokens
.next().map_err(|e
| self.token_error(e
))
1674 fn peek(&mut self) -> Result
<Option
<(Span
, Token
<'a
>)>, Error
> {
1675 self.tokens
.peek().map_err(|e
| self.token_error(e
))
1678 fn eof(&self) -> Error
{
1679 self.error(self.input
.len(), ErrorKind
::UnexpectedEof
)
1682 fn token_error(&self, error
: TokenError
) -> Error
{
1684 TokenError
::InvalidCharInString(at
, ch
) => {
1685 self.error(at
, ErrorKind
::InvalidCharInString(ch
))
1687 TokenError
::InvalidEscape(at
, ch
) => self.error(at
, ErrorKind
::InvalidEscape(ch
)),
1688 TokenError
::InvalidEscapeValue(at
, v
) => {
1689 self.error(at
, ErrorKind
::InvalidEscapeValue(v
))
1691 TokenError
::InvalidHexEscape(at
, ch
) => self.error(at
, ErrorKind
::InvalidHexEscape(ch
)),
1692 TokenError
::NewlineInString(at
) => self.error(at
, ErrorKind
::NewlineInString
),
1693 TokenError
::Unexpected(at
, ch
) => self.error(at
, ErrorKind
::Unexpected(ch
)),
1694 TokenError
::UnterminatedString(at
) => self.error(at
, ErrorKind
::UnterminatedString
),
1695 TokenError
::NewlineInTableKey(at
) => self.error(at
, ErrorKind
::NewlineInTableKey
),
1696 TokenError
::Wanted
{
1707 TokenError
::EmptyTableKey(at
) => self.error(at
, ErrorKind
::EmptyTableKey
),
1708 TokenError
::MultilineStringKey(at
) => self.error(at
, ErrorKind
::MultilineStringKey
),
1712 fn error(&self, at
: usize, kind
: ErrorKind
) -> Error
{
1713 let mut err
= Error
::from_kind(kind
);
1714 let (line
, col
) = self.to_linecol(at
);
1715 err
.inner
.line
= Some(line
);
1716 err
.inner
.col
= col
;
1720 /// Converts a byte offset from an error message to a (line, column) pair
1722 /// All indexes are 0-based.
1723 fn to_linecol(&self, offset
: usize) -> (usize, usize) {
1725 for (i
, line
) in self.input
.lines().enumerate() {
1726 if cur
+ line
.len() + 1 > offset
{
1727 return (i
, offset
- cur
);
1729 cur
+= line
.len() + 1;
1731 (self.input
.lines().count(), 0)
1736 /// Produces a (line, column) pair of the position of the error if available
1738 /// All indexes are 0-based.
1739 pub fn line_col(&self) -> Option
<(usize, usize)> {
1740 self.inner
.line
.map(|line
| (line
, self.inner
.col
))
1743 fn from_kind(kind
: ErrorKind
) -> Error
{
1745 inner
: Box
::new(ErrorInner
{
1749 message
: String
::new(),
1755 fn custom(s
: String
) -> Error
{
1757 inner
: Box
::new(ErrorInner
{
1758 kind
: ErrorKind
::Custom
,
1767 /// Do not call this method, it may be removed at any time, it's just an
1768 /// internal implementation detail.
1770 pub fn add_key_context(&mut self, key
: &str) {
1771 self.inner
.key
.insert(0, key
.to_string());
1775 impl fmt
::Display
for Error
{
1776 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
1777 match self.inner
.kind
{
1778 ErrorKind
::UnexpectedEof
=> "unexpected eof encountered".fmt(f
)?
,
1779 ErrorKind
::InvalidCharInString(c
) => write
!(
1781 "invalid character in string: `{}`",
1782 c
.escape_default().collect
::<String
>()
1784 ErrorKind
::InvalidEscape(c
) => write
!(
1786 "invalid escape character in string: `{}`",
1787 c
.escape_default().collect
::<String
>()
1789 ErrorKind
::InvalidHexEscape(c
) => write
!(
1791 "invalid hex escape character in string: `{}`",
1792 c
.escape_default().collect
::<String
>()
1794 ErrorKind
::InvalidEscapeValue(c
) => write
!(f
, "invalid escape value: `{}`", c
)?
,
1795 ErrorKind
::NewlineInString
=> "newline in string found".fmt(f
)?
,
1796 ErrorKind
::Unexpected(ch
) => write
!(
1798 "unexpected character found: `{}`",
1799 ch
.escape_default().collect
::<String
>()
1801 ErrorKind
::UnterminatedString
=> "unterminated string".fmt(f
)?
,
1802 ErrorKind
::NewlineInTableKey
=> "found newline in table key".fmt(f
)?
,
1803 ErrorKind
::Wanted { expected, found }
=> {
1804 write
!(f
, "expected {}, found {}", expected
, found
)?
1806 ErrorKind
::NumberInvalid
=> "invalid number".fmt(f
)?
,
1807 ErrorKind
::DateInvalid
=> "invalid date".fmt(f
)?
,
1808 ErrorKind
::MixedArrayType
=> "mixed types in an array".fmt(f
)?
,
1809 ErrorKind
::DuplicateTable(ref s
) => {
1810 write
!(f
, "redefinition of table `{}`", s
)?
;
1812 ErrorKind
::RedefineAsArray
=> "table redefined as array".fmt(f
)?
,
1813 ErrorKind
::EmptyTableKey
=> "empty table key found".fmt(f
)?
,
1814 ErrorKind
::MultilineStringKey
=> "multiline strings are not allowed for key".fmt(f
)?
,
1815 ErrorKind
::Custom
=> self.inner
.message
.fmt(f
)?
,
1816 ErrorKind
::ExpectedTuple(l
) => write
!(f
, "expected table with length {}", l
)?
,
1817 ErrorKind
::ExpectedTupleIndex
{
1820 } => write
!(f
, "expected table key `{}`, but was `{}`", expected
, found
)?
,
1821 ErrorKind
::ExpectedEmptyTable
=> "expected empty table".fmt(f
)?
,
1822 ErrorKind
::DottedKeyInvalidType
=> {
1823 "dotted key attempted to extend non-table type".fmt(f
)?
1825 ErrorKind
::UnexpectedKeys
{
1830 "unexpected keys in table: `{:?}`, available keys: `{:?}`",
1833 ErrorKind
::__Nonexhaustive
=> panic
!(),
1836 if !self.inner
.key
.is_empty() {
1837 write
!(f
, " for key `")?
;
1838 for (i
, k
) in self.inner
.key
.iter().enumerate() {
1842 write
!(f
, "{}", k
)?
;
1847 if let Some(line
) = self.inner
.line
{
1848 write
!(f
, " at line {}", line
+ 1)?
;
1855 impl error
::Error
for Error
{
1856 fn description(&self) -> &str {
1857 match self.inner
.kind
{
1858 ErrorKind
::UnexpectedEof
=> "unexpected eof encountered",
1859 ErrorKind
::InvalidCharInString(_
) => "invalid char in string",
1860 ErrorKind
::InvalidEscape(_
) => "invalid escape in string",
1861 ErrorKind
::InvalidHexEscape(_
) => "invalid hex escape in string",
1862 ErrorKind
::InvalidEscapeValue(_
) => "invalid escape value in string",
1863 ErrorKind
::NewlineInString
=> "newline in string found",
1864 ErrorKind
::Unexpected(_
) => "unexpected or invalid character",
1865 ErrorKind
::UnterminatedString
=> "unterminated string",
1866 ErrorKind
::NewlineInTableKey
=> "found newline in table key",
1867 ErrorKind
::Wanted { .. }
=> "expected a token but found another",
1868 ErrorKind
::NumberInvalid
=> "invalid number",
1869 ErrorKind
::DateInvalid
=> "invalid date",
1870 ErrorKind
::MixedArrayType
=> "mixed types in an array",
1871 ErrorKind
::DuplicateTable(_
) => "duplicate table",
1872 ErrorKind
::RedefineAsArray
=> "table redefined as array",
1873 ErrorKind
::EmptyTableKey
=> "empty table key found",
1874 ErrorKind
::MultilineStringKey
=> "invalid multiline string for key",
1875 ErrorKind
::Custom
=> "a custom error",
1876 ErrorKind
::ExpectedTuple(_
) => "expected table length",
1877 ErrorKind
::ExpectedTupleIndex { .. }
=> "expected table key",
1878 ErrorKind
::ExpectedEmptyTable
=> "expected empty table",
1879 ErrorKind
::DottedKeyInvalidType
=> "dotted key invalid type",
1880 ErrorKind
::UnexpectedKeys { .. }
=> "unexpected keys in table",
1881 ErrorKind
::__Nonexhaustive
=> panic
!(),
1886 impl de
::Error
for Error
{
1887 fn custom
<T
: fmt
::Display
>(msg
: T
) -> Error
{
1888 Error
::custom(msg
.to_string())
1898 KeyValue(Vec
<Cow
<'a
, str>>, Value
<'a
>),
1904 require_newline_after_table
: bool
,
1905 tokens
: Tokenizer
<'a
>,
1908 impl<'a
> Header
<'a
> {
1909 fn new(tokens
: Tokenizer
<'a
>, array
: bool
, require_newline_after_table
: bool
) -> Header
<'a
> {
1914 require_newline_after_table
: require_newline_after_table
,
1918 fn next(&mut self) -> Result
<Option
<Cow
<'a
, str>>, TokenError
> {
1919 self.tokens
.eat_whitespace()?
;
1921 if self.first
|| self.tokens
.eat(Token
::Period
)?
{
1923 self.tokens
.eat_whitespace()?
;
1924 self.tokens
.table_key().map(|t
| t
.1).map(Some
)
1926 self.tokens
.expect(Token
::RightBracket
)?
;
1928 self.tokens
.expect(Token
::RightBracket
)?
;
1931 self.tokens
.eat_whitespace()?
;
1932 if self.require_newline_after_table
{
1933 if !self.tokens
.eat_comment()?
{
1934 self.tokens
.eat_newline_or_eof()?
;
1954 String(Cow
<'a
, str>),
1956 Array(Vec
<Value
<'a
>>),
1957 InlineTable(Vec
<(Cow
<'a
, str>, Value
<'a
>)>),
1958 DottedTable(Vec
<(Cow
<'a
, str>, Value
<'a
>)>),
1962 fn type_name(&self) -> &'
static str {
1964 E
::String(..) => "string",
1965 E
::Integer(..) => "integer",
1966 E
::Float(..) => "float",
1967 E
::Boolean(..) => "boolean",
1968 E
::Datetime(..) => "datetime",
1969 E
::Array(..) => "array",
1970 E
::InlineTable(..) => "inline table",
1971 E
::DottedTable(..) => "dotted table",
1976 impl<'a
> Value
<'a
> {
1977 fn same_type(&self, other
: &Value
<'a
>) -> bool
{
1978 match (&self.e
, &other
.e
) {
1979 (&E
::String(..), &E
::String(..))
1980 | (&E
::Integer(..), &E
::Integer(..))
1981 | (&E
::Float(..), &E
::Float(..))
1982 | (&E
::Boolean(..), &E
::Boolean(..))
1983 | (&E
::Datetime(..), &E
::Datetime(..))
1984 | (&E
::Array(..), &E
::Array(..))
1985 | (&E
::InlineTable(..), &E
::InlineTable(..)) => true,
1986 (&E
::DottedTable(..), &E
::DottedTable(..)) => true,