Struct BitSet128 

pub struct BitSet128(/* private fields */);

Available on crate feature b128 only.

A set of 128 bits.

Implementations

impl BitSet128

pub const CAPACITY: usize = 128usize

The capacity of a BitSet128.

pub const fn new() -> Self

Creates an empty set.

pub const fn unit(index: usize) -> Self

Creates a set containing with only the bit at index set.

If index >=Self::CAPACITY, the resulting set will be empty.

pub const fn all() -> Self

Creates a set with all bits set.

pub const fn from_bits(bits: u128) -> Self

Creates a set with the given bits.

pub const fn bits(self) -> u128

Returns the underlying bits of the set.

pub const fn complement(self) -> Self

Creates a new set that complements self. This is the const alternative to Neg::neg or Not::not for BitSet128s.

pub const fn intersection(self, rhs: Self) -> Self

Creates a new set with values that are in both self and rhs. This is the const alternative to BitAnd::bitand for BitSet128s.

pub const fn union(self, rhs: Self) -> Self

Creates a new set with values that are in self or rhs. This is the const alternative to BitOr::bitor for BitSet128s.

pub const fn difference(self, rhs: Self) -> Self

Creates a new set with values that are in self, but not in rhs. This is the const alternative to Sub::sub for BitSet128s.

pub const fn symmetric_difference(self, rhs: Self) -> Self

Creates a new set with values that are in self or rhs, but not in both. This is the const alternative to BitXor::bitxor for BitSet128s.

pub const fn is(self, rhs: Self) -> bool

Returns true if self is equal to rhs, i.e., both sets have the same exact values. This is the const alternative to PartialEq::eq for BitSet128s.

pub const fn is_not(self, rhs: Self) -> bool

Returns true if self is not equal to rhs, i.e., the sets do not have exactly the same values. This is the const alternative to PartialEq::ne for BitSet128s.

pub const fn is_disjoint(self, rhs: Self) -> bool

Returns true if self has no elements in common with rhs. This is equivalent to checking for an empty intersection.

pub const fn is_subset(self, rhs: Self) -> bool

Returns true if the set is a subset of another, i.e., rhs contains at least all the values in self.

pub const fn is_strict_subset(self, rhs: Self) -> bool

Returns true if the set is a strict subset of another, i.e., rhs contains all the values in self and is larger than self.

pub const fn is_superset(self, rhs: Self) -> bool

Returns true if the set is a superset of another, i.e., self contains at least all the values in rhs.

pub const fn is_strict_superset(self, rhs: Self) -> bool

Returns true if the set is a strict superset of another, i.e., self contains all the values in rhs and is larger than rhs.

pub const fn is_empty(self) -> bool

Returns true if the set contains no elements.

pub const fn is_full(self) -> bool

Returns true if the set contains all Self::CAPACITY elements.

pub const fn len(self) -> usize

Returns the number of elements in the set.

pub const fn contains(self, index: usize) -> bool

Returns true if the bit at index is set.

pub const fn get(self, index: usize) -> bool

Gets the bit at index.

If index >=Self::CAPACITY, this will simply return false.

pub const fn min_index(self) -> usize

Returns the index of the least significant bit that is set.

If no bits are set, this returns Self::CAPACITY.

pub const fn max_index(self) -> usize

Returns the index of the most significant bit that is set.

Panics

Panics if no bits are set. For a non-panicking alternative, see max_index_checked.

pub const fn max_index_checked(self) -> Option<usize>

Returns the index of the most significant bit that is set, or None if no bits are set.

pub const fn clear(&mut self)

Clears the set, removing all values.

pub const fn masked_0_to_i(self, index: usize) -> Self

Creates a copy of this set that only has values less than index.

Panics

Panics if index >=Self::CAPACITY.

pub const fn mask_0_to_i(&mut self, index: usize)

Removes any bits with indices outside the range 0..index.

Panics

Panics if index >=Self::CAPACITY.

pub const fn masked_i_to_128(self, index: usize) -> Self

Creates a copy of this set that only has bits with indices greater than or equal to index.

Panics

Panics if index >=Self::CAPACITY.

pub const fn mask_i_to_128(&mut self, index: usize)

Removes any bits with indices outside the range index..128.

Panics

Panics if index >=Self::CAPACITY.

pub const fn cleared_0_to_i(self, index: usize) -> Self

Creates a copy of this set without the bits with indices in the range 0..index.

Panics

Panics if index >=Self::CAPACITY.

pub const fn clear_0_to_i(&mut self, index: usize)

Clears bits 0..index, keeping bits index..128 in their original states.

Panics

Panics if index >=Self::CAPACITY.

pub const fn cleared_i_to_128(self, index: usize) -> Self

Creates a copy of this set without the bits with indices in the range index..128.

Panics

Panics if index >=Self::CAPACITY.

pub const fn clear_i_to_128(&mut self, index: usize)

Clears bits index..128, keeping bits 0..index in their original states.

Panics

Panics if index >=Self::CAPACITY.

pub const fn insert_quiet(&mut self, index: usize)

Sets the bit at index to 1.

If you would like to know if the insertion succeeded, use insert instead.

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

Sets the bit at index to 1. Returns whether the bit was not already set.

If the return value is not needed, use insert_quiet instead.

pub const fn replace_quiet(&mut self, index: usize, bit: bool)

Sets the bit at index to bit.

If you would like to know the old value of the bit, use replace instead.

pub const fn replace(&mut self, index: usize, bit: bool) -> bool

Sets the bit at index to bit.

If the return value is not needed, use replace_quiet instead.

pub const fn remove_quiet(&mut self, index: usize)

Sets the bit at index to 0.

If you would like to know if the removal succeeded, use remove instead.

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

Sets the bit at index to 0. Returns whether the bit was set.

If the return value is not needed, use remove_quiet instead.

impl BitSet128

pub const fn iter_indices<Direction>(&self) -> BitSetIndices128<'_, Direction>

where for<'a> BitSetIndices128<'a, Direction>: Iterator<Item = usize>,

Creates an iterator over the indices of the bits that are set in the set.

impl BitSet128

pub const fn iter_bits<Direction>(&self) -> BitSetIter128<'_, Direction>

where for<'a> BitSetIter128<'a, Direction>: Iterator<Item = bool>,

Creates an iterator over the bits of the set.

Trait Implementations

impl BitAnd for BitSet128

type Output = BitSet128

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAndAssign for BitSet128

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr for BitSet128

type Output = BitSet128

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign for BitSet128

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor for BitSet128

type Output = BitSet128

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXorAssign for BitSet128

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for BitSet128

fn clone(&self) -> BitSet128

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitSet128

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

Formats the value using the given formatter.

impl Default for BitSet128

fn default() -> BitSet128

Returns the “default value” for a type.

impl From<BitSet128> for u128

fn from(value: BitSet128) -> Self

Converts to this type from the input type.

impl From<u128> for BitSet128

fn from(value: u128) -> Self

Converts to this type from the input type.

impl Hash for BitSet128

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Neg for BitSet128

type Output = BitSet128

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for BitSet128

type Output = BitSet128

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for BitSet128

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub for BitSet128

type Output = BitSet128

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl SubAssign for BitSet128

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for BitSet128

impl Eq for BitSet128

impl StructuralPartialEq for BitSet128