Struct hibitset::BitSetAnd

pub struct BitSetAnd<A: BitSetLike, B: BitSetLike>(pub A, pub B);

BitSetAnd takes two BitSetLike items, and merges the masks returning a new virtual set, which represents an intersection of the two original sets.

Tuple Fields

0: A

1: B

Trait Implementations

impl<'a, A, B, T> BitAnd<T> for &'a BitSetAnd<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetAnd<&'a BitSetAnd<A, B>, T>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<A, B, T> BitAnd<T> for BitSetAnd<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetAnd<BitSetAnd<A, B>, T>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<'a, A, B, T> BitOr<T> for &'a BitSetAnd<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetOr<&'a BitSetAnd<A, B>, T>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<A, B, T> BitOr<T> for BitSetAnd<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetOr<BitSetAnd<A, B>, T>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<A: BitSetLike, B: BitSetLike> BitSetLike for BitSetAnd<A, B>

fn layer3(&self) -> usize

Return a usize where each bit represents if any word in layer2 has been set.

fn layer2(&self, i: usize) -> usize

Return the usize from the array of usizes that indicates if any bit has been set in layer1

fn layer1(&self, i: usize) -> usize

Return the usize from the array of usizes that indicates if any bit has been set in layer0

fn layer0(&self, i: usize) -> usize

Return a usize that maps to the direct 1:1 association with each index of the set

fn contains(&self, i: u32) -> bool

Allows checking if set bit is contained in the bit set.

fn get_from_layer(&self, layer: usize, idx: usize) -> usize

Gets the usize corresponding to layer and index.

fn is_empty(&self) -> bool

Returns true if this BitSetLike contains nothing, and false otherwise.

fn iter(self) -> BitIter<Self> where
    Self: Sized, 

Create an iterator that will scan over the keyspace

fn par_iter(self) -> BitParIter<Self> where
    Self: Sized, 

Create a parallel iterator that will scan over the keyspace

impl<'a, A, B, T> BitXor<T> for &'a BitSetAnd<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetXor<&'a BitSetAnd<A, B>, T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<A, B, T> BitXor<T> for BitSetAnd<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetXor<BitSetAnd<A, B>, T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<A: Clone + BitSetLike, B: Clone + BitSetLike> Clone for BitSetAnd<A, B>

fn clone(&self) -> BitSetAnd<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug + BitSetLike, B: Debug + BitSetLike> Debug for BitSetAnd<A, B>

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

Formats the value using the given formatter.

impl<A: DrainableBitSet, B: DrainableBitSet> DrainableBitSet for BitSetAnd<A, B>

fn remove(&mut self, i: u32) -> bool

Removes bit from the bit set.

fn drain<'a>(&'a mut self) -> DrainBitIter<'a, Self> where
    Self: Sized, 

Create a draining iterator that will scan over the keyspace and clears it while doing so.

impl<'a, A, B> IntoIterator for &'a BitSetAnd<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Item = <BitIter<&'a BitSetAnd<A, B>> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = BitIter<&'a BitSetAnd<A, B>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, B> IntoIterator for BitSetAnd<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Item = <BitIter<BitSetAnd<A, B>> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = BitIter<BitSetAnd<A, B>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, A, B> Not for &'a BitSetAnd<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetNot<&'a BitSetAnd<A, B>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B> Not for BitSetAnd<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetNot<BitSetAnd<A, B>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.