Enum CachedKeySet 

pub enum CachedKeySet<K, KS> {
    Dynamic(KS, usize),
    Cached(Vec<K>),
}

Implementation of KeySet that initially stores another KeySet (which is usually succinct but slow, such as DynamicKeySet), but when number of keys drops below given threshold, the remaining keys are cached (cloned into the vector), and later only the cache is used.

Variants

Dynamic(KS, usize)

Cached(Vec<K>)

Implementations

impl<K, KS> CachedKeySet<K, KS>

pub fn new(key_set: KS, clone_threshold: usize) -> Self

Constructs cached key_set. The keys are cloned and cached as soon as their number drops below clone_threshold.

impl<K, PI: GetIterator> CachedKeySet<K, DynamicKeySet<PI>>

pub fn dynamic(keys: PI, clone_threshold: usize) -> Self

Constructs cached DynamicKeySet that obtains the keys by keys that returns iterator over keys. The keys are cloned and cached as soon as their number drops below clone_threshold.

If the number of keys is known, it is more efficient to call CachedKeySet::dynamic_with_len instead.

Example

use {ph::fmph::keyset::{KeySet, CachedKeySet}, rayon::iter::{ParallelIterator, IntoParallelIterator}};
// Constructing a dynamic key set consisting of the squares of the integers from 1 to 100,
// part of which will be cached by the first call of any of the retain methods:
let ks = CachedKeySet::dynamic(|| (1..=100).map(|v| v*v), usize::MAX);
assert_eq!(ks.keys_len(), 100);
// Same as above but using multiple threads to generate keys:
let ks = CachedKeySet::dynamic((|| (1..=100).map(|v| v*v), || (1..=100).into_par_iter().map(|v| v*v)), usize::MAX);
assert_eq!(ks.keys_len(), 100);

pub fn dynamic_with_len(keys: PI, len: usize, clone_threshold: usize) -> Self

Constructs cached DynamicKeySet that obtains the keys by keys that returns iterator over exactly len keys. The keys are cloned and cached as soon as their number drops below clone_threshold.

Example

use {ph::fmph::keyset::{KeySet, CachedKeySet}, rayon::iter::{ParallelIterator, IntoParallelIterator}};
// Constructing a dynamic key set consisting of the squares of the integers from 1 to 100,
// part of which will be cached by the first call of any of the retain methods:
let ks = CachedKeySet::dynamic_with_len(|| (1..=100).map(|v| v*v), 100, usize::MAX);
assert_eq!(ks.keys_len(), 100);
// Same as above but using multiple threads to generate keys:
let ks = CachedKeySet::dynamic_with_len((|| (1..=100).map(|v| v*v), || (1..=100).into_par_iter().map(|v| v*v)), 100, usize::MAX);
assert_eq!(ks.keys_len(), 100);

impl<'k, K: Sync> CachedKeySet<K, SliceSourceWithRefs<'k, K>>

pub fn slice(keys: &'k [K], clone_threshold: usize) -> Self

Constructs cached SliceSourceWithRefs that wraps given keys. The keys are cloned and cached as soon as their number drops below clone_threshold. After cloning, the keys are placed in a continuous memory area which is friendly to the CPU cache.

Trait Implementations

impl<K, KS> Default for CachedKeySet<K, KS>

fn default() -> Self

Returns the “default value” for a type.

impl<K: Clone + Sync + Send, KS: KeySet<K>> KeySet<K> for CachedKeySet<K, KS>

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

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