Serialization support

Cargo.toml

@@ -26,6 +26,7 @@ sanitize = ['crossbeam-epoch/sanitize']
 crossbeam-epoch = "0.8.2"
 parking_lot = "0.10"
 num_cpus = "1.12.0"
+serde = {version = "1.0.105", optional = true}
 
 [dependencies.ahash]
 version = "0.3.2"

src/map.rs

@@ -2,11 +2,18 @@ use crate::iter::*;
 use crate::node::*;
 use crate::raw::*;
 use crossbeam_epoch::{self as epoch, Atomic, Guard, Owned, Shared};
+#[cfg(feature = "serde")]
+use serde::{
+    de::{MapAccess, Visitor},
+    Deserialize, Deserializer, Serialize, Serializer,
+};
 use std::borrow::Borrow;
 use std::error::Error;
 use std::fmt::{self, Debug, Display, Formatter};
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::iter::FromIterator;
+#[cfg(feature = "serde")]
+use std::marker::PhantomData;
 use std::sync::{
     atomic::{AtomicIsize, AtomicUsize, Ordering},
     Once,
@@ -2353,6 +2360,86 @@ where
     }
 }
 
+#[cfg(feature = "serde")]
+impl<K, V, S> Serialize for HashMap<K, V, S>
+where
+    K: Serialize,
+    V: Serialize,
+{
+    fn serialize<Sr>(&self, serializer: Sr) -> Result<Sr::Ok, Sr::Error>
+    where
+        Sr: Serializer,
+    {
+        self.pin().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, K, V, S> Deserialize<'de> for HashMap<K, V, S>
+where
+    K: 'static + Deserialize<'de> + Send + Sync + Hash + Clone + Eq,
+    V: 'static + Deserialize<'de> + Send + Sync + Eq,
+    S: Default + BuildHasher,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(HashMapVisitor::new())
+    }
+}
+
+#[cfg(feature = "serde")]
+struct HashMapVisitor<K, V, S> {
+    key_marker: PhantomData<K>,
+    value_marker: PhantomData<V>,
+    hash_builder_marker: PhantomData<S>,
+}
+
+#[cfg(feature = "serde")]
+impl<K, V, S> HashMapVisitor<K, V, S> {
+    pub(crate) fn new() -> Self {
+        Self {
+            key_marker: PhantomData,
+            value_marker: PhantomData,
+            hash_builder_marker: PhantomData,
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, K, V, S> Visitor<'de> for HashMapVisitor<K, V, S>
+where
+    K: 'static + Deserialize<'de> + Send + Sync + Hash + Clone + Eq,
+    V: 'static + Deserialize<'de> + Send + Sync + Eq,
+    S: Default + BuildHasher,
+{
+    type Value = HashMap<K, V, S>;
+
+    fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "a map could no be deserialized");
+    }
+
+    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
+    where
+        M: MapAccess<'de>,
+    {
+        let map = match access.size_hint() {
+            Some(n) => HashMap::with_capacity_and_hasher(n, S::default()),
+            None => HashMap::with_hasher(S::default()),
+        };
+        let guard = map.guard();
+
+        while let Some((key, value)) = access.next_entry()? {
+            if let Some(_old_value) = map.insert(key, value, &guard) {
+                unreachable!("Serialized map held two values with the same key");
+            }
+        }
+
+        Ok(map)
+    }
+}
+
 #[cfg(not(miri))]
 #[inline]
 /// Returns the number of physical CPUs in the machine (_O(1)_).

src/map_ref.rs

@@ -1,6 +1,8 @@
 use crate::iter::*;
 use crate::{GuardRef, HashMap, TryInsertError};
 use crossbeam_epoch::Guard;
+#[cfg(feature = "serde")]
+use serde::{Serialize, Serializer};
 use std::borrow::Borrow;
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{BuildHasher, Hash};
@@ -304,3 +306,17 @@ where
         self.get(key).expect("no entry found for key")
     }
 }
+
+#[cfg(feature = "serde")]
+impl<K, V, S> Serialize for HashMapRef<'_, K, V, S>
+where
+    K: Serialize,
+    V: Serialize,
+{
+    fn serialize<Sr>(&self, serializer: Sr) -> Result<Sr::Ok, Sr::Error>
+    where
+        Sr: Serializer,
+    {
+        serializer.collect_map(self.iter())
+    }
+}

src/set.rs

@@ -2,10 +2,17 @@
 //!
 //! See `HashSet` for details.
 
+#[cfg(feature = "serde")]
+use serde::{
+    de::{SeqAccess, Visitor},
+    Deserialize, Deserializer, Serialize, Serializer,
+};
 use std::borrow::Borrow;
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{BuildHasher, Hash};
 use std::iter::FromIterator;
+#[cfg(feature = "serde")]
+use std::marker::PhantomData;
 
 use crate::epoch::Guard;
 use crate::iter::Keys;
@@ -600,3 +607,74 @@ where
         }
     }
 }
+
+#[cfg(feature = "serde")]
+impl<T, S> Serialize for HashSet<T, S>
+where
+    T: Serialize,
+{
+    fn serialize<Sr>(&self, serializer: Sr) -> Result<Sr::Ok, Sr::Error>
+    where
+        Sr: Serializer,
+    {
+        self.pin().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, T, S> Deserialize<'de> for HashSet<T, S>
+where
+    T: 'static + Deserialize<'de> + Send + Sync + Hash + Clone + Eq,
+    S: Default + BuildHasher,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(HashSetVisitor::new())
+    }
+}
+
+#[cfg(feature = "serde")]
+struct HashSetVisitor<T, S> {
+    type_marker: PhantomData<T>,
+    hash_builder_marker: PhantomData<S>,
+}
+
+#[cfg(feature = "serde")]
+impl<T, S> HashSetVisitor<T, S> {
+    pub(crate) fn new() -> Self {
+        Self {
+            type_marker: PhantomData,
+            hash_builder_marker: PhantomData,
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, T, S> Visitor<'de> for HashSetVisitor<T, S>
+where
+    T: 'static + Deserialize<'de> + Send + Sync + Hash + Clone + Eq,
+    S: Default + BuildHasher,
+{
+    type Value = HashSet<T, S>;
+
+    // TODO: Create an error message
+    fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "a set could not be parsed");
+    }
+
+    fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let set = HashSet::default();
+        let guard = set.guard();
+
+        while let Some(value) = access.next_element()? {
+            let _ = set.insert(value, &guard);
+        }
+
+        Ok(set)
+    }
+}

src/set_ref.rs

@@ -1,6 +1,8 @@
 use crate::iter::*;
 use crate::{GuardRef, HashSet};
 use crossbeam_epoch::Guard;
+#[cfg(feature = "serde")]
+use serde::{Serialize, Serializer};
 use std::borrow::Borrow;
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{BuildHasher, Hash};
@@ -235,3 +237,16 @@ where
     S: BuildHasher,
 {
 }
+
+#[cfg(feature = "serde")]
+impl<T, S> Serialize for HashSetRef<'_, T, S>
+where
+    T: Serialize,
+{
+    fn serialize<Sr>(&self, serilizer: Sr) -> Result<Sr::Ok, Sr::Error>
+    where
+        Sr: Serializer,
+    {
+        serilizer.collect_seq(self.iter())
+    }
+}