anyseq 0.2.0

Automatically generate serde Deserializer from separated values.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::de::{self, Deserializer};
use crate::{Lexer, Token};

pub struct TokenIter;

impl<I, O> Lexer<I, Token<O>> for TokenIter
where
    I: Iterator<Item = Token<O>>,
{
    type Error = ();

    fn item(input: &mut I) -> Result<Token<O>, Self::Error> {
        match input.next() {
            Some(item) => Ok(item),
            None => Ok(Token::Eof),
        }
    }
}

pub fn from_iter<'de, T, I>(
    iter: I,
) -> Result<T, de::Error<<TokenIter as Lexer<I, Token<&'de str>>>::Error>>
where
    I: Iterator<Item = Token<&'de str>>,
    T: serde::Deserialize<'de>,
{
    let mut de = Deserializer::<TokenIter, _, _>::new(iter);
    T::deserialize(&mut de)
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde::Deserialize;

    #[test]
    fn test_seq_access() {
        let tokens = vec![
            Token::SeqStart { len: None },
            Token::Item("1"),
            Token::Item("2"),
            Token::Item("3"),
            Token::SeqEnd,
        ];
        assert_eq!(
            from_iter::<Vec<i8>, _>(tokens.into_iter()).unwrap(),
            vec![1, 2, 3]
        );
    }

    #[test]
    fn test_struct() {
        #[derive(Deserialize, Debug, PartialEq)]
        struct Test {
            name: String,
            age: u32,
        }

        let tokens = vec![
            Token::MapStart { len: None },
            Token::Item("age"),
            Token::Item("21"),
            Token::Item("name"),
            Token::Item("John"),
            Token::MapEnd,
        ];
        assert_eq!(
            from_iter::<Test, _>(tokens.into_iter()).unwrap(),
            Test {
                name: "John".to_string(),
                age: 21
            }
        );

        let tokens = vec![
            Token::SeqStart { len: None },
            Token::MapStart { len: None },
            Token::Item("name"),
            Token::Item("John"),
            Token::Item("age"),
            Token::Item("21"),
            Token::MapEnd,
            Token::MapStart { len: None },
            Token::Item("name"),
            Token::Item("Jane"),
            Token::Item("age"),
            Token::Item("31"),
            Token::MapEnd,
            Token::SeqEnd,
        ];

        assert_eq!(
            from_iter::<Vec<Test>, _>(tokens.into_iter()).unwrap(),
            vec![
                Test {
                    name: "John".to_string(),
                    age: 21
                },
                Test {
                    name: "Jane".to_string(),
                    age: 31
                }
            ]
        );
    }
}