Trait entity_component::BitSet [−][src]
The BitSet API.
Required methods
pub fn bit_len(&self) -> usize
[src]
Returns total number of bits.
pub fn bit_init(&mut self, value: bool) -> &mut Self
[src]
Initializes all bits.
pub fn bit_test(&self, bit: usize) -> bool
[src]
Returns if the given bit is set.
pub fn bit_set(&mut self, bit: usize) -> &mut Self
[src]
Sets the given bit.
pub fn bit_reset(&mut self, bit: usize) -> &mut Self
[src]
Resets the given bit.
pub fn bit_flip(&mut self, bit: usize) -> &mut Self
[src]
Flips the given bit.
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Self
[src]
Conditionally sets or resets the given bit.
pub fn bit_all(&self) -> bool
[src]
Returns if all bits are set.
pub fn bit_any(&self) -> bool
[src]
Returns if any bits are set.
pub fn bit_eq(&self, rhs: &Self) -> bool
[src]
Returns if the two bitsets are equal.
pub fn bit_disjoint(&self, rhs: &Self) -> bool
[src]
Returns if the two bitsets have no bits in common.
pub fn bit_subset(&self, rhs: &Self) -> bool
[src]
Returns if self is a subset of rhs.
pub fn bit_or(&mut self, rhs: &Self) -> &mut Self
[src]
Bitwise OR.
pub fn bit_and(&mut self, rhs: &Self) -> &mut Self
[src]
Bitwise AND.
pub fn bit_andnot(&mut self, rhs: &Self) -> &mut Self
[src]
Bitwise AND after NOT of rhs.
pub fn bit_xor(&mut self, rhs: &Self) -> &mut Self
[src]
Bitwise XOR.
pub fn bit_not(&mut self) -> &mut Self
[src]
Bitwise NOT.
pub fn bit_mask(&mut self, rhs: &Self, mask: &Self) -> &mut Self
[src]
Bitwise combine with MASK.
pub fn bit_count(&self) -> usize
[src]
Counts the number of set bits.
Provided methods
pub fn bit_fmt(&self) -> &BitFmt<Self>
[src]
Format the bits.
pub fn bit_none(&self) -> bool
[src]
Returns if none of the bits are set.
pub fn bit_superset(&self, rhs: &Self) -> bool
[src]
Returns if self is a superset of rhs.
Implementations on Foreign Types
impl<T> BitSet for Box<[T], Global> where
[T]: BitSet,
[src]
[T]: BitSet,
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut Box<[T], Global>
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut Box<[T], Global>
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut Box<[T], Global>
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut Box<[T], Global>
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Box<[T], Global>
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_none(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &Box<[T], Global>) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &Box<[T], Global>) -> bool
[src]
pub fn bit_subset(&self, rhs: &Box<[T], Global>) -> bool
[src]
pub fn bit_superset(&self, rhs: &Box<[T], Global>) -> bool
[src]
pub fn bit_or(&mut self, rhs: &Box<[T], Global>) -> &mut Box<[T], Global>
[src]
pub fn bit_and(&mut self, rhs: &Box<[T], Global>) -> &mut Box<[T], Global>
[src]
pub fn bit_andnot(&mut self, rhs: &Box<[T], Global>) -> &mut Box<[T], Global>
[src]
pub fn bit_xor(&mut self, rhs: &Box<[T], Global>) -> &mut Box<[T], Global>
[src]
pub fn bit_not(&mut self) -> &mut Box<[T], Global>
[src]
pub fn bit_mask(
&mut self,
rhs: &Box<[T], Global>,
mask: &Box<[T], Global>
) -> &mut Box<[T], Global>
[src]
&mut self,
rhs: &Box<[T], Global>,
mask: &Box<[T], Global>
) -> &mut Box<[T], Global>
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [u16]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [u16]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [u16]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [u16]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [u16]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u16]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[u16]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[u16]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[u16]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[u16]) -> &mut [u16]
[src]
pub fn bit_and(&mut self, rhs: &[u16]) -> &mut [u16]
[src]
pub fn bit_andnot(&mut self, rhs: &[u16]) -> &mut [u16]
[src]
pub fn bit_xor(&mut self, rhs: &[u16]) -> &mut [u16]
[src]
pub fn bit_not(&mut self) -> &mut [u16]
[src]
pub fn bit_mask(&mut self, rhs: &[u16], mask: &[u16]) -> &mut [u16]
[src]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u8; 16]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u8; 16]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u8; 16]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u8; 16]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u8; 16]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u8; 16]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u8; 16]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u8; 16]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u8; 16]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]
[src]
pub fn bit_and(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u8; 16]]) -> &mut [[u8; 16]]
[src]
pub fn bit_not(&mut self) -> &mut [[u8; 16]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u8; 16]],
mask: &[[u8; 16]]
) -> &mut [[u8; 16]]
[src]
&mut self,
rhs: &[[u8; 16]],
mask: &[[u8; 16]]
) -> &mut [[u8; 16]]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [u128]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [u128]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [u128]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [u128]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [u128]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u128]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[u128]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[u128]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[u128]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[u128]) -> &mut [u128]
[src]
pub fn bit_and(&mut self, rhs: &[u128]) -> &mut [u128]
[src]
pub fn bit_andnot(&mut self, rhs: &[u128]) -> &mut [u128]
[src]
pub fn bit_xor(&mut self, rhs: &[u128]) -> &mut [u128]
[src]
pub fn bit_not(&mut self) -> &mut [u128]
[src]
pub fn bit_mask(&mut self, rhs: &[u128], mask: &[u128]) -> &mut [u128]
[src]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u16; 8]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u16; 8]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u16; 8]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u16; 8]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u16; 8]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u16; 8]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u16; 8]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u16; 8]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u16; 8]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]
[src]
pub fn bit_and(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u16; 8]]) -> &mut [[u16; 8]]
[src]
pub fn bit_not(&mut self) -> &mut [[u16; 8]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u16; 8]],
mask: &[[u16; 8]]
) -> &mut [[u16; 8]]
[src]
&mut self,
rhs: &[[u16; 8]],
mask: &[[u16; 8]]
) -> &mut [[u16; 8]]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u64; 4]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u64; 4]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u64; 4]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u64; 4]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u64; 4]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u64; 4]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u64; 4]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u64; 4]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u64; 4]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]
[src]
pub fn bit_and(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u64; 4]]) -> &mut [[u64; 4]]
[src]
pub fn bit_not(&mut self) -> &mut [[u64; 4]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u64; 4]],
mask: &[[u64; 4]]
) -> &mut [[u64; 4]]
[src]
&mut self,
rhs: &[[u64; 4]],
mask: &[[u64; 4]]
) -> &mut [[u64; 4]]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for u128
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut u128
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut u128
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut u128
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut u128
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u128
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_none(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &u128) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &u128) -> bool
[src]
pub fn bit_subset(&self, rhs: &u128) -> bool
[src]
pub fn bit_superset(&self, rhs: &u128) -> bool
[src]
pub fn bit_or(&mut self, rhs: &u128) -> &mut u128
[src]
pub fn bit_and(&mut self, rhs: &u128) -> &mut u128
[src]
pub fn bit_andnot(&mut self, rhs: &u128) -> &mut u128
[src]
pub fn bit_xor(&mut self, rhs: &u128) -> &mut u128
[src]
pub fn bit_not(&mut self) -> &mut u128
[src]
pub fn bit_mask(&mut self, rhs: &u128, mask: &u128) -> &mut u128
[src]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [u8]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [u8]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [u8]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [u8]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [u8]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u8]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[u8]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[u8]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[u8]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[u8]) -> &mut [u8]
[src]
pub fn bit_and(&mut self, rhs: &[u8]) -> &mut [u8]
[src]
pub fn bit_andnot(&mut self, rhs: &[u8]) -> &mut [u8]
[src]
pub fn bit_xor(&mut self, rhs: &[u8]) -> &mut [u8]
[src]
pub fn bit_not(&mut self) -> &mut [u8]
[src]
pub fn bit_mask(&mut self, rhs: &[u8], mask: &[u8]) -> &mut [u8]
[src]
pub fn bit_count(&self) -> usize
[src]
impl<T> BitSet for Vec<T, Global> where
[T]: BitSet,
[src]
[T]: BitSet,
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut Vec<T, Global>
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut Vec<T, Global>
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut Vec<T, Global>
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut Vec<T, Global>
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Vec<T, Global>
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_none(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &Vec<T, Global>) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &Vec<T, Global>) -> bool
[src]
pub fn bit_subset(&self, rhs: &Vec<T, Global>) -> bool
[src]
pub fn bit_superset(&self, rhs: &Vec<T, Global>) -> bool
[src]
pub fn bit_or(&mut self, rhs: &Vec<T, Global>) -> &mut Vec<T, Global>
[src]
pub fn bit_and(&mut self, rhs: &Vec<T, Global>) -> &mut Vec<T, Global>
[src]
pub fn bit_andnot(&mut self, rhs: &Vec<T, Global>) -> &mut Vec<T, Global>
[src]
pub fn bit_xor(&mut self, rhs: &Vec<T, Global>) -> &mut Vec<T, Global>
[src]
pub fn bit_not(&mut self) -> &mut Vec<T, Global>
[src]
pub fn bit_mask(
&mut self,
rhs: &Vec<T, Global>,
mask: &Vec<T, Global>
) -> &mut Vec<T, Global>
[src]
&mut self,
rhs: &Vec<T, Global>,
mask: &Vec<T, Global>
) -> &mut Vec<T, Global>
pub fn bit_count(&self) -> usize
[src]
impl BitSet for u64
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut u64
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut u64
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut u64
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut u64
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u64
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_none(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &u64) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &u64) -> bool
[src]
pub fn bit_subset(&self, rhs: &u64) -> bool
[src]
pub fn bit_superset(&self, rhs: &u64) -> bool
[src]
pub fn bit_or(&mut self, rhs: &u64) -> &mut u64
[src]
pub fn bit_and(&mut self, rhs: &u64) -> &mut u64
[src]
pub fn bit_andnot(&mut self, rhs: &u64) -> &mut u64
[src]
pub fn bit_xor(&mut self, rhs: &u64) -> &mut u64
[src]
pub fn bit_not(&mut self) -> &mut u64
[src]
pub fn bit_mask(&mut self, rhs: &u64, mask: &u64) -> &mut u64
[src]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for u32
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut u32
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut u32
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut u32
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut u32
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u32
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_none(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &u32) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &u32) -> bool
[src]
pub fn bit_subset(&self, rhs: &u32) -> bool
[src]
pub fn bit_superset(&self, rhs: &u32) -> bool
[src]
pub fn bit_or(&mut self, rhs: &u32) -> &mut u32
[src]
pub fn bit_and(&mut self, rhs: &u32) -> &mut u32
[src]
pub fn bit_andnot(&mut self, rhs: &u32) -> &mut u32
[src]
pub fn bit_xor(&mut self, rhs: &u32) -> &mut u32
[src]
pub fn bit_not(&mut self) -> &mut u32
[src]
pub fn bit_mask(&mut self, rhs: &u32, mask: &u32) -> &mut u32
[src]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u32; 8]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u32; 8]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u32; 8]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u32; 8]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u32; 8]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u32; 8]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u32; 8]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u32; 8]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u32; 8]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]
[src]
pub fn bit_and(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u32; 8]]) -> &mut [[u32; 8]]
[src]
pub fn bit_not(&mut self) -> &mut [[u32; 8]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u32; 8]],
mask: &[[u32; 8]]
) -> &mut [[u32; 8]]
[src]
&mut self,
rhs: &[[u32; 8]],
mask: &[[u32; 8]]
) -> &mut [[u32; 8]]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u32; 4]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u32; 4]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u32; 4]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u32; 4]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u32; 4]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u32; 4]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u32; 4]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u32; 4]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u32; 4]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]
[src]
pub fn bit_and(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u32; 4]]) -> &mut [[u32; 4]]
[src]
pub fn bit_not(&mut self) -> &mut [[u32; 4]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u32; 4]],
mask: &[[u32; 4]]
) -> &mut [[u32; 4]]
[src]
&mut self,
rhs: &[[u32; 4]],
mask: &[[u32; 4]]
) -> &mut [[u32; 4]]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u64; 2]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u64; 2]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u64; 2]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u64; 2]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u64; 2]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u64; 2]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u64; 2]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u64; 2]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u64; 2]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]
[src]
pub fn bit_and(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u64; 2]]) -> &mut [[u64; 2]]
[src]
pub fn bit_not(&mut self) -> &mut [[u64; 2]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u64; 2]],
mask: &[[u64; 2]]
) -> &mut [[u64; 2]]
[src]
&mut self,
rhs: &[[u64; 2]],
mask: &[[u64; 2]]
) -> &mut [[u64; 2]]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u16; 16]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u16; 16]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u16; 16]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u16; 16]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u16; 16]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u16; 16]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u16; 16]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u16; 16]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u16; 16]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]
[src]
pub fn bit_and(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u16; 16]]) -> &mut [[u16; 16]]
[src]
pub fn bit_not(&mut self) -> &mut [[u16; 16]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u16; 16]],
mask: &[[u16; 16]]
) -> &mut [[u16; 16]]
[src]
&mut self,
rhs: &[[u16; 16]],
mask: &[[u16; 16]]
) -> &mut [[u16; 16]]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for u16
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut u16
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut u16
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut u16
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut u16
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut u16
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_none(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &u16) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &u16) -> bool
[src]
pub fn bit_subset(&self, rhs: &u16) -> bool
[src]
pub fn bit_superset(&self, rhs: &u16) -> bool
[src]
pub fn bit_or(&mut self, rhs: &u16) -> &mut u16
[src]
pub fn bit_and(&mut self, rhs: &u16) -> &mut u16
[src]
pub fn bit_andnot(&mut self, rhs: &u16) -> &mut u16
[src]
pub fn bit_xor(&mut self, rhs: &u16) -> &mut u16
[src]
pub fn bit_not(&mut self) -> &mut u16
[src]
pub fn bit_mask(&mut self, rhs: &u16, mask: &u16) -> &mut u16
[src]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [u64]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [u64]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [u64]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [u64]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [u64]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [u64]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[u64]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[u64]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[u64]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[u64]) -> &mut [u64]
[src]
pub fn bit_and(&mut self, rhs: &[u64]) -> &mut [u64]
[src]
pub fn bit_andnot(&mut self, rhs: &[u64]) -> &mut [u64]
[src]
pub fn bit_xor(&mut self, rhs: &[u64]) -> &mut [u64]
[src]
pub fn bit_not(&mut self) -> &mut [u64]
[src]
pub fn bit_mask(&mut self, rhs: &[u64], mask: &[u64]) -> &mut [u64]
[src]
pub fn bit_count(&self) -> usize
[src]
impl BitSet for [[u8; 32]]
[src]
pub fn bit_len(&self) -> usize
[src]
pub fn bit_init(&mut self, value: bool) -> &mut [[u8; 32]]
[src]
pub fn bit_test(&self, bit: usize) -> bool
[src]
pub fn bit_set(&mut self, bit: usize) -> &mut [[u8; 32]]
[src]
pub fn bit_reset(&mut self, bit: usize) -> &mut [[u8; 32]]
[src]
pub fn bit_flip(&mut self, bit: usize) -> &mut [[u8; 32]]
[src]
pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut [[u8; 32]]
[src]
pub fn bit_all(&self) -> bool
[src]
pub fn bit_any(&self) -> bool
[src]
pub fn bit_eq(&self, rhs: &[[u8; 32]]) -> bool
[src]
pub fn bit_disjoint(&self, rhs: &[[u8; 32]]) -> bool
[src]
pub fn bit_subset(&self, rhs: &[[u8; 32]]) -> bool
[src]
pub fn bit_or(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]
[src]
pub fn bit_and(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]
[src]
pub fn bit_andnot(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]
[src]
pub fn bit_xor(&mut self, rhs: &[[u8; 32]]) -> &mut [[u8; 32]]
[src]
pub fn bit_not(&mut self) -> &mut [[u8; 32]]
[src]
pub fn bit_mask(
&mut self,
rhs: &[[u8; 32]],
mask: &[[u8; 32]]
) -> &mut [[u8; 32]]
[src]
&mut self,
rhs: &[[u8; 32]],
mask: &[[u8; 32]]
) -> &mut [[u8; 32]]