Merge pull request sekineh#5 from sekineh/depend-external-compare-crate

v0.2.0

Author: sekineh

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "binary-heap-plus"
-version = "0.1.6"
+version = "0.2.0"
 authors = ["SEKINE, Hideki <sekineh@me.com>"]
 description = "Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps."
 license = "MIT"
@@ -9,12 +9,9 @@ readme = "README.md"
 keywords = ["binary", "heap", "priority", "queue"]
 category = ["data-structures", "algorithms", ]
 
-[features]
-serde1 = ["serde", "serde_derive"]
-
 [dependencies]
-serde = { version = "1", optional = true }
-serde_derive = { version = "^1.0.38", optional = true }
+compare = "0.1.0"
+serde = { version = "1.0", optional = true, features = ["derive"] }
 
 [dev-dependencies]
 serde_json = "1.0.39"

README.md

@@ -54,6 +54,14 @@ for the same purpose.
 
 # Changes
 
+## v0.2.0
+
+* [COMPATIBILITY CHANGE] Use `Compare` trait from `compare` crate instead of our own definition.
+Most users should not be affected by this. TIP: External `Compare<T>` impls needs to be updated to use `Fn` instead of `FnMut`.
+* [COMPATIBILITY CHANGE] rename feature `serde1` to `serde` in order to comply with the guideline: 
+https://rust-lang-nursery.github.io/api-guidelines/interoperability.html#c-serde
+* Refactor ctor impl.
+
 ## v0.1.6
 
 * Add generic constructor `from_vec()` and `from_vec_cmp()`.

appveyor.yml

@@ -45,13 +45,13 @@ test_script:
   # we don't run the "test phase" when doing deploys
   - if [%APPVEYOR_REPO_TAG%]==[false] (
       cargo build --target %TARGET% &&
-      cargo build --target %TARGET% --features serde1 &&
+      cargo build --target %TARGET% --features serde &&
       cargo build --target %TARGET% --release &&
-      cargo build --target %TARGET% --release --features serde1 &&
+      cargo build --target %TARGET% --release --features serde &&
       cargo test --target %TARGET% &&
-      cargo test --target %TARGET% --features serde1 &&
+      cargo test --target %TARGET% --features serde &&
       cargo test --target %TARGET% --release &&
-      cargo test --target %TARGET% --release --features serde1
+      cargo test --target %TARGET% --release --features serde
     )
 
 before_deploy:

ci/script.sh

@@ -5,16 +5,18 @@ set -ex
 # DONE This is the "test phase", tweak it as you see fit
 main() {
     cross build --target $TARGET
+    cross build --target $TARGET --features serde
     cross build --target $TARGET --release
+    cross build --target $TARGET --release --features serde
 
     if [ ! -z $DISABLE_TESTS ]; then
         return
     fi
 
     cross test --target $TARGET
-    cross test --target $TARGET --features serde1
+    cross test --target $TARGET --features serde
     cross test --target $TARGET --release
-    cross test --target $TARGET --release --features serde1
+    cross test --target $TARGET --release --features serde
 
     # cross run --target $TARGET
     # cross run --target $TARGET --release

src/binary_heap.rs

@@ -165,9 +165,12 @@ use std::iter::FromIterator;
 use std::slice;
 // use std::iter::FusedIterator;
 // use std::vec::Drain;
+use compare::Compare;
 use core::fmt;
 use core::mem::{size_of, swap};
 use core::ptr;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::vec;
@@ -229,7 +232,7 @@ use std::vec;
 /// assert!(heap.is_empty())
 /// ```
 // #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct BinaryHeap<T, C = MaxComparator>
 where
     C: Compare<T>,
@@ -238,61 +241,54 @@ where
     cmp: C,
 }
 
-/// Simpler replacement for the `Ord` trait.
-/// The difference is that you can define multiple sort orders on a single type `T`.
-/// Unlike `Ord` trait, `Compare<T>` trait can be easily implemented by providing a single function.
-pub trait Compare<T>: Clone {
-    fn compare(&mut self, a: &T, b: &T) -> Ordering;
-}
-
 /// For `T` that implements `Ord`, you can use this struct to quickly
 /// set up a max heap.
-#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
-#[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
 pub struct MaxComparator;
 
 impl<T: Ord> Compare<T> for MaxComparator {
-    fn compare(&mut self, a: &T, b: &T) -> Ordering {
+    fn compare(&self, a: &T, b: &T) -> Ordering {
         a.cmp(&b)
     }
 }
 
 /// For `T` that implements `Ord`, you can use this struct to quickly
 /// set up a min heap.
-#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
-#[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
 pub struct MinComparator;
 
 impl<T: Ord> Compare<T> for MinComparator {
-    fn compare(&mut self, a: &T, b: &T) -> Ordering {
+    fn compare(&self, a: &T, b: &T) -> Ordering {
         b.cmp(&a)
     }
 }
 
 /// The comparator defined by closure
-#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
-#[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
 pub struct FnComparator<F>(pub F);
 
 impl<T, F> Compare<T> for FnComparator<F>
 where
-    F: Clone + FnMut(&T, &T) -> Ordering,
+    F: Clone + Fn(&T, &T) -> Ordering,
 {
-    fn compare(&mut self, a: &T, b: &T) -> Ordering {
+    fn compare(&self, a: &T, b: &T) -> Ordering {
         self.0(a, b)
     }
 }
 
 /// The comparator ordered by key
-#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
-#[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
 pub struct KeyComparator<F: Clone>(pub F);
 
 impl<K: Ord, T, F> Compare<T> for KeyComparator<F>
 where
-    F: Clone + FnMut(&T) -> K,
+    F: Clone + Fn(&T) -> K,
 {
-    fn compare(&mut self, a: &T, b: &T) -> Ordering {
+    fn compare(&self, a: &T, b: &T) -> Ordering {
         self.0(a).cmp(&self.0(b))
     }
 }
@@ -353,7 +349,7 @@ impl<'a, T, C: Compare<T>> PeekMut<'a, T, C> {
 }
 
 // #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone, C: Compare<T>> Clone for BinaryHeap<T, C> {
+impl<T: Clone, C: Compare<T> + Clone> Clone for BinaryHeap<T, C> {
     fn clone(&self) -> Self {
         BinaryHeap {
             data: self.data.clone(),
@@ -383,22 +379,22 @@ impl<T: fmt::Debug, C: Compare<T>> fmt::Debug for BinaryHeap<T, C> {
 }
 
 impl<T, C: Compare<T> + Default> BinaryHeap<T, C> {
+    /// Generic constructor for `BinaryHeap` from `Vec`.
+    ///
+    /// Because `BinaryHeap` stores the elements in its internal `Vec`,
+    /// it's natural to construct it from `Vec`.
     pub fn from_vec(vec: Vec<T>) -> Self {
-        let mut heap = BinaryHeap {
-            data: vec,
-            cmp: C::default(),
-        };
-        heap.rebuild();
-        heap
+        BinaryHeap::from_vec_cmp(vec, C::default())
     }
 }
 
 impl<T, C: Compare<T>> BinaryHeap<T, C> {
+    /// Generic constructor for `BinaryHeap` from `Vec` and comparator.
+    ///
+    /// Because `BinaryHeap` stores the elements in its internal `Vec`,
+    /// it's natural to construct it from `Vec`.
     pub fn from_vec_cmp(vec: Vec<T>, cmp: C) -> Self {
-        let mut heap = BinaryHeap {
-            data: vec,
-            cmp,
-        };
+        let mut heap = BinaryHeap { data: vec, cmp };
         heap.rebuild();
         heap
     }
@@ -500,7 +496,7 @@ impl<T: Ord> BinaryHeap<T, MinComparator> {
 
 impl<T, F> BinaryHeap<T, FnComparator<F>>
 where
-    F: Clone + FnMut(&T, &T) -> Ordering,
+    F: Clone + Fn(&T, &T) -> Ordering,
 {
     /// Creates an empty `BinaryHeap`.
     ///
@@ -549,7 +545,7 @@ where
 
 impl<T, F, K: Ord> BinaryHeap<T, KeyComparator<F>>
 where
-    F: Clone + FnMut(&T) -> K,
+    F: Clone + Fn(&T) -> K,
 {
     /// Creates an empty `BinaryHeap`.
     ///

src/lib.rs

@@ -1,53 +1,58 @@
 //! This crate provides `BinaryHeap` which is backward-compatible with `std::collections::BinaryHeap`.
 //! 
-//! # Constructers
-//! 
-//! ## Dedicated methods to create different kind of heaps
-//! 
-//! * `BinaryHeap::new()` creates a max heap.
-//! * `BinaryHeap::new_min()` creates a min heap.
-//! * `BinaryHeap::new_by()` creates a heap sorted by the given closure.
-//! * `BinaryHeap::new_by_key()` creates a heap sorted by the key generated by the given closure.
+//! Added features include:
+//! * Heaps other than max heap.
+//! * Optional `serde` feature.
 //! 
+//! # Constructers
+//!
 //! ## Generic methods to create different kind of heaps from initial `vec` data.
-//! 
+//!
 //! * `BinaryHeap::from_vec(vec)`
 //! * `BinaryHeap::from_vec_cmp(vec, cmp)`
+//! 
 //! ```
 //! use binary_heap_plus::*;
-//! 
-//! // max heap
+//!
+//! // max heap (default)
 //! let mut heap: BinaryHeap<i32> = BinaryHeap::from_vec(vec![1,5,3]);
 //! assert_eq!(heap.pop(), Some(5));
-//! 
+//!
 //! // min heap
 //! let mut heap: BinaryHeap<i32, MinComparator> = BinaryHeap::from_vec(vec![1,5,3]);
 //! assert_eq!(heap.pop(), Some(1));
-//! 
+//!
 //! // custom-sort heap
-//! let mut heap = BinaryHeap::from_vec_cmp(vec![1,5,3], FnComparator(|a: &i32, b: &i32| a.cmp(b)));
-//! assert_eq!(heap.pop(), Some(5));
-//! 
+//! let mut heap = BinaryHeap::from_vec_cmp(vec![1,5,3], FnComparator(|a: &i32, b: &i32| b.cmp(a)));
+//! assert_eq!(heap.pop(), Some(1));
+//!
 //! // custom-key heap
 //! let mut heap = BinaryHeap::from_vec_cmp(vec![6,3,1], KeyComparator(|k: &i32| k % 4));
 //! assert_eq!(heap.pop(), Some(3));
-//! 
+//!
 //! // TIP: How to reuse a comparator
 //! let mod4_comparator = KeyComparator(|k: &_| k % 4);
-//! let mut heap = BinaryHeap::from_vec_cmp(vec![6,3,1], mod4_comparator);
-//! assert_eq!(heap.pop(), Some(3));
+//! let mut heap1 = BinaryHeap::from_vec_cmp(vec![6,3,1], mod4_comparator);
+//! assert_eq!(heap1.pop(), Some(3));
+//! let mut heap2 = BinaryHeap::from_vec_cmp(vec![2,4,1], mod4_comparator);
+//! assert_eq!(heap2.pop(), Some(2));
 //! ```
+//!
+//! ## Dedicated methods to create different kind of heaps
+//!
+//! * `BinaryHeap::new()` creates a max heap.
+//! * `BinaryHeap::new_min()` creates a min heap.
+//! * `BinaryHeap::new_by()` creates a heap sorted by the given closure.
+//! * `BinaryHeap::new_by_key()` creates a heap sorted by the key generated by the given closure.
+//!
 
 mod binary_heap;
 pub use binary_heap::*;
+extern crate compare;
 extern crate core;
-#[cfg(feature = "serde1")]
+#[cfg(feature = "serde")]
 extern crate serde;
-#[cfg(feature = "serde1")]
-#[macro_use]
-extern crate serde_derive;
-
-#[cfg(all(feature = "serde1", test))]
+#[cfg(all(feature = "serde", test))]
 extern crate serde_json;
 
 /// An intermediate trait for specialization of `Extend`.
@@ -361,9 +366,9 @@ mod from_liballoc {
 
 }
 
-#[cfg(feature = "serde1")]
+#[cfg(feature = "serde")]
 #[cfg(test)]
-mod tests_serde1 {
+mod tests_serde {
     use super::binary_heap::*;
     use serde_json;