darklua 0.19.0

Transform Lua scripts
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

use std::{cmp, fmt, marker::PhantomData};

use serde::{
    de::{MapAccess, Visitor},
    Deserialize, Deserializer,
};

pub(crate) fn deserialize_vec_of_pairs<'de, D, K, V>(
    deserializer: D,
) -> Result<Vec<(K, V)>, D::Error>
where
    D: Deserializer<'de>,
    K: Deserialize<'de>,
    V: Deserialize<'de>,
{
    struct MapAsVecVisitor<K, V>(PhantomData<Vec<(K, V)>>);

    impl<K, V> MapAsVecVisitor<K, V> {
        fn new() -> Self {
            MapAsVecVisitor(PhantomData)
        }
    }

    impl<'de, K, V> Visitor<'de> for MapAsVecVisitor<K, V>
    where
        K: Deserialize<'de>,
        V: Deserialize<'de>,
    {
        type Value = Vec<(K, V)>;

        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str("a map")
        }

        #[inline]
        fn visit_unit<E>(self) -> Result<Vec<(K, V)>, E> {
            Ok(Vec::new())
        }

        #[inline]
        fn visit_map<T>(self, mut access: T) -> Result<Vec<(K, V)>, T::Error>
        where
            T: MapAccess<'de>,
        {
            let mut values = Vec::with_capacity(cmp::min(access.size_hint().unwrap_or(0), 4096));

            while let Some((key, value)) = access.next_entry()? {
                values.push((key, value));
            }

            Ok(values)
        }
    }

    let visitor = MapAsVecVisitor::<K, V>::new();

    deserializer.deserialize_map(visitor)
}

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

    #[derive(Debug, Deserialize)]
    struct TestVecOfPairs {
        #[serde(deserialize_with = "deserialize_vec_of_pairs")]
        items: Vec<(String, usize)>,
    }

    #[test]
    fn deserialize_empty_map() {
        let v: TestVecOfPairs = serde_json::from_str(r#"{"items": {}}"#).unwrap();
        assert_eq!(v.items, Vec::new());
    }

    #[test]
    fn deserialize_map_with_two_pairs() {
        let v: TestVecOfPairs =
            serde_json::from_str(r#"{"items": {"key": 1, "key2": 2}}"#).unwrap();

        assert_eq!(v.items, vec![("key".to_owned(), 1), ("key2".to_owned(), 2)]);
    }
}