dashmap/
serde.rs

1use crate::{mapref, setref, DashMap, DashSet};
2use core::fmt;
3use core::hash::{BuildHasher, Hash};
4use core::marker::PhantomData;
5use serde::de::{Deserialize, MapAccess, SeqAccess, Visitor};
6use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
7use serde::Deserializer;
8
9pub struct DashMapVisitor<K, V, S> {
10    marker: PhantomData<fn() -> DashMap<K, V, S>>,
11}
12
13impl<K, V, S> DashMapVisitor<K, V, S>
14where
15    K: Eq + Hash,
16    S: BuildHasher + Clone,
17{
18    fn new() -> Self {
19        DashMapVisitor {
20            marker: PhantomData,
21        }
22    }
23}
24
25impl<'de, K, V, S> Visitor<'de> for DashMapVisitor<K, V, S>
26where
27    K: Deserialize<'de> + Eq + Hash,
28    V: Deserialize<'de>,
29    S: BuildHasher + Clone + Default,
30{
31    type Value = DashMap<K, V, S>;
32
33    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
34        formatter.write_str("a DashMap")
35    }
36
37    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
38    where
39        M: MapAccess<'de>,
40    {
41        let map =
42            DashMap::with_capacity_and_hasher(access.size_hint().unwrap_or(0), Default::default());
43
44        while let Some((key, value)) = access.next_entry()? {
45            map.insert(key, value);
46        }
47
48        Ok(map)
49    }
50}
51
52impl<'de, K, V, S> Deserialize<'de> for DashMap<K, V, S>
53where
54    K: Deserialize<'de> + Eq + Hash,
55    V: Deserialize<'de>,
56    S: BuildHasher + Clone + Default,
57{
58    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
59    where
60        D: Deserializer<'de>,
61    {
62        deserializer.deserialize_map(DashMapVisitor::<K, V, S>::new())
63    }
64}
65
66impl<K, V, H> Serialize for DashMap<K, V, H>
67where
68    K: Serialize + Eq + Hash,
69    V: Serialize,
70    H: BuildHasher + Clone,
71{
72    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
73    where
74        S: Serializer,
75    {
76        let mut map = serializer.serialize_map(Some(self.len()))?;
77
78        for ref_multi in self.iter() {
79            map.serialize_entry(ref_multi.key(), ref_multi.value())?;
80        }
81
82        map.end()
83    }
84}
85
86pub struct DashSetVisitor<K, S> {
87    marker: PhantomData<fn() -> DashSet<K, S>>,
88}
89
90impl<K, S> DashSetVisitor<K, S>
91where
92    K: Eq + Hash,
93    S: BuildHasher + Clone,
94{
95    fn new() -> Self {
96        DashSetVisitor {
97            marker: PhantomData,
98        }
99    }
100}
101
102impl<'de, K, S> Visitor<'de> for DashSetVisitor<K, S>
103where
104    K: Deserialize<'de> + Eq + Hash,
105    S: BuildHasher + Clone + Default,
106{
107    type Value = DashSet<K, S>;
108
109    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
110        formatter.write_str("a DashSet")
111    }
112
113    fn visit_seq<M>(self, mut access: M) -> Result<Self::Value, M::Error>
114    where
115        M: SeqAccess<'de>,
116    {
117        let map =
118            DashSet::with_capacity_and_hasher(access.size_hint().unwrap_or(0), Default::default());
119
120        while let Some(key) = access.next_element()? {
121            map.insert(key);
122        }
123
124        Ok(map)
125    }
126}
127
128impl<'de, K, S> Deserialize<'de> for DashSet<K, S>
129where
130    K: Deserialize<'de> + Eq + Hash,
131    S: BuildHasher + Clone + Default,
132{
133    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
134    where
135        D: Deserializer<'de>,
136    {
137        deserializer.deserialize_seq(DashSetVisitor::<K, S>::new())
138    }
139}
140
141impl<K, H> Serialize for DashSet<K, H>
142where
143    K: Serialize + Eq + Hash,
144    H: BuildHasher + Clone,
145{
146    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
147    where
148        S: Serializer,
149    {
150        let mut seq = serializer.serialize_seq(Some(self.len()))?;
151
152        for ref_multi in self.iter() {
153            seq.serialize_element(ref_multi.key())?;
154        }
155
156        seq.end()
157    }
158}
159
160macro_rules! serialize_impl {
161    () => {
162        fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
163        where
164            Ser: serde::Serializer,
165        {
166            std::ops::Deref::deref(self).serialize(serializer)
167        }
168    };
169}
170
171// Map
172impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize
173    for mapref::multiple::RefMulti<'a, K, V, S>
174{
175    serialize_impl! {}
176}
177
178impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize
179    for mapref::multiple::RefMutMulti<'a, K, V, S>
180{
181    serialize_impl! {}
182}
183
184impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize for mapref::one::Ref<'a, K, V, S> {
185    serialize_impl! {}
186}
187
188impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize
189    for mapref::one::RefMut<'a, K, V, S>
190{
191    serialize_impl! {}
192}
193
194impl<'a, K: Eq + Hash, V, T: Serialize, S: BuildHasher> Serialize
195    for mapref::one::MappedRef<'a, K, V, T, S>
196{
197    serialize_impl! {}
198}
199
200impl<'a, K: Eq + Hash, V, T: Serialize, S: BuildHasher> Serialize
201    for mapref::one::MappedRefMut<'a, K, V, T, S>
202{
203    serialize_impl! {}
204}
205
206// Set
207impl<'a, V: Hash + Eq + Serialize, S: BuildHasher> Serialize
208    for setref::multiple::RefMulti<'a, V, S>
209{
210    serialize_impl! {}
211}
212
213impl<'a, V: Hash + Eq + Serialize, S: BuildHasher> Serialize for setref::one::Ref<'a, V, S> {
214    serialize_impl! {}
215}
dashmap/serde.rs

dashmap/
serde.rs
