Trait KeySet 

pub trait KeySet<K> {
    // Required methods
    fn keys_len(&self) -> usize;
    fn for_each_key<F, P>(&self, f: F, retained_hint: P)
       where F: FnMut(&K),
             P: FnMut(&K) -> bool;
    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;

    // Provided methods
    fn has_par_for_each_key(&self) -> bool { ... }
    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 { ... }
    fn map_each_key<R, M, P>(&self, map: M, retained_hint: P) -> Vec<R>
       where M: FnMut(&K) -> R,
             P: FnMut(&K) -> bool { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    fn into_vec<P>(self, retained_hint: P) -> Vec<K>
       where P: FnMut(&K) -> bool,
             K: Clone,
             Self: Sized { ... }
    fn par_into_vec<P>(self, retained_hint: P) -> Vec<K>
       where P: Fn(&K) -> bool + Sync + Send,
             Self: Sized,
             K: Clone + Send { ... }
}

A trait for accessing and managing sets of keys (of the type K) during construction of fmph::Function or fmph::GOFunction.

Required Methods

fn keys_len(&self) -> usize

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

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.

If self doesn’t remember which keys are retained it uses retained_hint to check this.

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.

• filter shows the keys to be retained (the result of the function can be unspecified for keys removed earlier),
• retained_earlier shows the keys that have not been removed earlier,
• remove_count returns number of keys to remove.

Provided Methods

fn has_par_for_each_key(&self) -> bool

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

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.

If self doesn’t remember which keys are retained it uses retained_hint to check this.

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.

• index_filter shows indices (consistent with par_map_each_key) of keys to be retained,
• filter shows the keys to be retained,
• retained_earlier shows the keys that have not been removed earlier,
• remove_count returns number of keys to remove.

The results of index_filter and filter are unspecified for keys removed earlier.

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.

If self doesn’t remember which keys are retained it uses retained_hint to check this.

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<K: Sync + Send> KeySet<K> for Vec<K>

fn keys_len(&self) -> usize

fn has_par_for_each_key(&self) -> bool

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

where F: FnMut(&K),

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

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

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

where F: Fn(&K) + Sync + Send,

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,

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

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

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

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

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,

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, R: Fn() -> usize,

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

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

Implementors

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

impl<'k, K: Sync> KeySet<K> for SliceMutSource<'k, K>

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

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

where GetKeyIter::Item: Send,

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