/rust/registry/src/index.crates.io-6f17d22bba15001f/radix_trie-0.2.1/src/serde.rs

Source (jump to first uncovered line)
extern crate serde;

use self::serde::ser::SerializeMap;
use self::serde::{de, Deserialize, Deserializer, Serialize, Serializer};
use super::{Trie, TrieCommon, TrieKey};
use std::fmt::{self, Formatter};
use std::marker::PhantomData;

impl<K, V> Serialize for Trie<K, V>
where
    K: Serialize + TrieKey,
    V: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.len()))?;
        for (k, v) in self.iter() {
            map.serialize_entry(k, v)?;
        }
        map.end()
    }
}

struct TrieVisitor<K, V> {
    marker: PhantomData<Trie<K, V>>,
}

impl<K, V> TrieVisitor<K, V> {
    fn new() -> Self {
        TrieVisitor {
            marker: PhantomData,
        }
    }
}

impl<'a, K, V> de::Visitor<'a> for TrieVisitor<K, V>
where
    K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
    V: Deserialize<'a>,
{
    type Value = Trie<K, V>;

    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
        write!(formatter, "a serialized trie")
    }

    fn visit_map<M>(self, mut visitor: M) -> Result<Self::Value, M::Error>
    where
        M: de::MapAccess<'a>,
    {
        let mut values = Trie::new();

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

        Ok(values)
    }

    fn visit_unit<E>(self) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        Ok(Trie::new())
    }
}

impl<'a, K, V> Deserialize<'a> for Trie<K, V>
where
    K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
    V: Deserialize<'a>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'a>,
    {
        // Instantiate our Visitor and ask the Deserializer to drive
        // it over the input data, resulting in an instance of MyMap.
        deserializer.deserialize_map(TrieVisitor::new())
    }
}

#[cfg(test)]
mod test {
    extern crate serde_test;
    use self::serde_test::Token;
    use super::super::Trie;

    macro_rules! tests_de {
        ($($name:ident => $value:expr => $tokens:expr,)+) => {
            $(#[test]
            fn $name() {
                // Test ser/de roundtripping
                serde_test::assert_de_tokens(&$value, $tokens);
            })+
        }
    }

    macro_rules! tests_ser {
        ($($name:ident => $value:expr => $tokens:expr,)+) => {
            $(#[test]
            fn $name() {
                serde_test::assert_ser_tokens(&$value, $tokens);
            })+
        }
    }

    macro_rules! trie {
        () => {
            Trie::new()
        };
        ($($key:expr => $value:expr),+) => {
            {
                let mut map = Trie::new();
                $(map.insert($key, $value);)+
                map
            }
        }
    }

    tests_ser! {
        test_ser_empty_trie => Trie::<&str, isize>::new() => &[
            Token::Map { len: Some(0) },
            Token::MapEnd,
        ],
        test_ser_single_element_trie => trie!["1" => 2] => &[
            Token::Map { len: Some(1) },

            Token::Str("1"),
            Token::I32(2),
            Token::MapEnd,
        ],
        test_ser_multiple_element_trie => trie!["1" => 2, "3" => 4] => &[
            Token::Map { len: Some(2) },
            Token::Str("1"),
            Token::I32(2),

            Token::Str("3"),
            Token::I32(4),
            Token::MapEnd,
        ],
        test_ser_deep_trie => trie!["1" => trie![], "2" => trie!["3" => 4, "5" => 6]] => &[
            Token::Map { len: Some(2) },
            Token::Str("1"),
            Token::Map { len: Some(0) },
            Token::MapEnd,

            Token::Str("2"),
            Token::Map { len: Some(2) },
            Token::Str("3"),
            Token::I32(4),

            Token::Str("5"),
            Token::I32(6),
            Token::MapEnd,
            Token::MapEnd,
        ],
    }

    tests_de! {
        test_de_empty_trie1 => Trie::<String, isize>::new() => &[
            Token::Unit,
        ],
        test_de_empty_trie2 => Trie::<String, isize>::new() => &[
            Token::Map { len: Some(0) },
            Token::MapEnd,
        ],
        test_de_single_element_trie => trie!["1".to_string() => 2] => &[
            Token::Map { len: Some(1) },
                Token::Str("1"),
                Token::I32(2),
            Token::MapEnd,
        ],
        test_de_multiple_element_trie => trie!["1".to_string()  => 2, "3".to_string()  => 4] => &[
            Token::Map { len: Some(2) },
                Token::Str("1"),
                Token::I32(2),

                Token::Str("3"),
                Token::I32(4),
            Token::MapEnd,
        ],
        test_de_deep_trie => trie!["1".to_string()  => trie![], "2".to_string()  => trie!["3".to_string()  => 4, "5".to_string()  => 6]] => &[
            Token::Map { len: Some(2) },
                Token::Str("1"),
                Token::Map { len: Some(0) },
                Token::MapEnd,

                Token::Str("2"),
                Token::Map { len: Some(2) },
                    Token::Str("3"),
                    Token::I32(4),

                    Token::Str("5"),
                    Token::I32(6),
                Token::MapEnd,
            Token::MapEnd,
        ],
        test_de_empty_trie3 => Trie::<String, isize>::new() => &[
            Token::UnitStruct { name: "Anything" },
        ],
        test_de_empty_trie4 => Trie::<String, isize>::new() => &[
            Token::Struct {
                name: "Anything",
                len: 0,
            },
            Token::StructEnd,
        ],
    }
}

Coverage Report

Created: 2025-02-21 07:11

Line	Count	Source (jump to first uncovered line)
1		extern crate serde;
2
3		use self::serde::ser::SerializeMap;
4		use self::serde::{de, Deserialize, Deserializer, Serialize, Serializer};
5		use super::{Trie, TrieCommon, TrieKey};
6		use std::fmt::{self, Formatter};
7		use std::marker::PhantomData;
8
9		impl<K, V> Serialize for Trie<K, V>
10		where
11		K: Serialize + TrieKey,
12		V: Serialize,
13		{
14	0	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
15	0	where
16	0	S: Serializer,
17	0	{
18	0	let mut map = serializer.serialize_map(Some(self.len()))?;
19	0	for (k, v) in self.iter() {
20	0	map.serialize_entry(k, v)?;
21		}
22	0	map.end()
23	0	} Unexecuted instantiation: <radix_trie::Trie<alloc::vec::Vec<u8>, u64> as serde::ser::Serialize>::serialize::<&mut bincode::ser::Serializer<&mut alloc::vec::Vec<u8>, bincode::config::WithOtherIntEncoding<bincode::config::DefaultOptions, bincode::config::int::FixintEncoding>>> Unexecuted instantiation: <radix_trie::Trie<alloc::vec::Vec<u8>, u64> as serde::ser::Serialize>::serialize::<&mut bincode::ser::SizeChecker<&mut bincode::config::WithOtherIntEncoding<bincode::config::DefaultOptions, bincode::config::int::FixintEncoding>>> Unexecuted instantiation: <radix_trie::Trie<_, _> as serde::ser::Serialize>::serialize::<_>
24		}
25
26		struct TrieVisitor<K, V> {
27		marker: PhantomData<Trie<K, V>>,
28		}
29
30		impl<K, V> TrieVisitor<K, V> {
31	0	fn new() -> Self {
32	0	TrieVisitor {
33	0	marker: PhantomData,
34	0	}
35	0	} Unexecuted instantiation: <radix_trie::serde::TrieVisitor<alloc::vec::Vec<u8>, u64>>::new Unexecuted instantiation: <radix_trie::serde::TrieVisitor<_, _>>::new
36		}
37
38		impl<'a, K, V> de::Visitor<'a> for TrieVisitor<K, V>
39		where
40		K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
41		V: Deserialize<'a>,
42		{
43		type Value = Trie<K, V>;
44
45	0	fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
46	0	write!(formatter, "a serialized trie")
47	0	}
48
49	0	fn visit_map<M>(self, mut visitor: M) -> Result<Self::Value, M::Error>
50	0	where
51	0	M: de::MapAccess<'a>,
52	0	{
53	0	let mut values = Trie::new();
54
55	0	while let Some((key, value)) = visitor.next_entry()? {
56	0	values.insert(key, value);
57	0	}
58
59	0	Ok(values)
60	0	} Unexecuted instantiation: <radix_trie::serde::TrieVisitor<alloc::vec::Vec<u8>, u64> as serde::de::Visitor>::visit_map::<<&mut bincode::de::Deserializer<_, _> as serde::de::Deserializer>::deserialize_map::Access<bincode::de::read::IoReader<&[u8]>, bincode::config::WithOtherTrailing<bincode::config::WithOtherIntEncoding<bincode::config::DefaultOptions, bincode::config::int::FixintEncoding>, bincode::config::trailing::AllowTrailing>>> Unexecuted instantiation: <radix_trie::serde::TrieVisitor<_, _> as serde::de::Visitor>::visit_map::<_>
61
62	0	fn visit_unit<E>(self) -> Result<Self::Value, E>
63	0	where
64	0	E: de::Error,
65	0	{
66	0	Ok(Trie::new())
67	0	}
68		}
69
70		impl<'a, K, V> Deserialize<'a> for Trie<K, V>
71		where
72		K: Deserialize<'a> + Clone + Eq + PartialEq + TrieKey,
73		V: Deserialize<'a>,
74		{
75	0	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
76	0	where
77	0	D: Deserializer<'a>,
78	0	{
79	0	// Instantiate our Visitor and ask the Deserializer to drive
80	0	// it over the input data, resulting in an instance of MyMap.
81	0	deserializer.deserialize_map(TrieVisitor::new())
82	0	} Unexecuted instantiation: <radix_trie::Trie<alloc::vec::Vec<u8>, u64> as serde::de::Deserialize>::deserialize::<&mut bincode::de::Deserializer<bincode::de::read::IoReader<&[u8]>, bincode::config::WithOtherTrailing<bincode::config::WithOtherIntEncoding<bincode::config::DefaultOptions, bincode::config::int::FixintEncoding>, bincode::config::trailing::AllowTrailing>>> Unexecuted instantiation: <radix_trie::Trie<_, _> as serde::de::Deserialize>::deserialize::<_>
83		}
84
85		#[cfg(test)]
86		mod test {
87		extern crate serde_test;
88		use self::serde_test::Token;
89		use super::super::Trie;
90
91		macro_rules! tests_de {
92		($($name:ident => $value:expr => $tokens:expr,)+) => {
93		$(#[test]
94		fn $name() {
95		// Test ser/de roundtripping
96		serde_test::assert_de_tokens(&$value, $tokens);
97		})+
98		}
99		}
100
101		macro_rules! tests_ser {
102		($($name:ident => $value:expr => $tokens:expr,)+) => {
103		$(#[test]
104		fn $name() {
105		serde_test::assert_ser_tokens(&$value, $tokens);
106		})+
107		}
108		}
109
110		macro_rules! trie {
111		() => {
112		Trie::new()
113		};
114		($($key:expr => $value:expr),+) => {
115		{
116		let mut map = Trie::new();
117		$(map.insert($key, $value);)+
118		map
119		}
120		}
121		}
122
123		tests_ser! {
124		test_ser_empty_trie => Trie::<&str, isize>::new() => &[
125		Token::Map { len: Some(0) },
126		Token::MapEnd,
127		],
128		test_ser_single_element_trie => trie!["1" => 2] => &[
129		Token::Map { len: Some(1) },
130
131		Token::Str("1"),
132		Token::I32(2),
133		Token::MapEnd,
134		],
135		test_ser_multiple_element_trie => trie!["1" => 2, "3" => 4] => &[
136		Token::Map { len: Some(2) },
137		Token::Str("1"),
138		Token::I32(2),
139
140		Token::Str("3"),
141		Token::I32(4),
142		Token::MapEnd,
143		],
144		test_ser_deep_trie => trie!["1" => trie![], "2" => trie!["3" => 4, "5" => 6]] => &[
145		Token::Map { len: Some(2) },
146		Token::Str("1"),
147		Token::Map { len: Some(0) },
148		Token::MapEnd,
149
150		Token::Str("2"),
151		Token::Map { len: Some(2) },
152		Token::Str("3"),
153		Token::I32(4),
154
155		Token::Str("5"),
156		Token::I32(6),
157		Token::MapEnd,
158		Token::MapEnd,
159		],
160		}
161
162		tests_de! {
163		test_de_empty_trie1 => Trie::<String, isize>::new() => &[
164		Token::Unit,
165		],
166		test_de_empty_trie2 => Trie::<String, isize>::new() => &[
167		Token::Map { len: Some(0) },
168		Token::MapEnd,
169		],
170		test_de_single_element_trie => trie!["1".to_string() => 2] => &[
171		Token::Map { len: Some(1) },
172		Token::Str("1"),
173		Token::I32(2),
174		Token::MapEnd,
175		],
176		test_de_multiple_element_trie => trie!["1".to_string() => 2, "3".to_string() => 4] => &[
177		Token::Map { len: Some(2) },
178		Token::Str("1"),
179		Token::I32(2),
180
181		Token::Str("3"),
182		Token::I32(4),
183		Token::MapEnd,
184		],
185		test_de_deep_trie => trie!["1".to_string() => trie![], "2".to_string() => trie!["3".to_string() => 4, "5".to_string() => 6]] => &[
186		Token::Map { len: Some(2) },
187		Token::Str("1"),
188		Token::Map { len: Some(0) },
189		Token::MapEnd,
190
191		Token::Str("2"),
192		Token::Map { len: Some(2) },
193		Token::Str("3"),
194		Token::I32(4),
195
196		Token::Str("5"),
197		Token::I32(6),
198		Token::MapEnd,
199		Token::MapEnd,
200		],
201		test_de_empty_trie3 => Trie::<String, isize>::new() => &[
202		Token::UnitStruct { name: "Anything" },
203		],
204		test_de_empty_trie4 => Trie::<String, isize>::new() => &[
205		Token::Struct {
206		name: "Anything",
207		len: 0,
208		},
209		Token::StructEnd,
210		],
211		}
212		}