better_vdf/
de.rs

1use std::str::FromStr;
2
3use serde::{
4    de::{MapAccess, SeqAccess},
5    Deserialize,
6};
7
8use crate::error::{Error, Result};
9
10pub struct Deserializer<'de> {
11    original: &'de str,
12    input: &'de str,
13}
14
15impl<'de> Deserializer<'de> {
16    pub fn from_str(input: &'de str) -> Self {
17        Deserializer {
18            original: input,
19            input,
20        }
21    }
22}
23
24pub fn from_str<'a, T>(s: &'a str) -> Result<T>
25where
26    T: Deserialize<'a>,
27{
28    let mut deserializer = Deserializer::from_str(s);
29    let t = T::deserialize(&mut deserializer)?;
30    if deserializer
31        .input
32        .chars()
33        .filter(|&x| x != '\t' && x != '\n' && x != '\r')
34        .count()
35        == 0
36    {
37        Ok(t)
38    } else {
39        Err(Error::TrailingCharacters)
40    }
41}
42
43impl<'de> Deserializer<'de> {
44    fn peek_char(&self) -> Result<char> {
45        self.input
46            .chars()
47            .next()
48            .ok_or(Error::Eof)
49            .or_else(|x| panic!("{x:?}"))
50    }
51
52    fn next_char(&mut self) -> Result<char> {
53        let ch = self.peek_char()?;
54        self.input = &self.input[ch.len_utf8()..];
55        Ok(ch)
56    }
57
58    fn peek_real_char(&self) -> Result<char> {
59        self.input
60            .chars()
61            .find(|&x| x != '\t' && x != '\n' && x != '\r')
62            .ok_or(Error::Eof)
63        // .or_else(|x| panic!("{x:?}"))
64    }
65
66    fn next_real_char(&mut self) -> Result<char> {
67        let mut ch = self.next_char()?;
68
69        while ch == '\t' || ch == '\n' || ch == '\r' {
70            ch = self.next_char()?;
71        }
72
73        Ok(ch)
74    }
75
76    fn parse_string(&mut self) -> Result<&'de str> {
77        if self.next_real_char()? != '"' {
78            return Err(Error::ExpectedString);
79        }
80        match self.input.find('"') {
81            Some(len) => {
82                let s = &self.input[..len];
83                self.input = &self.input[len + 1..];
84                Ok(s)
85            }
86            None => {
87                // Err(Error::Eof)
88                panic!("{:?}", Error::Eof)
89            }
90        }
91    }
92
93    fn parse_bool(&mut self) -> Result<bool> {
94        let str = self.parse_string()?;
95
96        match str {
97            "1" => Ok(true),
98            "0" => Ok(false),
99            _ => Err(Error::ExpectedBoolean),
100        }
101    }
102
103    fn parse_value<T>(&mut self) -> Result<T>
104    where
105        T: FromStr,
106    {
107        let str = self.parse_string()?;
108
109        str.parse::<T>().map_err(|_| Error::ExpectedInteger)
110    }
111}
112
113impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut Deserializer<'de> {
114    type Error = Error;
115
116    fn deserialize_any<V>(self, _visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
117    where
118        V: serde::de::Visitor<'de>,
119    {
120        Err(Error::NonSelfDescribing)
121    }
122
123    fn deserialize_bool<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
124    where
125        V: serde::de::Visitor<'de>,
126    {
127        visitor.visit_bool(self.parse_bool()?)
128    }
129
130    fn deserialize_i8<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
131    where
132        V: serde::de::Visitor<'de>,
133    {
134        visitor.visit_i8(self.parse_value()?)
135    }
136
137    fn deserialize_i16<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
138    where
139        V: serde::de::Visitor<'de>,
140    {
141        visitor.visit_i16(self.parse_value()?)
142    }
143
144    fn deserialize_i32<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
145    where
146        V: serde::de::Visitor<'de>,
147    {
148        visitor.visit_i32(self.parse_value()?)
149    }
150
151    fn deserialize_i64<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
152    where
153        V: serde::de::Visitor<'de>,
154    {
155        visitor.visit_i64(self.parse_value()?)
156    }
157
158    fn deserialize_u8<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
159    where
160        V: serde::de::Visitor<'de>,
161    {
162        visitor.visit_u8(self.parse_value()?)
163    }
164
165    fn deserialize_u16<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
166    where
167        V: serde::de::Visitor<'de>,
168    {
169        visitor.visit_u16(self.parse_value()?)
170    }
171
172    fn deserialize_u32<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
173    where
174        V: serde::de::Visitor<'de>,
175    {
176        visitor.visit_u32(self.parse_value()?)
177    }
178
179    fn deserialize_u64<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
180    where
181        V: serde::de::Visitor<'de>,
182    {
183        visitor.visit_u64(self.parse_value()?)
184    }
185
186    fn deserialize_f32<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
187    where
188        V: serde::de::Visitor<'de>,
189    {
190        visitor.visit_f32(self.parse_value()?)
191    }
192
193    fn deserialize_f64<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
194    where
195        V: serde::de::Visitor<'de>,
196    {
197        visitor.visit_f32(self.parse_value()?)
198    }
199
200    fn deserialize_char<V>(self, _visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
201    where
202        V: serde::de::Visitor<'de>,
203    {
204        Err(Error::UnsupportedType)
205    }
206
207    fn deserialize_str<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
208    where
209        V: serde::de::Visitor<'de>,
210    {
211        visitor.visit_borrowed_str(self.parse_string()?)
212    }
213
214    fn deserialize_string<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
215    where
216        V: serde::de::Visitor<'de>,
217    {
218        self.deserialize_str(visitor)
219    }
220
221    fn deserialize_bytes<V>(self, _visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
222    where
223        V: serde::de::Visitor<'de>,
224    {
225        Err(Error::UnsupportedType)
226    }
227
228    fn deserialize_byte_buf<V>(self, _visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
229    where
230        V: serde::de::Visitor<'de>,
231    {
232        Err(Error::UnsupportedType)
233    }
234
235    fn deserialize_option<V>(self, _visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
236    where
237        V: serde::de::Visitor<'de>,
238    {
239        Err(Error::UnsupportedType)
240    }
241
242    fn deserialize_unit<V>(self, _visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
243    where
244        V: serde::de::Visitor<'de>,
245    {
246        Err(Error::UnsupportedType)
247    }
248
249    fn deserialize_unit_struct<V>(
250        self,
251        _name: &'static str,
252        _visitor: V,
253    ) -> std::prelude::v1::Result<V::Value, Self::Error>
254    where
255        V: serde::de::Visitor<'de>,
256    {
257        Err(Error::UnsupportedType)
258    }
259
260    fn deserialize_newtype_struct<V>(
261        self,
262        _name: &'static str,
263        visitor: V,
264    ) -> std::prelude::v1::Result<V::Value, Self::Error>
265    where
266        V: serde::de::Visitor<'de>,
267    {
268        visitor.visit_newtype_struct(self)
269    }
270
271    fn deserialize_seq<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
272    where
273        V: serde::de::Visitor<'de>,
274    {
275        if self.next_real_char()? == '{' {
276            let value = visitor.visit_seq(VdfSeq::new(self))?;
277
278            if self.next_real_char()? == '}' {
279                Ok(value)
280            } else {
281                Err(Error::ExpectedArrayEnd)
282            }
283        } else {
284            Err(Error::ExpectedArray)
285        }
286    }
287
288    fn deserialize_tuple<V>(
289        self,
290        _len: usize,
291        visitor: V,
292    ) -> std::prelude::v1::Result<V::Value, Self::Error>
293    where
294        V: serde::de::Visitor<'de>,
295    {
296        self.deserialize_seq(visitor)
297    }
298
299    fn deserialize_tuple_struct<V>(
300        self,
301        _name: &'static str,
302        _len: usize,
303        visitor: V,
304    ) -> std::prelude::v1::Result<V::Value, Self::Error>
305    where
306        V: serde::de::Visitor<'de>,
307    {
308        self.deserialize_seq(visitor)
309    }
310
311    fn deserialize_map<V>(self, visitor: V) -> std::prelude::v1::Result<V::Value, Self::Error>
312    where
313        V: serde::de::Visitor<'de>,
314    {
315        let begin = self.original.as_ptr() == self.input.as_ptr();
316
317        if begin || self.next_real_char()? == '{' {
318            let value = visitor.visit_map(VdfMap::new(self))?;
319
320            if begin || self.next_real_char()? == '}' {
321                Ok(value)
322            } else {
323                Err(Error::ExpectedMapEnd)
324            }
325        } else {
326            Err(Error::ExpectedMap)
327        }
328    }
329
330    fn deserialize_struct<V>(
331        self,
332        _name: &'static str,
333        _fields: &'static [&'static str],
334        visitor: V,
335    ) -> std::prelude::v1::Result<V::Value, Self::Error>
336    where
337        V: serde::de::Visitor<'de>,
338    {
339        self.deserialize_map(visitor)
340    }
341
342    fn deserialize_enum<V>(
343        self,
344        _name: &'static str,
345        _variants: &'static [&'static str],
346        _visitor: V,
347    ) -> std::prelude::v1::Result<V::Value, Self::Error>
348    where
349        V: serde::de::Visitor<'de>,
350    {
351        Err(Error::UnsupportedType)
352    }
353
354    fn deserialize_identifier<V>(
355        self,
356        visitor: V,
357    ) -> std::prelude::v1::Result<V::Value, Self::Error>
358    where
359        V: serde::de::Visitor<'de>,
360    {
361        self.deserialize_str(visitor)
362    }
363
364    fn deserialize_ignored_any<V>(
365        self,
366        visitor: V,
367    ) -> std::prelude::v1::Result<V::Value, Self::Error>
368    where
369        V: serde::de::Visitor<'de>,
370    {
371        self.deserialize_any(visitor)
372    }
373}
374
375struct VdfSeq<'a, 'de: 'a> {
376    de: &'a mut Deserializer<'de>,
377    index: usize,
378}
379
380impl<'a, 'de> VdfSeq<'a, 'de> {
381    fn new(de: &'a mut Deserializer<'de>) -> Self {
382        VdfSeq { de, index: 0 }
383    }
384}
385
386impl<'de, 'a> SeqAccess<'de> for VdfSeq<'a, 'de> {
387    type Error = Error;
388
389    fn next_element_seed<T>(
390        &mut self,
391        seed: T,
392    ) -> std::prelude::v1::Result<Option<T::Value>, Self::Error>
393    where
394        T: serde::de::DeserializeSeed<'de>,
395    {
396        match self.de.peek_real_char()? {
397            '}' => Ok(None),
398            '"' => {
399                //
400                let ind: usize = self.de.parse_value()?;
401
402                if ind != self.index {
403                    println!("Expected index {}, found {ind}", self.index);
404                    return Err(Error::ArrayIndex);
405                }
406
407                self.index += 1;
408
409                seed.deserialize(&mut *self.de).map(Some)
410            }
411            _ => Err(Error::SeqSyntax),
412        }
413    }
414}
415
416struct VdfMap<'a, 'de: 'a> {
417    de: &'a mut Deserializer<'de>,
418    root: bool,
419    initialized: bool,
420}
421
422impl<'a, 'de> VdfMap<'a, 'de> {
423    fn new(de: &'a mut Deserializer<'de>) -> Self {
424        VdfMap {
425            root: de.input.as_ptr() == de.original.as_ptr(),
426            de,
427            initialized: false,
428        }
429    }
430}
431
432impl<'de, 'a> MapAccess<'de> for VdfMap<'a, 'de> {
433    type Error = Error;
434
435    fn next_key_seed<K>(
436        &mut self,
437        seed: K,
438    ) -> std::prelude::v1::Result<Option<K::Value>, Self::Error>
439    where
440        K: serde::de::DeserializeSeed<'de>,
441    {
442        let res = self.de.peek_real_char();
443
444        if self.root && self.initialized && res.is_err() || res? == '}' {
445            return Ok(None);
446        }
447
448        self.initialized = true;
449
450        seed.deserialize(&mut *self.de).map(Some)
451    }
452
453    fn next_value_seed<V>(&mut self, seed: V) -> std::prelude::v1::Result<V::Value, Self::Error>
454    where
455        V: serde::de::DeserializeSeed<'de>,
456    {
457        seed.deserialize(&mut *self.de)
458    }
459}
better_vdf/de.rs

better_vdf/
de.rs
