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 IntoDeserializer<'_, 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}
215