1 files changed, 87 insertions, 77 deletions

diff --git a/src/serde.rs b/src/serde.rs
index b8e307c..f44ebb3 100644
--- a/src/serde.rs
+++ b/src/serde.rs
@@ -31,54 +31,59 @@ where
     }
 }
 
-#[derive(Debug)]
-pub struct LinkedHashMapVisitor<K, V> {
-    marker: PhantomData<LinkedHashMap<K, V>>,
-}
-
-impl<K, V> LinkedHashMapVisitor<K, V> {
-    fn new() -> Self {
-        LinkedHashMapVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<K, V> Default for LinkedHashMapVisitor<K, V> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<'de, K, V> Visitor<'de> for LinkedHashMapVisitor<K, V>
+impl<'de, K, V, S> Deserialize<'de> for LinkedHashMap<K, V, S>
 where
     K: Deserialize<'de> + Eq + Hash,
     V: Deserialize<'de>,
+    S: BuildHasher + Default,
 {
-    type Value = LinkedHashMap<K, V>;
-
-    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-        write!(formatter, "a map")
-    }
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        #[derive(Debug)]
+        pub struct LinkedHashMapVisitor<K, V, S> {
+            marker: PhantomData<LinkedHashMap<K, V, S>>,
+        }
 
-    #[inline]
-    fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<Self::Value, M::Error> {
-        let mut values = LinkedHashMap::with_capacity(map.size_hint().unwrap_or(0));
+        impl<K, V, S> LinkedHashMapVisitor<K, V, S> {
+            fn new() -> Self {
+                LinkedHashMapVisitor {
+                    marker: PhantomData,
+                }
+            }
+        }
 
-        while let Some((k, v)) = map.next_entry()? {
-            values.insert(k, v);
+        impl<K, V, S> Default for LinkedHashMapVisitor<K, V, S> {
+            fn default() -> Self {
+                Self::new()
+            }
         }
 
-        Ok(values)
-    }
-}
+        impl<'de, K, V, S> Visitor<'de> for LinkedHashMapVisitor<K, V, S>
+        where
+            K: Deserialize<'de> + Eq + Hash,
+            V: Deserialize<'de>,
+            S: BuildHasher + Default,
+        {
+            type Value = LinkedHashMap<K, V, S>;
+
+            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                write!(formatter, "a map")
+            }
+
+            #[inline]
+            fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<Self::Value, M::Error> {
+                let mut values = LinkedHashMap::with_capacity_and_hasher(
+                    map.size_hint().unwrap_or(0),
+                    S::default(),
+                );
+
+                while let Some((k, v)) = map.next_entry()? {
+                    values.insert(k, v);
+                }
+
+                Ok(values)
+            }
+        }
 
-impl<'de, K, V> Deserialize<'de> for LinkedHashMap<K, V>
-where
-    K: Deserialize<'de> + Eq + Hash,
-    V: Deserialize<'de>,
-{
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         deserializer.deserialize_map(LinkedHashMapVisitor::default())
     }
 }
@@ -100,52 +105,57 @@ where
     }
 }
 
-#[derive(Debug)]
-pub struct LinkedHashSetVisitor<T> {
-    marker: PhantomData<LinkedHashSet<T>>,
-}
-
-impl<T> LinkedHashSetVisitor<T> {
-    fn new() -> Self {
-        LinkedHashSetVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<T> Default for LinkedHashSetVisitor<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<'de, T> Visitor<'de> for LinkedHashSetVisitor<T>
+impl<'de, T, S> Deserialize<'de> for LinkedHashSet<T, S>
 where
     T: Deserialize<'de> + Eq + Hash,
+    S: BuildHasher + Default,
 {
-    type Value = LinkedHashSet<T>;
-
-    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-        write!(formatter, "a sequence")
-    }
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        #[derive(Debug)]
+        pub struct LinkedHashSetVisitor<T, S> {
+            marker: PhantomData<LinkedHashSet<T, S>>,
+        }
 
-    #[inline]
-    fn visit_seq<S: SeqAccess<'de>>(self, mut seq: S) -> Result<Self::Value, S::Error> {
-        let mut values = LinkedHashSet::with_capacity(seq.size_hint().unwrap_or(0));
+        impl<T, S> LinkedHashSetVisitor<T, S> {
+            fn new() -> Self {
+                LinkedHashSetVisitor {
+                    marker: PhantomData,
+                }
+            }
+        }
 
-        while let Some(v) = seq.next_element()? {
-            values.insert(v);
+        impl<T, S> Default for LinkedHashSetVisitor<T, S> {
+            fn default() -> Self {
+                Self::new()
+            }
         }
 
-        Ok(values)
-    }
-}
+        impl<'de, T, S> Visitor<'de> for LinkedHashSetVisitor<T, S>
+        where
+            T: Deserialize<'de> + Eq + Hash,
+            S: BuildHasher + Default,
+        {
+            type Value = LinkedHashSet<T, S>;
+
+            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                write!(formatter, "a sequence")
+            }
+
+            #[inline]
+            fn visit_seq<SA: SeqAccess<'de>>(self, mut seq: SA) -> Result<Self::Value, SA::Error> {
+                let mut values = LinkedHashSet::with_capacity_and_hasher(
+                    seq.size_hint().unwrap_or(0),
+                    S::default(),
+                );
+
+                while let Some(v) = seq.next_element()? {
+                    values.insert(v);
+                }
+
+                Ok(values)
+            }
+        }
 
-impl<'de, T> Deserialize<'de> for LinkedHashSet<T>
-where
-    T: Deserialize<'de> + Eq + Hash,
-{
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         deserializer.deserialize_seq(LinkedHashSetVisitor::default())
     }
 }