BitSet

Trait BitSet 

pub trait BitSet {
Show 22 methods // Required methods fn bit_len(&self) -> usize; fn bit_init(&mut self, value: bool) -> &mut Self; fn bit_test(&self, bit: usize) -> bool; fn bit_set(&mut self, bit: usize) -> &mut Self; fn bit_reset(&mut self, bit: usize) -> &mut Self; fn bit_flip(&mut self, bit: usize) -> &mut Self; fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Self; fn bit_all(&self) -> bool; fn bit_any(&self) -> bool; fn bit_eq(&self, rhs: &Self) -> bool; fn bit_disjoint(&self, rhs: &Self) -> bool; fn bit_subset(&self, rhs: &Self) -> bool; fn bit_or(&mut self, rhs: &Self) -> &mut Self; fn bit_and(&mut self, rhs: &Self) -> &mut Self; fn bit_andnot(&mut self, rhs: &Self) -> &mut Self; fn bit_xor(&mut self, rhs: &Self) -> &mut Self; fn bit_not(&mut self) -> &mut Self; fn bit_mask(&mut self, rhs: &Self, mask: &Self) -> &mut Self; fn bit_count(&self) -> usize; // Provided methods fn bit_fmt(&self) -> &BitFmt<Self> { ... } fn bit_none(&self) -> bool { ... } fn bit_superset(&self, rhs: &Self) -> bool { ... }
}
Expand description

The BitSet API.

Required Methods§

fn bit_len(&self) -> usize

Returns total number of bits.

fn bit_init(&mut self, value: bool) -> &mut Self

Initializes all bits.

fn bit_test(&self, bit: usize) -> bool

Returns if the given bit is set.

fn bit_set(&mut self, bit: usize) -> &mut Self

Sets the given bit.

fn bit_reset(&mut self, bit: usize) -> &mut Self

Resets the given bit.

fn bit_flip(&mut self, bit: usize) -> &mut Self

Flips the given bit.

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Self

Conditionally sets or resets the given bit.

fn bit_all(&self) -> bool

Returns if all bits are set.

fn bit_any(&self) -> bool

Returns if any bits are set.

fn bit_eq(&self, rhs: &Self) -> bool

Returns if the two bitsets are equal.

fn bit_disjoint(&self, rhs: &Self) -> bool

Returns if the two bitsets have no bits in common.

fn bit_subset(&self, rhs: &Self) -> bool

Returns if self is a subset of rhs.

fn bit_or(&mut self, rhs: &Self) -> &mut Self

Bitwise OR.

fn bit_and(&mut self, rhs: &Self) -> &mut Self

Bitwise AND.

fn bit_andnot(&mut self, rhs: &Self) -> &mut Self

Bitwise AND after NOT of rhs.

fn bit_xor(&mut self, rhs: &Self) -> &mut Self

Bitwise XOR.

fn bit_not(&mut self) -> &mut Self

Bitwise NOT.

fn bit_mask(&mut self, rhs: &Self, mask: &Self) -> &mut Self

Bitwise combine with MASK.

fn bit_count(&self) -> usize

Counts the number of set bits.

Provided Methods§

fn bit_fmt(&self) -> &BitFmt<Self>

Format the bits.

fn bit_none(&self) -> bool

Returns if none of the bits are set.

fn bit_superset(&self, rhs: &Self) -> bool

Returns if self is a superset of rhs.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

§

impl BitSet for u8

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut u8

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut u8

§

fn bit_reset(&mut self, bit: usize) -> &mut u8

§

fn bit_flip(&mut self, bit: usize) -> &mut u8

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u8

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_none(&self) -> bool

§

fn bit_eq(&self, rhs: &u8) -> bool

§

fn bit_disjoint(&self, rhs: &u8) -> bool

§

fn bit_subset(&self, rhs: &u8) -> bool

§

fn bit_superset(&self, rhs: &u8) -> bool

§

fn bit_or(&mut self, rhs: &u8) -> &mut u8

§

fn bit_and(&mut self, rhs: &u8) -> &mut u8

§

fn bit_andnot(&mut self, rhs: &u8) -> &mut u8

§

fn bit_xor(&mut self, rhs: &u8) -> &mut u8

§

fn bit_not(&mut self) -> &mut u8

§

fn bit_mask(&mut self, rhs: &u8, mask: &u8) -> &mut u8

§

fn bit_count(&self) -> usize

§

impl BitSet for u16

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut u16

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut u16

§

fn bit_reset(&mut self, bit: usize) -> &mut u16

§

fn bit_flip(&mut self, bit: usize) -> &mut u16

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u16

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_none(&self) -> bool

§

fn bit_eq(&self, rhs: &u16) -> bool

§

fn bit_disjoint(&self, rhs: &u16) -> bool

§

fn bit_subset(&self, rhs: &u16) -> bool

§

fn bit_superset(&self, rhs: &u16) -> bool

§

fn bit_or(&mut self, rhs: &u16) -> &mut u16

§

fn bit_and(&mut self, rhs: &u16) -> &mut u16

§

fn bit_andnot(&mut self, rhs: &u16) -> &mut u16

§

fn bit_xor(&mut self, rhs: &u16) -> &mut u16

§

fn bit_not(&mut self) -> &mut u16

§

fn bit_mask(&mut self, rhs: &u16, mask: &u16) -> &mut u16

§

fn bit_count(&self) -> usize

§

impl BitSet for u32

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut u32

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut u32

§

fn bit_reset(&mut self, bit: usize) -> &mut u32

§

fn bit_flip(&mut self, bit: usize) -> &mut u32

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u32

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_none(&self) -> bool

§

fn bit_eq(&self, rhs: &u32) -> bool

§

fn bit_disjoint(&self, rhs: &u32) -> bool

§

fn bit_subset(&self, rhs: &u32) -> bool

§

fn bit_superset(&self, rhs: &u32) -> bool

§

fn bit_or(&mut self, rhs: &u32) -> &mut u32

§

fn bit_and(&mut self, rhs: &u32) -> &mut u32

§

fn bit_andnot(&mut self, rhs: &u32) -> &mut u32

§

fn bit_xor(&mut self, rhs: &u32) -> &mut u32

§

fn bit_not(&mut self) -> &mut u32

§

fn bit_mask(&mut self, rhs: &u32, mask: &u32) -> &mut u32

§

fn bit_count(&self) -> usize

§

impl BitSet for u64

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut u64

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut u64

§

fn bit_reset(&mut self, bit: usize) -> &mut u64

§

fn bit_flip(&mut self, bit: usize) -> &mut u64

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u64

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_none(&self) -> bool

§

fn bit_eq(&self, rhs: &u64) -> bool

§

fn bit_disjoint(&self, rhs: &u64) -> bool

§

fn bit_subset(&self, rhs: &u64) -> bool

§

fn bit_superset(&self, rhs: &u64) -> bool

§

fn bit_or(&mut self, rhs: &u64) -> &mut u64

§

fn bit_and(&mut self, rhs: &u64) -> &mut u64

§

fn bit_andnot(&mut self, rhs: &u64) -> &mut u64

§

fn bit_xor(&mut self, rhs: &u64) -> &mut u64

§

fn bit_not(&mut self) -> &mut u64

§

fn bit_mask(&mut self, rhs: &u64, mask: &u64) -> &mut u64

§

fn bit_count(&self) -> usize

§

impl BitSet for u128

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut u128

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut u128

§

fn bit_reset(&mut self, bit: usize) -> &mut u128

§

fn bit_flip(&mut self, bit: usize) -> &mut u128

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u128

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_none(&self) -> bool

§

fn bit_eq(&self, rhs: &u128) -> bool

§

fn bit_disjoint(&self, rhs: &u128) -> bool

§

fn bit_subset(&self, rhs: &u128) -> bool

§

fn bit_superset(&self, rhs: &u128) -> bool

§

fn bit_or(&mut self, rhs: &u128) -> &mut u128

§

fn bit_and(&mut self, rhs: &u128) -> &mut u128

§

fn bit_andnot(&mut self, rhs: &u128) -> &mut u128

§

fn bit_xor(&mut self, rhs: &u128) -> &mut u128

§

fn bit_not(&mut self) -> &mut u128

§

fn bit_mask(&mut self, rhs: &u128, mask: &u128) -> &mut u128

§

fn bit_count(&self) -> usize

§

impl BitSet for [u8]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [u8]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [u8]

§

fn bit_reset(&mut self, bit: usize) -> &mut [u8]

§

fn bit_flip(&mut self, bit: usize) -> &mut [u8]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u8]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[u8]) -> bool

§

fn bit_disjoint(&self, rhs: &[u8]) -> bool

§

fn bit_subset(&self, rhs: &[u8]) -> bool

§

fn bit_or(&mut self, rhs: &[u8]) -> &mut [u8]

§

fn bit_and(&mut self, rhs: &[u8]) -> &mut [u8]

§

fn bit_andnot(&mut self, rhs: &[u8]) -> &mut [u8]

§

fn bit_xor(&mut self, rhs: &[u8]) -> &mut [u8]

§

fn bit_not(&mut self) -> &mut [u8]

§

fn bit_mask(&mut self, rhs: &[u8], mask: &[u8]) -> &mut [u8]

§

fn bit_count(&self) -> usize

§

impl BitSet for [u16]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [u16]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [u16]

§

fn bit_reset(&mut self, bit: usize) -> &mut [u16]

§

fn bit_flip(&mut self, bit: usize) -> &mut [u16]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u16]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[u16]) -> bool

§

fn bit_disjoint(&self, rhs: &[u16]) -> bool

§

fn bit_subset(&self, rhs: &[u16]) -> bool

§

fn bit_or(&mut self, rhs: &[u16]) -> &mut [u16]

§

fn bit_and(&mut self, rhs: &[u16]) -> &mut [u16]

§

fn bit_andnot(&mut self, rhs: &[u16]) -> &mut [u16]

§

fn bit_xor(&mut self, rhs: &[u16]) -> &mut [u16]

§

fn bit_not(&mut self) -> &mut [u16]

§

fn bit_mask(&mut self, rhs: &[u16], mask: &[u16]) -> &mut [u16]

§

fn bit_count(&self) -> usize

§

impl BitSet for [u32]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [u32]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [u32]

§

fn bit_reset(&mut self, bit: usize) -> &mut [u32]

§

fn bit_flip(&mut self, bit: usize) -> &mut [u32]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u32]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[u32]) -> bool

§

fn bit_disjoint(&self, rhs: &[u32]) -> bool

§

fn bit_subset(&self, rhs: &[u32]) -> bool

§

fn bit_or(&mut self, rhs: &[u32]) -> &mut [u32]

§

fn bit_and(&mut self, rhs: &[u32]) -> &mut [u32]

§

fn bit_andnot(&mut self, rhs: &[u32]) -> &mut [u32]

§

fn bit_xor(&mut self, rhs: &[u32]) -> &mut [u32]

§

fn bit_not(&mut self) -> &mut [u32]

§

fn bit_mask(&mut self, rhs: &[u32], mask: &[u32]) -> &mut [u32]

§

fn bit_count(&self) -> usize

§

impl BitSet for [u64]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [u64]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [u64]

§

fn bit_reset(&mut self, bit: usize) -> &mut [u64]

§

fn bit_flip(&mut self, bit: usize) -> &mut [u64]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u64]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[u64]) -> bool

§

fn bit_disjoint(&self, rhs: &[u64]) -> bool

§

fn bit_subset(&self, rhs: &[u64]) -> bool

§

fn bit_or(&mut self, rhs: &[u64]) -> &mut [u64]

§

fn bit_and(&mut self, rhs: &[u64]) -> &mut [u64]

§

fn bit_andnot(&mut self, rhs: &[u64]) -> &mut [u64]

§

fn bit_xor(&mut self, rhs: &[u64]) -> &mut [u64]

§

fn bit_not(&mut self) -> &mut [u64]

§

fn bit_mask(&mut self, rhs: &[u64], mask: &[u64]) -> &mut [u64]

§

fn bit_count(&self) -> usize

§

impl BitSet for [u128]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [u128]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [u128]

§

fn bit_reset(&mut self, bit: usize) -> &mut [u128]

§

fn bit_flip(&mut self, bit: usize) -> &mut [u128]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u128]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[u128]) -> bool

§

fn bit_disjoint(&self, rhs: &[u128]) -> bool

§

fn bit_subset(&self, rhs: &[u128]) -> bool

§

fn bit_or(&mut self, rhs: &[u128]) -> &mut [u128]

§

fn bit_and(&mut self, rhs: &[u128]) -> &mut [u128]

§

fn bit_andnot(&mut self, rhs: &[u128]) -> &mut [u128]

§

fn bit_xor(&mut self, rhs: &[u128]) -> &mut [u128]

§

fn bit_not(&mut self) -> &mut [u128]

§

fn bit_mask(&mut self, rhs: &[u128], mask: &[u128]) -> &mut [u128]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u8; 16]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u8; 16]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u8; 16]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u8; 16]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u8; 16]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u8; 16]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u8; 16]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u8; 16]]) -> bool

§

fn bit_subset(&self, rhs: &[[u8; 16]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]

§

fn bit_and(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]

§

fn bit_andnot(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]

§

fn bit_xor(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]

§

fn bit_not(&mut self) -> &mut [[u8; 16]]

§

fn bit_mask(&mut self, rhs: &[[u8; 16]], mask: &[[u8; 16]]) -> &mut [[u8; 16]]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u8; 32]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u8; 32]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u8; 32]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u8; 32]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u8; 32]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u8; 32]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u8; 32]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u8; 32]]) -> bool

§

fn bit_subset(&self, rhs: &[[u8; 32]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]

§

fn bit_and(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]

§

fn bit_andnot(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]

§

fn bit_xor(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]

§

fn bit_not(&mut self) -> &mut [[u8; 32]]

§

fn bit_mask(&mut self, rhs: &[[u8; 32]], mask: &[[u8; 32]]) -> &mut [[u8; 32]]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u16; 8]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u16; 8]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u16; 8]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u16; 8]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u16; 8]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u16; 8]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u16; 8]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u16; 8]]) -> bool

§

fn bit_subset(&self, rhs: &[[u16; 8]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]

§

fn bit_and(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]

§

fn bit_andnot(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]

§

fn bit_xor(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]

§

fn bit_not(&mut self) -> &mut [[u16; 8]]

§

fn bit_mask(&mut self, rhs: &[[u16; 8]], mask: &[[u16; 8]]) -> &mut [[u16; 8]]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u16; 16]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u16; 16]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u16; 16]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u16; 16]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u16; 16]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u16; 16]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u16; 16]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u16; 16]]) -> bool

§

fn bit_subset(&self, rhs: &[[u16; 16]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]

§

fn bit_and(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]

§

fn bit_andnot(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]

§

fn bit_xor(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]

§

fn bit_not(&mut self) -> &mut [[u16; 16]]

§

fn bit_mask( &mut self, rhs: &[[u16; 16]], mask: &[[u16; 16]], ) -> &mut [[u16; 16]]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u32; 4]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u32; 4]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u32; 4]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u32; 4]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u32; 4]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u32; 4]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u32; 4]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u32; 4]]) -> bool

§

fn bit_subset(&self, rhs: &[[u32; 4]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]

§

fn bit_and(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]

§

fn bit_andnot(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]

§

fn bit_xor(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]

§

fn bit_not(&mut self) -> &mut [[u32; 4]]

§

fn bit_mask(&mut self, rhs: &[[u32; 4]], mask: &[[u32; 4]]) -> &mut [[u32; 4]]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u32; 8]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u32; 8]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u32; 8]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u32; 8]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u32; 8]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u32; 8]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u32; 8]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u32; 8]]) -> bool

§

fn bit_subset(&self, rhs: &[[u32; 8]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]

§

fn bit_and(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]

§

fn bit_andnot(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]

§

fn bit_xor(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]

§

fn bit_not(&mut self) -> &mut [[u32; 8]]

§

fn bit_mask(&mut self, rhs: &[[u32; 8]], mask: &[[u32; 8]]) -> &mut [[u32; 8]]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u64; 2]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u64; 2]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u64; 2]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u64; 2]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u64; 2]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u64; 2]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u64; 2]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u64; 2]]) -> bool

§

fn bit_subset(&self, rhs: &[[u64; 2]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]

§

fn bit_and(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]

§

fn bit_andnot(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]

§

fn bit_xor(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]

§

fn bit_not(&mut self) -> &mut [[u64; 2]]

§

fn bit_mask(&mut self, rhs: &[[u64; 2]], mask: &[[u64; 2]]) -> &mut [[u64; 2]]

§

fn bit_count(&self) -> usize

§

impl BitSet for [[u64; 4]]

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut [[u64; 4]]

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut [[u64; 4]]

§

fn bit_reset(&mut self, bit: usize) -> &mut [[u64; 4]]

§

fn bit_flip(&mut self, bit: usize) -> &mut [[u64; 4]]

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u64; 4]]

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_eq(&self, rhs: &[[u64; 4]]) -> bool

§

fn bit_disjoint(&self, rhs: &[[u64; 4]]) -> bool

§

fn bit_subset(&self, rhs: &[[u64; 4]]) -> bool

§

fn bit_or(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]

§

fn bit_and(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]

§

fn bit_andnot(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]

§

fn bit_xor(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]

§

fn bit_not(&mut self) -> &mut [[u64; 4]]

§

fn bit_mask(&mut self, rhs: &[[u64; 4]], mask: &[[u64; 4]]) -> &mut [[u64; 4]]

§

fn bit_count(&self) -> usize

§

impl<T> BitSet for Box<[T]>
where [T]: BitSet,

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut Box<[T]>

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut Box<[T]>

§

fn bit_reset(&mut self, bit: usize) -> &mut Box<[T]>

§

fn bit_flip(&mut self, bit: usize) -> &mut Box<[T]>

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Box<[T]>

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_none(&self) -> bool

§

fn bit_eq(&self, rhs: &Box<[T]>) -> bool

§

fn bit_disjoint(&self, rhs: &Box<[T]>) -> bool

§

fn bit_subset(&self, rhs: &Box<[T]>) -> bool

§

fn bit_superset(&self, rhs: &Box<[T]>) -> bool

§

fn bit_or(&mut self, rhs: &Box<[T]>) -> &mut Box<[T]>

§

fn bit_and(&mut self, rhs: &Box<[T]>) -> &mut Box<[T]>

§

fn bit_andnot(&mut self, rhs: &Box<[T]>) -> &mut Box<[T]>

§

fn bit_xor(&mut self, rhs: &Box<[T]>) -> &mut Box<[T]>

§

fn bit_not(&mut self) -> &mut Box<[T]>

§

fn bit_mask(&mut self, rhs: &Box<[T]>, mask: &Box<[T]>) -> &mut Box<[T]>

§

fn bit_count(&self) -> usize

§

impl<T> BitSet for Vec<T>
where [T]: BitSet,

§

fn bit_len(&self) -> usize

§

fn bit_init(&mut self, value: bool) -> &mut Vec<T>

§

fn bit_test(&self, bit: usize) -> bool

§

fn bit_set(&mut self, bit: usize) -> &mut Vec<T>

§

fn bit_reset(&mut self, bit: usize) -> &mut Vec<T>

§

fn bit_flip(&mut self, bit: usize) -> &mut Vec<T>

§

fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Vec<T>

§

fn bit_all(&self) -> bool

§

fn bit_any(&self) -> bool

§

fn bit_none(&self) -> bool

§

fn bit_eq(&self, rhs: &Vec<T>) -> bool

§

fn bit_disjoint(&self, rhs: &Vec<T>) -> bool

§

fn bit_subset(&self, rhs: &Vec<T>) -> bool

§

fn bit_superset(&self, rhs: &Vec<T>) -> bool

§

fn bit_or(&mut self, rhs: &Vec<T>) -> &mut Vec<T>

§

fn bit_and(&mut self, rhs: &Vec<T>) -> &mut Vec<T>

§

fn bit_andnot(&mut self, rhs: &Vec<T>) -> &mut Vec<T>

§

fn bit_xor(&mut self, rhs: &Vec<T>) -> &mut Vec<T>

§

fn bit_not(&mut self) -> &mut Vec<T>

§

fn bit_mask(&mut self, rhs: &Vec<T>, mask: &Vec<T>) -> &mut Vec<T>

§

fn bit_count(&self) -> usize

Implementors§