Debian Codegraph @

.cargo/vendor/indexmap/src/serde.rs

raw
1 use serde::de::value::{MapDeserializer, SeqDeserializer};
2 use serde::de::{
3 Deserialize, Deserializer, Error, IntoDeserializer, MapAccess, SeqAccess, Visitor,
4 };
5 use serde::ser::{Serialize, Serializer};
6
7 use core::fmt::{self, Formatter};
8 use core::hash::{BuildHasher, Hash};
9 use core::marker::PhantomData;
10
11 use crate::IndexMap;
12
13 /// Requires crate feature `"serde"` or `"serde-1"`
14 impl<K, V, S> Serialize for IndexMap<K, V, S>
15 where
16 K: Serialize + Hash + Eq,
17 V: Serialize,
18 S: BuildHasher,
19 {
20 fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
21 where
22 T: Serializer,
23 {
24 serializer.collect_map(self)
25 }
26 }
27
28 struct IndexMapVisitor<K, V, S>(PhantomData<(K, V, S)>);
29
30 impl<'de, K, V, S> Visitor<'de> for IndexMapVisitor<K, V, S>
31 where
32 K: Deserialize<'de> + Eq + Hash,
33 V: Deserialize<'de>,
34 S: Default + BuildHasher,
35 {
36 type Value = IndexMap<K, V, S>;
37
38 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
39 write!(formatter, "a map")
40 }
41
42 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
43 where
44 A: MapAccess<'de>,
45 {
46 let mut values =
47 IndexMap::with_capacity_and_hasher(map.size_hint().unwrap_or(0), S::default());
48
49 while let Some((key, value)) = map.next_entry()? {
50 values.insert(key, value);
51 }
52
53 Ok(values)
54 }
55 }
56
57 /// Requires crate feature `"serde"` or `"serde-1"`
58 impl<'de, K, V, S> Deserialize<'de> for IndexMap<K, V, S>
59 where
60 K: Deserialize<'de> + Eq + Hash,
61 V: Deserialize<'de>,
62 S: Default + BuildHasher,
63 {
64 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
65 where
66 D: Deserializer<'de>,
67 {
68 deserializer.deserialize_map(IndexMapVisitor(PhantomData))
69 }
70 }
71
72 impl<'de, K, V, S, E> IntoDeserializer<'de, E> for IndexMap<K, V, S>
73 where
74 K: IntoDeserializer<'de, E> + Eq + Hash,
75 V: IntoDeserializer<'de, E>,
76 S: BuildHasher,
77 E: Error,
78 {
79 type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
80
81 fn into_deserializer(self) -> Self::Deserializer {
82 MapDeserializer::new(self.into_iter())
83 }
84 }
85
86 use crate::IndexSet;
87
88 /// Requires crate feature `"serde"` or `"serde-1"`
89 impl<T, S> Serialize for IndexSet<T, S>
90 where
91 T: Serialize + Hash + Eq,
92 S: BuildHasher,
93 {
94 fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>
95 where
96 Se: Serializer,
97 {
98 serializer.collect_seq(self)
99 }
100 }
101
102 struct IndexSetVisitor<T, S>(PhantomData<(T, S)>);
103
104 impl<'de, T, S> Visitor<'de> for IndexSetVisitor<T, S>
105 where
106 T: Deserialize<'de> + Eq + Hash,
107 S: Default + BuildHasher,
108 {
109 type Value = IndexSet<T, S>;
110
111 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
112 write!(formatter, "a set")
113 }
114
115 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
116 where
117 A: SeqAccess<'de>,
118 {
119 let mut values =
120 IndexSet::with_capacity_and_hasher(seq.size_hint().unwrap_or(0), S::default());
121
122 while let Some(value) = seq.next_element()? {
123 values.insert(value);
124 }
125
126 Ok(values)
127 }
128 }
129
130 /// Requires crate feature `"serde"` or `"serde-1"`
131 impl<'de, T, S> Deserialize<'de> for IndexSet<T, S>
132 where
133 T: Deserialize<'de> + Eq + Hash,
134 S: Default + BuildHasher,
135 {
136 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
137 where
138 D: Deserializer<'de>,
139 {
140 deserializer.deserialize_seq(IndexSetVisitor(PhantomData))
141 }
142 }
143
144 impl<'de, T, S, E> IntoDeserializer<'de, E> for IndexSet<T, S>
145 where
146 T: IntoDeserializer<'de, E> + Eq + Hash,
147 S: BuildHasher,
148 E: Error,
149 {
150 type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
151
152 fn into_deserializer(self) -> Self::Deserializer {
153 SeqDeserializer::new(self.into_iter())
154 }
155 }