Trait std::ops::BitAndAssign

pub trait BitAndAssign<Rhs = Self> {
    fn bitand_assign(&mut self, Rhs);
}

The BitAndAssign trait is used to specify the functionality of &=.

Examples

In this example, the &= operator is lifted to a trivial Scalar type.

use std::ops::BitAndAssign;

#[derive(Debug, PartialEq)]
struct Scalar(bool);

impl BitAndAssign for Scalar {
    // rhs is the "right-hand side" of the expression `a &= b`
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Scalar(self.0 & rhs.0)
    }
}

fn main() {
    let mut scalar = Scalar(true);
    scalar &= Scalar(true);
    assert_eq!(scalar, Scalar(true));

    let mut scalar = Scalar(true);
    scalar &= Scalar(false);
    assert_eq!(scalar, Scalar(false));

    let mut scalar = Scalar(false);
    scalar &= Scalar(true);
    assert_eq!(scalar, Scalar(false));

    let mut scalar = Scalar(false);
    scalar &= Scalar(false);
    assert_eq!(scalar, Scalar(false));
}

In this example, the BitAndAssign trait is implemented for a BooleanVector struct.

use std::ops::BitAndAssign;

#[derive(Debug, PartialEq)]
struct BooleanVector(Vec<bool>);

impl BitAndAssign for BooleanVector {
    // rhs is the "right-hand side" of the expression `a &= b`
    fn bitand_assign(&mut self, rhs: Self) {
        assert_eq!(self.0.len(), rhs.0.len());
        *self = BooleanVector(self.0
                                  .iter()
                                  .zip(rhs.0.iter())
                                  .map(|(x, y)| *x && *y)
                                  .collect());
    }
}

fn main() {
    let mut bv = BooleanVector(vec![true, true, false, false]);
    bv &= BooleanVector(vec![true, false, true, false]);
    let expected = BooleanVector(vec![true, false, false, false]);
    assert_eq!(bv, expected);
}

Required Methods

Implementors

• impl BitAndAssign<Wrapping<usize>> for std::num::Wrapping<usize>
• impl BitAndAssign<Wrapping<u8>> for std::num::Wrapping<u8>
• impl BitAndAssign<Wrapping<u16>> for std::num::Wrapping<u16>
• impl BitAndAssign<Wrapping<u32>> for std::num::Wrapping<u32>
• impl BitAndAssign<Wrapping<u64>> for std::num::Wrapping<u64>
• impl BitAndAssign<Wrapping<isize>> for std::num::Wrapping<isize>
• impl BitAndAssign<Wrapping<i8>> for std::num::Wrapping<i8>
• impl BitAndAssign<Wrapping<i16>> for std::num::Wrapping<i16>
• impl BitAndAssign<Wrapping<i32>> for std::num::Wrapping<i32>
• impl BitAndAssign<Wrapping<i64>> for std::num::Wrapping<i64>
• impl BitAndAssign<Wrapping<u128>> for std::num::Wrapping<u128>
• impl BitAndAssign<Wrapping<i128>> for std::num::Wrapping<i128>
• impl BitAndAssign<bool> for bool
• impl BitAndAssign<usize> for usize
• impl BitAndAssign<u8> for u8
• impl BitAndAssign<u16> for u16
• impl BitAndAssign<u32> for u32
• impl BitAndAssign<u64> for u64
• impl BitAndAssign<isize> for isize
• impl BitAndAssign<i8> for i8
• impl BitAndAssign<i16> for i16
• impl BitAndAssign<i32> for i32
• impl BitAndAssign<i64> for i64
• impl BitAndAssign<u128> for u128
• impl BitAndAssign<i128> for i128