Implement Rayon traits (optional)

.travis.yml

@@ -10,6 +10,9 @@ matrix:
     - rust: stable
       env:
        - FEATURES='serde-1'
+    - rust: stable
+      env:
+       - FEATURES='rayon'
     - rust: beta
     - rust: nightly
     - rust: nightly

Cargo.toml

@@ -29,6 +29,7 @@ bench = false
 
 [dependencies]
 serde = { version = "1.0", optional = true }
+rayon = { version = "1.0", optional = true }
 
 [dev-dependencies]
 itertools = "0.8"
@@ -53,4 +54,4 @@ debug = true
 no-dev-version = true
 
 [package.metadata.docs.rs]
-features = ["serde-1"]
+features = ["serde-1", "rayon"]

src/lib.rs

@@ -32,6 +32,11 @@ mod mutable_keys;
 pub mod set;
 pub mod map;
 
+// Placed after `map` and `set` so new `rayon` methods on the types
+// are documented after the "normal" methods.
+#[cfg(feature = "rayon")]
+mod rayon;
+
 pub use equivalent::Equivalent;
 pub use map::IndexMap;
 pub use set::IndexSet;
@@ -78,3 +83,11 @@ impl<K, V> Bucket<K, V> {
     fn muts(&mut self) -> (&mut K, &mut V) { (&mut self.key, &mut self.value) }
 }
 
+trait Entries {
+    type Entry;
+    fn into_entries(self) -> Vec<Self::Entry>;
+    fn as_entries(&self) -> &[Self::Entry];
+    fn as_entries_mut(&mut self) -> &mut [Self::Entry];
+    fn with_entries<F>(&mut self, f: F)
+        where F: FnOnce(&mut [Self::Entry]);
+}

src/map.rs

@@ -3,6 +3,9 @@
 
 pub use mutable_keys::MutableKeys;
 
+#[cfg(feature = "rayon")]
+pub use ::rayon::map as rayon;
+
 use std::hash::Hash;
 use std::hash::BuildHasher;
 use std::hash::Hasher;
@@ -19,6 +22,7 @@ use util::{third, ptrdistance, enumerate};
 use equivalent::Equivalent;
 use {
     Bucket,
+    Entries,
     HashValue,
 };
 
@@ -280,6 +284,30 @@ fn desired_pos(mask: usize, hash: HashValue) -> usize {
     hash.0 & mask
 }
 
+impl<K, V, S> Entries for IndexMap<K, V, S> {
+    type Entry = Bucket<K, V>;
+
+    fn into_entries(self) -> Vec<Self::Entry> {
+        self.core.entries
+    }
+
+    fn as_entries(&self) -> &[Self::Entry] {
+        &self.core.entries
+    }
+
+    fn as_entries_mut(&mut self) -> &mut [Self::Entry] {
+        &mut self.core.entries
+    }
+
+    fn with_entries<F>(&mut self, f: F)
+        where F: FnOnce(&mut [Self::Entry])
+    {
+        let side_index = self.core.save_hash_index();
+        f(&mut self.core.entries);
+        self.core.restore_hash_index(side_index);
+    }
+}
+
 /// The number of steps that `current` is forward of the desired position for hash
 #[inline(always)]
 fn probe_distance(mask: usize, hash: HashValue, current: usize) -> usize {
@@ -1437,15 +1465,21 @@ impl<K, V> OrderMapCore<K, V> {
     fn sort_by<F>(&mut self, mut compare: F)
         where F: FnMut(&K, &V, &K, &V) -> Ordering,
     {
+        let side_index = self.save_hash_index();
+        self.entries.sort_by(move |ei, ej| compare(&ei.key, &ei.value, &ej.key, &ej.value));
+        self.restore_hash_index(side_index);
+    }
+
+    fn save_hash_index(&mut self) -> Vec<usize> {
         // Temporarily use the hash field in a bucket to store the old index.
         // Save the old hash values in `side_index`.  Then we can sort
         // `self.entries` in place.
-        let mut side_index = Vec::from_iter(enumerate(&mut self.entries).map(|(i, elt)| {
+        Vec::from_iter(enumerate(&mut self.entries).map(|(i, elt)| {
             replace(&mut elt.hash, HashValue(i)).get()
-        }));
-
-        self.entries.sort_by(move |ei, ej| compare(&ei.key, &ei.value, &ej.key, &ej.value));
+        }))
+    }
 
+    fn restore_hash_index(&mut self, mut side_index: Vec<usize>) {
         // Write back the hash values from side_index and fill `side_index` with
         // a mapping from the old to the new index instead.
         for (i, ent) in enumerate(&mut self.entries) {