Replace deprecated HashState with BuildHasher

Closes #38.

Author: apasel422

src/lib.rs

@@ -28,15 +28,13 @@
 //! ```
 
 #![forbid(missing_docs)]
-#![feature(hashmap_hasher)]
 #![cfg_attr(test, feature(test))]
 
 use std::borrow::Borrow;
 use std::cmp::Ordering;
 use std::collections::hash_map::{self, HashMap};
-use std::collections::hash_state::HashState;
 use std::fmt;
-use std::hash::{Hash, Hasher};
+use std::hash::{BuildHasher, Hash, Hasher};
 use std::iter;
 use std::marker;
 use std::mem;
@@ -131,7 +129,7 @@ impl<K, V, S> LinkedHashMap<K, V, S> {
     }
 }
 
-impl<K: Hash + Eq, V, S: HashState> LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     fn with_map(map: HashMap<KeyRef<K>, Box<LinkedHashMapEntry<K, V>>, S>) -> Self {
         LinkedHashMap {
             map: map,
@@ -142,12 +140,12 @@ impl<K: Hash + Eq, V, S: HashState> LinkedHashMap<K, V, S> {
 
     /// Creates an empty linked hash map with the given initial hash state.
     pub fn with_hash_state(hash_state: S) -> Self {
-        Self::with_map(HashMap::with_hash_state(hash_state))
+        Self::with_map(HashMap::with_hasher(hash_state))
     }
 
     /// Creates an empty linked hash map with the given initial capacity and hash state.
     pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S) -> Self {
-        Self::with_map(HashMap::with_capacity_and_hash_state(capacity, hash_state))
+        Self::with_map(HashMap::with_capacity_and_hasher(capacity, hash_state))
     }
 
     /// Reserves capacity for at least `additional` more elements to be inserted into the map. The
@@ -576,7 +574,7 @@ impl<K: Hash + Eq, V, S: HashState> LinkedHashMap<K, V, S> {
 }
 
 impl<'a, K, V, S, Q: ?Sized> Index<&'a Q> for LinkedHashMap<K, V, S>
-    where K: Hash + Eq + Borrow<Q>, S: HashState, Q: Eq + Hash
+    where K: Hash + Eq + Borrow<Q>, S: BuildHasher, Q: Eq + Hash
 {
     type Output = V;
 
@@ -586,14 +584,14 @@ impl<'a, K, V, S, Q: ?Sized> Index<&'a Q> for LinkedHashMap<K, V, S>
 }
 
 impl<'a, K, V, S, Q: ?Sized> IndexMut<&'a Q> for LinkedHashMap<K, V, S>
-    where K: Hash + Eq + Borrow<Q>, S: HashState, Q: Eq + Hash
+    where K: Hash + Eq + Borrow<Q>, S: BuildHasher, Q: Eq + Hash
 {
     fn index_mut(&mut self, index: &'a Q) -> &mut V {
         self.get_mut(index).expect("no entry found for key")
     }
 }
 
-impl<K: Hash + Eq, V, S: HashState> LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
     #[inline]
     fn detach(&mut self, node: *mut LinkedHashMapEntry<K, V>) {
         unsafe {
@@ -622,19 +620,19 @@ impl<K: Hash + Eq + Clone, V: Clone> Clone for LinkedHashMap<K, V> {
     }
 }
 
-impl<K: Hash + Eq, V, S: HashState + Default> Default for LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq, V, S: BuildHasher + Default> Default for LinkedHashMap<K, V, S> {
     fn default() -> Self { LinkedHashMap::with_hash_state(Default::default()) }
 }
 
-impl<K: Hash + Eq, V, S: HashState> Extend<(K, V)> for LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq, V, S: BuildHasher> Extend<(K, V)> for LinkedHashMap<K, V, S> {
     fn extend<T: IntoIterator<Item=(K, V)>>(&mut self, iter: T) {
         for (k, v) in iter {
             self.insert(k, v);
         }
     }
 }
 
-impl<K: Hash + Eq, V, S: HashState + Default> iter::FromIterator<(K, V)> for LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq, V, S: BuildHasher + Default> iter::FromIterator<(K, V)> for LinkedHashMap<K, V, S> {
     fn from_iter<I: IntoIterator<Item=(K, V)>>(iter: I) -> Self {
         let iter = iter.into_iter();
         let mut map = Self::with_capacity_and_hash_state(iter.size_hint().0, Default::default());
@@ -643,14 +641,14 @@ impl<K: Hash + Eq, V, S: HashState + Default> iter::FromIterator<(K, V)> for Lin
     }
 }
 
-impl<A: fmt::Debug + Hash + Eq, B: fmt::Debug, S: HashState> fmt::Debug for LinkedHashMap<A, B, S> {
+impl<A: fmt::Debug + Hash + Eq, B: fmt::Debug, S: BuildHasher> fmt::Debug for LinkedHashMap<A, B, S> {
     /// Returns a string that lists the key-value pairs in insertion order.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_map().entries(self).finish()
     }
 }
 
-impl<K: Hash + Eq, V: PartialEq, S: HashState> PartialEq for LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq, V: PartialEq, S: BuildHasher> PartialEq for LinkedHashMap<K, V, S> {
     fn eq(&self, other: &Self) -> bool {
         self.len() == other.len() && self.iter().eq(other)
     }
@@ -660,9 +658,9 @@ impl<K: Hash + Eq, V: PartialEq, S: HashState> PartialEq for LinkedHashMap<K, V,
     }
 }
 
-impl<K: Hash + Eq, V: Eq, S: HashState> Eq for LinkedHashMap<K, V, S> {}
+impl<K: Hash + Eq, V: Eq, S: BuildHasher> Eq for LinkedHashMap<K, V, S> {}
 
-impl<K: Hash + Eq + PartialOrd, V: PartialOrd, S: HashState> PartialOrd for LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq + PartialOrd, V: PartialOrd, S: BuildHasher> PartialOrd for LinkedHashMap<K, V, S> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.iter().partial_cmp(other)
     }
@@ -684,13 +682,13 @@ impl<K: Hash + Eq + PartialOrd, V: PartialOrd, S: HashState> PartialOrd for Link
     }
 }
 
-impl<K: Hash + Eq + Ord, V: Ord, S: HashState> Ord for LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq + Ord, V: Ord, S: BuildHasher> Ord for LinkedHashMap<K, V, S> {
     fn cmp(&self, other: &Self) -> Ordering {
         self.iter().cmp(other)
     }
 }
 
-impl<K: Hash + Eq, V: Hash, S: HashState> Hash for LinkedHashMap<K, V, S> {
+impl<K: Hash + Eq, V: Hash, S: BuildHasher> Hash for LinkedHashMap<K, V, S> {
     fn hash<H: Hasher>(&self, h: &mut H) { for e in self.iter() { e.hash(h); } }
 }
 
@@ -867,13 +865,13 @@ impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {
     fn len(&self) -> usize { self.inner.len() }
 }
 
-impl<'a, K: Hash + Eq, V, S: HashState> IntoIterator for &'a LinkedHashMap<K, V, S> {
+impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a LinkedHashMap<K, V, S> {
     type Item = (&'a K, &'a V);
     type IntoIter = Iter<'a, K, V>;
     fn into_iter(self) -> Iter<'a, K, V> { self.iter() }
 }
 
-impl<'a, K: Hash + Eq, V, S: HashState> IntoIterator for &'a mut LinkedHashMap<K, V, S> {
+impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a mut LinkedHashMap<K, V, S> {
     type Item = (&'a K, &'a mut V);
     type IntoIter = IterMut<'a, K, V>;
     fn into_iter(self) -> IterMut<'a, K, V> { self.iter_mut() }