Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Eliminated SmallIntSet #7934

Closed
wants to merge 1 commit into from
Closed

Eliminated SmallIntSet #7934

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
369 changes: 0 additions & 369 deletions src/libextra/smallintmap.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,8 +15,6 @@

#[allow(missing_doc)];


use std::cmp;
use std::iterator::{Iterator, IteratorUtil, EnumerateIterator, FilterMapIterator, InvertIterator};
use std::uint;
use std::util::replace;
Expand Down Expand Up @@ -309,155 +307,6 @@ double_ended_iterator!(impl SmallIntMapMutIterator -> (uint, &'self mut T), get_
pub type SmallIntMapMutRevIterator<'self, T> = InvertIterator<(uint, &'self mut T),
SmallIntMapMutIterator<'self, T>>;


/// A set implemented on top of the SmallIntMap type. This set is always a set
/// of integers, and the space requirements are on the order of the highest
/// valued integer in the set.
pub struct SmallIntSet {
priv map: SmallIntMap<()>
}

impl Container for SmallIntSet {
/// Return the number of elements in the map
fn len(&self) -> uint {
self.map.len()
}

/// Return true if the map contains no elements
fn is_empty(&self) -> bool { self.len() == 0 }
}

impl Mutable for SmallIntSet {
/// Clear the map, removing all key-value pairs.
fn clear(&mut self) { self.map.clear() }
}

impl Set<uint> for SmallIntSet {
/// Return true if the set contains a value
fn contains(&self, value: &uint) -> bool { self.map.contains_key(value) }

/// Return true if the set has no elements in common with `other`.
/// This is equivalent to checking for an empty uintersection.
fn is_disjoint(&self, other: &SmallIntSet) -> bool {
for self.each |v| { if other.contains(v) { return false } }
true
}

/// Return true if the set is a subset of another
fn is_subset(&self, other: &SmallIntSet) -> bool {
for self.each |v| { if !other.contains(v) { return false } }
true
}

/// Return true if the set is a superset of another
fn is_superset(&self, other: &SmallIntSet) -> bool {
other.is_subset(self)
}

/// Visit the values representing the difference
fn difference(&self, other: &SmallIntSet, f: &fn(&uint) -> bool) -> bool {
self.each(|v| other.contains(v) || f(v))
}

/// Visit the values representing the symmetric difference
fn symmetric_difference(&self,
other: &SmallIntSet,
f: &fn(&uint) -> bool) -> bool {
let len = cmp::max(self.map.v.len() ,other.map.v.len());

for uint::range(0, len) |i| {
if self.contains(&i) ^ other.contains(&i) {
if !f(&i) { return false; }
}
}
return true;
}

/// Visit the values representing the uintersection
fn intersection(&self, other: &SmallIntSet, f: &fn(&uint) -> bool) -> bool {
self.each(|v| !other.contains(v) || f(v))
}

/// Visit the values representing the union
fn union(&self, other: &SmallIntSet, f: &fn(&uint) -> bool) -> bool {
let len = cmp::max(self.map.v.len() ,other.map.v.len());

for uint::range(0, len) |i| {
if self.contains(&i) || other.contains(&i) {
if !f(&i) { return false; }
}
}
return true;
}
}

impl MutableSet<uint> for SmallIntSet {
/// Add a value to the set. Return true if the value was not already
/// present in the set.
fn insert(&mut self, value: uint) -> bool { self.map.insert(value, ()) }

/// Remove a value from the set. Return true if the value was
/// present in the set.
fn remove(&mut self, value: &uint) -> bool { self.map.remove(value) }
}

impl SmallIntSet {
/// Create an empty SmallIntSet
pub fn new() -> SmallIntSet { SmallIntSet{map: SmallIntMap::new()} }

/// Visit all values in order
pub fn each(&self, f: &fn(&uint) -> bool) -> bool { self.map.each_key(f) }

/// An iterator visiting all set members in ascending order.
/// Iterator element type is uint
pub fn iter<'r>(&'r self) -> SmallIntSetIterator<'r> {
SmallIntSetIterator {
iter: self.map.iter()
}
}

/// An iterator visiting all set members in descending order.
/// Iterator element type is uint
pub fn rev_iter<'r>(&'r mut self) -> SmallIntSetRevIterator<'r> {
self.iter().invert()
}

}

pub struct SmallIntSetIterator<'self> {
priv iter: SmallIntMapIterator<'self, ()>
}

impl<'self> Iterator<uint> for SmallIntSetIterator<'self> {
#[inline]
fn next(&mut self) -> Option<uint> {
let next_opt = self.iter.next();
match next_opt {
None => { None }
Some((idx, _)) => { Some(idx) }
}
}

#[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
self.iter.size_hint()
}
}

impl<'self> DoubleEndedIterator<uint> for SmallIntSetIterator<'self> {
#[inline]
fn next_back(&mut self) -> Option<uint> {
let next_opt = self.iter.next_back();
match next_opt {
None => { None }
Some((idx, _)) => { Some(idx) }
}
}
}

pub type SmallIntSetRevIterator<'self> = InvertIterator<uint, SmallIntSetIterator<'self>>;


#[cfg(test)]
mod test_map {

Expand Down Expand Up @@ -732,221 +581,3 @@ mod bench {
find_seq_n(10_000, &mut m, bh);
}
}

#[cfg(test)]
mod test_set {

use super::SmallIntSet;

#[test]
fn test_disjoint() {
let mut xs = SmallIntSet::new();
let mut ys = SmallIntSet::new();
assert!(xs.is_disjoint(&ys));
assert!(ys.is_disjoint(&xs));
assert!(xs.insert(5));
assert!(ys.insert(11));
assert!(xs.is_disjoint(&ys));
assert!(ys.is_disjoint(&xs));
assert!(xs.insert(7));
assert!(xs.insert(19));
assert!(xs.insert(4));
assert!(ys.insert(2));
assert!(xs.is_disjoint(&ys));
assert!(ys.is_disjoint(&xs));
assert!(ys.insert(7));
assert!(!xs.is_disjoint(&ys));
assert!(!ys.is_disjoint(&xs));
}

#[test]
fn test_subset_and_superset() {
let mut a = SmallIntSet::new();
assert!(a.insert(0));
assert!(a.insert(5));
assert!(a.insert(11));
assert!(a.insert(7));

let mut b = SmallIntSet::new();
assert!(b.insert(0));
assert!(b.insert(7));
assert!(b.insert(19));
assert!(b.insert(250));
assert!(b.insert(11));
assert!(b.insert(200));

assert!(!a.is_subset(&b));
assert!(!a.is_superset(&b));
assert!(!b.is_subset(&a));
assert!(!b.is_superset(&a));

assert!(b.insert(5));

assert!(a.is_subset(&b));
assert!(!a.is_superset(&b));
assert!(!b.is_subset(&a));
assert!(b.is_superset(&a));
}

#[test]
fn test_intersection() {
let mut a = SmallIntSet::new();
let mut b = SmallIntSet::new();

assert!(a.insert(11));
assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(77));
assert!(a.insert(103));
assert!(a.insert(5));

assert!(b.insert(2));
assert!(b.insert(11));
assert!(b.insert(77));
assert!(b.insert(5));
assert!(b.insert(3));

let mut i = 0;
let expected = [3, 5, 11, 77];
for a.intersection(&b) |x| {
assert!(expected.contains(x));
i += 1
}
assert_eq!(i, expected.len());
}

#[test]
fn test_difference() {
let mut a = SmallIntSet::new();
let mut b = SmallIntSet::new();

assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(5));
assert!(a.insert(9));
assert!(a.insert(11));

assert!(b.insert(3));
assert!(b.insert(9));

let mut i = 0;
let expected = [1, 5, 11];
for a.difference(&b) |x| {
assert!(expected.contains(x));
i += 1
}
assert_eq!(i, expected.len());
}

#[test]
fn test_symmetric_difference() {
let mut a = SmallIntSet::new();
let mut b = SmallIntSet::new();

assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(5));
assert!(a.insert(9));
assert!(a.insert(11));

assert!(b.insert(3));
assert!(b.insert(9));
assert!(b.insert(14));
assert!(b.insert(22));

let mut i = 0;
let expected = [1, 5, 11, 14, 22];
for a.symmetric_difference(&b) |x| {
assert!(expected.contains(x));
i += 1
}
assert_eq!(i, expected.len());
}

#[test]
fn test_union() {
let mut a = SmallIntSet::new();
let mut b = SmallIntSet::new();

assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(5));
assert!(a.insert(9));
assert!(a.insert(11));
assert!(a.insert(16));
assert!(a.insert(19));
assert!(a.insert(24));

assert!(b.insert(1));
assert!(b.insert(5));
assert!(b.insert(9));
assert!(b.insert(13));
assert!(b.insert(19));

let mut i = 0;
let expected = [1, 3, 5, 9, 11, 13, 16, 19, 24];
for a.union(&b) |x| {
assert!(expected.contains(x));
i += 1
}
assert_eq!(i, expected.len());
}

#[test]
fn test_iterator() {
let mut a = SmallIntSet::new();

assert!(a.insert(0));
assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(6));
assert!(a.insert(10));

let mut it = a.iter();
assert_eq!(it.size_hint(), (0, Some(11)));
assert_eq!(it.next().unwrap(), 0);
assert_eq!(it.size_hint(), (0, Some(10)));
assert_eq!(it.next().unwrap(), 1);
assert_eq!(it.size_hint(), (0, Some(9)));
assert_eq!(it.next().unwrap(), 3);
assert_eq!(it.size_hint(), (0, Some(7)));
assert_eq!(it.next().unwrap(), 6);
assert_eq!(it.size_hint(), (0, Some(4)));
assert_eq!(it.next().unwrap(), 10);
assert_eq!(it.size_hint(), (0, Some(0)));
assert!(it.next().is_none());
}

#[test]
fn test_iterator_size_hints() {
let mut a = SmallIntSet::new();

assert!(a.insert(0));
assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(6));
assert!(a.insert(10));

assert_eq!(a.iter().size_hint(), (0, Some(11)));
assert_eq!(a.rev_iter().size_hint(), (0, Some(11)));
}

#[test]
fn test_rev_iterator() {
let mut a = SmallIntSet::new();

assert!(a.insert(0));
assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(6));
assert!(a.insert(10));

let mut it = a.rev_iter();
assert_eq!(it.next().unwrap(), 10);
assert_eq!(it.next().unwrap(), 6);
assert_eq!(it.next().unwrap(), 3);
assert_eq!(it.next().unwrap(), 1);
assert_eq!(it.next().unwrap(), 0);
assert!(it.next().is_none());
}
}