Struct 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 = [u128; N]

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 = [u16; N]

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 = [u32; N]

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 = [u64; N]

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 = [u8; N]

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 = bool

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 = u128

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 = u16

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 = u32

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 = u64

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 = u8

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 = [u128; N]

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 = [u16; N]

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 = [u32; N]

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 = [u64; N]

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 = [u8; N]

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 = bool

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 = u128

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 = u16

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 = u32

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 = u64

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 = u8

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 = T::MAX_UNSET_INDEX

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<[u128; N]>

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<[u16; N]>

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<[u32; N]>

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<[u64; N]>

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<[u8; N]>

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

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

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

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

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

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

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 = T::MAX_SET_INDEX

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 duplicate 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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

impl<T> StructuralPartialEq for Complement<T>