Struct bit_set::BitSet

source ·

pub struct BitSet<B = u32> { /* private fields */ }

Implementations§

source §

impl BitSet<u32>

source

pub fn new() -> Self

Creates a new empty BitSet.

§Examples

use bit_set::BitSet;

let mut s = BitSet::new();

source

pub fn with_capacity(nbits: usize) -> Self

Creates a new BitSet with initially no contents, able to hold nbits elements without resizing.

§Examples

use bit_set::BitSet;

let mut s = BitSet::with_capacity(100);
assert!(s.capacity() >= 100);

source

pub fn from_bit_vec(bit_vec: BitVec) -> Self

Creates a new BitSet from the given bit vector.

§Examples

extern crate bit_vec;
extern crate bit_set;

fn main() {
    use bit_vec::BitVec;
    use bit_set::BitSet;

    let bv = BitVec::from_bytes(&[0b01100000]);
    let s = BitSet::from_bit_vec(bv);

    // Print 1, 2 in arbitrary order
    for x in s.iter() {
        println!("{}", x);
    }
}

source

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

source §

impl<B: BitBlock> BitSet

source

pub 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_set::BitSet;

let mut s = BitSet::with_capacity(100);
assert!(s.capacity() >= 100);

source

pub fn reserve_len(&mut self, len: usize)

Reserves capacity for the given BitSet to contain len distinct elements. In the case of BitSet this means reallocations will not occur as long as all inserted elements are less than len.

The collection may reserve more space to avoid frequent reallocations.

§Examples

use bit_set::BitSet;

let mut s = BitSet::new();
s.reserve_len(10);
assert!(s.capacity() >= 10);

source

pub fn reserve_len_exact(&mut self, len: usize)

Reserves the minimum capacity for the given BitSet to contain len distinct elements. In the case of BitSet this means reallocations will not occur as long as all inserted elements are less than len.

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_len if future insertions are expected.

§Examples

use bit_set::BitSet;

let mut s = BitSet::new();
s.reserve_len_exact(10);
assert!(s.capacity() >= 10);

source

pub fn into_bit_vec(self) -> BitVec

Consumes this set to return the underlying bit vector.

§Examples

use bit_set::BitSet;

let mut s = BitSet::new();
s.insert(0);
s.insert(3);

let bv = s.into_bit_vec();
assert!(bv[0]);
assert!(bv[3]);

source

pub fn get_ref(&self) -> &BitVec

Returns a reference to the underlying bit vector.

§Examples

use bit_set::BitSet;

let mut s = BitSet::new();
s.insert(0);

let bv = s.get_ref();
assert_eq!(bv[0], true);

source

pub fn shrink_to_fit(&mut self)

Truncates the underlying vector to the least length required.

§Examples

use bit_set::BitSet;

let mut s = BitSet::new();
s.insert(32183231);
s.remove(32183231);

// Internal storage will probably be bigger than necessary
println!("old capacity: {}", s.capacity());

// Now should be smaller
s.shrink_to_fit();
println!("new capacity: {}", s.capacity());

source

pub fn iter(&self) -> Iter<'_, B> ⓘ

Iterator over each usize stored in the BitSet.

§Examples

use bit_set::BitSet;

let s = BitSet::from_bytes(&[0b01001010]);

// Print 1, 4, 6 in arbitrary order
for x in s.iter() {
    println!("{}", x);
}

source

pub fn union<'a>(&'a self, other: &'a Self) -> Union<'a, B> ⓘ

Iterator over each usize stored in self union other. See union_with for an efficient in-place version.

§Examples

use bit_set::BitSet;

let a = BitSet::from_bytes(&[0b01101000]);
let b = BitSet::from_bytes(&[0b10100000]);

// Print 0, 1, 2, 4 in arbitrary order
for x in a.union(&b) {
    println!("{}", x);
}

source

pub fn intersection<'a>(&'a self, other: &'a Self) -> Intersection<'a, B> ⓘ

Iterator over each usize stored in self intersect other. See intersect_with for an efficient in-place version.

§Examples

use bit_set::BitSet;

let a = BitSet::from_bytes(&[0b01101000]);
let b = BitSet::from_bytes(&[0b10100000]);

// Print 2
for x in a.intersection(&b) {
    println!("{}", x);
}

source

pub fn difference<'a>(&'a self, other: &'a Self) -> Difference<'a, B> ⓘ

Iterator over each usize stored in the self setminus other. See difference_with for an efficient in-place version.

§Examples

use bit_set::BitSet;

let a = BitSet::from_bytes(&[0b01101000]);
let b = BitSet::from_bytes(&[0b10100000]);

// Print 1, 4 in arbitrary order
for x in a.difference(&b) {
    println!("{}", x);
}

// Note that difference is not symmetric,
// and `b - a` means something else.
// This prints 0
for x in b.difference(&a) {
    println!("{}", x);
}

source

pub fn symmetric_difference<'a>( &'a self, other: &'a Self ) -> SymmetricDifference<'a, B> ⓘ

Iterator over each usize stored in the symmetric difference of self and other. See symmetric_difference_with for an efficient in-place version.

§Examples

use bit_set::BitSet;

let a = BitSet::from_bytes(&[0b01101000]);
let b = BitSet::from_bytes(&[0b10100000]);

// Print 0, 1, 4 in arbitrary order
for x in a.symmetric_difference(&b) {
    println!("{}", x);
}

source

pub fn union_with(&mut self, other: &Self)

Unions in-place with the specified other bit vector.

§Examples

use bit_set::BitSet;

let a   = 0b01101000;
let b   = 0b10100000;
let res = 0b11101000;

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

a.union_with(&b);
assert_eq!(a, res);

source

pub fn intersect_with(&mut self, other: &Self)

Intersects in-place with the specified other bit vector.

§Examples

use bit_set::BitSet;

let a   = 0b01101000;
let b   = 0b10100000;
let res = 0b00100000;

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

a.intersect_with(&b);
assert_eq!(a, res);

source

pub fn difference_with(&mut self, other: &Self)

Makes this bit vector the difference with the specified other bit vector in-place.

§Examples

use bit_set::BitSet;

let a   = 0b01101000;
let b   = 0b10100000;
let a_b = 0b01001000; // a - b
let b_a = 0b10000000; // b - a

let mut bva = BitSet::from_bytes(&[a]);
let bvb = BitSet::from_bytes(&[b]);
let bva_b = BitSet::from_bytes(&[a_b]);
let bvb_a = BitSet::from_bytes(&[b_a]);

bva.difference_with(&bvb);
assert_eq!(bva, bva_b);

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

bvb.difference_with(&bva);
assert_eq!(bvb, bvb_a);

source

pub fn symmetric_difference_with(&mut self, other: &Self)

Makes this bit vector the symmetric difference with the specified other bit vector in-place.

§Examples

use bit_set::BitSet;

let a   = 0b01101000;
let b   = 0b10100000;
let res = 0b11001000;

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

a.symmetric_difference_with(&b);
assert_eq!(a, res);