Skip to main content

matchmaker_partial/
simple_de.rs

1use crate::errors::SimpleError;
2use serde::de::{
3    self, DeserializeSeed, Deserializer, EnumAccess, IntoDeserializer, MapAccess, SeqAccess,
4    VariantAccess, Visitor,
5};
6use serde::forward_to_deserialize_any;
7
8#[derive(Debug)]
9pub struct SimpleDeserializer<'de> {
10    input: &'de [String],
11    start: usize,
12    // Ok(len) for tuple, Err(field_names) for struct
13    consuming: Option<Result<usize, &'static [&'static str]>>,
14
15    // configurable
16    pub option_hatch: Option<&'de str>,
17}
18
19pub fn deserialize<'de, T>(input: &'de [String]) -> Result<T, SimpleError>
20where
21    T: de::Deserialize<'de> + std::fmt::Debug,
22{
23    let mut de = SimpleDeserializer::from_slice(input);
24    let value = T::deserialize(&mut de)?;
25
26    if de.start != input.len() {
27        return Err(SimpleError::TrailingTokens { index: de.start });
28    }
29
30    Ok(value)
31}
32
33impl<'de> SimpleDeserializer<'de> {
34    pub fn from_slice(input: &'de [String]) -> Self {
35        Self {
36            input,
37            start: 0,
38            consuming: None,
39            option_hatch: None,
40        }
41    }
42
43    fn expect_single(&self) -> Result<&'de str, SimpleError> {
44        self.input
45            .get(self.start)
46            .map(|s| s.as_str())
47            .ok_or(SimpleError::ExpectedSingle)
48    }
49
50    fn with_sub<T, F>(
51        &mut self,
52        f: F,
53        consuming: impl Into<Option<Result<usize, &'static [&'static str]>>>,
54    ) -> Result<T, SimpleError>
55    where
56        F: FnOnce(&mut Self) -> Result<T, SimpleError>,
57    {
58        let mut sub = Self {
59            input: &self.input[self.start..],
60            start: 0,
61            consuming: None,
62            option_hatch: self.option_hatch,
63        };
64        sub.consuming = consuming.into();
65        let ret = f(&mut sub)?;
66        self.start += sub.start;
67        Ok(ret)
68    }
69}
70
71macro_rules! impl_number {
72    ($name:ident, $ty:ty, $visit:ident, $expect:literal) => {
73        fn $name<V>(self, visitor: V) -> Result<V::Value, Self::Error>
74        where
75            V: Visitor<'de>,
76        {
77            let s = self.expect_single()?;
78            let v: $ty = s.parse().map_err(|_| SimpleError::InvalidType {
79                expected: $expect,
80                found: s.to_string(),
81            })?;
82            self.start += 1;
83            visitor.$visit(v)
84        }
85    };
86}
87
88impl<'de> Deserializer<'de> for &mut SimpleDeserializer<'de> {
89    type Error = SimpleError;
90
91    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
92    where
93        V: Visitor<'de>,
94    {
95        let remaining = self.input.len() - self.start;
96
97        let no_sequences = matches!(self.consuming, Some(Err(_fields)));
98
99        if remaining > 1 && !no_sequences {
100            return self.deserialize_seq(visitor);
101        }
102
103        if remaining == 0 {
104            return self.deserialize_seq(visitor);
105        }
106
107        let s = &self.input[self.start];
108        let val = if s == "true" {
109            visitor.visit_bool(true)?
110        } else if s == "false" {
111            visitor.visit_bool(false)?
112        } else if s.is_empty() || s == "()" {
113            visitor.visit_unit()?
114        } else if let Ok(i) = s.parse::<i64>() {
115            visitor.visit_i64(i)?
116        } else if let Ok(f) = s.parse::<f64>() {
117            visitor.visit_f64(f)?
118        } else {
119            visitor.visit_str(s)?
120        };
121
122        self.start += 1;
123        Ok(val)
124    }
125
126    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
127    where
128        V: Visitor<'de>,
129    {
130        let s = self.expect_single()?;
131        //  else {
132        //     return visitor.visit_bool(true); // note that, like Option, this runs the risk of infinite loop
133        // };
134        let val = match s {
135            "true" | "" => visitor.visit_bool(true)?,
136            "false" => visitor.visit_bool(false)?,
137            _ => {
138                return Err(SimpleError::InvalidType {
139                    expected: "a boolean",
140                    found: s.to_string(),
141                });
142            }
143        };
144        self.start += 1;
145        Ok(val)
146    }
147
148    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
149    where
150        V: Visitor<'de>,
151    {
152        let s = self.expect_single()?;
153        let mut chars = s.chars();
154        let c = chars.next().ok_or(SimpleError::InvalidType {
155            expected: "a char",
156            found: s.to_string(),
157        })?;
158        if chars.next().is_some() {
159            return Err(SimpleError::InvalidType {
160                expected: "a single character",
161                found: s.to_string(),
162            });
163        }
164        self.start += 1;
165        visitor.visit_char(c)
166    }
167
168    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
169    where
170        V: Visitor<'de>,
171    {
172        let val = visitor.visit_str(self.expect_single()?)?;
173        self.start += 1;
174        Ok(val)
175    }
176
177    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
178    where
179        V: Visitor<'de>,
180    {
181        let val = visitor.visit_string(self.expect_single()?.to_string())?;
182        self.start += 1;
183        Ok(val)
184    }
185
186    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
187    where
188        V: Visitor<'de>,
189    {
190        self.deserialize_str(visitor)
191    }
192
193    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
194    where
195        V: Visitor<'de>,
196    {
197        let s = self.expect_single()?;
198        if s.is_empty() || s == "()" {
199            self.start += 1;
200            visitor.visit_unit()
201        } else {
202            Err(SimpleError::InvalidType {
203                expected: "unit",
204                found: s.to_string(),
205            })
206        }
207    }
208
209    fn deserialize_unit_struct<V>(
210        self,
211        _name: &'static str,
212        visitor: V,
213    ) -> Result<V::Value, Self::Error>
214    where
215        V: Visitor<'de>,
216    {
217        self.deserialize_unit(visitor)
218    }
219
220    fn deserialize_newtype_struct<V>(
221        self,
222        _name: &'static str,
223        visitor: V,
224    ) -> Result<V::Value, Self::Error>
225    where
226        V: Visitor<'de>,
227    {
228        visitor.visit_newtype_struct(self)
229    }
230
231    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
232    where
233        V: Visitor<'de>,
234    {
235        if self.start >= self.input.len() {
236            visitor.visit_none()
237        } else if self.option_hatch == Some(&self.input[self.start]) {
238            self.start += 1;
239            visitor.visit_none()
240        } else {
241            visitor.visit_some(self)
242        }
243    }
244
245    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
246    where
247        V: Visitor<'de>,
248    {
249        self.with_sub(|s| visitor.visit_seq(s), None)
250    }
251
252    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
253    where
254        V: Visitor<'de>,
255    {
256        self.with_sub(|s| visitor.visit_seq(s), Ok(len))
257    }
258
259    fn deserialize_tuple_struct<V>(
260        self,
261        _name: &'static str,
262        len: usize,
263        visitor: V,
264    ) -> Result<V::Value, Self::Error>
265    where
266        V: Visitor<'de>,
267    {
268        self.deserialize_tuple(len, visitor)
269    }
270
271    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
272    where
273        V: Visitor<'de>,
274    {
275        self.with_sub(|s| visitor.visit_map(s), None)
276    }
277
278    fn deserialize_struct<V>(
279        self,
280        _name: &'static str,
281        fields: &'static [&'static str],
282        visitor: V,
283    ) -> Result<V::Value, Self::Error>
284    where
285        V: Visitor<'de>,
286    {
287        self.with_sub(|s| visitor.visit_map(s), Err(fields))
288    }
289
290    fn deserialize_enum<V>(
291        self,
292        _name: &'static str,
293        variants: &'static [&'static str],
294        visitor: V,
295    ) -> Result<V::Value, Self::Error>
296    where
297        V: Visitor<'de>,
298    {
299        // we don't actually use the passed in variants
300        self.with_sub(|s| visitor.visit_enum(s), Err(variants))
301    }
302
303    impl_number!(deserialize_i8, i8, visit_i8, "an i8");
304    impl_number!(deserialize_i16, i16, visit_i16, "an i16");
305    impl_number!(deserialize_i32, i32, visit_i32, "an i32");
306    impl_number!(deserialize_i64, i64, visit_i64, "an i64");
307    impl_number!(deserialize_u8, u8, visit_u8, "a u8");
308    impl_number!(deserialize_u16, u16, visit_u16, "a u16");
309    impl_number!(deserialize_u32, u32, visit_u32, "a u32");
310    impl_number!(deserialize_u64, u64, visit_u64, "a u64");
311    impl_number!(deserialize_f32, f32, visit_f32, "an f32");
312    impl_number!(deserialize_f64, f64, visit_f64, "an f64");
313
314    forward_to_deserialize_any! { bytes byte_buf ignored_any }
315}
316
317// === Implement SeqAccess, MapAccess, EnumAccess, VariantAccess ===
318
319impl<'de> SeqAccess<'de> for &mut SimpleDeserializer<'de> {
320    type Error = SimpleError;
321
322    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
323    where
324        T: DeserializeSeed<'de>,
325    {
326        if let Some(Ok(len)) = self.consuming
327            && len == 0
328        {
329            return Ok(None);
330        }
331
332        if self.start >= self.input.len() {
333            return Ok(None);
334        }
335
336        // prevent deserialize_any from deserializing sequences
337        let val = self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?;
338
339        if let Some(Ok(ref mut len)) = self.consuming {
340            *len -= 1;
341        }
342
343        Ok(Some(val))
344    }
345}
346
347impl<'de> MapAccess<'de> for &mut SimpleDeserializer<'de> {
348    type Error = SimpleError;
349
350    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
351    where
352        K: DeserializeSeed<'de>,
353    {
354        if self.start >= self.input.len() {
355            return Ok(None);
356        }
357
358        let key = if let Some(Err(fields)) = self.consuming {
359            let key = &self.input[self.start];
360            if !fields.contains(&key.as_str()) {
361                return Ok(None);
362            } else {
363                self.start += 1;
364                seed.deserialize(key.clone().into_deserializer())?
365            }
366        } else {
367            self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?
368        };
369
370        Ok(Some(key))
371    }
372
373    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
374    where
375        V: DeserializeSeed<'de>,
376    {
377        let val = self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?;
378        Ok(val)
379    }
380}
381
382impl<'de> EnumAccess<'de> for &mut SimpleDeserializer<'de> {
383    type Error = SimpleError;
384    type Variant = Self;
385
386    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
387    where
388        V: DeserializeSeed<'de>,
389    {
390        let val = self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?;
391        Ok((val, self))
392    }
393}
394
395impl<'de> VariantAccess<'de> for &mut SimpleDeserializer<'de> {
396    type Error = SimpleError;
397
398    fn unit_variant(self) -> Result<(), Self::Error> {
399        Ok(())
400    }
401
402    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
403    where
404        T: DeserializeSeed<'de>,
405    {
406        self.with_sub(|s| seed.deserialize(s), None)
407    }
408
409    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
410    where
411        V: Visitor<'de>,
412    {
413        self.deserialize_tuple(len, visitor)
414    }
415
416    fn struct_variant<V>(
417        self,
418        fields: &'static [&'static str],
419        visitor: V,
420    ) -> Result<V::Value, Self::Error>
421    where
422        V: Visitor<'de>,
423    {
424        self.deserialize_struct("", fields, visitor)
425    }
426}