Struct std::collections::BitVec
[−]
[src]
pub struct BitVec { // some fields omitted }
: 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
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
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
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)
: 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)
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)
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
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
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
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
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)
: 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
: 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
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
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>
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
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)
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.