Struct DynamicKeySet 

pub struct DynamicKeySet<GetKeyIter: GetIterator> {
    pub keys: GetKeyIter,
    pub len: usize,
}

Implementation of KeySet that stores only the object that returns iterator over all keys (the iterator can even expose the keys that have been removed earlier by retain methods). It is usually a good idea to use it within CachedKeySet, see CachedKeySet::dynamic.

Fields

keys: GetKeyIter

len: usize

Implementations

impl<GetKeyIter: GetIterator> DynamicKeySet<GetKeyIter>

pub fn new(keys: GetKeyIter) -> Self

Constructs a DynamicKeySet that obtains the keys by keys.

pub fn with_len(keys: GetKeyIter, len: usize) -> Self

Constructs a DynamicKeySet that obtains the keys by keys (which should produce len keys).

Trait Implementations

impl<GetKeyIter: GetIterator> KeySet<<GetKeyIter as GetIterator>::Item> for DynamicKeySet<GetKeyIter>

where GetKeyIter::Item: Send,

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(&GetKeyIter::Item), P: FnMut(&GetKeyIter::Item) -> 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(&GetKeyIter::Item) + Sync + Send, P: Fn(&GetKeyIter::Item) -> 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(&GetKeyIter::Item) -> R + Sync + Send, R: Send, P: Fn(&GetKeyIter::Item) -> 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(&GetKeyIter::Item) -> bool, P: FnMut(&GetKeyIter::Item) -> bool, R: FnMut() -> usize,

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

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

where P: FnMut(&GetKeyIter::Item) -> bool, Self: Sized,

Convert self into the vector of retained keys.

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

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

Multi-threaded version of into_vec.

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