Struct Difference 

pub struct Difference<T, U>(pub T, pub U);

Bit-set wrapper that acts like set complement.

Effectively inverses all bits in the underlying bit-set.

Tuple Fields

0: T

1: U

Trait Implementations

impl<T, U> BitComplement for Difference<T, U>

where T: BitComplement,

type Output = Union<<T as BitComplement>::Output, U>

fn complement(self) -> Self::Output

impl<T, U, Y> BitDifference<Y> for Difference<T, U>

where T: BitDifference<Y>,

type Output = Difference<<T as BitDifference<Y>>::Output, U>

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

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

impl<T, U> BitEmpty for Difference<T, U>

where T: BitEmpty, U: Default,

fn empty() -> Self

Returns empty bitset for which all bits are unset.

impl<T, U> BitFull for Difference<T, U>

where T: BitFull, U: BitEmpty,

fn full() -> Self

Returns full bitset for which all bits are set.

impl<T, U, Y> BitIntersection<Y> for Difference<T, U>

where T: BitIntersection<Y>,

type Output = Difference<<T as BitIntersection<Y>>::Output, U>

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

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

impl<T, U> BitSearch for Difference<T, U>

where T: BitSearch, U: BitTest,

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, U> BitSet for Difference<T, U>

where T: BitSet, U: 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, U> BitSetLimit for Difference<T, U>

where T: BitSetLimit, U: 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<T, U> BitTest for Difference<T, U>

where T: BitTest, U: BitTest,

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

Tests if bit at specified index is set.

impl<T, U> BitTestAll for Difference<T, U>

where T: BitTestAll, U: BitTestNone,

fn test_all(&self) -> bool

Tests if all bits are set.

impl<T, U> BitTestNone for Difference<T, U>

where T: BitSubset<U>,

fn test_none(&self) -> bool

Tests if none bits is set.

impl<T, U, Y> BitUnion<Y> for Difference<T, U>

type Output = Union<Difference<T, U>, Y>

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

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

impl<T, U> BitUnset for Difference<T, U>

where T: BitUnset, U: 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, U> BitUnsetLimit for Difference<T, U>

where T: BitUnsetLimit, U: 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, U: Clone> Clone for Difference<T, U>

fn clone(&self) -> Difference<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, U: Debug> Debug for Difference<T, U>

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

Formats the value using the given formatter.

impl<T: Default, U: Default> Default for Difference<T, U>

fn default() -> Difference<T, U>

Returns the “default value” for a type.

impl<T, U> Display for Difference<T, U>

where T: Display, U: Display,

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

Formats the value using the given formatter.

impl<T: Hash, U: Hash> Hash for Difference<T, U>

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, U: PartialEq> PartialEq for Difference<T, U>

fn eq(&self, other: &Difference<T, U>) -> 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, U: Copy> Copy for Difference<T, U>

impl<T: Eq, U: Eq> Eq for Difference<T, U>

impl<T, U> StructuralPartialEq for Difference<T, U>