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