FEAT: Implement in-place sorting with .sort_by()

Author: bluss

src/lib.rs

@@ -1044,6 +1044,52 @@ impl<K, V, S> OrderMap<K, V, S>
         }
     }
 
+    pub fn sort_by<F>(&mut self, mut compare: F)
+        where F: FnMut(&K, &V, &K, &V) -> Ordering,
+    {
+        // new_index will form a lookup map from current index -> new index.
+        let mut new_index = Vec::from_iter(0..self.len());
+        new_index.sort_by(|&i, &j| {
+            let ei = &self.entries[i];
+            let ej = &self.entries[j];
+            compare(&ei.key, &ei.value, &ej.key, &ej.value)
+        });
+
+        // Apply new index to self.indices
+        dispatch_32_vs_64!(self.apply_new_index(&new_index));
+
+        // Apply new index to entries
+        apply_permutation(&mut new_index, &mut self.entries);
+
+        /// Apply a permutation
+        ///
+        /// perm: Each index 0..v.len() appear exactly once.
+        fn apply_permutation<T>(perm: &mut [usize], v: &mut [T]) {
+            debug_assert_eq!(perm.len(), v.len());
+             
+            for i in 0..perm.len() {
+                let mut current = i;
+                while i != perm[current] {
+                    let next = replace(&mut perm[current], current);
+                    // move element from next to current
+                    v.swap(next, current);
+                    current = next;
+                }
+                perm[current] = current;
+            }
+        }
+    }
+
+    fn apply_new_index<Sz>(&mut self, new_index: &[usize])
+        where Sz: Size
+    {
+        for pos in self.indices.iter_mut() {
+            if let Some((i, _)) = pos.resolve::<Sz>() {
+                pos.set_pos::<Sz>(new_index[i]);
+            }
+        }
+    }
+
     /// Sort the key-value pairs of the map and return a by value iterator of
     /// the key-value pairs with the result.
     ///

tests/quick.rs

@@ -273,6 +273,40 @@ quickcheck! {
         // check the order
         itertools::assert_equal(map.keys(), initial_map.keys().filter(|&k| !remove_map.contains_key(k)));
     }
+
+    fn sort_1(keyvals: Large<Vec<(i8, i8)>>) -> () {
+        let mut map: OrderMap<_, _> = OrderMap::from_iter(keyvals.to_vec());
+        let mut answer = keyvals.0;
+        answer.sort_by_key(|t| t.0);
+
+        // reverse dedup: Because OrderMap::from_iter keeps the last value for
+        // identical keys
+        answer.reverse();
+        answer.dedup_by_key(|t| t.0);
+        answer.reverse();
+
+        map.sort_by(|k1, _, k2, _| Ord::cmp(k1, k2));
+        let mapv = Vec::from_iter(map);
+        assert_eq!(answer, mapv);
+    }
+
+    fn sort_2(keyvals: Large<Vec<(i8, i8)>>) -> () {
+        let mut map: OrderMap<_, _> = OrderMap::from_iter(keyvals.to_vec());
+        map.sort_by(|_, v1, _, v2| Ord::cmp(v1, v2));
+        assert_sorted_by_key(map, |t| t.1);
+    }
+}
+
+fn assert_sorted_by_key<I, Key, X>(iterable: I, key: Key)
+    where I: IntoIterator,
+          I::Item: Ord + Clone + Debug,
+          Key: Fn(&I::Item) -> X,
+          X: Ord,
+{
+    let input = Vec::from_iter(iterable);
+    let mut sorted = input.clone();
+    sorted.sort_by_key(key);
+    assert_eq!(input, sorted);
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]