Struct bitvec::index::BitMask

#[repr(transparent)]
pub struct BitMask<R> where
    R: BitRegister,  { /* fields omitted */ }

A multi-bit selection mask for a register R.

Unlike BitSel, which enforces a strict one-hot mask encoding, this mask type permits any number of bits to be set or unset. This is used to accumulate selections for a batched operation on a register.

Type Parameters

• R: The register element that this masks.

Construction

This can only be constructed by combining BitSel selection mask produced through the BitIdx and BitOrder chain of custody.

Implementations

impl<R> BitMask<R> where
    R: BitRegister, 

pub const ALL: Self

A full mask.

pub const ZERO: Self

An empty mask.

pub fn new(value: R) -> Self

Wraps any R value as a bit-mask.

This constructor is provided to explicitly declare that an operation is discarding the numeric value of an integer and instead using it only as a bit-mask.

Parameters

• value: Some integer to use as a bit-mask.

Returns

The value wrapped as a bit-mask, with its numeric context discarded.

Prefer accumulating BitSel values using the Sum implementation.

Safety

The value must be computed from a set of valid bit positions in the caller’s context.

pub fn value(self) -> R

Removes the mask wrapper, leaving the internal value.

pub fn test(&self, sel: BitSel<R>) -> bool

Tests whether the mask contains a given selector bit.

Parameters

• &self
• sel: Some single selection bit to test in self.

Returns

Whether self is set high at sel.

pub fn insert(&mut self, sel: BitSel<R>)

Inserts a selector bit into an existing mask.

Parameters

• &mut self
• sel: A selector bit to set in self.

Effects

The bit at sel is set high in self.

pub fn combine(self, sel: BitSel<R>) -> Self

Creates a new mask with a selector bit activated.

Parameters

• self
• sel: A selector bit to set in self

Returns

A copy of self, with sel set high.

Trait Implementations

impl<R> Binary for BitMask<R> where
    R: BitRegister, 

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

Formats the value using the given formatter.

impl<R> BitAnd<R> for BitMask<R> where
    R: BitRegister, 

type Output = Self

The resulting type after applying the & operator.

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

Performs the & operation.

impl<R> BitOr<R> for BitMask<R> where
    R: BitRegister, 

type Output = Self

The resulting type after applying the | operator.

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

Performs the | operation.

impl<R: Clone> Clone for BitMask<R> where
    R: BitRegister, 

fn clone(&self) -> BitMask<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R> Debug for BitMask<R> where
    R: BitRegister, 

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

Formats the value using the given formatter.

impl<R: Default> Default for BitMask<R> where
    R: BitRegister, 

fn default() -> BitMask<R>

Returns the “default value” for a type.

impl<R> Display for BitMask<R> where
    R: BitRegister, 

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

Formats the value using the given formatter.

impl<R: Hash> Hash for BitMask<R> where
    R: BitRegister, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<R> Not for BitMask<R> where
    R: BitRegister, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<R: Ord> Ord for BitMask<R> where
    R: BitRegister, 

fn cmp(&self, other: &BitMask<R>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<R: PartialEq> PartialEq<BitMask<R>> for BitMask<R> where
    R: BitRegister, 

fn eq(&self, other: &BitMask<R>) -> bool

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

fn ne(&self, other: &BitMask<R>) -> bool

This method tests for !=.

impl<R: PartialOrd> PartialOrd<BitMask<R>> for BitMask<R> where
    R: BitRegister, 

fn partial_cmp(&self, other: &BitMask<R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

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

impl<R> Sum<BitSel<R>> for BitMask<R> where
    R: BitRegister, 

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = BitSel<R>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<R: Copy> Copy for BitMask<R> where
    R: BitRegister, 

impl<R: Eq> Eq for BitMask<R> where
    R: BitRegister, 

impl<R> StructuralEq for BitMask<R> where
    R: BitRegister, 

impl<R> StructuralPartialEq for BitMask<R> where
    R: BitRegister,