toml_edit/de/
table.rs

1use serde::de::IntoDeserializer;
2
3use crate::de::Error;
4
5pub(crate) struct TableDeserializer {
6    span: Option<std::ops::Range<usize>>,
7    items: crate::table::KeyValuePairs,
8}
9
10// Note: this is wrapped by `Deserializer` and `ValueDeserializer` and any trait methods
11// implemented here need to be wrapped there
12impl<'de> serde::Deserializer<'de> for TableDeserializer {
13    type Error = Error;
14
15    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
16    where
17        V: serde::de::Visitor<'de>,
18    {
19        visitor.visit_map(TableMapAccess::new(self))
20    }
21
22    // `None` is interpreted as a missing field so be sure to implement `Some`
23    // as a present field.
24    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
25    where
26        V: serde::de::Visitor<'de>,
27    {
28        visitor.visit_some(self)
29    }
30
31    fn deserialize_newtype_struct<V>(
32        self,
33        _name: &'static str,
34        visitor: V,
35    ) -> Result<V::Value, Error>
36    where
37        V: serde::de::Visitor<'de>,
38    {
39        visitor.visit_newtype_struct(self)
40    }
41
42    fn deserialize_struct<V>(
43        self,
44        name: &'static str,
45        fields: &'static [&'static str],
46        visitor: V,
47    ) -> Result<V::Value, Error>
48    where
49        V: serde::de::Visitor<'de>,
50    {
51        if serde_spanned::__unstable::is_spanned(name, fields) {
52            if let Some(span) = self.span.clone() {
53                return visitor.visit_map(super::SpannedDeserializer::new(self, span));
54            }
55        }
56
57        self.deserialize_any(visitor)
58    }
59
60    // Called when the type to deserialize is an enum, as opposed to a field in the type.
61    fn deserialize_enum<V>(
62        self,
63        _name: &'static str,
64        _variants: &'static [&'static str],
65        visitor: V,
66    ) -> Result<V::Value, Error>
67    where
68        V: serde::de::Visitor<'de>,
69    {
70        if self.items.is_empty() {
71            Err(Error::custom(
72                "wanted exactly 1 element, found 0 elements",
73                self.span,
74            ))
75        } else if self.items.len() != 1 {
76            Err(Error::custom(
77                "wanted exactly 1 element, more than 1 element",
78                self.span,
79            ))
80        } else {
81            visitor.visit_enum(TableMapAccess::new(self))
82        }
83    }
84
85    serde::forward_to_deserialize_any! {
86        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
87        bytes byte_buf map unit
88        ignored_any unit_struct tuple_struct tuple identifier
89    }
90}
91
92impl<'de> IntoDeserializer<'de, Error> for TableDeserializer {
93    type Deserializer = TableDeserializer;
94
95    fn into_deserializer(self) -> Self::Deserializer {
96        self
97    }
98}
99
100impl crate::Table {
101    pub(crate) fn into_deserializer(self) -> TableDeserializer {
102        TableDeserializer {
103            span: self.span(),
104            items: self.items,
105        }
106    }
107}
108
109impl crate::InlineTable {
110    pub(crate) fn into_deserializer(self) -> TableDeserializer {
111        TableDeserializer {
112            span: self.span(),
113            items: self.items,
114        }
115    }
116}
117
118pub(crate) struct TableMapAccess {
119    iter: indexmap::map::IntoIter<crate::Key, crate::Item>,
120    span: Option<std::ops::Range<usize>>,
121    value: Option<(crate::Key, crate::Item)>,
122}
123
124impl TableMapAccess {
125    pub(crate) fn new(input: TableDeserializer) -> Self {
126        Self {
127            iter: input.items.into_iter(),
128            span: input.span,
129            value: None,
130        }
131    }
132}
133
134impl<'de> serde::de::MapAccess<'de> for TableMapAccess {
135    type Error = Error;
136
137    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
138    where
139        K: serde::de::DeserializeSeed<'de>,
140    {
141        match self.iter.next() {
142            Some((k, v)) => {
143                let key_span = k.span();
144                let ret = seed
145                    .deserialize(super::KeyDeserializer::new(k.clone(), key_span.clone()))
146                    .map(Some)
147                    .map_err(|mut e: Self::Error| {
148                        if e.span().is_none() {
149                            e.set_span(key_span);
150                        }
151                        e
152                    });
153                self.value = Some((k, v));
154                ret
155            }
156            None => Ok(None),
157        }
158    }
159
160    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
161    where
162        V: serde::de::DeserializeSeed<'de>,
163    {
164        match self.value.take() {
165            Some((k, v)) => {
166                let span = v.span().or_else(|| k.span());
167                seed.deserialize(crate::de::ValueDeserializer::new(v))
168                    .map_err(|mut e: Self::Error| {
169                        if e.span().is_none() {
170                            e.set_span(span);
171                        }
172                        e.add_key(k.get().to_owned());
173                        e
174                    })
175            }
176            None => {
177                panic!("no more values in next_value_seed, internal error in ValueDeserializer")
178            }
179        }
180    }
181}
182
183impl<'de> serde::de::EnumAccess<'de> for TableMapAccess {
184    type Error = Error;
185    type Variant = super::TableEnumDeserializer;
186
187    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
188    where
189        V: serde::de::DeserializeSeed<'de>,
190    {
191        let (key, value) = match self.iter.next() {
192            Some(pair) => pair,
193            None => {
194                return Err(Error::custom(
195                    "expected table with exactly 1 entry, found empty table",
196                    self.span,
197                ));
198            }
199        };
200
201        let val = seed
202            .deserialize(key.into_deserializer())
203            .map_err(|mut e: Self::Error| {
204                if e.span().is_none() {
205                    e.set_span(key.span());
206                }
207                e
208            })?;
209
210        let variant = super::TableEnumDeserializer::new(value);
211
212        Ok((val, variant))
213    }
214}
toml_edit/de/table.rs

toml_edit/de/
table.rs
