Struct bit_vec::BitVec [−] [src]

pub struct BitVec<B = u32> {
    // some fields omitted
}

The bitvector type.

Examples

use bit_vec::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<u32>`

`fn new() -> Self`

Creates an empty BitVec.

Examples

use bit_vec::BitVec;
let mut bv = BitVec::new();

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

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

Examples

use bit_vec::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) -> Self`

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]) -> Self`

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

use bit_vec::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) -> Self where F: FnMut(usize) -> bool`

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

Examples

use bit_vec::BitVec;

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

`impl<B: BitBlock> BitVec<B>`

`fn blocks(&self) -> Blocks<B>`

Iterator over the underlying blocks of data

`fn storage(&self) -> &[B]`

Exposes the raw block storage of this BitVec

Only really intended for BitSet.

`unsafe fn storage_mut(&mut self) -> &mut Vec<B>`

Exposes the raw block storage of this BitVec

Can probably cause unsafety. Only really intended for BitSet.

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

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

Examples

use bit_vec::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)`

Sets the value of a bit at an index i.

Panics

Panics if i is out of bounds.

Examples

use bit_vec::BitVec;

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

`fn set_all(&mut self)`

Sets all bits to 1.

Examples

use bit_vec::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)`

Flips all bits.

Examples

use bit_vec::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: &Self) -> bool`

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

use bit_vec::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: &Self) -> bool`

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

use bit_vec::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: &Self) -> bool`

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

use bit_vec::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`

Returns true if all bits are 1.

Examples

use bit_vec::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<B>`

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

Examples

use bit_vec::BitVec;

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

`fn none(&self) -> bool`

Returns true if all bits are 0.

Examples

use bit_vec::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`

Returns true if any bit is 1.

Examples

use bit_vec::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>`

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

use bit_vec::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`

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

use bit_vec::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

use bit_vec::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

use bit_vec::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

use bit_vec::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

use bit_vec::BitVec;

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

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

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

Panics

Panics if the new len overflows a usize.

Examples

use bit_vec::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

use bit_vec::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

use bit_vec::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

`unsafe fn set_len(&mut self, len: usize)`

Sets the number of bits that this BitVec considers initialized.

Almost certainly can cause bad stuff. Only really intended for BitSet.

`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 bit_vec::BitVec [−] [src]

Methods

impl BitVec<u32>

fn new() -> Self

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

fn with_capacity(nbits: usize) -> Self

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

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

impl<B: BitBlock> BitVec<B>

fn blocks(&self) -> Blocks<B>

fn storage(&self) -> &[B]

unsafe fn storage_mut(&mut self) -> &mut Vec<B>

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: &Self) -> bool

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

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

fn all(&self) -> bool

fn iter(&self) -> Iter<B>

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

unsafe fn set_len(&mut self, len: usize)

fn is_empty(&self) -> bool

fn clear(&mut self)

Trait Implementations

impl<B: BitBlock> Index<usize> for BitVec<B>

type Output = bool

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

impl<B: BitBlock> Default for BitVec<B>

fn default() -> Self

impl<B: BitBlock> FromIterator<bool> for BitVec<B>

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

impl<B: BitBlock> Extend<bool> for BitVec<B>

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

impl<B: BitBlock> Clone for BitVec<B>

fn clone(&self) -> Self

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

impl<B: BitBlock> PartialOrd for BitVec<B>

fn partial_cmp(&self, other: &Self) -> 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<B: BitBlock> Ord for BitVec<B>

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

impl<B: BitBlock> Debug for BitVec<B>

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

impl<B: BitBlock> Hash for BitVec<B>

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

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

impl<B: BitBlock> PartialEq for BitVec<B>

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

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

impl<B: BitBlock> Eq for BitVec<B>

impl<'a, B: BitBlock> IntoIterator for &'a BitVec<B>

type Item = bool

type IntoIter = Iter<'a, B>

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

impl<B: BitBlock> IntoIterator for BitVec<B>

type Item = bool

type IntoIter = IntoIter<B>

fn into_iter(self) -> IntoIter<B>

`impl BitVec<u32>`

`fn new() -> Self`

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

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

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

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

`impl<B: BitBlock> BitVec<B>`

`fn blocks(&self) -> Blocks<B>`

`fn storage(&self) -> &[B]`

`unsafe fn storage_mut(&mut self) -> &mut Vec<B>`

`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: &Self) -> bool`

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

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

`fn all(&self) -> bool`

`fn iter(&self) -> Iter<B>`

`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`

`unsafe fn set_len(&mut self, len: usize)`

`fn is_empty(&self) -> bool`

`fn clear(&mut self)`

`impl<B: BitBlock> Index<usize> for BitVec<B>`

`type Output = bool`

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

`impl<B: BitBlock> Default for BitVec<B>`

`fn default() -> Self`

`impl<B: BitBlock> FromIterator<bool> for BitVec<B>`

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

`impl<B: BitBlock> Extend<bool> for BitVec<B>`

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

`impl<B: BitBlock> Clone for BitVec<B>`

`fn clone(&self) -> Self`

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

`impl<B: BitBlock> PartialOrd for BitVec<B>`

`fn partial_cmp(&self, other: &Self) -> 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<B: BitBlock> Ord for BitVec<B>`

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

`impl<B: BitBlock> Debug for BitVec<B>`

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

`impl<B: BitBlock> Hash for BitVec<B>`

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

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

`impl<B: BitBlock> PartialEq for BitVec<B>`

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

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

`impl<B: BitBlock> Eq for BitVec<B>`

`impl<'a, B: BitBlock> IntoIterator for &'a BitVec<B>`

`type Item = bool`

`type IntoIter = Iter<'a, B>`

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

`impl<B: BitBlock> IntoIterator for BitVec<B>`

`type Item = bool`

`type IntoIter = IntoIter<B>`

`fn into_iter(self) -> IntoIter<B>`