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 {
serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error> where T: Serializer,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 
expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result38     fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
39         write!(formatter, "a map")
40     }
41 
visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: MapAccess<'de>,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 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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 
into_deserializer(self) -> Self::Deserializer81     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 {
serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error> where Se: Serializer,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 
expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result111     fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
112         write!(formatter, "a set")
113     }
114 
visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>,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 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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 
into_deserializer(self) -> Self::Deserializer152     fn into_deserializer(self) -> Self::Deserializer {
153         SeqDeserializer::new(self.into_iter())
154     }
155 }
156