Struct SliceMutSource 

pub struct SliceMutSource<'k, K> {
    pub slice: &'k mut [K],
    pub len: usize,
}

Implements KeySet, storing keys in the mutable slice.

Retain operations reorder the slice, putting retained keys at the beginning of the slice.

Fields

slice: &'k mut [K]

All keys (retained ones occupy len beginning indices).

len: usize

How many first keys are retained.

Implementations

impl<'k, K> SliceMutSource<'k, K>

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

Trait Implementations

impl<'k, K> From<&'k mut [K]> for SliceMutSource<'k, K>

fn from(slice: &'k mut [K]) -> Self

Converts to this type from the input type.

impl<'k, K: Sync> KeySet<K> for SliceMutSource<'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),

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,

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,

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,

Multi-threaded version of map_each_key.

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

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

Retains in self keys pointed by the filter and remove the rest, using 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).

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.