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 | impl<K, V, S> Serialize for IndexMap<K, V, S> |
14 | where |
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 | |
27 | struct IndexMapVisitor<K, V, S>(PhantomData<(K, V, S)>); |
28 | |
29 | impl<'de, K, V, S> Visitor<'de> for IndexMapVisitor<K, V, S> |
30 | where |
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 | |
56 | impl<'de, K, V, S> Deserialize<'de> for IndexMap<K, V, S> |
57 | where |
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 | |
70 | impl<'de, K, V, S, E> IntoDeserializer<'de, E> for IndexMap<K, V, S> |
71 | where |
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 | |
84 | use crate::IndexSet; |
85 | |
86 | impl<T, S> Serialize for IndexSet<T, S> |
87 | where |
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 | |
99 | struct IndexSetVisitor<T, S>(PhantomData<(T, S)>); |
100 | |
101 | impl<'de, T, S> Visitor<'de> for IndexSetVisitor<T, S> |
102 | where |
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 | |
127 | impl<'de, T, S> Deserialize<'de> for IndexSet<T, S> |
128 | where |
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 | |
140 | impl<'de, T, S, E> IntoDeserializer<'de, E> for IndexSet<T, S> |
141 | where |
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 | |