---

yaml
---
r: 22591
b: refs/heads/master
c: c858eb0
h: refs/heads/master
i:
  22589: 6dbc851
  22587: d1b4098
  22583: 0273c9e
  22575: 88dc75a
  22559: 8067642
  22527: 8f84e2e
v: v3

Author: eholk

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ee855caa5df4a9224aaf7b4ab5f644d3ef071f1b
+refs/heads/master: c858eb06546ce2be77fd284f707f76cb820c6211
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libstd/bitv.rs

@@ -15,16 +15,20 @@ export is_false;
 export to_vec;
 export to_str;
 export eq_vec;
+export methods;
 
 // FIXME (#2341): With recursive object types, we could implement binary
 // methods like union, intersection, and difference. At that point, we could
 // write an optimizing version of this module that produces a different obj
 // for the case where nbits <= 32.
 
 /// The bitvector type
-type bitv = @{storage: ~[mut uint], nbits: uint};
+type bitv = {storage: ~[mut uint], nbits: uint};
 
-const uint_bits: uint = 32u + (1u << 32u >> 27u);
+#[cfg(target_arch="x86")]
+const uint_bits: uint = 32;
+#[cfg(target_arch="x86_64")]
+const uint_bits: uint = 64;
 
 /**
  * Constructs a bitvector
@@ -37,7 +41,7 @@ const uint_bits: uint = 32u + (1u << 32u >> 27u);
 fn bitv(nbits: uint, init: bool) -> bitv {
     let elt = if init { !0u } else { 0u };
     let storage = vec::to_mut(vec::from_elem(nbits / uint_bits + 1u, elt));
-    ret @{storage: storage, nbits: nbits};
+    ret {storage: storage, nbits: nbits};
 }
 
 fn process(v0: bitv, v1: bitv, op: fn(uint, uint) -> uint) -> bool {
@@ -55,23 +59,24 @@ fn process(v0: bitv, v1: bitv, op: fn(uint, uint) -> uint) -> bool {
 }
 
 
-fn lor(w0: uint, w1: uint) -> uint { ret w0 | w1; }
-
+/**
+ * Calculates the union of two bitvectors
+ *
+ * Sets `v0` to the union of `v0` and `v1`. Both bitvectors must be the
+ * same length. Returns 'true' if `v0` was changed.
+ */
 fn union(v0: bitv, v1: bitv) -> bool {
-    let sub = lor; ret process(v0, v1, sub);
+    process(v0, v1, |a, b| a | b)
 }
 
-fn land(w0: uint, w1: uint) -> uint { ret w0 & w1; }
-
 /**
  * Calculates the intersection of two bitvectors
  *
  * Sets `v0` to the intersection of `v0` and `v1`. Both bitvectors must be the
  * same length. Returns 'true' if `v0` was changed.
  */
 fn intersect(v0: bitv, v1: bitv) -> bool {
-    let sub = land;
-    ret process(v0, v1, sub);
+    process(v0, v1, |a, b| a & b)
 }
 
 fn right(_w0: uint, w1: uint) -> uint { ret w1; }
@@ -87,10 +92,7 @@ fn assign(v0: bitv, v1: bitv) -> bool {
 
 /// Makes a copy of a bitvector
 fn clone(v: bitv) -> bitv {
-    let storage = vec::to_mut(vec::from_elem(v.nbits / uint_bits + 1u, 0u));
-    let len = vec::len(v.storage);
-    for uint::range(0u, len) |i| { storage[i] = v.storage[i]; };
-    ret @{storage: storage, nbits: v.nbits};
+    copy v
 }
 
 /// Retrieve the value at index `i`
@@ -174,18 +176,13 @@ fn is_false(v: bitv) -> bool {
     ret true;
 }
 
-fn init_to_vec(v: bitv, i: uint) -> uint {
-    ret if get(v, i) { 1u } else { 0u };
-}
-
 /**
  * Converts the bitvector to a vector of uint with the same length.
  *
  * Each uint in the resulting vector has either value 0u or 1u.
  */
 fn to_vec(v: bitv) -> ~[uint] {
-    let sub = |x| init_to_vec(v, x);
-    ret vec::from_fn::<uint>(v.nbits, sub);
+    vec::from_fn::<uint>(v.nbits, |i| if get(v, i) { 1 } else { 0 })
 }
 
 #[inline(always)]
@@ -238,6 +235,30 @@ fn eq_vec(v0: bitv, v1: ~[uint]) -> bool {
     ret true;
 }
 
+impl methods for bitv {
+    fn union(rhs: bitv) -> bool { union(self, rhs) }
+    fn intersect(rhs: bitv) -> bool { intersect(self, rhs) }
+    fn assign(rhs: bitv) -> bool { assign(self, rhs) }
+    fn get(i: uint) -> bool { get(self, i) }
+    fn [](i: uint) -> bool { self.get(i) }
+    fn eq(rhs: bitv) -> bool { equal(self, rhs) }
+    fn clear() { clear(self) }
+    fn set_all() { set_all(self) }
+    fn invert() { invert(self) }
+    fn difference(rhs: bitv) -> bool { difference(self, rhs) }
+    fn set(i: uint, x: bool) { set(self, i, x) }
+    fn is_true() -> bool { is_true(self) }
+    fn is_false() -> bool { is_false(self) }
+    fn to_vec() -> ~[uint] { to_vec(self) }
+    fn each(f: fn(bool) -> bool) { each(self, f) }
+    fn each_storage(f: fn(&uint) -> bool) { each_storage(self, f) }
+    fn eq_vec(v: ~[uint]) -> bool { eq_vec(self, v) }
+}
+
+impl of to_str::to_str for bitv {
+    fn to_str() -> ~str { to_str(self) }
+}
+
 #[cfg(test)]
 mod tests {
     #[test]