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

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<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]);
source

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);
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(3231);
s.remove(3231);

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

// 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);
source

pub fn len(&self) -> usize

Returns the number of set bits in this set.

source

pub fn is_empty(&self) -> bool

Returns whether there are no bits set in this set

source

pub fn clear(&mut self)

Clears all bits in this set

source

pub fn contains(&self, value: usize) -> bool

Returns true if this set contains the specified integer.

source

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.

source

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

Returns true if the set is a subset of another.

source

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

Returns true if the set is a superset of another.

source

pub fn insert(&mut self, value: usize) -> bool

Adds a value to the set. Returns true if the value was not already present in the set.

source

pub fn remove(&mut self, value: usize) -> bool

Removes a value from the set. Returns true if the value was present in the set.

Trait Implementations§

source§

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

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
source§

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

Performs copy-assignment from source. Read more
source§

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

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<B: BitBlock> Extend<usize> for BitSet<B>

source§

fn extend<I: IntoIterator<Item = usize>>(&mut self, iter: I)

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
source§

impl<B: BitBlock> FromIterator<usize> for BitSet<B>

source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more
source§

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

§

type Item = usize

The type of the elements being iterated over.
§

type IntoIter = Iter<'a, B>

Which kind of iterator are we turning this into?
source§

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

Creates an iterator from a value. Read more
source§

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

source§

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

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

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

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

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

source§

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 · source§

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 · source§

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
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

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

Auto Trait Implementations§

§

impl<B> Freeze for BitSet<B>

§

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§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

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

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

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

Performs the conversion.