Struct bitvec::index::BitMask

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

A multi-bit selection mask.

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 batch operation on a register.

Construction

It is only constructed by accumulating BitSel values. The chain of custody for safe construction in this module and in order ensures that all masks that are applied to register values can be trusted to not cause memory unsafety.

Implementations

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

pub const ALL: Self

A full mask.

pub const ZERO: Self

An empty mask.

pub unsafe fn new(mask: 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 reading it only as a bit-mask.

Parameters

• mask: Some integer value

Returns

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

Safety

This function must only be called within a BitOrder::mask implementation which is verified to be correct.

Prefer accumulating BitSel values using the Sum implementation.

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

Creates a new mask with a selector bit activated.

Parameters

• self
• sel: The selector bit to activate in the new mask.

Returns

A copy of self, with the selector at sel activated.

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

Inserts a selector into an existing mask.

Parameters

• &mut self
• sel: The selector bit to insert into the mask.

Effects

The selector’s bit in the self mask is activated.

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

Tests whether a mask contains a given selector bit.

Paramters

• self
• sel: The selector bit to test in the self mask.

Returns

Whether self has set the bit at sel.

pub fn value(self) -> R

Views the internal mask value.

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

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

Performs the | operation.

impl<R: Clone> Clone for BitMask<R> where
    R: 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: Copy> Copy for BitMask<R> where
    R: BitRegister, 

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: Eq> Eq for BitMask<R> where
    R: BitRegister, 

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.

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]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

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.

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

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

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

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

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

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

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

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

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

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

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.