Struct actyxos_data_flow::flow::Grouped

pub struct Grouped<'a, K, V>(_, _)
 where
    K: ExchangeData + Hashable,
    V: ExchangeData;

An arrangement of a collection by key

The collection is partitioned by key and stored in-memory so that it can be manipulated

Implementations

impl<'a, K, V> Grouped<'a, K, V> where
    K: ExchangeData + Hashable,
    V: ExchangeData, 

pub fn join<V2, L, D, I>(
    &self,
    other: &Grouped<'a, K, V2>,
    f: L
) -> Flow<'a, D, Stateful> where
    V2: ExchangeData,
    D: ExchangeData,
    I: IntoIterator<Item = D>,
    L: FnMut(&K, &V, &V2) -> I + 'static, 

Join this collection with another that uses the same key, combining values with the given 1:many function

pub fn join_single<V2, L, D>(
    &self,
    other: &Grouped<'a, K, V2>,
    f: L
) -> Flow<'a, D, Stateful> where
    V2: ExchangeData,
    D: ExchangeData,
    L: FnMut(&K, &V, &V2) -> D + 'static, 

Join this collection with another that uses the same key, combining values with the given 1:1 function

pub fn reduce<V2, L>(&self, f: L) -> Grouped<'a, K, V2> where
    V2: ExchangeData,
    L: FnMut(&K, &[(&V, isize)], &mut Vec<(V2, isize)>) + 'static, 

Reduce each per-key collection to a vector of output values

pub fn threshold(&self, f: impl FnMut(&K, &V, isize) -> isize + 'static) -> Self

Transform the multiplicity of each collection element

pub fn distinct(&self) -> Self

Set the multiplicity of each collection element to 1

pub fn count(&self) -> Grouped<'a, K, isize>

Count the number of elements per key

pub fn min(&self) -> Self

Compute the minimum element per key

pub fn max(&self) -> Self

Compute the maximum element per key

pub fn max_by<T, F>(&self, f: F) -> Self where
    F: Fn(&V) -> T + 'static + Clone,
    T: Ord, 

Compute the maximum element per key, sorting by the result of applying the given function to each value

pub fn ungroup(&self) -> Flow<'a, V, Stateful>

Ungroup by discarding the key

pub fn ungroup_with<T: ExchangeData>(
    &self,
    f: impl FnMut(&K, &V) -> T + 'static
) -> Flow<'a, T, Stateful>

Ungroup by computing the new element from key and value

pub fn ungroup_both(&self) -> Flow<'a, (K, V), Stateful>

Ungroup to a collection of key-value pairs

pub fn regroup<K2, V2, L>(&self, f: L) -> Grouped<'a, K2, V2> where
    K2: ExchangeData + Hashable,
    V2: ExchangeData,
    L: FnMut(&K, &V) -> (K2, V2) + 'static, 

Rearrange this collection by a different key