---

yaml
---
r: 42111
b: refs/heads/master
c: bfa9c9a
h: refs/heads/master
i:
  42109: 6d697e7
  42107: 6807641
  42103: 9b15c94
  42095: 8b45c67
  42079: df6601b
  42047: f810075
  41983: 3f927ed
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 456af7a79da586a3c64d810a9157bba0616b6b53
+refs/heads/master: bfa9c9a00f0a301a5e936ae14c6a95e98f3bf5ee
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/src/libcore/container.rs

@@ -65,4 +65,10 @@ pub trait Set<T>: Mutable {
     /// Remove a value from the set. Return true if the value was
     /// present in the set.
     fn remove(&mut self, value: &T) -> bool;
+
+    /// Return true if the set is a subset of another
+    pure fn is_subset(&self, other: &self) -> bool;
+
+    /// Return true if the set is a superset of another
+    pure fn is_superset(&self, other: &self) -> bool;
 }

trunk/src/libcore/hashmap.rs

@@ -25,6 +25,7 @@ pub mod linear {
     use cmp::Eq;
     use cmp;
     use hash::Hash;
+    use iter;
     use kinds::Copy;
     use option::{None, Option, Some};
     use option;
@@ -453,6 +454,16 @@ pub mod linear {
         /// Remove a value from the set. Return true if the value was
         /// present in the set.
         fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
+
+        /// Return true if the set is a subset of another
+        pure fn is_subset(&self, other: &LinearSet<T>) -> bool {
+            iter::all(self, |v| other.contains(v))
+        }
+
+        /// Return true if the set is a superset of another
+        pure fn is_superset(&self, other: &LinearSet<T>) -> bool {
+            other.is_subset(self)
+        }
     }
 
     pub impl <T: Hash IterBytes Eq> LinearSet<T> {
@@ -462,7 +473,7 @@ pub mod linear {
 }
 
 #[test]
-pub mod test {
+mod test_map {
     use container::{Container, Mutable, Map, Set};
     use option::{None, Some};
     use hashmap::linear::LinearMap;
@@ -610,3 +621,37 @@ pub mod test {
         assert !m.is_empty();
     }
 }
+
+#[test]
+mod test_set {
+    use super::*;
+
+    #[test]
+    fn test_subset_and_superset() {
+        let mut a = linear::LinearSet::new();
+        assert a.insert(0);
+        assert a.insert(5);
+        assert a.insert(11);
+        assert a.insert(7);
+
+        let mut b = linear::LinearSet::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);
+    }
+}

trunk/src/libstd/treemap.rs

@@ -291,6 +291,43 @@ impl <T: Ord> TreeSet<T>: Set<T> {
     /// Remove a value from the set. Return true if the value was
     /// present in the set.
     fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
+
+    /// Return true if the set is a subset of another
+    pure fn is_subset(&self, other: &TreeSet<T>) -> bool {
+        other.is_superset(self)
+    }
+
+    /// Return true if the set is a superset of another
+    pure fn is_superset(&self, other: &TreeSet<T>) -> bool {
+        let mut x = self.iter();
+        let mut y = other.iter();
+        unsafe { // purity workaround
+            x = x.next();
+            y = y.next();
+            let mut a = x.get();
+            let mut b = y.get();
+            while b.is_some() {
+                if a.is_none() {
+                    return false
+                }
+
+                let a1 = a.unwrap();
+                let b1 = b.unwrap();
+
+                if b1 < a1 {
+                    return false
+                }
+
+                if !(a1 < b1) {
+                    y = y.next();
+                    b = y.get();
+                }
+                x = x.next();
+                a = x.get();
+            }
+        }
+        true
+    }
 }
 
 impl <T: Ord> TreeSet<T> {
@@ -335,43 +372,6 @@ impl <T: Ord> TreeSet<T> {
         true
     }
 
-    /// Check of the set is a subset of another
-    pure fn is_subset(&self, other: &TreeSet<T>) -> bool {
-        other.is_superset(self)
-    }
-
-    /// Check of the set is a superset of another
-    pure fn is_superset(&self, other: &TreeSet<T>) -> bool {
-        let mut x = self.iter();
-        let mut y = other.iter();
-        unsafe { // purity workaround
-            x = x.next();
-            y = y.next();
-            let mut a = x.get();
-            let mut b = y.get();
-            while b.is_some() {
-                if a.is_none() {
-                    return false
-                }
-
-                let a1 = a.unwrap();
-                let b1 = b.unwrap();
-
-                if b1 < a1 {
-                    return false
-                }
-
-                if !(a1 < b1) {
-                    y = y.next();
-                    b = y.get();
-                }
-                x = x.next();
-                a = x.get();
-            }
-        }
-        true
-    }
-
     /// Visit the values (in-order) representing the difference
     pure fn difference(&self, other: &TreeSet<T>, f: fn(&T) -> bool) {
         let mut x = self.iter();