Struct Layered

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

Trait Implementations

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

type Output = Complement<Layered<T, B, N>>

fn complement(self) -> Complement<Self>

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

type Output = Difference<Layered<T, B, N>, 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<Layered<T, B, N>, 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<Layered<T, B, N>, 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 = 18_446_744_073_709_551_615usize

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 duplicate 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>