Trait plank_ecs::BitSet

pub trait BitSet {
    pub fn bit_len(&self) -> usize;
    pub fn bit_init(&mut self, value: bool) -> &mut Self;
    pub fn bit_test(&self, bit: usize) -> bool;
    pub fn bit_set(&mut self, bit: usize) -> &mut Self;
    pub fn bit_reset(&mut self, bit: usize) -> &mut Self;
    pub fn bit_flip(&mut self, bit: usize) -> &mut Self;
    pub fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Self;
    pub fn bit_all(&self) -> bool;
    pub fn bit_any(&self) -> bool;
    pub fn bit_eq(&self, rhs: &Self) -> bool;
    pub fn bit_disjoint(&self, rhs: &Self) -> bool;
    pub fn bit_subset(&self, rhs: &Self) -> bool;
    pub fn bit_or(&mut self, rhs: &Self) -> &mut Self;
    pub fn bit_and(&mut self, rhs: &Self) -> &mut Self;
    pub fn bit_andnot(&mut self, rhs: &Self) -> &mut Self;
    pub fn bit_xor(&mut self, rhs: &Self) -> &mut Self;
    pub fn bit_not(&mut self) -> &mut Self;
    pub fn bit_mask(&mut self, rhs: &Self, mask: &Self) -> &mut Self;
    pub fn bit_count(&self) -> usize;

    pub fn bit_fmt(&self) -> &BitFmt<Self> { ... }
    pub fn bit_none(&self) -> bool { ... }
    pub fn bit_superset(&self, rhs: &Self) -> bool { ... }
}

The BitSet API.

Required methods

pub fn bit_len(&self) -> usize

Returns total number of bits.

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

Initializes all bits.

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

Returns if the given bit is set.

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

Sets the given bit.

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

Resets the given bit.

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

Flips the given bit.

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

Conditionally sets or resets the given bit.

pub fn bit_all(&self) -> bool

Returns if all bits are set.

pub fn bit_any(&self) -> bool

Returns if any bits are set.

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

Returns if the two bitsets are equal.

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

Returns if the two bitsets have no bits in common.

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

Returns if self is a subset of rhs.

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

Bitwise OR.

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

Bitwise AND.

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

Bitwise AND after NOT of rhs.

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

Bitwise XOR.

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

Bitwise NOT.

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

Bitwise combine with MASK.

pub fn bit_count(&self) -> usize

Counts the number of set bits.

Loading content...

Provided methods

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

Format the bits.

pub fn bit_none(&self) -> bool

Returns if none of the bits are set.

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

Returns if self is a superset of rhs.

Loading content...

Implementations on Foreign Types

impl BitSet for u8

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

pub fn bit_none(&self) -> bool

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

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u64; 4]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [u128]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u64; 2]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for u64

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

pub fn bit_none(&self) -> bool

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

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for u16

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

pub fn bit_none(&self) -> bool

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

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for u32

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

pub fn bit_none(&self) -> bool

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

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u16; 8]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u8; 16]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u16; 16]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [u64]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u32; 4]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [u8]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u32; 8]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for u128

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

pub fn bit_none(&self) -> bool

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

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [[u8; 32]]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [u16]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

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

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

pub fn bit_none(&self) -> bool

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

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

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

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

pub fn bit_none(&self) -> bool

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

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

impl BitSet for [u32]

pub fn bit_len(&self) -> usize

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

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

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

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

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

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

pub fn bit_all(&self) -> bool

pub fn bit_any(&self) -> bool

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

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

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

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

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

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

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

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

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

pub fn bit_count(&self) -> usize

Loading content...

Implementors

Loading content...