Trait bones_framework::prelude::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.

Object Safety§

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§