toml/de/deserializer/
mod.rs

1//! Deserializing TOML into Rust structures.
2//!
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.
6
7mod array;
8mod key;
9mod table;
10mod table_enum;
11mod value;
12
13pub use value::ValueDeserializer;
14
15use crate::de::DeTable;
16use crate::de::DeValue;
17use crate::de::Error;
18use array::ArrayDeserializer;
19use key::KeyDeserializer;
20use serde_spanned::de::SpannedDeserializer;
21use serde_spanned::Spanned;
22use table::TableDeserializer;
23use table_enum::TableEnumDeserializer;
24use toml_datetime::de::DatetimeDeserializer;
25
26/// Deserialization for TOML [documents][crate::Table].
27///
28/// To deserializes TOML values, instead of documents, see [`ValueDeserializer`].
29pub struct Deserializer<'i> {
30    span: core::ops::Range<usize>,
31    root: DeTable<'i>,
32    raw: Option<&'i str>,
33}
34
35impl<'i> Deserializer<'i> {
36    /// Parse a TOML document
37    pub fn parse(raw: &'i str) -> Result<Self, Error> {
38        let root = DeTable::parse(raw)?;
39        let span = root.span();
40        let root = root.into_inner();
41        Ok(Self {
42            span,
43            root,
44            raw: Some(raw),
45        })
46    }
47
48    /// Deprecated, replaced with [`Deserializer::parse`]
49    #[deprecated(since = "0.9.0", note = "replaced with `Deserializer::parse`")]
50    pub fn new(raw: &'i str) -> Result<Self, Error> {
51        Self::parse(raw)
52    }
53
54    fn into_table_de(self) -> ValueDeserializer<'i> {
55        ValueDeserializer::with_parts(DeValue::Table(self.root), self.span)
56    }
57}
58
59impl<'i> From<Spanned<DeTable<'i>>> for Deserializer<'i> {
60    fn from(root: Spanned<DeTable<'i>>) -> Self {
61        let span = root.span();
62        let root = root.into_inner();
63        Self {
64            span,
65            root,
66            raw: None,
67        }
68    }
69}
70
71impl<'de> serde::Deserializer<'de> for Deserializer<'de> {
72    type Error = Error;
73
74    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
75    where
76        V: serde::de::Visitor<'de>,
77    {
78        let raw = self.raw;
79        self.into_table_de()
80            .deserialize_any(visitor)
81            .map_err(|mut e: Self::Error| {
82                e.set_input(raw);
83                e
84            })
85    }
86
87    // `None` is interpreted as a missing field so be sure to implement `Some`
88    // as a present field.
89    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
90    where
91        V: serde::de::Visitor<'de>,
92    {
93        let raw = self.raw;
94        self.into_table_de()
95            .deserialize_option(visitor)
96            .map_err(|mut e: Self::Error| {
97                e.set_input(raw);
98                e
99            })
100    }
101
102    fn deserialize_newtype_struct<V>(
103        self,
104        name: &'static str,
105        visitor: V,
106    ) -> Result<V::Value, Error>
107    where
108        V: serde::de::Visitor<'de>,
109    {
110        let raw = self.raw;
111        self.into_table_de()
112            .deserialize_newtype_struct(name, visitor)
113            .map_err(|mut e: Self::Error| {
114                e.set_input(raw);
115                e
116            })
117    }
118
119    fn deserialize_struct<V>(
120        self,
121        name: &'static str,
122        fields: &'static [&'static str],
123        visitor: V,
124    ) -> Result<V::Value, Error>
125    where
126        V: serde::de::Visitor<'de>,
127    {
128        let raw = self.raw;
129        self.into_table_de()
130            .deserialize_struct(name, fields, visitor)
131            .map_err(|mut e: Self::Error| {
132                e.set_input(raw);
133                e
134            })
135    }
136
137    // Called when the type to deserialize is an enum, as opposed to a field in the type.
138    fn deserialize_enum<V>(
139        self,
140        name: &'static str,
141        variants: &'static [&'static str],
142        visitor: V,
143    ) -> Result<V::Value, Error>
144    where
145        V: serde::de::Visitor<'de>,
146    {
147        let raw = self.raw;
148        self.into_table_de()
149            .deserialize_enum(name, variants, visitor)
150            .map_err(|mut e: Self::Error| {
151                e.set_input(raw);
152                e
153            })
154    }
155
156    serde::forward_to_deserialize_any! {
157        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
158        bytes byte_buf map unit
159        ignored_any unit_struct tuple_struct tuple identifier
160    }
161}
162
163impl<'de> serde::de::IntoDeserializer<'de, Error> for Deserializer<'de> {
164    type Deserializer = Self;
165
166    fn into_deserializer(self) -> Self::Deserializer {
167        self
168    }
169}
170
171impl<'de> serde::de::IntoDeserializer<'de, Error> for Spanned<DeTable<'de>> {
172    type Deserializer = Deserializer<'de>;
173
174    fn into_deserializer(self) -> Self::Deserializer {
175        Deserializer::from(self)
176    }
177}
toml/de/deserializer/mod.rs

toml/de/deserializer/
mod.rs
