Struct ph::fmph::keyset::SliceSourceWithRefs

pub struct SliceSourceWithRefs<'k, K, I: RefsIndex = u8> { /* private fields */ }

KeySet implementation that stores reference to slice with keys, and indices of this slice that points retained keys. Indices are stored partitioned to segments and stored as 8 (if I=u8) or 16-bit (if I=u16) integers. Each segment covers $2^8$ or $2^{16}$ consecutive keys. Empty segments are not stored.

Implementations

impl<'k, K: Sync + 'k, I: RefsIndex + Send + Sync> SliceSourceWithRefs<'k, K, I>

pub fn new(slice: &'k [K]) -> Self

Trait Implementations

impl<'k, K: Sync, I: RefsIndex + Sync + Send> KeySet<K> for SliceSourceWithRefs<'k, K, I>

fn keys_len(&self) -> usize

Returns number of retained keys. Guarantee to be very fast.

fn has_par_for_each_key(&self) -> bool

Returns true only if Self::par_for_each_key can use multiple threads.

fn for_each_key<F, P>(&self, f: F, _retained_hint: P)

where F: FnMut(&K), P: FnMut(&K) -> bool,

Call f for each key in the set, using single thread.

fn par_for_each_key<F, P>(&self, f: F, _retained_hint: P)

where F: Fn(&K) + Sync + Send, P: Fn(&K) -> bool + Sync + Send,

Multi-threaded version of for_each_key.

fn par_map_each_key<R, M, P>(&self, map: M, _retained_hint: P) -> Vec<R>

where M: Fn(&K) -> R + Sync + Send, R: Send, P: Fn(&K) -> bool,

Multi-threaded version of map_each_key.

fn retain_keys<F, P, R>( &mut self, filter: F, _retained_earlier: P, remove_count: R )

where F: FnMut(&K) -> bool, P: FnMut(&K) -> bool, R: FnMut() -> usize,

Retains in self keys pointed by the filter and remove the rest, using single thread.

fn par_retain_keys<F, P, R>( &mut self, filter: F, _retained_earlier: P, remove_count: R )

where F: Fn(&K) -> bool + Sync + Send, P: Fn(&K) -> bool + Sync + Send, R: Fn() -> usize,

Multi-threaded version of retain_keys.

fn retain_keys_with_indices<IF, F, P, R>( &mut self, index_filter: IF, _filter: F, retained_earlier: P, remove_count: R )

where IF: FnMut(usize) -> bool, F: FnMut(&K) -> bool, P: FnMut(&K) -> bool, R: FnMut() -> usize,

Retains in self keys pointed by the index_filter (or filter if self does not support index_filter) and remove the rest. Uses single thread.

fn par_retain_keys_with_indices<IF, F, P, R>( &mut self, index_filter: IF, _filter: F, _retained_earlier: P, remove_count: R )

where IF: Fn(usize) -> bool + Sync + Send, F: Fn(&K) -> bool + Sync + Send, P: Fn(&K) -> bool + Sync + Send, R: Fn() -> usize,

Multi-threaded version of retain_keys_with_indices.

fn map_each_key<R, M, P>(&self, map: M, retained_hint: P) -> Vec<R>

where M: FnMut(&K) -> R, P: FnMut(&K) -> bool,

Calls map for each key in the set, and returns outputs of these calls. Uses single thread.

fn maybe_par_map_each_key<R, M, P>( &self, map: M, retained_hint: P, use_mt: bool ) -> Vec<R>

where M: Fn(&K) -> R + Sync + Send, R: Send, P: Fn(&K) -> bool + Sync + Send,

Calls either map_each_key (if use_mt is false) or par_map_each_key (if use_mt is true).

fn maybe_par_retain_keys<F, P, R>( &mut self, filter: F, retained_earlier: P, remove_count: R, use_mt: bool )

where F: Fn(&K) -> bool + Sync + Send, P: Fn(&K) -> bool + Sync + Send, R: Fn() -> usize,

Calls either retain_keys (if use_mt is false) or par_retain_keys (if use_mt is true).

fn maybe_par_retain_keys_with_indices<IF, F, P, R>( &mut self, index_filter: IF, filter: F, retained_earlier: P, remove_count: R, use_mt: bool )

where IF: Fn(usize) -> bool + Sync + Send, F: Fn(&K) -> bool + Sync + Send, P: Fn(&K) -> bool + Sync + Send, R: Fn() -> usize,

Calls either retain_keys_with_indices (if use_mt is false) or par_retain_keys_with_indices (if use_mt is true).