Added Serde support

Cargo.toml

@@ -19,6 +19,10 @@ maintenance = { status = "passively-maintained" }
 
 [dependencies]
 griddle = { version = "0.5", optional = true }
+serde = { version = "1.0", features = ["derive"], optional = true }
+
+[dev-dependencies]
+serde_json = { version = "1.0" }
 
 [features]
 amortize = ["griddle"]

src/lib.rs

@@ -25,6 +25,8 @@ use std::collections::hash_map::RandomState;
 use std::collections::HashMap;
 use std::hash::{BuildHasher, Hash};
 
+#[cfg(feature = "serde")]
+mod serde;
 /// A hash bag implemented as a `HashMap` where the value is `usize`.
 ///
 /// A bag, unlike a set, allows duplicate values, and keeps track of how many

src/serde.rs

@@ -0,0 +1,128 @@
+use crate::HashBag;
+use core::fmt;
+use core::hash::{BuildHasher, Hash};
+use core::marker::PhantomData;
+use serde::de::{SeqAccess, Visitor};
+use serde::ser::{SerializeSeq, Serializer};
+use serde::Deserializer;
+use serde::{Deserialize, Serialize};
+
+pub(crate) struct HashBagVisitor<T, S> {
+    marker: PhantomData<fn() -> HashBag<T, S>>,
+}
+
+impl<T, S> HashBagVisitor<T, S>
+where
+    T: Eq + Hash,
+    S: BuildHasher + Clone,
+{
+    fn new() -> Self {
+        HashBagVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de, T, S> Visitor<'de> for HashBagVisitor<T, S>
+where
+    T: Deserialize<'de> + Eq + Hash,
+    S: BuildHasher + Clone + Default,
+{
+    type Value = HashBag<T, S>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a HashBag")
+    }
+
+    fn visit_seq<M>(self, mut access: M) -> Result<Self::Value, M::Error>
+    where
+        M: SeqAccess<'de>,
+    {
+        let mut bag: HashBag<T, S> =
+            HashBag::with_capacity_and_hasher(access.size_hint().unwrap_or(0), Default::default());
+
+        while let Some(entry) = access.next_element::<(T, usize)>()? {
+            bag.insert_many(entry.0, entry.1);
+        }
+
+        Ok(bag)
+    }
+}
+
+impl<'de, T, S> Deserialize<'de> for HashBag<T, S>
+where
+    T: Deserialize<'de> + Eq + Hash,
+    S: BuildHasher + Clone + Default,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(HashBagVisitor::<T, S>::new())
+    }
+}
+
+impl<T, H> Serialize for HashBag<T, H>
+where
+    T: Serialize + Eq + Hash,
+    H: BuildHasher + Clone,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut bag = serializer.serialize_seq(Some(self.len()))?;
+
+        for (entry, count) in self.set_iter() {
+            bag.serialize_element(&(&entry, &count))?;
+        }
+
+        bag.end()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use serde_json;
+
+    #[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
+    struct VeryHelpfulStruct {
+        pub(crate) name: String,
+    }
+
+    #[test]
+    fn format_simple_data() {
+        let vikings: HashBag<String> = ["Einar", "Olaf", "Harald"]
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+        println!("{:?}", vikings);
+        let jsonified_vikings: String =
+            serde_json::to_string(&vikings).expect("Unable to convert data to json!");
+        println!("{}", jsonified_vikings);
+        let reconsituted_vikings: HashBag<String> =
+            serde_json::from_str(&jsonified_vikings).expect("Unable to convert json to hashbag!");
+        println!("{:?}", reconsituted_vikings);
+        assert_eq!(vikings, reconsituted_vikings);
+    }
+
+    #[test]
+    fn format_struct_data() {
+        let vikings: HashBag<VeryHelpfulStruct> = ["Einar", "Olaf", "Harald"]
+            .iter()
+            .map(|n| VeryHelpfulStruct {
+                name: n.to_string(),
+            })
+            .collect();
+        println!("{:?}", vikings);
+        let jsonified_vikings: String =
+            serde_json::to_string(&vikings).expect("Unable to convert data to json!");
+        println!("{}", jsonified_vikings);
+        let reconsituted_vikings: HashBag<VeryHelpfulStruct> =
+            serde_json::from_str(&jsonified_vikings).expect("Unable to convert json to hashbag!");
+        println!("{:?}", reconsituted_vikings);
+        assert_eq!(vikings, reconsituted_vikings);
+    }
+}