Struct std::collections::bit_vec::BitVec [] [src]

pub struct BitVec {
    // some fields omitted
}
Unstable

: RFC 509

The bitvector type.

Examples

#![feature(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`BitVec`.

Examples

#![feature(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`BitVecthat holds` that holds nbits`nbitselements, setting each element to` elements, setting each element to bit`bit`.

Examples

#![feature(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`BitVec` with the specified capacity.

The bitvector will be able to hold at least capacity`capacitybits without reallocating. If` bits without reallocating. If capacity`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`BitVec. Each byte becomes eight bits, with the most significant bits of each byte coming first. Each bit becomes`. Each byte becomes eight bits, with the most significant bits of each byte coming first. Each bit becomes true`trueif equal to 1 or` if equal to 1 or false`false` if equal to 0.

Examples

#![feature(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`BitVecof the specified length where the value at each index is` of the specified length where the value at each index is f(index)`f(index)`.

Examples

#![feature(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`i, or`, or None`None` if the index is out of bounds.

Examples

#![feature(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`i`.

Panics

Panics if i`i` is out of bounds.

Examples

#![feature(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)] 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)] 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`or` function.

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

Panics

Panics if the bitvectors are of different lengths.

Examples

#![feature(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`and` function.

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

Panics

Panics if the bitvectors are of different lengths.

Examples

#![feature(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`selfto the value of that element minus the element of` to the value of that element minus the element of other`otherat the same index. Both bitvectors must be the same length. Returns` at the same index. Both bitvectors must be the same length. Returns true`trueif` if self`self` changed.

Panics

Panics if the bitvectors are of different length.

Examples

#![feature(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`true` if all bits are 1.

Examples

#![feature(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)] 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 BitVec)

Unstable

: recently added as part of collections reform 2

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

Examples

#![feature(collections, bit_vec_append_split_off)] 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) -> BitVec

Unstable

: recently added as part of collections reform 2

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

Panics

Panics if at`at` is out of bounds.

Examples

#![feature(collections, bit_vec_append_split_off)] 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`true` if all bits are 0.

Examples

#![feature(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`true` if any bit is 1.

Examples

#![feature(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`BitVecbecomes the high-order bit of the first byte. If the size of the` becomes the high-order bit of the first byte. If the size of the BitVec`BitVecis not a multiple of eight then trailing bits will be filled-in with` is not a multiple of eight then trailing bits will be filled-in with false`false`.

Examples

#![feature(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`BitVecto a slice of` to a slice of bool`bools. Both the`s. Both the BitVec`BitVec` and slice must have the same length.

Panics

Panics if the BitVec`BitVec` and slice are of different length.

Examples

#![feature(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`BitVec`, dropping excess elements.

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

Examples

#![feature(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`additionalmore bits to be inserted in the given` more bits to be inserted in the given BitVec`BitVec`. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new capacity overflows usize`usize`.

Examples

#![feature(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`additionalmore bits to be inserted in the given` more bits to be inserted in the given BitVec`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`reserve` if future insertions are expected.

Panics

Panics if the new capacity overflows usize`usize`.

Examples

#![feature(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)] 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`BitVecin-place, adding` in-place, adding n`ncopies of` copies of value`valueto the` to the BitVec`BitVec`.

Panics

Panics if the new len overflows a usize`usize`.

Examples

#![feature(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)] 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`bool` onto the end.

Examples

#![feature(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.

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>(iter: I) -> BitVec where I: IntoIterator<Item=bool>

impl Extend<bool> for BitVec

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

impl Clone for BitVec

fn clone(&self) -> BitVec

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

impl PartialOrd<BitVec> 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<(), Error>

impl Hash for BitVec

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

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

impl PartialEq<BitVec> 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>