1 use crate::{mapref, setref, DashMap, DashSet}; 2 use core::fmt; 3 use core::hash::{BuildHasher, Hash}; 4 use core::marker::PhantomData; 5 use serde::de::{Deserialize, MapAccess, SeqAccess, Visitor}; 6 use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer}; 7 use serde::Deserializer; 8 9 pub struct DashMapVisitor<K, V, S> { 10 marker: PhantomData<fn() -> DashMap<K, V, S>>, 11 } 12 13 impl<K, V, S> DashMapVisitor<K, V, S> 14 where 15 K: Eq + Hash, 16 S: BuildHasher + Clone, 17 { new() -> Self18 fn new() -> Self { 19 DashMapVisitor { 20 marker: PhantomData, 21 } 22 } 23 } 24 25 impl<'de, K, V, S> Visitor<'de> for DashMapVisitor<K, V, S> 26 where 27 K: Deserialize<'de> + Eq + Hash, 28 V: Deserialize<'de>, 29 S: BuildHasher + Clone + Default, 30 { 31 type Value = DashMap<K, V, S>; 32 expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result33 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 34 formatter.write_str("a DashMap") 35 } 36 visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error> where M: MapAccess<'de>,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 52 impl<'de, K, V, S> Deserialize<'de> for DashMap<K, V, S> 53 where 54 K: Deserialize<'de> + Eq + Hash, 55 V: Deserialize<'de>, 56 S: BuildHasher + Clone + Default, 57 { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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 66 impl<K, V, H> Serialize for DashMap<K, V, H> 67 where 68 K: Serialize + Eq + Hash, 69 V: Serialize, 70 H: BuildHasher + Clone, 71 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 86 pub struct DashSetVisitor<K, S> { 87 marker: PhantomData<fn() -> DashSet<K, S>>, 88 } 89 90 impl<K, S> DashSetVisitor<K, S> 91 where 92 K: Eq + Hash, 93 S: BuildHasher + Clone, 94 { new() -> Self95 fn new() -> Self { 96 DashSetVisitor { 97 marker: PhantomData, 98 } 99 } 100 } 101 102 impl<'de, K, S> Visitor<'de> for DashSetVisitor<K, S> 103 where 104 K: Deserialize<'de> + Eq + Hash, 105 S: BuildHasher + Clone + Default, 106 { 107 type Value = DashSet<K, S>; 108 expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result109 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 110 formatter.write_str("a DashSet") 111 } 112 visit_seq<M>(self, mut access: M) -> Result<Self::Value, M::Error> where M: SeqAccess<'de>,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 128 impl<'de, K, S> Deserialize<'de> for DashSet<K, S> 129 where 130 K: Deserialize<'de> + Eq + Hash, 131 S: BuildHasher + Clone + Default, 132 { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,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 141 impl<K, H> Serialize for DashSet<K, H> 142 where 143 K: Serialize + Eq + Hash, 144 H: BuildHasher + Clone, 145 { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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 160 macro_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 172 impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize 173 for mapref::multiple::RefMulti<'a, K, V, S> 174 { 175 serialize_impl! {} 176 } 177 178 impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize 179 for mapref::multiple::RefMutMulti<'a, K, V, S> 180 { 181 serialize_impl! {} 182 } 183 184 impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize for mapref::one::Ref<'a, K, V, S> { 185 serialize_impl! {} 186 } 187 188 impl<'a, K: Eq + Hash, V: Serialize, S: BuildHasher> Serialize 189 for mapref::one::RefMut<'a, K, V, S> 190 { 191 serialize_impl! {} 192 } 193 194 impl<'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 200 impl<'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 207 impl<'a, V: Hash + Eq + Serialize, S: BuildHasher> Serialize 208 for setref::multiple::RefMulti<'a, V, S> 209 { 210 serialize_impl! {} 211 } 212 213 impl<'a, V: Hash + Eq + Serialize, S: BuildHasher> Serialize for setref::one::Ref<'a, V, S> { 214 serialize_impl! {} 215 } 216