Struct bitsetium::Layered

pub struct Layered<T, B, const N: usize> { /* fields omitted */ }

Trait Implementations

impl<T, B, const N: usize> BitComplement for Layered<T, B, N>

type Output = Complement<Self>

fn complement(self) -> Complement<Self>

impl<T, B, U, const N: usize> BitDifference<U> for Layered<T, B, N>

type Output = Difference<Self, U>

fn difference(self, rhs: U) -> Difference<Self, U>

Returns bit-set has bits set for each index that has bit set in exactly one of two arguments.

impl<T, B, const N: usize> BitEmpty for Layered<T, B, N> where
    T: BitEmpty,
    B: BitEmpty, 

fn empty() -> Self

Returns empty bitset for which all bits are unset.

impl<T, B, U, const N: usize> BitIntersection<U> for Layered<T, B, N>

type Output = Intersection<Self, U>

fn intersection(self, rhs: U) -> Intersection<Self, U>

Returns bit-set with bits set for each index that has bit set in either of two arguments.

impl<T, B, const N: usize> BitSearch for Layered<T, B, N> where
    T: BitSearch + BitSetLimit,
    B: BitSearch + BitSetLimit, 

fn find_first_set(&self, lower_bound: usize) -> Option<usize>

Searches for first bit set starting with lower_bound. Returns index of first bit set.

fn find_set_in_range<R>(&self, range: R) -> Option<usize> where
    R: RangeBounds<usize>, 

Searches for bit set specified range. Returns index of bit set.

impl<T, B, const N: usize> BitSet for Layered<T, B, N> where
    T: BitSet,
    B: BitSet, 

unsafe fn set_unchecked(&mut self, idx: usize)

Set bit at specified index.

fn set(&mut self, idx: usize)

Sets bit at specified index.

impl<T, B, const N: usize> BitSetLimit for Layered<T, B, N> where
    T: BitSetLimit,
    B: BitSetLimit, 

const MAX_SET_INDEX: usize

Largest possible bit index that can be set. Any larger index will always be unset. Setting larger index is now allowed.

impl<T, B, const N: usize> BitTest for Layered<T, B, N> where
    T: BitTest + BitSetLimit,
    B: BitTest + BitSetLimit, 

fn test(&self, idx: usize) -> bool

Tests if bit at specified index is set.

impl<T, B, U, const N: usize> BitUnion<U> for Layered<T, B, N>

type Output = Union<Self, U>

fn union(self, rhs: U) -> Union<Self, U>

Returns bit-set with bits set for each index that has bit set in both of two arguments.

impl<T, B, const N: usize> BitUnset for Layered<T, B, N> where
    T: BitUnset,
    B: BitUnset + BitSetLimit + BitTestNone, 

unsafe fn unset_unchecked(&mut self, idx: usize)

Unsets bit at specified index.

fn unset(&mut self, idx: usize)

Unsets bit at specified index.

impl<T, B, const N: usize> BitUnsetLimit for Layered<T, B, N>

const MAX_UNSET_INDEX: usize

Largest possible bit index that can be unset. Any larger index will always be set. Unsetting larger index is now allowed.

impl<T: Clone, B: Clone, const N: usize> Clone for Layered<T, B, N>

fn clone(&self) -> Layered<T, B, N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, B: Debug, const N: usize> Debug for Layered<T, B, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Copy, B: Copy, const N: usize> Copy for Layered<T, B, N>