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: &Self) -> Blocks<'_, B>

Iterator over the underlying blocks of data

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

Exposes the raw block storage of this BitVec.

Only really intended for BitSet.

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

Exposes the raw block storage of this BitVec.

Safety

Can probably cause unsafety. Only really intended for BitSet.

fn get(self: &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);

unsafe fn get_unchecked(self: &Self, i: usize) -> bool

Retrieves the value at index i, without doing bounds checking.

For a safe alternative, see get.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

Examples

use bit_vec::BitVec;

let bv = BitVec::from_bytes(&[0b01100000]);
unsafe {
    assert_eq!(bv.get_unchecked(0), false);
    assert_eq!(bv.get_unchecked(1), true);
}

fn get_mut(self: &mut Self, index: usize) -> Option<MutBorrowedBit<'_, B>>

Retrieves a smart pointer to the value at index i, or None if the index is out of bounds.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_bytes(&[0b01100000]);
*bv.get_mut(0).unwrap() = true;
*bv.get_mut(1).unwrap() = false;
assert!(bv.get_mut(100).is_none());
assert_eq!(bv, BitVec::from_bytes(&[0b10100000]));

unsafe fn get_unchecked_mut(self: &mut Self, index: usize) -> MutBorrowedBit<'_, B>

Retrieves a smart pointer to the value at index i, without doing bounds checking.

Safety

Calling this method with out-of-bounds index may cause undefined behavior even when the result is not used.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_bytes(&[0b01100000]);
unsafe {
    *bv.get_unchecked_mut(0) = true;
    *bv.get_unchecked_mut(1) = false;
}
assert_eq!(bv, BitVec::from_bytes(&[0b10100000]));

fn set(self: &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(self: &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(self: &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(self: &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(self: &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 or(self: &mut Self, other: &Self) -> bool

Calculates the bitwise or of two bitvectors.

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.or(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

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

Calculates the bitwise and of two bitvectors.

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.and(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

fn difference(self: &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 xor(self: &mut Self, other: &Self) -> bool

Calculates the xor of two bitvectors.

Sets self to the xor of self and other. 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   = 0b01100110;
let b   = 0b01010100;
let res = 0b00110010;

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

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

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

Calculates the nand of two bitvectors.

Sets self to the nand of self and other. 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   = 0b01100110;
let b   = 0b01010100;
let res = 0b10111011;

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

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

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

Calculates the nor of two bitvectors.

Sets self to the nor of self and other. 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   = 0b01100110;
let b   = 0b01010100;
let res = 0b10001001;

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

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

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

Calculates the xnor of two bitvectors.

Sets self to the xnor of self and other. 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   = 0b01100110;
let b   = 0b01010100;
let res = 0b11001101;

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

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

fn all(self: &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 count_ones(self: &Self) -> u64

Returns the number of ones in the binary representation.

Also known as the Hamming weight.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(100, true);
assert_eq!(bv.count_ones(), 100);

bv.set(50, false);
assert_eq!(bv.count_ones(), 99);

fn count_zeros(self: &Self) -> u64

Returns the number of zeros in the binary representation.

Also known as the opposite of Hamming weight.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(100, false);
assert_eq!(bv.count_zeros(), 100);

bv.set(50, true);
assert_eq!(bv.count_zeros(), 99);

fn iter(self: &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 iter_mut(self: &mut Self) -> IterMut<'_, B>

Returns an iterator over mutable smart pointers to the elements of the vector in order.

Examples

use bit_vec::BitVec;

let mut a = BitVec::from_elem(8, false);
a.iter_mut().enumerate().for_each(|(index, mut bit)| {
    *bit = if index % 2 == 1 { true } else { false };
});
assert!(a.eq_vec(&[
   false, true, false, true, false, true, false, true
]));

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

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

Examples

use bit_vec::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(self: &mut Self, at: usize) -> Self

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

use bit_vec::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: &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: &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: &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: &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(self: &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(self: &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(self: &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: &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(self: &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(self: &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(self: &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: &Self) -> usize

Returns the total number of bits in this vector

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

Sets the number of bits that this BitVec considers initialized.

Safety

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

fn is_empty(self: &Self) -> bool

Returns true if there are no bits in this vector

fn clear(self: &mut Self)

Clears all bits in this vector.

fn shrink_to_fit(self: &mut Self)

Shrinks the capacity of the underlying storage as much as possible.

It will drop down as close as possible to the length but the allocator may still inform the underlying storage that there is space for a few more elements/bits.

fn insert(self: &mut Self, at: usize, bit: bool)

Inserts a given bit at index at, shifting all bits after by one

Panics

Panics if at is out of bounds for BitVec's length (that is, if at > BitVec::len())

Examples

 use bit_vec::BitVec;

 let mut b = BitVec::new();

 b.push(true);
 b.push(true);
 b.insert(1, false);

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

Time complexity

Takes O(len) time. All items after the insertion index must be shifted to the right. In the worst case, all elements are shifted when the insertion index is 0.

impl<B> Freeze for BitVec<B>

impl<B> RefUnwindSafe for BitVec<B>

impl<B> Send for BitVec<B>

impl<B> Sync for BitVec<B>

impl<B> Unpin for BitVec<B>

impl<B> UnsafeUnpin for BitVec<B>

impl<B> UnwindSafe for BitVec<B>

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

fn clone(self: &Self) -> Self

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

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

fn fmt(self: &Self, fmt: &mut Formatter<'_>) -> Result

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

fn default() -> Self

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

fn fmt(self: &Self, fmt: &mut Formatter<'_>) -> Result

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

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

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

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

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

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

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

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

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

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

fn into_iter(self: Self) -> IntoIter<B>

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

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

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

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

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

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

impl<T> Any for BitVec<B>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for BitVec<B>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for BitVec<B>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for BitVec<B>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for BitVec<B>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for BitVec<B>

fn to_owned(self: &Self) -> T

fn clone_into(self: &Self, target: &mut T)

impl<T> ToString for BitVec<B>

fn to_string(self: &Self) -> String

impl<T, U> Into for BitVec<B>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for BitVec<B>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for BitVec<B>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>