Struct ImmutableSlice 

pub struct ImmutableSlice<'k, K> { /* private fields */ }

Implements KeySet that use immutable slice.

It does not use any index for pointing remain keys. That is why it is recommended to use it with CachedKeySet.

Implementations

impl<'k, K: Sync> ImmutableSlice<'k, K>

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

pub fn cached( slice: &[K], clone_threshold: usize, ) -> CachedKeySet<K, ImmutableSlice<'_, K>>

Trait Implementations

impl<'k, K: Sync + Send + Clone> KeySet<K> for ImmutableSlice<'k, K>

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 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 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 retain_keys<F, P, R>( &mut self, _filter: F, _retained_earlier: P, remove_count: R, )

where R: FnMut() -> usize,

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

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 + Sync + Send,

Multi-threaded version of map_each_key.

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 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 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 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 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).

fn into_vec<P>(self, retained_hint: P) -> Vec<K>

where P: FnMut(&K) -> bool, K: Clone, Self: Sized,

Convert self into the vector of retained keys.

fn par_into_vec<P>(self, retained_hint: P) -> Vec<K>

where P: Fn(&K) -> bool + Sync + Send, Self: Sized, K: Clone + Send,

Multi-threaded version of into_vec.