Struct bitvec::index::BitMask[−][src]

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

Expand description

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.

Struct bitvec::index::BitMask[−][src]

Implementations

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

pub const ALL: Self

pub const ZERO: Self

pub unsafe fn new(mask: R) -> Self

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

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

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

pub fn value(self) -> R

Trait Implementations

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

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

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

type Output = Self

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

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

type Output = Self

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

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

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

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

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

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

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

fn default() -> BitMask<R>

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

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

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

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

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

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

type Output = Self

fn not(self) -> Self::Output

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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,

Auto Trait Implementations

impl<R> RefUnwindSafe for BitMask<R> where R: RefUnwindSafe,

impl<R> Send for BitMask<R>

impl<R> Sync for BitMask<R>

impl<R> Unpin for BitMask<R>

impl<R> UnwindSafe for BitMask<R> where R: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<R: PartialOrd> PartialOrd<BitMask<R>> 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>>,

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,

impl<R> RefUnwindSafe for BitMask<R> where
R: RefUnwindSafe,

impl<R> UnwindSafe for BitMask<R> where
R: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,

fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,

fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,

impl<T, U> TapAsRef<U> for T where
U: ?Sized,

fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,

fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,