Struct collections::BitVec [−] [src]

pub struct BitVec {
    // some fields omitted
}

Unstable
: RFC 509

The bitvector type.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(10, false); // insert all primes less than 10 bv.set(2, true); bv.set(3, true); bv.set(5, true); bv.set(7, true); println!("{:?}", bv); println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); // flip all values in bitvector, producing non-primes less than 10 bv.negate(); println!("{:?}", bv); println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); // reset bitvector to empty bv.clear(); println!("{:?}", bv); println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(10, false);

// insert all primes less than 10
bv.set(2, true);
bv.set(3, true);
bv.set(5, true);
bv.set(7, true);
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// flip all values in bitvector, producing non-primes less than 10
bv.negate();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// reset bitvector to empty
bv.clear();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

Methods

`impl BitVec`

`fn new() -> BitVec`

Creates an empty BitVec.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::new(); }

use std::collections::BitVec;
let mut bv = BitVec::new();

`fn from_elem(nbits: usize, bit: bool) -> BitVec`

Unstable

Creates a BitVec that holds nbits elements, setting each element to bit.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(10, false); assert_eq!(bv.len(), 10); for x in bv.iter() { assert_eq!(x, false); } }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.len(), 10);
for x in bv.iter() {
    assert_eq!(x, false);
}

`fn with_capacity(nbits: usize) -> BitVec`

Constructs a new, empty BitVec with the specified capacity.

The bitvector will be able to hold at least capacity bits without reallocating. If capacity is 0, it will not allocate.

It is important to note that this function does not specify the length of the returned bitvector, but only the capacity.

`fn from_bytes(bytes: &[u8]) -> BitVec`

Unstable

Transforms a byte-vector into a BitVec. Each byte becomes eight bits, with the most significant bits of each byte coming first. Each bit becomes true if equal to 1 or false if equal to 0.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let bv = BitVec::from_bytes(&[0b10100000, 0b00010010]); assert!(bv.eq_vec(&[true, false, true, false, false, false, false, false, false, false, false, true, false, false, true, false])); }

use std::collections::BitVec;

let bv = BitVec::from_bytes(&[0b10100000, 0b00010010]);
assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false,
                    false, false, false, true,
                    false, false, true, false]));

`fn from_fn<F>(len: usize, f: F) -> BitVec where F: FnMut(usize) -> bool`

Unstable

Creates a BitVec of the specified length where the value at each index is f(index).

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let bv = BitVec::from_fn(5, |i| { i % 2 == 0 }); assert!(bv.eq_vec(&[true, false, true, false, true])); }

use std::collections::BitVec;

let bv = BitVec::from_fn(5, |i| { i % 2 == 0 });
assert!(bv.eq_vec(&[true, false, true, false, true]));

`fn get(&self, i: usize) -> Option<bool>`

Retrieves the value at index i, or None if the index is out of bounds.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let bv = BitVec::from_bytes(&[0b01100000]); assert_eq!(bv.get(0), Some(false)); assert_eq!(bv.get(1), Some(true)); assert_eq!(bv.get(100), None); // Can also use array indexing assert_eq!(bv[1], true); }

use std::collections::BitVec;

let bv = BitVec::from_bytes(&[0b01100000]);
assert_eq!(bv.get(0), Some(false));
assert_eq!(bv.get(1), Some(true));
assert_eq!(bv.get(100), None);

// Can also use array indexing
assert_eq!(bv[1], true);

`fn set(&mut self, i: usize, x: bool)`

Unstable
: panic semantics are likely to change in the future

Sets the value of a bit at an index i.

Panics

Panics if i is out of bounds.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(5, false); bv.set(3, true); assert_eq!(bv[3], true); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(5, false);
bv.set(3, true);
assert_eq!(bv[3], true);

`fn set_all(&mut self)`

Unstable

Sets all bits to 1.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let before = 0b01100000; let after = 0b11111111; let mut bv = BitVec::from_bytes(&[before]); bv.set_all(); assert_eq!(bv, BitVec::from_bytes(&[after])); }

use std::collections::BitVec;

let before = 0b01100000;
let after  = 0b11111111;

let mut bv = BitVec::from_bytes(&[before]);
bv.set_all();
assert_eq!(bv, BitVec::from_bytes(&[after]));

`fn negate(&mut self)`

Unstable

Flips all bits.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let before = 0b01100000; let after = 0b10011111; let mut bv = BitVec::from_bytes(&[before]); bv.negate(); assert_eq!(bv, BitVec::from_bytes(&[after])); }

use std::collections::BitVec;

let before = 0b01100000;
let after  = 0b10011111;

let mut bv = BitVec::from_bytes(&[before]);
bv.negate();
assert_eq!(bv, BitVec::from_bytes(&[after]));

`fn union(&mut self, other: &BitVec) -> bool`

Unstable

Calculates the union of two bitvectors. This acts like the bitwise or function.

Sets self to the union of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different lengths.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let a = 0b01100100; let b = 0b01011010; let res = 0b01111110; let mut a = BitVec::from_bytes(&[a]); let b = BitVec::from_bytes(&[b]); assert!(a.union(&b)); assert_eq!(a, BitVec::from_bytes(&[res])); }

use std::collections::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01111110;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.union(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

`fn intersect(&mut self, other: &BitVec) -> bool`

Unstable

Calculates the intersection of two bitvectors. This acts like the bitwise and function.

Sets self to the intersection of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different lengths.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let a = 0b01100100; let b = 0b01011010; let res = 0b01000000; let mut a = BitVec::from_bytes(&[a]); let b = BitVec::from_bytes(&[b]); assert!(a.intersect(&b)); assert_eq!(a, BitVec::from_bytes(&[res])); }

use std::collections::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01000000;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.intersect(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

`fn difference(&mut self, other: &BitVec) -> bool`

Unstable

Calculates the difference between two bitvectors.

Sets each element of self to the value of that element minus the element of other at the same index. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different length.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let a = 0b01100100; let b = 0b01011010; let a_b = 0b00100100; // a - b let b_a = 0b00011010; // b - a let mut bva = BitVec::from_bytes(&[a]); let bvb = BitVec::from_bytes(&[b]); assert!(bva.difference(&bvb)); assert_eq!(bva, BitVec::from_bytes(&[a_b])); let bva = BitVec::from_bytes(&[a]); let mut bvb = BitVec::from_bytes(&[b]); assert!(bvb.difference(&bva)); assert_eq!(bvb, BitVec::from_bytes(&[b_a])); }

use std::collections::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let a_b = 0b00100100; // a - b
let b_a = 0b00011010; // b - a

let mut bva = BitVec::from_bytes(&[a]);
let bvb = BitVec::from_bytes(&[b]);

assert!(bva.difference(&bvb));
assert_eq!(bva, BitVec::from_bytes(&[a_b]));

let bva = BitVec::from_bytes(&[a]);
let mut bvb = BitVec::from_bytes(&[b]);

assert!(bvb.difference(&bva));
assert_eq!(bvb, BitVec::from_bytes(&[b_a]));

`fn all(&self) -> bool`

Unstable

Returns true if all bits are 1.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(5, true); assert_eq!(bv.all(), true); bv.set(1, false); assert_eq!(bv.all(), false); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(5, true);
assert_eq!(bv.all(), true);

bv.set(1, false);
assert_eq!(bv.all(), false);

`fn iter(&self) -> Iter`

Returns an iterator over the elements of the vector in order.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let bv = BitVec::from_bytes(&[0b01110100, 0b10010010]); assert_eq!(bv.iter().filter(|x| *x).count(), 7); }

use std::collections::BitVec;

let bv = BitVec::from_bytes(&[0b01110100, 0b10010010]);
assert_eq!(bv.iter().filter(|x| *x).count(), 7);

`fn append(&mut self, other: &mut Self)`

Unstable
: recently added as part of collections reform 2

Moves all bits from other into Self, leaving other empty.

Examples

#![feature(collections, bit_vec_append_split_off)] extern crate collections; fn main() { use std::collections::BitVec; let mut a = BitVec::from_bytes(&[0b10000000]); let mut b = BitVec::from_bytes(&[0b01100001]); a.append(&mut b); assert_eq!(a.len(), 16); assert_eq!(b.len(), 0); assert!(a.eq_vec(&[true, false, false, false, false, false, false, false, false, true, true, false, false, false, false, true])); }

use std::collections::BitVec;

let mut a = BitVec::from_bytes(&[0b10000000]);
let mut b = BitVec::from_bytes(&[0b01100001]);

a.append(&mut b);

assert_eq!(a.len(), 16);
assert_eq!(b.len(), 0);
assert!(a.eq_vec(&[true, false, false, false, false, false, false, false,
                   false, true, true, false, false, false, false, true]));

`fn split_off(&mut self, at: usize) -> Self`

Unstable
: recently added as part of collections reform 2

Splits the BitVec into two at the given bit, retaining the first half in-place and returning the second one.

Panics

Panics if at is out of bounds.

Examples

#![feature(collections, bit_vec_append_split_off)] extern crate collections; fn main() { use std::collections::BitVec; let mut a = BitVec::new(); a.push(true); a.push(false); a.push(false); a.push(true); let b = a.split_off(2); assert_eq!(a.len(), 2); assert_eq!(b.len(), 2); assert!(a.eq_vec(&[true, false])); assert!(b.eq_vec(&[false, true])); }

use std::collections::BitVec;
let mut a = BitVec::new();
a.push(true);
a.push(false);
a.push(false);
a.push(true);

let b = a.split_off(2);

assert_eq!(a.len(), 2);
assert_eq!(b.len(), 2);
assert!(a.eq_vec(&[true, false]));
assert!(b.eq_vec(&[false, true]));

`fn none(&self) -> bool`

Unstable

Returns true if all bits are 0.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(10, false); assert_eq!(bv.none(), true); bv.set(3, true); assert_eq!(bv.none(), false); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.none(), true);

bv.set(3, true);
assert_eq!(bv.none(), false);

`fn any(&self) -> bool`

Unstable

Returns true if any bit is 1.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(10, false); assert_eq!(bv.any(), false); bv.set(3, true); assert_eq!(bv.any(), true); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.any(), false);

bv.set(3, true);
assert_eq!(bv.any(), true);

`fn to_bytes(&self) -> Vec<u8>`

Unstable

Organises the bits into bytes, such that the first bit in the BitVec becomes the high-order bit of the first byte. If the size of the BitVec is not a multiple of eight then trailing bits will be filled-in with false.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(3, true); bv.set(1, false); assert_eq!(bv.to_bytes(), [0b10100000]); let mut bv = BitVec::from_elem(9, false); bv.set(2, true); bv.set(8, true); assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(3, true);
bv.set(1, false);

assert_eq!(bv.to_bytes(), [0b10100000]);

let mut bv = BitVec::from_elem(9, false);
bv.set(2, true);
bv.set(8, true);

assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);

`fn eq_vec(&self, v: &[bool]) -> bool`

Unstable

Compares a BitVec to a slice of bools. Both the BitVec and slice must have the same length.

Panics

Panics if the BitVec and slice are of different length.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let bv = BitVec::from_bytes(&[0b10100000]); assert!(bv.eq_vec(&[true, false, true, false, false, false, false, false])); }

use std::collections::BitVec;

let bv = BitVec::from_bytes(&[0b10100000]);

assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false]));

`fn truncate(&mut self, len: usize)`

Shortens a BitVec, dropping excess elements.

If len is greater than the vector's current length, this has no effect.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_bytes(&[0b01001011]); bv.truncate(2); assert!(bv.eq_vec(&[false, true])); }

use std::collections::BitVec;

let mut bv = BitVec::from_bytes(&[0b01001011]);
bv.truncate(2);
assert!(bv.eq_vec(&[false, true]));

`fn reserve(&mut self, additional: usize)`

Reserves capacity for at least additional more bits to be inserted in the given BitVec. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new capacity overflows usize.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(3, false); bv.reserve(10); assert_eq!(bv.len(), 3); assert!(bv.capacity() >= 13); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);

`fn reserve_exact(&mut self, additional: usize)`

Reserves the minimum capacity for exactly additional more bits to be inserted in the given BitVec. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity overflows usize.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_elem(3, false); bv.reserve(10); assert_eq!(bv.len(), 3); assert!(bv.capacity() >= 13); }

use std::collections::BitVec;

let mut bv = BitVec::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);

`fn capacity(&self) -> usize`

Returns the capacity in bits for this bit vector. Inserting any element less than this amount will not trigger a resizing.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::new(); bv.reserve(10); assert!(bv.capacity() >= 10); }

use std::collections::BitVec;

let mut bv = BitVec::new();
bv.reserve(10);
assert!(bv.capacity() >= 10);

`fn grow(&mut self, n: usize, value: bool)`

Unstable

Grows the BitVec in-place, adding n copies of value to the BitVec.

Panics

Panics if the new len overflows a usize.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_bytes(&[0b01001011]); bv.grow(2, true); assert_eq!(bv.len(), 10); assert_eq!(bv.to_bytes(), [0b01001011, 0b11000000]); }

use std::collections::BitVec;

let mut bv = BitVec::from_bytes(&[0b01001011]);
bv.grow(2, true);
assert_eq!(bv.len(), 10);
assert_eq!(bv.to_bytes(), [0b01001011, 0b11000000]);

`fn pop(&mut self) -> Option<bool>`

Removes the last bit from the BitVec, and returns it. Returns None if the BitVec is empty.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::from_bytes(&[0b01001001]); assert_eq!(bv.pop(), Some(true)); assert_eq!(bv.pop(), Some(false)); assert_eq!(bv.len(), 6); }

use std::collections::BitVec;

let mut bv = BitVec::from_bytes(&[0b01001001]);
assert_eq!(bv.pop(), Some(true));
assert_eq!(bv.pop(), Some(false));
assert_eq!(bv.len(), 6);

`fn push(&mut self, elem: bool)`

Pushes a bool onto the end.

Examples

#![feature(collections)] extern crate collections; fn main() { use std::collections::BitVec; let mut bv = BitVec::new(); bv.push(true); bv.push(false); assert!(bv.eq_vec(&[true, false])); }

use std::collections::BitVec;

let mut bv = BitVec::new();
bv.push(true);
bv.push(false);
assert!(bv.eq_vec(&[true, false]));

`fn len(&self) -> usize`

Returns the total number of bits in this vector

`fn is_empty(&self) -> bool`

Returns true if there are no bits in this vector

`fn clear(&mut self)`

Clears all bits in this vector.

Struct collections::BitVec [−] [src]

Methods

impl BitVec

fn new() -> BitVec

fn from_elem(nbits: usize, bit: bool) -> BitVec

fn with_capacity(nbits: usize) -> BitVec

fn from_bytes(bytes: &[u8]) -> BitVec

fn from_fn<F>(len: usize, f: F) -> BitVec where F: FnMut(usize) -> bool

fn get(&self, i: usize) -> Option<bool>

fn set(&mut self, i: usize, x: bool)

fn set_all(&mut self)

fn negate(&mut self)

fn union(&mut self, other: &BitVec) -> bool

fn intersect(&mut self, other: &BitVec) -> bool

fn difference(&mut self, other: &BitVec) -> bool

fn all(&self) -> bool

fn iter(&self) -> Iter

fn append(&mut self, other: &mut Self)

fn split_off(&mut self, at: usize) -> Self

fn none(&self) -> bool

fn any(&self) -> bool

fn to_bytes(&self) -> Vec<u8>

fn eq_vec(&self, v: &[bool]) -> bool

fn truncate(&mut self, len: usize)

fn reserve(&mut self, additional: usize)

fn reserve_exact(&mut self, additional: usize)

fn capacity(&self) -> usize

fn grow(&mut self, n: usize, value: bool)

fn pop(&mut self) -> Option<bool>

fn push(&mut self, elem: bool)

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn clear(&mut self)

Trait Implementations

impl Index<usize> for BitVec

type Output = bool

fn index(&self, i: usize) -> &bool

impl Default for BitVec

fn default() -> BitVec

impl FromIterator<bool> for BitVec

fn from_iter<I: IntoIterator<Item=bool>>(iter: I) -> BitVec

impl Extend<bool> for BitVec

fn extend<I: IntoIterator<Item=bool>>(&mut self, iterable: I)

impl Clone for BitVec

fn clone(&self) -> BitVec

fn clone_from(&mut self, source: &BitVec)

impl PartialOrd for BitVec

fn partial_cmp(&self, other: &BitVec) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl Ord for BitVec

fn cmp(&self, other: &BitVec) -> Ordering

impl Debug for BitVec

fn fmt(&self, fmt: &mut Formatter) -> Result

impl Hash for BitVec

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

impl PartialEq for BitVec

fn eq(&self, other: &BitVec) -> bool

fn ne(&self, other: &Rhs) -> bool

impl Eq for BitVec

impl<'a> IntoIterator for &'a BitVec

type Item = bool

type IntoIter = Iter<'a>

fn into_iter(self) -> Iter<'a>

Keyboard shortcuts

Search tricks

`impl BitVec`

`fn new() -> BitVec`

`fn from_elem(nbits: usize, bit: bool) -> BitVec`

`fn with_capacity(nbits: usize) -> BitVec`

`fn from_bytes(bytes: &[u8]) -> BitVec`

`fn from_fn<F>(len: usize, f: F) -> BitVec where F: FnMut(usize) -> bool`

`fn get(&self, i: usize) -> Option<bool>`

`fn set(&mut self, i: usize, x: bool)`

`fn set_all(&mut self)`

`fn negate(&mut self)`

`fn union(&mut self, other: &BitVec) -> bool`

`fn intersect(&mut self, other: &BitVec) -> bool`

`fn difference(&mut self, other: &BitVec) -> bool`

`fn all(&self) -> bool`

`fn iter(&self) -> Iter`

`fn append(&mut self, other: &mut Self)`

`fn split_off(&mut self, at: usize) -> Self`

`fn none(&self) -> bool`

`fn any(&self) -> bool`

`fn to_bytes(&self) -> Vec<u8>`

`fn eq_vec(&self, v: &[bool]) -> bool`

`fn truncate(&mut self, len: usize)`

`fn reserve(&mut self, additional: usize)`

`fn reserve_exact(&mut self, additional: usize)`

`fn capacity(&self) -> usize`

`fn grow(&mut self, n: usize, value: bool)`

`fn pop(&mut self) -> Option<bool>`

`fn push(&mut self, elem: bool)`

`fn len(&self) -> usize`

`fn is_empty(&self) -> bool`

`fn clear(&mut self)`

`impl Index<usize> for BitVec`

`type Output = bool`

`fn index(&self, i: usize) -> &bool`

`impl Default for BitVec`

`fn default() -> BitVec`

`impl FromIterator<bool> for BitVec`

`fn from_iter<I: IntoIterator<Item=bool>>(iter: I) -> BitVec`

`impl Extend<bool> for BitVec`

`fn extend<I: IntoIterator<Item=bool>>(&mut self, iterable: I)`

`impl Clone for BitVec`

`fn clone(&self) -> BitVec`

`fn clone_from(&mut self, source: &BitVec)`

`impl PartialOrd for BitVec`

`fn partial_cmp(&self, other: &BitVec) -> Option<Ordering>`

`fn lt(&self, other: &Rhs) -> bool`

`fn le(&self, other: &Rhs) -> bool`

`fn gt(&self, other: &Rhs) -> bool`

`fn ge(&self, other: &Rhs) -> bool`

`impl Ord for BitVec`

`fn cmp(&self, other: &BitVec) -> Ordering`

`impl Debug for BitVec`

`fn fmt(&self, fmt: &mut Formatter) -> Result`

`impl Hash for BitVec`

`fn hash<H: Hasher>(&self, state: &mut H)`

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher`

`impl PartialEq for BitVec`

`fn eq(&self, other: &BitVec) -> bool`

`fn ne(&self, other: &Rhs) -> bool`

`impl Eq for BitVec`

`impl<'a> IntoIterator for &'a BitVec`

`type Item = bool`

`type IntoIter = Iter<'a>`

`fn into_iter(self) -> Iter<'a>`