use core::default::Default;
use core::fmt;
use core::iter::Take;
+use core::iter;
use core::ops::Index;
use core::slice;
use core::uint;
}
}
+impl PartialOrd for Bitv {
+ #[inline]
+ fn partial_cmp(&self, other: &Bitv) -> Option<Ordering> {
+ iter::order::partial_cmp(self.iter(), other.iter())
+ }
+}
+
+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() {
/// assert!(bv.eq_vec([true, true, false, true,
/// false, false, false, false]));
/// ```
-#[deriving(Clone, PartialEq, Eq)]
+#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct BitvSet(Bitv);
impl Default for BitvSet {
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();
}
}
+impl<V: PartialOrd> PartialOrd for SmallIntMap<V> {
+ #[inline]
+ fn partial_cmp(&self, other: &SmallIntMap<V>) -> Option<Ordering> {
+ iter::order::partial_cmp(self.iter(), other.iter())
+ }
+}
+
+impl<V: Ord> Ord for SmallIntMap<V> {
+ #[inline]
+ fn cmp(&self, other: &SmallIntMap<V>) -> Ordering {
+ iter::order::cmp(self.iter(), other.iter())
+ }
+}
+
impl<V: fmt::Show> fmt::Show for SmallIntMap<V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "{{"));
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();
impl<T: Eq> Eq for TrieMap<T> {}
+impl<T: PartialOrd> PartialOrd for TrieMap<T> {
+ #[inline]
+ fn partial_cmp(&self, other: &TrieMap<T>) -> Option<Ordering> {
+ iter::order::partial_cmp(self.iter(), other.iter())
+ }
+}
+
+impl<T: Ord> Ord for TrieMap<T> {
+ #[inline]
+ fn cmp(&self, other: &TrieMap<T>) -> Ordering {
+ iter::order::cmp(self.iter(), other.iter())
+ }
+}
+
impl<T: Show> Show for TrieMap<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "{{"));
/// set.clear();
/// assert!(set.is_empty());
/// ```
-#[deriving(Clone, Hash, PartialEq, Eq)]
+#[deriving(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct TrieSet {
map: TrieMap<()>
}
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();
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);
+ }
}