archlinux_repo_parser/
de.rs

1use std::ops::{AddAssign, MulAssign, Neg};
2
3use serde::de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor};
4use serde::Deserialize;
5
6use crate::error::{Error, Result};
7use std::str::FromStr;
8
9pub struct Deserializer<'de> {
10    input: &'de str,
11}
12
13impl<'de> Deserializer<'de> {
14    #[allow(clippy::should_implement_trait)]
15    pub fn from_str(input: &'de str) -> Self {
16        Deserializer { input }
17    }
18}
19
20pub fn from_str<'a, T>(s: &'a str) -> Result<T>
21where
22    T: Deserialize<'a>,
23{
24    let mut de = Deserializer::from_str(s);
25    let mut deserializer = TopDeserializer::new(&mut de);
26    let t = T::deserialize(&mut deserializer)?;
27    if de.input.is_empty() {
28        Ok(t)
29    } else {
30        println!("{}", &de.input);
31        Err(Error::TrailingCharacters)
32    }
33}
34
35impl<'de> Deserializer<'de> {
36    fn parse_line(&mut self) -> Result<&'de str> {
37        match self.input.find('\n') {
38            Some(len) => {
39                let s = &self.input[..len];
40                self.input = &self.input[len + 1..];
41                Ok(s)
42            }
43            None => {
44                if self.input.is_empty() {
45                    Err(Error::Eof)
46                } else {
47                    let s = self.input;
48                    self.input = "";
49                    Ok(s)
50                }
51            }
52        }
53    }
54
55    fn peek_delimiter(&mut self) -> bool {
56        match self.input.find('\n') {
57            Some(len) => len == 0,
58            None => self.input.is_empty(),
59        }
60    }
61
62    fn parse_field_name(&mut self) -> Result<&'de str> {
63        let line = self.parse_line()?;
64        if line.starts_with('%') && line.ends_with('%') {
65            Ok(&line[1..line.len() - 1])
66        } else {
67            Err(Error::FieldNameUnexpectedWrapper(String::from(line)))
68        }
69    }
70
71    fn parse_string(&mut self) -> Result<&'de str> {
72        let line = self.parse_line()?;
73        if line.is_empty() {
74            Err(Error::DelimiterNotExpected)
75        } else {
76            Ok(line)
77        }
78    }
79
80    fn parse_char(&mut self) -> Result<char> {
81        let line = self.parse_line()?;
82        if line.is_empty() {
83            Err(Error::DelimiterNotExpected)
84        } else if line.len() != 1 {
85            Err(Error::CharOverflow)
86        } else {
87            Ok(line.chars().next().unwrap())
88        }
89    }
90
91    fn parse_delimiter(&mut self) -> Result<()> {
92        match self.input.find('\n') {
93            Some(len) => {
94                let s = &self.input[..len];
95                self.input = &self.input[len + 1..];
96                if s.is_empty() {
97                    Ok(())
98                } else {
99                    Err(Error::DelimiterExpected)
100                }
101            }
102            None => Ok(()),
103        }
104    }
105
106    fn parse_unsigned<T>(&mut self) -> Result<T>
107    where
108        T: AddAssign<T> + MulAssign<T> + FromStr,
109    {
110        let line = self.parse_line()?;
111        match line.parse() {
112            Ok(n) => Ok(n),
113            Err(_) => Err(Error::IntegerError),
114        }
115    }
116
117    fn parse_signed<T>(&mut self) -> Result<T>
118    where
119        T: Neg<Output = T> + AddAssign<T> + MulAssign<T> + FromStr,
120    {
121        let line = self.parse_line()?;
122        match line.parse() {
123            Ok(n) => Ok(n),
124            Err(_) => Err(Error::IntegerError),
125        }
126    }
127}
128
129impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
130    type Error = Error;
131
132    fn deserialize_any<V>(self, _: V) -> Result<V::Value>
133    where
134        V: Visitor<'de>,
135    {
136        Err(Error::NotSupported)
137    }
138
139    fn deserialize_bool<V>(self, _: V) -> Result<V::Value>
140    where
141        V: Visitor<'de>,
142    {
143        Err(Error::NotSupported)
144    }
145
146    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
147    where
148        V: Visitor<'de>,
149    {
150        visitor.visit_i8(self.parse_signed()?)
151    }
152
153    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
154    where
155        V: Visitor<'de>,
156    {
157        visitor.visit_i16(self.parse_signed()?)
158    }
159
160    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
161    where
162        V: Visitor<'de>,
163    {
164        visitor.visit_i32(self.parse_signed()?)
165    }
166
167    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
168    where
169        V: Visitor<'de>,
170    {
171        visitor.visit_i64(self.parse_signed()?)
172    }
173
174    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
175    where
176        V: Visitor<'de>,
177    {
178        visitor.visit_u8(self.parse_unsigned()?)
179    }
180
181    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
182    where
183        V: Visitor<'de>,
184    {
185        visitor.visit_u16(self.parse_unsigned()?)
186    }
187
188    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
189    where
190        V: Visitor<'de>,
191    {
192        visitor.visit_u32(self.parse_unsigned()?)
193    }
194
195    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
196    where
197        V: Visitor<'de>,
198    {
199        visitor.visit_u64(self.parse_unsigned()?)
200    }
201
202    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
203    where
204        V: Visitor<'de>,
205    {
206        Err(Error::NotSupported)
207    }
208
209    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
210    where
211        V: Visitor<'de>,
212    {
213        Err(Error::NotSupported)
214    }
215
216    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
217    where
218        V: Visitor<'de>,
219    {
220        visitor.visit_char(self.parse_char()?)
221    }
222
223    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
224    where
225        V: Visitor<'de>,
226    {
227        visitor.visit_borrowed_str(self.parse_string()?)
228    }
229
230    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
231    where
232        V: Visitor<'de>,
233    {
234        self.deserialize_str(visitor)
235    }
236
237    // The `Serializer` implementation on the previous page serialized byte
238    // arrays as JSON arrays of bytes. Handle that representation here.
239    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
240    where
241        V: Visitor<'de>,
242    {
243        Err(Error::NotSupported)
244    }
245
246    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>
247    where
248        V: Visitor<'de>,
249    {
250        Err(Error::NotSupported)
251    }
252
253    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
254    where
255        V: Visitor<'de>,
256    {
257        if self.peek_delimiter() {
258            self.parse_delimiter()?;
259            visitor.visit_none()
260        } else {
261            visitor.visit_some(self)
262        }
263    }
264
265    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
266    where
267        V: Visitor<'de>,
268    {
269        if self.peek_delimiter() {
270            self.parse_delimiter()?;
271            visitor.visit_unit()
272        } else {
273            Err(Error::DelimiterExpected)
274        }
275    }
276
277    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
278    where
279        V: Visitor<'de>,
280    {
281        self.deserialize_unit(visitor)
282    }
283
284    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
285    where
286        V: Visitor<'de>,
287    {
288        visitor.visit_newtype_struct(self)
289    }
290
291    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
292    where
293        V: Visitor<'de>,
294    {
295        let value = visitor.visit_seq(NewlineSeparated::new(&mut self))?;
296        Ok(value)
297    }
298
299    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
300    where
301        V: Visitor<'de>,
302    {
303        self.deserialize_seq(visitor)
304    }
305
306    fn deserialize_tuple_struct<V>(
307        self,
308        _name: &'static str,
309        _len: usize,
310        visitor: V,
311    ) -> Result<V::Value>
312    where
313        V: Visitor<'de>,
314    {
315        self.deserialize_seq(visitor)
316    }
317
318    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
319    where
320        V: Visitor<'de>,
321    {
322        let value = visitor.visit_map(NewlineSeparated::new(&mut self))?;
323        Ok(value)
324    }
325
326    fn deserialize_struct<V>(
327        self,
328        _name: &'static str,
329        _fields: &'static [&'static str],
330        visitor: V,
331    ) -> Result<V::Value>
332    where
333        V: Visitor<'de>,
334    {
335        self.deserialize_map(visitor)
336    }
337
338    fn deserialize_enum<V>(
339        self,
340        _name: &'static str,
341        _variants: &'static [&'static str],
342        _visitor: V,
343    ) -> Result<V::Value>
344    where
345        V: Visitor<'de>,
346    {
347        // _visitor.visit_enum(self.parse_string()?.into_deserializer())
348        Err(Error::NotSupported)
349    }
350
351    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
352    where
353        V: Visitor<'de>,
354    {
355        visitor.visit_borrowed_str(self.parse_field_name()?)
356    }
357
358    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
359    where
360        V: Visitor<'de>,
361    {
362        self.deserialize_any(visitor)
363    }
364}
365
366struct TopDeserializer<'a, 'de: 'a> {
367    de: &'a mut Deserializer<'de>,
368}
369
370impl<'a, 'de> TopDeserializer<'a, 'de> {
371    fn new(de: &'a mut Deserializer<'de>) -> Self {
372        TopDeserializer { de }
373    }
374}
375
376impl<'de, 'a> de::Deserializer<'de> for &'a mut TopDeserializer<'a, 'de> {
377    type Error = Error;
378
379    fn deserialize_any<V>(self, _: V) -> Result<<V as Visitor<'de>>::Value>
380    where
381        V: Visitor<'de>,
382    {
383        Err(Error::NotSupported)
384    }
385
386    fn deserialize_bool<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
387    where
388        V: Visitor<'de>,
389    {
390        Err(Error::StructExpected)
391    }
392
393    fn deserialize_i8<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
394    where
395        V: Visitor<'de>,
396    {
397        Err(Error::StructExpected)
398    }
399
400    fn deserialize_i16<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
401    where
402        V: Visitor<'de>,
403    {
404        Err(Error::StructExpected)
405    }
406
407    fn deserialize_i32<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
408    where
409        V: Visitor<'de>,
410    {
411        Err(Error::StructExpected)
412    }
413
414    fn deserialize_i64<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
415    where
416        V: Visitor<'de>,
417    {
418        Err(Error::StructExpected)
419    }
420
421    fn deserialize_u8<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
422    where
423        V: Visitor<'de>,
424    {
425        Err(Error::StructExpected)
426    }
427
428    fn deserialize_u16<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
429    where
430        V: Visitor<'de>,
431    {
432        Err(Error::StructExpected)
433    }
434
435    fn deserialize_u32<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
436    where
437        V: Visitor<'de>,
438    {
439        Err(Error::StructExpected)
440    }
441
442    fn deserialize_u64<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
443    where
444        V: Visitor<'de>,
445    {
446        Err(Error::StructExpected)
447    }
448
449    fn deserialize_f32<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
450    where
451        V: Visitor<'de>,
452    {
453        Err(Error::StructExpected)
454    }
455
456    fn deserialize_f64<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
457    where
458        V: Visitor<'de>,
459    {
460        Err(Error::StructExpected)
461    }
462
463    fn deserialize_char<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
464    where
465        V: Visitor<'de>,
466    {
467        Err(Error::StructExpected)
468    }
469
470    fn deserialize_str<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
471    where
472        V: Visitor<'de>,
473    {
474        Err(Error::StructExpected)
475    }
476
477    fn deserialize_string<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
478    where
479        V: Visitor<'de>,
480    {
481        Err(Error::StructExpected)
482    }
483
484    fn deserialize_bytes<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
485    where
486        V: Visitor<'de>,
487    {
488        Err(Error::StructExpected)
489    }
490
491    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
492    where
493        V: Visitor<'de>,
494    {
495        Err(Error::StructExpected)
496    }
497
498    fn deserialize_option<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
499    where
500        V: Visitor<'de>,
501    {
502        Err(Error::StructExpected)
503    }
504
505    fn deserialize_unit<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
506    where
507        V: Visitor<'de>,
508    {
509        Err(Error::StructExpected)
510    }
511
512    fn deserialize_unit_struct<V>(
513        self,
514        _name: &'static str,
515        _visitor: V,
516    ) -> Result<<V as Visitor<'de>>::Value>
517    where
518        V: Visitor<'de>,
519    {
520        Err(Error::StructExpected)
521    }
522
523    fn deserialize_newtype_struct<V>(
524        self,
525        _name: &'static str,
526        _visitor: V,
527    ) -> Result<<V as Visitor<'de>>::Value>
528    where
529        V: Visitor<'de>,
530    {
531        Err(Error::StructExpected)
532    }
533
534    fn deserialize_seq<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
535    where
536        V: Visitor<'de>,
537    {
538        Err(Error::StructExpected)
539    }
540
541    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
542    where
543        V: Visitor<'de>,
544    {
545        Err(Error::StructExpected)
546    }
547
548    fn deserialize_tuple_struct<V>(
549        self,
550        _name: &'static str,
551        _len: usize,
552        _visitor: V,
553    ) -> Result<<V as Visitor<'de>>::Value>
554    where
555        V: Visitor<'de>,
556    {
557        Err(Error::StructExpected)
558    }
559
560    fn deserialize_map<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
561    where
562        V: Visitor<'de>,
563    {
564        self.de.deserialize_map(visitor)
565    }
566
567    fn deserialize_struct<V>(
568        self,
569        name: &'static str,
570        fields: &'static [&'static str],
571        visitor: V,
572    ) -> Result<<V as Visitor<'de>>::Value>
573    where
574        V: Visitor<'de>,
575    {
576        self.de.deserialize_struct(name, fields, visitor)
577    }
578
579    fn deserialize_enum<V>(
580        self,
581        _name: &'static str,
582        _variants: &'static [&'static str],
583        _visitor: V,
584    ) -> Result<<V as Visitor<'de>>::Value>
585    where
586        V: Visitor<'de>,
587    {
588        Err(Error::StructExpected)
589    }
590
591    fn deserialize_identifier<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
592    where
593        V: Visitor<'de>,
594    {
595        Err(Error::StructExpected)
596    }
597
598    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<<V as Visitor<'de>>::Value>
599    where
600        V: Visitor<'de>,
601    {
602        Err(Error::NotSupported)
603    }
604}
605
606struct ValueDeserializer<'a, 'de: 'a> {
607    de: &'a mut Deserializer<'de>,
608    allow_arrays: bool,
609}
610
611impl<'a, 'de> ValueDeserializer<'a, 'de> {
612    fn new(de: &'a mut Deserializer<'de>, allow_arrays: bool) -> Self {
613        ValueDeserializer { de, allow_arrays }
614    }
615}
616
617impl<'de, 'a> de::Deserializer<'de> for &'a mut ValueDeserializer<'a, 'de> {
618    type Error = Error;
619
620    fn deserialize_any<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
621    where
622        V: Visitor<'de>,
623    {
624        self.de.deserialize_any(visitor)
625    }
626
627    fn deserialize_bool<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
628    where
629        V: Visitor<'de>,
630    {
631        self.de.deserialize_bool(visitor)
632    }
633
634    fn deserialize_i8<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
635    where
636        V: Visitor<'de>,
637    {
638        self.de.deserialize_i8(visitor)
639    }
640
641    fn deserialize_i16<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
642    where
643        V: Visitor<'de>,
644    {
645        self.de.deserialize_i16(visitor)
646    }
647
648    fn deserialize_i32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
649    where
650        V: Visitor<'de>,
651    {
652        self.de.deserialize_i32(visitor)
653    }
654
655    fn deserialize_i64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
656    where
657        V: Visitor<'de>,
658    {
659        self.de.deserialize_i64(visitor)
660    }
661
662    fn deserialize_u8<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
663    where
664        V: Visitor<'de>,
665    {
666        self.de.deserialize_u8(visitor)
667    }
668
669    fn deserialize_u16<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
670    where
671        V: Visitor<'de>,
672    {
673        self.de.deserialize_u16(visitor)
674    }
675
676    fn deserialize_u32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
677    where
678        V: Visitor<'de>,
679    {
680        self.de.deserialize_u32(visitor)
681    }
682
683    fn deserialize_u64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
684    where
685        V: Visitor<'de>,
686    {
687        self.de.deserialize_u64(visitor)
688    }
689
690    fn deserialize_f32<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
691    where
692        V: Visitor<'de>,
693    {
694        self.de.deserialize_f32(visitor)
695    }
696
697    fn deserialize_f64<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
698    where
699        V: Visitor<'de>,
700    {
701        self.de.deserialize_f64(visitor)
702    }
703
704    fn deserialize_char<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
705    where
706        V: Visitor<'de>,
707    {
708        self.de.deserialize_char(visitor)
709    }
710
711    fn deserialize_str<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
712    where
713        V: Visitor<'de>,
714    {
715        self.de.deserialize_str(visitor)
716    }
717
718    fn deserialize_string<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
719    where
720        V: Visitor<'de>,
721    {
722        self.de.deserialize_string(visitor)
723    }
724
725    fn deserialize_bytes<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
726    where
727        V: Visitor<'de>,
728    {
729        self.de.deserialize_bytes(visitor)
730    }
731
732    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
733    where
734        V: Visitor<'de>,
735    {
736        self.de.deserialize_byte_buf(visitor)
737    }
738
739    fn deserialize_option<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
740    where
741        V: Visitor<'de>,
742    {
743        self.de.deserialize_option(visitor)
744    }
745
746    fn deserialize_unit<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
747    where
748        V: Visitor<'de>,
749    {
750        self.de.deserialize_unit(visitor)
751    }
752
753    fn deserialize_unit_struct<V>(
754        self,
755        name: &'static str,
756        visitor: V,
757    ) -> Result<<V as Visitor<'de>>::Value>
758    where
759        V: Visitor<'de>,
760    {
761        self.de.deserialize_unit_struct(name, visitor)
762    }
763
764    fn deserialize_newtype_struct<V>(
765        self,
766        name: &'static str,
767        visitor: V,
768    ) -> Result<<V as Visitor<'de>>::Value>
769    where
770        V: Visitor<'de>,
771    {
772        self.de.deserialize_newtype_struct(name, visitor)
773    }
774
775    fn deserialize_seq<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
776    where
777        V: Visitor<'de>,
778    {
779        if self.allow_arrays {
780            self.de.deserialize_seq(visitor)
781        } else {
782            Err(Error::NotSupported)
783        }
784    }
785
786    fn deserialize_tuple<V>(self, size: usize, visitor: V) -> Result<<V as Visitor<'de>>::Value>
787    where
788        V: Visitor<'de>,
789    {
790        if self.allow_arrays {
791            self.de.deserialize_tuple(size, visitor)
792        } else {
793            Err(Error::NotSupported)
794        }
795    }
796
797    fn deserialize_tuple_struct<V>(
798        self,
799        name: &'static str,
800        size: usize,
801        visitor: V,
802    ) -> Result<<V as Visitor<'de>>::Value>
803    where
804        V: Visitor<'de>,
805    {
806        if self.allow_arrays {
807            self.de.deserialize_tuple_struct(name, size, visitor)
808        } else {
809            Err(Error::NotSupported)
810        }
811    }
812
813    fn deserialize_map<V>(self, _: V) -> Result<<V as Visitor<'de>>::Value>
814    where
815        V: Visitor<'de>,
816    {
817        Err(Error::NotSupported)
818    }
819
820    fn deserialize_struct<V>(
821        self,
822        _: &'static str,
823        _: &'static [&'static str],
824        _: V,
825    ) -> Result<<V as Visitor<'de>>::Value>
826    where
827        V: Visitor<'de>,
828    {
829        Err(Error::NotSupported)
830    }
831
832    fn deserialize_enum<V>(
833        self,
834        _: &'static str,
835        _: &'static [&'static str],
836        _: V,
837    ) -> Result<<V as Visitor<'de>>::Value>
838    where
839        V: Visitor<'de>,
840    {
841        Err(Error::NotSupported)
842    }
843
844    fn deserialize_identifier<V>(self, _: V) -> Result<<V as Visitor<'de>>::Value>
845    where
846        V: Visitor<'de>,
847    {
848        Err(Error::NotSupported)
849    }
850
851    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<<V as Visitor<'de>>::Value>
852    where
853        V: Visitor<'de>,
854    {
855        self.de.deserialize_ignored_any(visitor)
856    }
857}
858
859struct NewlineSeparated<'a, 'de: 'a> {
860    de: &'a mut Deserializer<'de>,
861}
862
863impl<'a, 'de> NewlineSeparated<'a, 'de> {
864    fn new(de: &'a mut Deserializer<'de>) -> Self {
865        NewlineSeparated { de }
866    }
867}
868
869impl<'de, 'a> SeqAccess<'de> for NewlineSeparated<'a, 'de> {
870    type Error = Error;
871
872    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
873    where
874        T: DeserializeSeed<'de>,
875    {
876        if self.de.peek_delimiter() {
877            return Ok(None);
878        }
879        let mut deserializer = ValueDeserializer::new(self.de, false);
880        seed.deserialize(&mut deserializer).map(Some)
881    }
882}
883
884impl<'de, 'a> MapAccess<'de> for NewlineSeparated<'a, 'de> {
885    type Error = Error;
886
887    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
888    where
889        K: DeserializeSeed<'de>,
890    {
891        if self.de.peek_delimiter() {
892            return Ok(None);
893        }
894        seed.deserialize(&mut *self.de).map(Some)
895    }
896
897    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
898    where
899        V: DeserializeSeed<'de>,
900    {
901        let mut deserializer = ValueDeserializer::new(self.de, true);
902        let result = seed.deserialize(&mut deserializer)?;
903        self.de.parse_delimiter()?;
904        Ok(result)
905    }
906}
907
908// struct Enum<'a, 'de: 'a> {
909//     de: &'a mut Deserializer<'de>,
910// }
911//
912// impl<'a, 'de> Enum<'a, 'de> {
913//     fn new(de: &'a mut Deserializer<'de>) -> Self {
914//         Enum { de }
915//     }
916// }
917//
918// // `EnumAccess` is provided to the `Visitor` to give it the ability to determine
919// // which variant of the enum is supposed to be deserialized.
920// //
921// // Note that all enum deserialization methods in Serde refer exclusively to the
922// // "externally tagged" enum representation.
923// impl<'de, 'a> EnumAccess<'de> for Enum<'a, 'de> {
924//     type Error = Error;
925//     type Variant = Self;
926//
927//     fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
928//         where
929//             V: DeserializeSeed<'de>,
930//     {
931//         // The `deserialize_enum` method parsed a `{` character so we are
932//         // currently inside of a map. The seed will be deserializing itself from
933//         // the key of the map.
934//         let val = seed.deserialize(&mut *self.de)?;
935//         // Parse the colon separating map key from value.
936//         if self.de.next_char()? == ':' {
937//             Ok((val, self))
938//         } else {
939//             Err(Error::ExpectedMapColon)
940//         }
941//     }
942// }
943//
944// // `VariantAccess` is provided to the `Visitor` to give it the ability to see
945// // the content of the single variant that it decided to deserialize.
946// impl<'de, 'a> VariantAccess<'de> for Enum<'a, 'de> {
947//     type Error = Error;
948//
949//     // If the `Visitor` expected this variant to be a unit variant, the input
950//     // should have been the plain string case handled in `deserialize_enum`.
951//     fn unit_variant(self) -> Result<()> {
952//         Err(Error::ExpectedString)
953//     }
954//
955//     // Newtype variants are represented in JSON as `{ NAME: VALUE }` so
956//     // deserialize the value here.
957//     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
958//         where
959//             T: DeserializeSeed<'de>,
960//     {
961//         seed.deserialize(self.de)
962//     }
963//
964//     // Tuple variants are represented in JSON as `{ NAME: [DATA...] }` so
965//     // deserialize the sequence of data here.
966//     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
967//         where
968//             V: Visitor<'de>,
969//     {
970//         de::Deserializer::deserialize_seq(self.de, visitor)
971//     }
972//
973//     // Struct variants are represented in JSON as `{ NAME: { K: V, ... } }` so
974//     // deserialize the inner map here.
975//     fn struct_variant<V>(
976//         self,
977//         _fields: &'static [&'static str],
978//         visitor: V,
979//     ) -> Result<V::Value>
980//         where
981//             V: Visitor<'de>,
982//     {
983//         de::Deserializer::deserialize_map(self.de, visitor)
984//     }
985// }
986
987#[cfg(test)]
988mod test {
989    use serde::Deserialize;
990
991    #[test]
992    fn test_struct() {
993        #[derive(Deserialize, PartialEq, Debug)]
994        struct Test {
995            #[serde(rename = "NAME")]
996            name: String,
997            #[serde(rename = "DEPENDS")]
998            depends: Vec<String>,
999            #[serde(rename = "BUILDDATE")]
1000            build_date: u32,
1001        }
1002
1003        let j = r#"%NAME%
1004mingw-w64-x86_64-vcdimager
1005
1006%BUILDDATE%
10071592300880
1008
1009%DEPENDS%
1010mingw-w64-x86_64-libcdio
1011mingw-w64-x86_64-libxml2
1012mingw-w64-x86_64-popt"#;
1013        let expected = Test {
1014            build_date: 1592300880,
1015            depends: vec![
1016                "mingw-w64-x86_64-libcdio".to_owned(),
1017                "mingw-w64-x86_64-libxml2".to_owned(),
1018                "mingw-w64-x86_64-popt".to_owned(),
1019            ],
1020            name: "mingw-w64-x86_64-vcdimager".to_owned(),
1021        };
1022        assert_eq!(expected, crate::from_str(j).unwrap());
1023    }
1024}
archlinux_repo_parser/de.rs

archlinux_repo_parser/
de.rs
