Struct BitMask

pub struct BitMask<R = usize>
where
    R: BitRegister,
{ /* private fields */ }

Multi-Bit Selection Mask

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

Type Parameters

• R: The register element that this mask governs.

Construction

This must only be constructed by combining BitSel selection masks produced through the accepted chains of custody beginning with BitIdx values. Bit-masks not constructed in this manner are not guaranteed to be correct in the caller’s context and may lead to incorrect memory behaviors.

Implementations

impl<R> BitMask<R>

where R: BitRegister,

pub const ALL: BitMask<R> = _

A full bit-mask with every bit set.

pub const ZERO: BitMask<R> = _

An empty bit-mask with every bit cleared.

pub fn new(mask: R) -> BitMask<R>

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

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

Returns

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

Prefer accumulating BitSel values using its Sum implementation.

Safety

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

pub fn into_inner(self) -> R

Available on non-tarpaulin_include only.

Removes the mask wrapper, leaving the internal value.

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

Tests if a mask contains a given selector bit.

Parameters

• &self: The mask being tested.
• sel: A selector bit to test in self.

Returns

Whether self has set the bit that sel indicates.

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

Inserts a selector bit into a mask.

Parameters

• &mut self: The mask being modified.
• sel: A selector bit to insert into self.

Effects

The sel bit is set in the mask.

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

Creates a new mask with a selector bit activated.

Parameters

• self: The original mask.
• sel: The selector bit being added into the mask.

Returns

A new bit-mask with sel activated.

Trait Implementations

impl<R> Binary for BitMask<R>

where R: BitRegister,

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

Formats the value using the given formatter.

impl<R> BitAnd<R> for BitMask<R>

where R: BitRegister,

type Output = BitMask<R>

The resulting type after applying the & operator.

fn bitand(self, rhs: R) -> <BitMask<R> as BitAnd<R>>::Output

Performs the & operation.

impl<R> BitOr<R> for BitMask<R>

where R: BitRegister,

type Output = BitMask<R>

The resulting type after applying the | operator.

fn bitor(self, rhs: R) -> <BitMask<R> as BitOr<R>>::Output

Performs the | operation.

impl<R> Clone for BitMask<R>

where R: Clone + BitRegister,

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

Returns a copy of the value.

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<(), Error>

Formats the value using the given formatter.

impl<R> Default for BitMask<R>

where R: Default + 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<(), Error>

Formats the value using the given formatter.

impl<R> Hash for BitMask<R>

where R: Hash + BitRegister,

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

where __H: Hasher,

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<R> Not for BitMask<R>

where R: BitRegister,

type Output = BitMask<R>

The resulting type after applying the ! operator.

fn not(self) -> <BitMask<R> as Not>::Output

Performs the unary ! operation.

impl<R> Ord for BitMask<R>

where R: Ord + BitRegister,

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<R> PartialEq for BitMask<R>

where R: PartialEq + BitRegister,

fn eq(&self, other: &BitMask<R>) -> 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<R> PartialOrd for BitMask<R>

where R: PartialOrd + BitRegister,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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) -> BitMask<R>

where I: Iterator<Item = BitSel<R>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<R> Copy for BitMask<R>

where R: Copy + BitRegister,

impl<R> Eq for BitMask<R>

where R: Eq + BitRegister,

impl<R> StructuralPartialEq for BitMask<R>

where R: BitRegister,

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.