From 16acc10bf9f0318d1d6e310a1fd23dd242811d10 Mon Sep 17 00:00:00 2001 From: nham Date: Sun, 27 Jul 2014 23:51:28 -0400 Subject: [PATCH 1/4] Implement PartialOrd for TrieMap and TrieSet --- src/libcollections/trie.rs | 73 +++++++++++++++++++++++++++++++++++++- 1 file changed, 72 insertions(+), 1 deletion(-) diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs index 1ac05fbd562ed..5d6a9080374e7 100644 --- a/src/libcollections/trie.rs +++ b/src/libcollections/trie.rs @@ -93,6 +93,13 @@ impl PartialEq for TrieMap { impl Eq for TrieMap {} +impl PartialOrd for TrieMap { + #[inline] + fn partial_cmp(&self, other: &TrieMap) -> Option { + iter::order::partial_cmp(self.iter(), other.iter()) + } +} + impl Show for TrieMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "{{")); @@ -517,7 +524,7 @@ impl> Hash for TrieMap { /// set.clear(); /// assert!(set.is_empty()); /// ``` -#[deriving(Clone, Hash, PartialEq, Eq)] +#[deriving(Clone, Hash, PartialEq, Eq, PartialOrd)] pub struct TrieSet { map: TrieMap<()> } @@ -1309,6 +1316,38 @@ mod test_map { assert!(a == b); } + #[test] + fn test_lt() { + let mut a = TrieMap::new(); + let mut b = TrieMap::new(); + + assert!(!(a < b) && !(b < a)); + assert!(b.insert(2u, 5i)); + assert!(a < b); + assert!(a.insert(2, 7)); + assert!(!(a < b) && b < a); + assert!(b.insert(1, 0)); + assert!(b < a); + assert!(a.insert(0, 6)); + assert!(a < b); + assert!(a.insert(6, 2)); + assert!(a < b && !(b < a)); + } + + #[test] + fn test_ord() { + let mut a = TrieMap::new(); + let mut b = TrieMap::new(); + + assert!(a <= b && a >= b); + assert!(a.insert(1u, 1i)); + assert!(a > b && a >= b); + assert!(b < a && b <= a); + assert!(b.insert(2, 2)); + assert!(b > a && b >= a); + assert!(a < b && a <= b); + } + #[test] fn test_hash() { let mut x = TrieMap::new(); @@ -1513,4 +1552,36 @@ mod test_set { assert!(a.clone() == a); } + + #[test] + fn test_lt() { + let mut a = TrieSet::new(); + let mut b = TrieSet::new(); + + assert!(!(a < b) && !(b < a)); + assert!(b.insert(2u)); + assert!(a < b); + assert!(a.insert(3u)); + assert!(!(a < b) && b < a); + assert!(b.insert(1)); + assert!(b < a); + assert!(a.insert(0)); + assert!(a < b); + assert!(a.insert(6)); + assert!(a < b && !(b < a)); + } + + #[test] + fn test_ord() { + let mut a = TrieSet::new(); + let mut b = TrieSet::new(); + + assert!(a <= b && a >= b); + assert!(a.insert(1u)); + assert!(a > b && a >= b); + assert!(b < a && b <= a); + assert!(b.insert(2u)); + assert!(b > a && b >= a); + assert!(a < b && a <= b); + } } From 220f8f6dcb37fd4db4d489337890a4d900e50503 Mon Sep 17 00:00:00 2001 From: nham Date: Mon, 28 Jul 2014 00:00:29 -0400 Subject: [PATCH 2/4] Implement PartialOrd for SmallIntMap --- src/libcollections/smallintmap.rs | 39 +++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs index a60f80b9aef2b..5acabecb6ee51 100644 --- a/src/libcollections/smallintmap.rs +++ b/src/libcollections/smallintmap.rs @@ -373,6 +373,13 @@ impl SmallIntMap { } } +impl PartialOrd for SmallIntMap { + #[inline] + fn partial_cmp(&self, other: &SmallIntMap) -> Option { + iter::order::partial_cmp(self.iter(), other.iter()) + } +} + impl fmt::Show for SmallIntMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "{{")); @@ -770,6 +777,38 @@ mod test_map { assert!(a == b); } + #[test] + fn test_lt() { + let mut a = SmallIntMap::new(); + let mut b = SmallIntMap::new(); + + assert!(!(a < b) && !(b < a)); + assert!(b.insert(2u, 5i)); + assert!(a < b); + assert!(a.insert(2, 7)); + assert!(!(a < b) && b < a); + assert!(b.insert(1, 0)); + assert!(b < a); + assert!(a.insert(0, 6)); + assert!(a < b); + assert!(a.insert(6, 2)); + assert!(a < b && !(b < a)); + } + + #[test] + fn test_ord() { + let mut a = SmallIntMap::new(); + let mut b = SmallIntMap::new(); + + assert!(a <= b && a >= b); + assert!(a.insert(1u, 1i)); + assert!(a > b && a >= b); + assert!(b < a && b <= a); + assert!(b.insert(2, 2)); + assert!(b > a && b >= a); + assert!(a < b && a <= b); + } + #[test] fn test_hash() { let mut x = SmallIntMap::new(); From 935c88ce1c863b6bfa3e4a295e6999a5593c08e2 Mon Sep 17 00:00:00 2001 From: nham Date: Mon, 28 Jul 2014 00:28:49 -0400 Subject: [PATCH 3/4] Implement PartialOrd for Bitv and BitvSet --- src/libcollections/bitv.rs | 41 +++++++++++++++++++++++++++++++++++++- 1 file changed, 40 insertions(+), 1 deletion(-) diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index 44af3d52db982..55caf807b4fd4 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -67,6 +67,7 @@ use core::cmp; use core::default::Default; use core::fmt; use core::iter::Take; +use core::iter; use core::ops::Index; use core::slice; use core::uint; @@ -830,6 +831,13 @@ impl Clone for Bitv { } } +impl PartialOrd for Bitv { + #[inline] + fn partial_cmp(&self, other: &Bitv) -> Option { + iter::order::partial_cmp(self.iter(), other.iter()) + } +} + impl fmt::Show for Bitv { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { for bit in self.iter() { @@ -955,7 +963,7 @@ impl<'a> RandomAccessIterator for Bits<'a> { /// assert!(bv.eq_vec([true, true, false, true, /// false, false, false, false])); /// ``` -#[deriving(Clone, PartialEq, Eq)] +#[deriving(Clone, PartialEq, Eq, PartialOrd)] pub struct BitvSet(Bitv); impl Default for BitvSet { @@ -2189,6 +2197,37 @@ mod tests { assert_eq!(a.capacity(), uint::BITS); } + #[test] + fn test_bitv_lt() { + let mut a = Bitv::with_capacity(5u, false); + let mut b = Bitv::with_capacity(5u, false); + + assert!(!(a < b) && !(b < a)); + b.set(2, true); + assert!(a < b); + a.set(3, true); + assert!(a < b); + a.set(2, true); + assert!(!(a < b) && b < a); + b.set(0, true); + assert!(a < b); + } + + #[test] + fn test_ord() { + let mut a = Bitv::with_capacity(5u, false); + let mut b = Bitv::with_capacity(5u, false); + + assert!(a <= b && a >= b); + a.set(1, true); + assert!(a > b && a >= b); + assert!(b < a && b <= a); + b.set(1, true); + b.set(2, true); + assert!(b > a && b >= a); + assert!(a < b && a <= b); + } + #[test] fn test_bitv_clone() { let mut a = BitvSet::new(); From 8ebd58cedf616580a4052ad6df1ce74cfcd520c0 Mon Sep 17 00:00:00 2001 From: nham Date: Mon, 28 Jul 2014 02:53:44 -0400 Subject: [PATCH 4/4] Implement Ord for TrieMap/TrieSet/SmallIntMap/Bitv/BitvSet --- src/libcollections/bitv.rs | 9 ++++++++- src/libcollections/smallintmap.rs | 7 +++++++ src/libcollections/trie.rs | 9 ++++++++- 3 files changed, 23 insertions(+), 2 deletions(-) diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index 55caf807b4fd4..3e1160b45eee4 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -838,6 +838,13 @@ impl PartialOrd for Bitv { } } +impl Ord for Bitv { + #[inline] + fn cmp(&self, other: &Bitv) -> Ordering { + iter::order::cmp(self.iter(), other.iter()) + } +} + impl fmt::Show for Bitv { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { for bit in self.iter() { @@ -963,7 +970,7 @@ impl<'a> RandomAccessIterator for Bits<'a> { /// assert!(bv.eq_vec([true, true, false, true, /// false, false, false, false])); /// ``` -#[deriving(Clone, PartialEq, Eq, PartialOrd)] +#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)] pub struct BitvSet(Bitv); impl Default for BitvSet { diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs index 5acabecb6ee51..f567c5777b171 100644 --- a/src/libcollections/smallintmap.rs +++ b/src/libcollections/smallintmap.rs @@ -380,6 +380,13 @@ impl PartialOrd for SmallIntMap { } } +impl Ord for SmallIntMap { + #[inline] + fn cmp(&self, other: &SmallIntMap) -> Ordering { + iter::order::cmp(self.iter(), other.iter()) + } +} + impl fmt::Show for SmallIntMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "{{")); diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs index 5d6a9080374e7..cd011b0e01339 100644 --- a/src/libcollections/trie.rs +++ b/src/libcollections/trie.rs @@ -100,6 +100,13 @@ impl PartialOrd for TrieMap { } } +impl Ord for TrieMap { + #[inline] + fn cmp(&self, other: &TrieMap) -> Ordering { + iter::order::cmp(self.iter(), other.iter()) + } +} + impl Show for TrieMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { try!(write!(f, "{{")); @@ -524,7 +531,7 @@ impl> Hash for TrieMap { /// set.clear(); /// assert!(set.is_empty()); /// ``` -#[deriving(Clone, Hash, PartialEq, Eq, PartialOrd)] +#[deriving(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct TrieSet { map: TrieMap<()> }