Enum rustc_index::bit_set::HybridBitSet

pub enum HybridBitSet<T> {
    Sparse(SparseBitSet<T>),
    Dense(BitSet<T>),
}

A fixed-size bitset type with a hybrid representation: sparse when there are up to a SPARSE_MAX elements in the set, but dense when there are more than SPARSE_MAX.

This type is especially efficient for sets that typically have a small number of elements, but a large domain_size, and are cleared frequently.

T is an index type, typically a newtyped usize wrapper, but it can also just be usize.

All operations that involve an element will panic if the element is equal to or greater than the domain size. All operations that involve two bitsets will panic if the bitsets have differing domain sizes.

Variants

Sparse(SparseBitSet<T>)

Tuple Fields of Sparse

0: SparseBitSet<T>

Dense(BitSet<T>)

Tuple Fields of Dense

0: BitSet<T>

Implementations

impl<T: Idx> HybridBitSet<T>

pub fn new_empty(domain_size: usize) -> Self

pub fn domain_size(&self) -> usize

pub fn clear(&mut self)

pub fn contains(&self, elem: T) -> bool

pub fn superset(&self, other: &HybridBitSet<T>) -> bool

pub fn is_empty(&self) -> bool

pub fn insert(&mut self, elem: T) -> bool

pub fn insert_all(&mut self)

pub fn remove(&mut self, elem: T) -> bool

pub fn to_dense(self) -> BitSet<T>

Converts to a dense set, consuming itself in the process.

pub fn iter(&self) -> HybridIter<'_, T>

pub fn union<Rhs>(&mut self, other: &Rhs) -> bool where
    Self: BitRelations<Rhs>, 

Sets self = self | other and returns true if self changed (i.e., if new bits were added).

pub fn subtract<Rhs>(&mut self, other: &Rhs) -> bool where
    Self: BitRelations<Rhs>, 

Sets self = self - other and returns true if self changed. (i.e., if any bits were removed).

pub fn intersect<Rhs>(&mut self, other: &Rhs) -> bool where
    Self: BitRelations<Rhs>, 

Sets self = self & other and return true if self changed. (i.e., if any bits were removed).

Trait Implementations

impl<T: Idx> BitRelations<BitSet<T>> for HybridBitSet<T>

fn union(&mut self, other: &BitSet<T>) -> bool

fn subtract(&mut self, other: &BitSet<T>) -> bool

fn intersect(&mut self, other: &BitSet<T>) -> bool

impl<T: Idx> BitRelations<HybridBitSet<T>> for BitSet<T>

fn union(&mut self, other: &HybridBitSet<T>) -> bool

fn subtract(&mut self, other: &HybridBitSet<T>) -> bool

fn intersect(&mut self, other: &HybridBitSet<T>) -> bool

impl<T: Idx> BitRelations<HybridBitSet<T>> for HybridBitSet<T>

fn union(&mut self, other: &HybridBitSet<T>) -> bool

fn subtract(&mut self, other: &HybridBitSet<T>) -> bool

fn intersect(&mut self, other: &HybridBitSet<T>) -> bool

impl<T: Clone> Clone for HybridBitSet<T>

fn clone(&self) -> HybridBitSet<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Idx> Debug for HybridBitSet<T>

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

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.