Skip to content

Commit 3165dde

Browse files
kud1inghuonw
kud1ing
authored andcommitted
bitv: backticks for code in documentation
1 parent c873216 commit 3165dde

File tree

1 file changed

+24
-24
lines changed

1 file changed

+24
-24
lines changed

src/libextra/bitv.rs

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -116,7 +116,7 @@ struct BigBitv {
116116
}
117117

118118
/**
119-
* a mask that has a 1 for each defined bit in the nth element of a big_bitv,
119+
* A mask that has a 1 for each defined bit in the n'th element of a `BigBitv`,
120120
* assuming n bits.
121121
*/
122122
#[inline]
@@ -284,7 +284,7 @@ impl Bitv {
284284
* Calculates the union of two bitvectors
285285
*
286286
* Sets `self` to the union of `self` and `v1`. Both bitvectors must be
287-
* the same length. Returns 'true' if `self` changed.
287+
* the same length. Returns `true` if `self` changed.
288288
*/
289289
#[inline]
290290
pub fn union(&mut self, v1: &Bitv) -> bool { self.do_op(Union, v1) }
@@ -293,7 +293,7 @@ impl Bitv {
293293
* Calculates the intersection of two bitvectors
294294
*
295295
* Sets `self` to the intersection of `self` and `v1`. Both bitvectors
296-
* must be the same length. Returns 'true' if `self` changed.
296+
* must be the same length. Returns `true` if `self` changed.
297297
*/
298298
#[inline]
299299
pub fn intersect(&mut self, v1: &Bitv) -> bool {
@@ -395,7 +395,7 @@ impl Bitv {
395395
self.do_op(Difference, v)
396396
}
397397

398-
/// Returns true if all bits are 1
398+
/// Returns `true` if all bits are 1
399399
#[inline]
400400
pub fn is_true(&self) -> bool {
401401
match self.rep {
@@ -417,7 +417,7 @@ impl Bitv {
417417
self.iter().invert()
418418
}
419419

420-
/// Returns true if all bits are 0
420+
/// Returns `true` if all bits are 0
421421
pub fn is_false(&self) -> bool {
422422
match self.rep {
423423
Small(ref b) => b.is_false(self.nbits),
@@ -433,18 +433,18 @@ impl Bitv {
433433
}
434434

435435
/**
436-
* Converts `self` to a vector of uint with the same length.
436+
* Converts `self` to a vector of `uint` with the same length.
437437
*
438-
* Each uint in the resulting vector has either value 0u or 1u.
438+
* Each `uint` in the resulting vector has either value `0u` or `1u`.
439439
*/
440440
pub fn to_vec(&self) -> ~[uint] {
441441
vec::from_fn(self.nbits, |x| self.init_to_vec(x))
442442
}
443443

444444
/**
445445
* Organise the bits into bytes, such that the first bit in the
446-
* bitv becomes the high-order bit of the first byte. If the
447-
* size of the bitv is not a multiple of 8 then trailing bits
446+
* `Bitv` becomes the high-order bit of the first byte. If the
447+
* size of the `Bitv` is not a multiple of 8 then trailing bits
448448
* will be filled-in with false/0
449449
*/
450450
pub fn to_bytes(&self) -> ~[u8] {
@@ -472,7 +472,7 @@ impl Bitv {
472472
}
473473

474474
/**
475-
* Transform self into a [bool] by turning each bit into a bool
475+
* Transform `self` into a `[bool]` by turning each bit into a `bool`.
476476
*/
477477
pub fn to_bools(&self) -> ~[bool] {
478478
vec::from_fn(self.nbits, |i| self[i])
@@ -498,7 +498,7 @@ impl Bitv {
498498

499499

500500
/**
501-
* Compare a bitvector to a vector of bool.
501+
* Compare a bitvector to a vector of `bool`.
502502
*
503503
* Both the bitvector and vector must have the same length.
504504
*/
@@ -519,9 +519,9 @@ impl Bitv {
519519
}
520520

521521
/**
522-
* Transform a byte-vector into a bitv. Each byte becomes 8 bits,
522+
* Transform a byte-vector into a `Bitv`. Each byte becomes 8 bits,
523523
* with the most significant bits of each byte coming first. Each
524-
* bit becomes true if equal to 1 or false if equal to 0.
524+
* bit becomes `true` if equal to 1 or `false` if equal to 0.
525525
*/
526526
pub fn from_utf8(bytes: &[u8]) -> Bitv {
527527
from_fn(bytes.len() * 8, |i| {
@@ -532,15 +532,15 @@ pub fn from_utf8(bytes: &[u8]) -> Bitv {
532532
}
533533

534534
/**
535-
* Transform a [bool] into a bitv by converting each bool into a bit.
535+
* Transform a `[bool]` into a `Bitv` by converting each `bool` into a bit.
536536
*/
537537
pub fn from_bools(bools: &[bool]) -> Bitv {
538538
from_fn(bools.len(), |i| bools[i])
539539
}
540540

541541
/**
542-
* Create a bitv of the specified length where the value at each
543-
* index is f(index).
542+
* Create a `Bitv` of the specified length where the value at each
543+
* index is `f(index)`.
544544
*/
545545
pub fn from_fn(len: uint, f: &fn(index: uint) -> bool) -> Bitv {
546546
let mut bitv = Bitv::new(len, false);
@@ -571,7 +571,7 @@ fn iterate_bits(base: uint, bits: uint, f: &fn(uint) -> bool) -> bool {
571571
return true;
572572
}
573573

574-
/// An iterator for Bitv
574+
/// An iterator for `Bitv`.
575575
pub struct BitvIterator<'self> {
576576
priv bitv: &'self Bitv,
577577
priv next_idx: uint,
@@ -631,12 +631,12 @@ impl<'self> RandomAccessIterator<bool> for BitvIterator<'self> {
631631
///
632632
/// It should also be noted that the amount of storage necessary for holding a
633633
/// set of objects is proportional to the maximum of the objects when viewed
634-
/// as a uint.
634+
/// as a `uint`.
635635
#[deriving(Clone)]
636636
pub struct BitvSet {
637637
priv size: uint,
638638

639-
// In theory this is a Bitv instead of always a BigBitv, but knowing that
639+
// In theory this is a `Bitv` instead of always a `BigBitv`, but knowing that
640640
// there's an array of storage makes our lives a whole lot easier when
641641
// performing union/intersection/etc operations
642642
priv bitv: BigBitv
@@ -861,7 +861,7 @@ impl MutableSet<uint> for BitvSet {
861861
}
862862

863863
impl BitvSet {
864-
/// Visits each of the words that the two bit vectors (self and other)
864+
/// Visits each of the words that the two bit vectors (`self` and `other`)
865865
/// both have in common. The three yielded arguments are (bit location,
866866
/// w1, w2) where the bit location is the number of bits offset so far,
867867
/// and w1/w2 are the words coming from the two vectors self, other.
@@ -874,13 +874,13 @@ impl BitvSet {
874874
.map(|((i, &w), o_store)| (i * uint::bits, w, o_store[i]))
875875
}
876876

877-
/// Visits each word in self or other that extends beyond the other. This
877+
/// Visits each word in `self` or `other` that extends beyond the other. This
878878
/// will only iterate through one of the vectors, and it only iterates
879879
/// over the portion that doesn't overlap with the other one.
880880
///
881-
/// The yielded arguments are a bool, the bit offset, and a word. The bool
882-
/// is true if the word comes from 'self', and false if it comes from
883-
/// 'other'.
881+
/// The yielded arguments are a `bool`, the bit offset, and a word. The `bool`
882+
/// is true if the word comes from `self`, and `false` if it comes from
883+
/// `other`.
884884
fn outlier_iter<'a>(&'a self, other: &'a BitvSet)
885885
-> Map<'static, ((uint, &'a uint), uint), (bool, uint, uint),
886886
Zip<Enumerate<vec::VecIterator<'a, uint>>, Repeat<uint>>> {

0 commit comments

Comments
 (0)