pub struct BitSet<B = u32> { /* private fields */ }
Implementations
sourceimpl BitSet<u32>
impl BitSet<u32>
sourcepub fn with_capacity(nbits: usize) -> Self
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);
sourcepub fn from_bit_vec(bit_vec: BitVec) -> Self
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);
}
}
pub fn from_bytes(bytes: &[u8]) -> Self
sourceimpl<B: BitBlock> BitSet<B>
impl<B: BitBlock> BitSet<B>
sourcepub fn capacity(&self) -> usize
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);
sourcepub fn reserve_len(&mut self, len: usize)
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);
sourcepub fn reserve_len_exact(&mut self, len: usize)
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);
sourcepub fn into_bit_vec(self) -> BitVec<B>
pub fn into_bit_vec(self) -> BitVec<B>
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]);
sourcepub fn get_ref(&self) -> &BitVec<B>
pub fn get_ref(&self) -> &BitVec<B>
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);
sourcepub fn shrink_to_fit(&mut self)
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());
sourcepub fn iter(&self) -> Iter<'_, B>ⓘNotable traits for Iter<'a, B>impl<'a, B: BitBlock> Iterator for Iter<'a, B> type Item = usize;
pub fn iter(&self) -> Iter<'_, B>ⓘNotable traits for Iter<'a, B>impl<'a, B: BitBlock> Iterator for Iter<'a, B> type Item = usize;
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);
}
sourcepub fn union<'a>(&'a self, other: &'a Self) -> Union<'a, B>ⓘNotable traits for Union<'a, B>impl<'a, B: BitBlock> Iterator for Union<'a, B> type Item = usize;
pub fn union<'a>(&'a self, other: &'a Self) -> Union<'a, B>ⓘNotable traits for Union<'a, B>impl<'a, B: BitBlock> Iterator for Union<'a, B> type Item = usize;
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);
}
sourcepub fn intersection<'a>(&'a self, other: &'a Self) -> Intersection<'a, B>ⓘNotable traits for Intersection<'a, B>impl<'a, B: BitBlock> Iterator for Intersection<'a, B> type Item = usize;
pub fn intersection<'a>(&'a self, other: &'a Self) -> Intersection<'a, B>ⓘNotable traits for Intersection<'a, B>impl<'a, B: BitBlock> Iterator for Intersection<'a, B> type Item = usize;
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);
}
sourcepub fn difference<'a>(&'a self, other: &'a Self) -> Difference<'a, B>ⓘNotable traits for Difference<'a, B>impl<'a, B: BitBlock> Iterator for Difference<'a, B> type Item = usize;
pub fn difference<'a>(&'a self, other: &'a Self) -> Difference<'a, B>ⓘNotable traits for Difference<'a, B>impl<'a, B: BitBlock> Iterator for Difference<'a, B> type Item = usize;
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);
}
sourcepub fn symmetric_difference<'a>(
&'a self,
other: &'a Self
) -> SymmetricDifference<'a, B>ⓘNotable traits for SymmetricDifference<'a, B>impl<'a, B: BitBlock> Iterator for SymmetricDifference<'a, B> type Item = usize;
pub fn symmetric_difference<'a>(
&'a self,
other: &'a Self
) -> SymmetricDifference<'a, B>ⓘNotable traits for SymmetricDifference<'a, B>impl<'a, B: BitBlock> Iterator for SymmetricDifference<'a, B> type Item = usize;
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);
}
sourcepub fn union_with(&mut self, other: &Self)
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);
sourcepub fn intersect_with(&mut self, other: &Self)
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);
sourcepub fn difference_with(&mut self, other: &Self)
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);
sourcepub fn symmetric_difference_with(&mut self, other: &Self)
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);
sourcepub fn contains(&self, value: usize) -> bool
pub fn contains(&self, value: usize) -> bool
Returns true
if this set contains the specified integer.
sourcepub fn is_disjoint(&self, other: &Self) -> bool
pub fn is_disjoint(&self, other: &Self) -> bool
Returns true
if the set has no elements in common with other
.
This is equivalent to checking for an empty intersection.
sourcepub fn is_superset(&self, other: &Self) -> bool
pub fn is_superset(&self, other: &Self) -> bool
Returns true
if the set is a superset of another.
Trait Implementations
sourceimpl<B: BitBlock> Extend<usize> for BitSet<B>
impl<B: BitBlock> Extend<usize> for BitSet<B>
sourcefn extend<I: IntoIterator<Item = usize>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = usize>>(&mut self, iter: I)
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
sourceimpl<B: BitBlock> FromIterator<usize> for BitSet<B>
impl<B: BitBlock> FromIterator<usize> for BitSet<B>
sourcefn from_iter<I: IntoIterator<Item = usize>>(iter: I) -> Self
fn from_iter<I: IntoIterator<Item = usize>>(iter: I) -> Self
Creates a value from an iterator. Read more
sourceimpl<'a, B: BitBlock> IntoIterator for &'a BitSet<B>
impl<'a, B: BitBlock> IntoIterator for &'a BitSet<B>
sourceimpl<B: BitBlock> Ord for BitSet<B>
impl<B: BitBlock> Ord for BitSet<B>
sourceimpl<B: BitBlock> PartialOrd<BitSet<B>> for BitSet<B>
impl<B: BitBlock> PartialOrd<BitSet<B>> for BitSet<B>
sourcefn partial_cmp(&self, other: &Self) -> Option<Ordering>
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<B: BitBlock> Eq for BitSet<B>
Auto Trait Implementations
impl<B> RefUnwindSafe for BitSet<B> where
B: RefUnwindSafe,
impl<B> Send for BitSet<B> where
B: Send,
impl<B> Sync for BitSet<B> where
B: Sync,
impl<B> Unpin for BitSet<B> where
B: Unpin,
impl<B> UnwindSafe for BitSet<B> where
B: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcepub fn to_owned(&self) -> T
pub fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
sourcepub fn clone_into(&self, target: &mut T)
pub fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more