Struct bitsetium::Complement

#[repr(transparent)]
pub struct Complement<T>(pub T);

Bit-set wrapper that acts like set complement.

Effectively inverses all bits in the underlying bit-set.

Tuple Fields

0: T

Implementations

impl<T> Complement<T>

pub fn inner(&self) -> &T

pub fn inner_mut(&mut self) -> &mut T

pub fn into_inner(self) -> T

impl<T> Complement<Complement<T>>

pub fn double_complement_unwrap(self) -> T

Convenience function to unwrap double Complement wrapper which must yield bitset with same bits set.

Trait Implementations

impl<T> BitComplement for Complement<T>

type Output = T

fn complement(self) -> T

impl<const N: usize> BitDifference<Complement<[u128; N]>> for [u128; N]

type Output = Self

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

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

impl<const N: usize> BitDifference<Complement<[u16; N]>> for [u16; N]

type Output = Self

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

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

impl<const N: usize> BitDifference<Complement<[u32; N]>> for [u32; N]

type Output = Self

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

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

impl<const N: usize> BitDifference<Complement<[u64; N]>> for [u64; N]

type Output = Self

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

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

impl<const N: usize> BitDifference<Complement<[u8; N]>> for [u8; N]

type Output = Self

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

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

impl BitDifference<Complement<bool>> for bool

type Output = Self

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

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

impl BitDifference<Complement<u128>> for u128

type Output = Self

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

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

impl BitDifference<Complement<u16>> for u16

type Output = Self

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

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

impl BitDifference<Complement<u32>> for u32

type Output = Self

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

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

impl BitDifference<Complement<u64>> for u64

type Output = Self

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

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

impl BitDifference<Complement<u8>> for u8

type Output = Self

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

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

impl<T, U> BitDifference<U> for Complement<T> where
    T: BitUnion<U>, 

type Output = Complement<<T as BitUnion<U>>::Output>

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

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

impl<const N: usize> BitDisjoint<Complement<[u128; N]>> for [u128; N]

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl<const N: usize> BitDisjoint<Complement<[u16; N]>> for [u16; N]

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl<const N: usize> BitDisjoint<Complement<[u32; N]>> for [u32; N]

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl<const N: usize> BitDisjoint<Complement<[u64; N]>> for [u64; N]

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl<const N: usize> BitDisjoint<Complement<[u8; N]>> for [u8; N]

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl BitDisjoint<Complement<bool>> for bool

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl BitDisjoint<Complement<u128>> for u128

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl BitDisjoint<Complement<u16>> for u16

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl BitDisjoint<Complement<u32>> for u32

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl BitDisjoint<Complement<u64>> for u64

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl BitDisjoint<Complement<u8>> for u8

fn is_disjoint(&self, rhs: &Complement<Self>) -> bool

Returns true if self is disjoint with rhs.

impl<T, U> BitDisjoint<U> for Complement<T> where
    U: BitSubset<T>, 

fn is_disjoint(&self, rhs: &U) -> bool

Returns true if self is disjoint with rhs.

impl<T> BitEmpty for Complement<T> where
    T: BitFull, 

fn empty() -> Self

Returns empty bitset for which all bits are unset.

impl<T> BitFull for Complement<T> where
    T: BitEmpty, 

fn full() -> Self

Returns full bitset for which all bits are set.

impl<const N: usize> BitIntersection<Complement<[u128; N]>> for [u128; N]

type Output = Self

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

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

impl<const N: usize> BitIntersection<Complement<[u16; N]>> for [u16; N]

type Output = Self

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

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

impl<const N: usize> BitIntersection<Complement<[u32; N]>> for [u32; N]

type Output = Self

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

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

impl<const N: usize> BitIntersection<Complement<[u64; N]>> for [u64; N]

type Output = Self

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

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

impl<const N: usize> BitIntersection<Complement<[u8; N]>> for [u8; N]

type Output = Self

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

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

impl BitIntersection<Complement<bool>> for bool

type Output = Self

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

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

impl BitIntersection<Complement<u128>> for u128

type Output = Self

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

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

impl BitIntersection<Complement<u16>> for u16

type Output = Self

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

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

impl BitIntersection<Complement<u32>> for u32

type Output = Self

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

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

impl BitIntersection<Complement<u64>> for u64

type Output = Self

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

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

impl BitIntersection<Complement<u8>> for u8

type Output = Self

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

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

impl<T, U> BitIntersection<U> for Complement<T> where
    U: BitDifference<T>, 

type Output = <U as BitDifference<T>>::Output

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

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

impl<T> BitSearch for Complement<Complement<T>> where
    T: BitSearch, 

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> BitSet for Complement<T> where
    T: BitUnset, 

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> BitSetLimit for Complement<T> where
    T: BitUnsetLimit, 

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<const N: usize> BitSubset<Complement<[u128; N]>> for [u128; N]

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl<const N: usize> BitSubset<Complement<[u16; N]>> for [u16; N]

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl<const N: usize> BitSubset<Complement<[u32; N]>> for [u32; N]

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl<const N: usize> BitSubset<Complement<[u64; N]>> for [u64; N]

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl<const N: usize> BitSubset<Complement<[u8; N]>> for [u8; N]

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl BitSubset<Complement<bool>> for bool

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl BitSubset<Complement<u128>> for u128

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl BitSubset<Complement<u16>> for u16

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl BitSubset<Complement<u32>> for u32

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl BitSubset<Complement<u64>> for u64

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl BitSubset<Complement<u8>> for u8

fn is_subset_of(&self, rhs: &Complement<Self>) -> bool

Returns true if self is subset of rhs.

impl<T> BitTest for Complement<T> where
    T: BitTest, 

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

Tests if bit at specified index is set.

impl<T> BitTestAll for Complement<T> where
    T: BitTestNone, 

fn test_all(&self) -> bool

Tests if all bits are set.

impl<T> BitTestNone for Complement<T> where
    T: BitTestAll, 

fn test_none(&self) -> bool

Tests if none bits is set.

impl<const N: usize> BitUnion<Complement<[u128; N]>> for [u128; N]

type Output = Complement<Self>

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

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

impl<const N: usize> BitUnion<Complement<[u16; N]>> for [u16; N]

type Output = Complement<Self>

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

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

impl<const N: usize> BitUnion<Complement<[u32; N]>> for [u32; N]

type Output = Complement<Self>

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

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

impl<const N: usize> BitUnion<Complement<[u64; N]>> for [u64; N]

type Output = Complement<Self>

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

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

impl<const N: usize> BitUnion<Complement<[u8; N]>> for [u8; N]

type Output = Complement<Self>

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

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

impl BitUnion<Complement<bool>> for bool

type Output = Complement<Self>

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

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

impl BitUnion<Complement<u128>> for u128

type Output = Complement<Self>

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

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

impl BitUnion<Complement<u16>> for u16

type Output = Complement<Self>

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

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

impl BitUnion<Complement<u32>> for u32

type Output = Complement<Self>

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

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

impl BitUnion<Complement<u64>> for u64

type Output = Complement<Self>

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

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

impl BitUnion<Complement<u8>> for u8

type Output = Complement<Self>

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

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

impl<T, U> BitUnion<U> for Complement<T> where
    T: BitDifference<U>, 

type Output = Complement<<T as BitDifference<U>>::Output>

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

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

impl<T> BitUnset for Complement<T> where
    T: BitSet, 

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> BitUnsetLimit for Complement<T> where
    T: BitSetLimit, 

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> Clone for Complement<T>

fn clone(&self) -> Complement<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Complement<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Complement<T>

fn default() -> Complement<T>

Returns the “default value” for a type.

impl<T> Display for Complement<T> where
    T: Display, 

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Complement<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq<Complement<T>> for Complement<T>

fn eq(&self, other: &Complement<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Complement<T>) -> bool

This method tests for !=.

impl<T: Copy> Copy for Complement<T>

impl<T: Eq> Eq for Complement<T>

impl<T> StructuralEq for Complement<T>

impl<T> StructuralPartialEq for Complement<T>