Struct hi_sparse_bitset::Reduce

pub struct Reduce<Op, S, Cache> { /* private fields */ }

Bitsets iterator reduction, as lazy bitset.

Constructed by reduce and reduce_w_cache.

Implementations

impl<Op, S, Cache> Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

pub fn block_iter<'a>(&'a self) -> CachingBlockIter<&'a Self>

pub fn iter<'a>(&'a self) -> CachingIndexIter<&'a Self>

pub fn contains(&self, index: usize) -> bool

pub fn is_empty(&self) -> bool

See BitSetInterface::is_empty()

Trait Implementations

impl<Op, S, Cache, Rhs> BitAnd<Rhs> for &Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Returns intersection of self and rhs bitsets.

type Output = Apply<And, &Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the & operator.

impl<Op, S, Cache, Rhs> BitAnd<Rhs> for Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Returns intersection of self and rhs bitsets.

type Output = Apply<And, Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the & operator.

impl<Op, S, Cache, Rhs> BitOr<Rhs> for &Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Returns union of self and rhs bitsets.

type Output = Apply<Or, &Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the | operator.

impl<Op, S, Cache, Rhs> BitOr<Rhs> for Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Returns union of self and rhs bitsets.

type Output = Apply<Or, Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the | operator.

impl<Op, S, Cache> BitSetBase for Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: LevelMasks,

const TRUSTED_HIERARCHY: bool = _

true if S and Op are TrustedHierarchy.

type Conf = <<S as Iterator>::Item as BitSetBase>::Conf

impl<Op, S, Cache> BitSetInterface for &Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

fn block_iter(&self) -> CachingBlockIter<&Self>

fn iter(&self) -> CachingIndexIter<&Self>

fn into_block_iter(self) -> CachingBlockIter<Self>

fn contains(&self, index: usize) -> bool

fn is_empty(&self) -> bool

O(1) if TRUSTED_HIERARCHY, O(N) otherwise.

impl<Op, S, Cache> BitSetInterface for Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

fn block_iter(&self) -> CachingBlockIter<&Self>

fn iter(&self) -> CachingIndexIter<&Self>

fn into_block_iter(self) -> CachingBlockIter<Self>

fn contains(&self, index: usize) -> bool

fn is_empty(&self) -> bool

O(1) if TRUSTED_HIERARCHY, O(N) otherwise.

impl<Op, S, Cache, Rhs> BitXor<Rhs> for &Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Returns symmetric difference of self and rhs bitsets.

type Output = Apply<Xor, &Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the ^ operator.

impl<Op, S, Cache, Rhs> BitXor<Rhs> for Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Returns symmetric difference of self and rhs bitsets.

type Output = Apply<Xor, Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the ^ operator.

impl<Op: Clone, S: Clone, Cache: Clone> Clone for Reduce<Op, S, Cache>

fn clone(&self) -> Reduce<Op, S, Cache>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Op, S, Cache> Debug for Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Formats the value using the given formatter.

impl<Op, S, Cache> IntoIterator for &Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

type Item = usize

The type of the elements being iterated over.

type IntoIter = CachingIndexIter<&Reduce<Op, S, Cache>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Op, S, Cache> IntoIterator for Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

type Item = usize

The type of the elements being iterated over.

type IntoIter = CachingIndexIter<Reduce<Op, S, Cache>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Op, S, Cache> LevelMasks for Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: LevelMasks,

fn level0_mask(&self) -> <Self::Conf as Config>::Level0BitBlock

unsafe fn level1_mask( &self, level0_index: usize ) -> <Self::Conf as Config>::Level1BitBlock

Safety

unsafe fn data_mask( &self, level0_index: usize, level1_index: usize ) -> <Self::Conf as Config>::DataBitBlock

Safety

impl<Op, S, Cache> LevelMasksIterExt for Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: LevelMasksIterExt, Cache: ReduceCache,

type IterState = <<Cache as ReduceCache>::Impl<Op, S> as ReduceCacheImpl>::IterState

Consists from child states (if any) + Self state.

type Level1BlockData = <<Cache as ReduceCache>::Impl<Op, S> as ReduceCacheImpl>::Level1BlockData

Level1 block related data, used to speed up data_mask access.

fn make_iter_state(&self) -> Self::IterState

unsafe fn drop_iter_state(&self, state: &mut ManuallyDrop<Self::IterState>)

Having separate function for drop not strictly necessary, since IterState can actually drop itself. But! This allows not to store cache size within IterState. Which makes FixedCache CacheData ZST, if its childs are ZSTs, and which makes cache construction and destruction noop. Which is important for short iteration sessions.

unsafe fn init_level1_block_data( &self, state: &mut Self::IterState, level1_block_data: &mut MaybeUninit<Self::Level1BlockData>, level0_index: usize ) -> (<Self::Conf as Config>::Level1BitBlock, bool)

Init level1_block_data and return (Level1Mask, is_not_empty).

unsafe fn data_mask_from_block_data( level1_blocks: &Self::Level1BlockData, level1_index: usize ) -> <Self::Conf as Config>::DataBitBlock

Safety

impl<Op, S, Cache, Rhs> PartialEq<Rhs> for Reduce<Op, S, Cache>

where Rhs: LevelMasksIterExt<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

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

Works faster with TRUSTED_HIERARCHY.

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

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

impl<Op, S, Cache, Rhs> Sub<Rhs> for &Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

fn sub(self, rhs: Rhs) -> Self::Output

Returns difference of self and rhs bitsets.

Or relative complement of rhs in self.

type Output = Apply<Sub, &Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the - operator.

impl<Op, S, Cache, Rhs> Sub<Rhs> for Reduce<Op, S, Cache>

where Rhs: BitSetInterface<Conf = <Self as BitSetBase>::Conf>, Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,

fn sub(self, rhs: Rhs) -> Self::Output

Returns difference of self and rhs bitsets.

Or relative complement of rhs in self.

type Output = Apply<Sub, Reduce<Op, S, Cache>, Rhs>

The resulting type after applying the - operator.

impl<Op, S, Cache> Eq for Reduce<Op, S, Cache>

where Op: BitSetOp, S: Iterator + Clone, S::Item: BitSetInterface, Cache: ReduceCache,