Type Alias StreamVec 

pub type StreamVec<S, D> = Stream<S, Vec<D>>;

A stream batching data in owning vectors.

Aliased Type

pub struct StreamVec<S, D> { /* private fields */ }

Trait Implementations

impl<G: Scope<Timestamp: Hash>, D: 'static> Accumulate<G, D> for StreamVec<G, D>

fn accumulate<A: Clone + 'static>( self, default: A, logic: impl Fn(&mut A, &mut Vec<D>) + 'static, ) -> StreamVec<G, A>

Accumulates records within a timestamp.

fn count(self) -> StreamVec<G, usize>

Counts the number of records observed at each time.

impl<S: Scope<Timestamp: Hash>, K: ExchangeData + Clone + Hash + Eq, V: ExchangeData> Aggregate<S, K, V> for StreamVec<S, (K, V)>

fn aggregate<R: 'static, D: Default + 'static, F: Fn(&K, V, &mut D) + 'static, E: Fn(K, D) -> R + 'static, H: Fn(&K) -> u64 + 'static>( self, fold: F, emit: E, hash: H, ) -> StreamVec<S, R>

where S::Timestamp: Eq,

Aggregates data of the form (key, val), using user-supplied logic.

impl<S: Scope, D: 'static> Branch<S, D> for StreamVec<S, D>

fn branch( self, condition: impl Fn(&S::Timestamp, &D) -> bool + 'static, ) -> (StreamVec<S, D>, StreamVec<S, D>)

Takes one input stream and splits it into two output streams. For each record, the supplied closure is called with a reference to the data and its time. If it returns true, the record will be sent to the second returned stream, otherwise it will be sent to the first.

impl<G: Scope, D: ExchangeData + Clone> Broadcast<D> for StreamVec<G, D>

fn broadcast(self) -> StreamVec<G, D>

Broadcast records to all workers.

impl<G: Scope<Timestamp: Hash>, D: 'static> Delay<G, D> for StreamVec<G, D>

fn delay<L: FnMut(&D, &G::Timestamp) -> G::Timestamp + 'static>( self, func: L, ) -> Self

Advances the timestamp of records using a supplied function.

fn delay_total<L: FnMut(&D, &G::Timestamp) -> G::Timestamp + 'static>( self, func: L, ) -> Self

where G::Timestamp: TotalOrder,

Advances the timestamp of records using a supplied function.

fn delay_batch<L: FnMut(&G::Timestamp) -> G::Timestamp + 'static>( self, func: L, ) -> Self

Advances the timestamp of batches of records using a supplied function.

impl<G: Scope, D: 'static> Filter<D> for StreamVec<G, D>

fn filter<P: FnMut(&D) -> bool + 'static>(self, predicate: P) -> StreamVec<G, D>

Returns a new instance of self containing only records satisfying predicate.

impl<S: Scope, D: 'static> Map<S, D> for StreamVec<S, D>

fn map_in_place<L: FnMut(&mut D) + 'static>(self, logic: L) -> StreamVec<S, D>

Updates each element of the stream and yields the element, re-using memory where possible.

fn flat_map<I: IntoIterator, L: FnMut(D) -> I + 'static>( self, logic: L, ) -> StreamVec<S, I::Item>

where I::Item: 'static,

Consumes each element of the stream and yields some number of new elements.

fn map<D2: 'static, L: FnMut(D) -> D2 + 'static>( self, logic: L, ) -> StreamVec<S, D2>

Consumes each element of the stream and yields a new element.

impl<G: Scope, D: 'static, D2: 'static, F: Fn(D) -> (u64, D2) + 'static> Partition<G, D, D2, F> for StreamVec<G, D>

fn partition(self, parts: u64, route: F) -> Vec<StreamVec<G, D2>>

Produces parts output streams, containing records produced and assigned by route.

impl<S: Scope, T: 'static, E: 'static> ResultStream<S, T, E> for StreamVec<S, Result<T, E>>

fn ok(self) -> StreamVec<S, T>

Returns a new instance of self containing only ok records.

fn err(self) -> StreamVec<S, E>

Returns a new instance of self containing only err records.

fn map_ok<T2: 'static, L: FnMut(T) -> T2 + 'static>( self, logic: L, ) -> StreamVec<S, Result<T2, E>>

Returns a new instance of self applying logic on all Ok records.

fn map_err<E2: 'static, L: FnMut(E) -> E2 + 'static>( self, logic: L, ) -> StreamVec<S, Result<T, E2>>

Returns a new instance of self applying logic on all Err records.

fn and_then<T2: 'static, L: FnMut(T) -> Result<T2, E> + 'static>( self, logic: L, ) -> StreamVec<S, Result<T2, E>>

Returns a new instance of self applying logic on all Ok records, passes through Err records.

fn unwrap_or_else<L: FnMut(E) -> T + 'static>(self, logic: L) -> StreamVec<S, T>

Returns a new instance of self applying logic on all Ok records.

impl<S: Scope, K: ExchangeData + Hash + Eq + Clone, V: ExchangeData> StateMachine<S, K, V> for StreamVec<S, (K, V)>

fn state_machine<R: 'static, D: Default + 'static, I: IntoIterator<Item = R>, F: Fn(&K, V, &mut D) -> (bool, I) + 'static, H: Fn(&K) -> u64 + 'static>( self, fold: F, hash: H, ) -> StreamVec<S, R>

where S::Timestamp: Hash + Eq,

Tracks a state for each presented key, using user-supplied state transition logic.