---

yaml
---
r: 14756
b: refs/heads/try
c: 95521c4
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: b22556a6f818845cd400ad58065a83916ba591a7
+refs/heads/try: 95521c408438efc5794e83953086c812b795c756
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/libstd/bitv.rs

@@ -1,9 +1,3 @@
-/*
-Module: bitv
-
-Bitvectors.
-*/
-
 export t;
 export create;
 export union;
@@ -28,25 +22,19 @@ export eq_vec;
 //        an optimizing version of this module that produces a different obj
 //        for the case where nbits <= 32.
 
-/*
-Type: t
-
-The bitvector type.
-*/
+#[doc = "The bitvector type"]
 type t = @{storage: [mutable uint], nbits: uint};
 
-
 const uint_bits: uint = 32u + (1u << 32u >> 27u);
 
-/*
-Function: create
+#[doc = "
+Constructs a bitvector
 
-Constructs a bitvector.
+# Arguments
 
-Parameters:
-nbits - The number of bits in the bitvector
-init - If true then the bits are initialized to 1, otherwise 0
-*/
+* nbits - The number of bits in the bitvector
+* init - If true then the bits are initialized to 1, otherwise 0
+"]
 fn create(nbits: uint, init: bool) -> t {
     let elt = if init { !0u } else { 0u };
     let storage = vec::to_mut(vec::init_elt(nbits / uint_bits + 1u, elt));
@@ -74,60 +62,35 @@ fn union(v0: t, v1: t) -> bool { let sub = lor; ret process(v0, v1, sub); }
 
 fn land(w0: uint, w1: uint) -> uint { ret w0 & w1; }
 
-/*
-Function: intersect
-
+#[doc = "
 Calculates the intersection of two bitvectors
 
-Sets `v0` to the intersection of `v0` and `v1`
-
-Preconditions:
-
-Both bitvectors must be the same length
-
-Returns:
-
-True if `v0` was changed
-*/
+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: t, v1: t) -> bool {
     let sub = land;
     ret process(v0, v1, sub);
 }
 
 fn right(_w0: uint, w1: uint) -> uint { ret w1; }
 
-/*
-Function: assign
-
+#[doc = "
 Assigns the value of `v1` to `v0`
 
-Preconditions:
-
-Both bitvectors must be the same length
-
-Returns:
-
-True if `v0` was changed
-*/
+Both bitvectors must be the same length. Returns `true` if `v0` was changed
+"]
 fn assign(v0: t, v1: t) -> bool { let sub = right; ret process(v0, v1, sub); }
 
-/*
-Function: clone
-
-Makes a copy of a bitvector
-*/
+#[doc = "Makes a copy of a bitvector"]
 fn clone(v: t) -> t {
     let storage = vec::to_mut(vec::init_elt(v.nbits / uint_bits + 1u, 0u));
     let len = vec::len(v.storage);
     uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
     ret @{storage: storage, nbits: v.nbits};
 }
 
-/*
-Function: get
-
-Retreive the value at index `i`
-*/
+#[doc = "Retreive the value at index `i`"]
 pure fn get(v: t, i: uint) -> bool {
     assert (i < v.nbits);
     let bits = uint_bits;
@@ -139,19 +102,12 @@ pure fn get(v: t, i: uint) -> bool {
 
 // FIXME: This doesn't account for the actual size of the vectors,
 // so it could end up comparing garbage bits
-/*
-Function: equal
-
+#[doc = "
 Compares two bitvectors
 
-Preconditions:
-
-Both bitvectors must be the same length
-
-Returns:
-
-True if both bitvectors contain identical elements
-*/
+Both bitvectors must be the same length. Returns `true` if both bitvectors
+contain identical elements.
+"]
 fn equal(v0: t, v1: t) -> bool {
     // FIXME: when we can break or return from inside an iterator loop,
     //        we can eliminate this painful while-loop
@@ -165,67 +121,43 @@ fn equal(v0: t, v1: t) -> bool {
     ret true;
 }
 
-/*
-Function: clear
-
-Set all bits to 0
-*/
+#[doc = "Set all bits to 0"]
 fn clear(v: t) {
     uint::range(0u, vec::len(v.storage)) {|i| v.storage[i] = 0u; };
 }
 
-/*
-Function: set_all
-
-Set all bits to 1
-*/
+#[doc = "Set all bits to 1"]
 fn set_all(v: t) {
     uint::range(0u, v.nbits) {|i| set(v, i, true); };
 }
 
-/*
-Function: invert
-
-Invert all bits
-*/
+#[doc = "Invert all bits"]
 fn invert(v: t) {
     uint::range(0u, vec::len(v.storage)) {|i|
         v.storage[i] = !v.storage[i];
     };
 }
 
-/*
-Function: difference
-
+#[doc = "
 Calculate the difference between two bitvectors
 
 Sets each element of `v0` to the value of that element minus the element
-of `v1` at the same index.
-
-Preconditions:
-
-Both bitvectors must be the same length
+of `v1` at the same index. Both bitvectors must be the same length.
 
-Returns:
-
-True if `v0` was changed
-*/
+Returns `true` if `v0` was changed.
+"]
 fn difference(v0: t, v1: t) -> bool {
     invert(v1);
     let b = intersect(v0, v1);
     invert(v1);
     ret b;
 }
 
-/*
-Function: set
-
+#[doc = "
 Set the value of a bit at a given index
 
-Preconditions:
-
-`i` must be less than the length of the bitvector
-*/
+`i` must be less than the length of the bitvector.
+"]
 fn set(v: t, i: uint, x: bool) {
     assert (i < v.nbits);
     let bits = uint_bits;
@@ -236,62 +168,50 @@ fn set(v: t, i: uint, x: bool) {
 }
 
 
-/*
-Function: is_true
-
-Returns true if all bits are 1
-*/
+#[doc = "Returns true if all bits are 1"]
 fn is_true(v: t) -> bool {
     for i: uint in to_vec(v) { if i != 1u { ret false; } }
     ret true;
 }
 
 
-/*
-Function: is_false
-
-Returns true if all bits are 0
-*/
+#[doc = "Returns true if all bits are 0"]
 fn is_false(v: t) -> bool {
     for i: uint in to_vec(v) { if i == 1u { ret false; } }
     ret true;
 }
 
 fn init_to_vec(v: t, i: uint) -> uint { ret if get(v, i) { 1u } else { 0u }; }
 
-/*
-Function: to_vec
+#[doc = "
+Converts the bitvector to a vector of uint with the same length.
 
-Converts the bitvector to a vector of uint with the same length. Each uint
-in the resulting vector has either value 0u or 1u.
-*/
+Each uint in the resulting vector has either value 0u or 1u.
+"]
 fn to_vec(v: t) -> [uint] {
     let sub = bind init_to_vec(v, _);
     ret vec::init_fn::<uint>(v.nbits, sub);
 }
 
-/*
-Function: to_str
 
-Converts the bitvector to a string. The resulting string has the same
-length as the bitvector, and each character is either '0' or '1'.
-*/
+#[doc = "
+Converts the bitvector to a string.
+
+The resulting string has the same length as the bitvector, and each character
+is either '0' or '1'.
+"]
 fn to_str(v: t) -> str {
     let rs = "";
     for i: uint in to_vec(v) { if i == 1u { rs += "1"; } else { rs += "0"; } }
     ret rs;
 }
 
-/*
-Function: eq_vec
-
-Compare a bitvector to a vector of uint. The uint vector is expected to
-only contain the values 0u and 1u.
-
-Preconditions:
+#[doc = "
+Compare a bitvector to a vector of uint
 
-Both the bitvector and vector must have the same length
-*/
+The uint vector is expected to only contain the values 0u and 1u. Both the
+bitvector and vector must have the same length
+"]
 fn eq_vec(v0: t, v1: [uint]) -> bool {
     assert (v0.nbits == vec::len::<uint>(v1));
     let len = v0.nbits;