Struct timely::dataflow::stream::Stream

pub struct Stream<S: Scope, D> { /* fields omitted */ }

Abstraction of a stream of D: Data records timestamped with S::Timestamp.

Internally Stream maintains a list of data recipients who should be presented with data produced by the source of the stream.

Implementations

impl<S: Scope, D> Stream<S, D>

pub fn connect_to<P: Push<Bundle<S::Timestamp, D>> + 'static>(
    &self,
    target: Target,
    pusher: P,
    identifier: usize
)

Connects the stream to a destination.

The destination is described both by a Target, for progress tracking information, and a P: Push where the records should actually be sent. The identifier is unique to the edge and is used only for logging purposes.

pub fn new(source: Source, output: TeeHelper<S::Timestamp, D>, scope: S) -> Self

Allocates a Stream from a supplied Source name and rendezvous point.

pub fn name(&self) -> &Source

The name of the stream’s source operator.

pub fn scope(&self) -> S

The scope immediately containing the stream.

Trait Implementations

impl<G: Scope, D: Data> Accumulate<G, D> for Stream<G, D>

fn accumulate<A: Data>(
    &self,
    default: A,
    logic: impl Fn(&mut A, RefOrMut<'_, Vec<D>>) + 'static
) -> Stream<G, A>

Accumulates records within a timestamp.

fn count(&self) -> Stream<G, usize>

Counts the number of records observed at each time.

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

fn aggregate<R: Data, 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
) -> Stream<S, R> where
    S::Timestamp: Eq, 

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

impl<S: Scope, D: Data> Branch<S, D> for Stream<S, D>

fn branch(
    &self,
    condition: impl Fn(&S::Timestamp, &D) -> bool + 'static
) -> (Stream<S, D>, Stream<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<S: Scope, D: Data> BranchWhen<S, D> for Stream<S, D>

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

Takes one input stream and splits it into two output streams. For each time, the supplied closure is called. If it returns true, the records for that will be sent to the second returned stream, otherwise they will be sent to the first.

impl<G: Scope, D: ExchangeData> Broadcast<D> for Stream<G, D>

fn broadcast(&self) -> Stream<G, D>

Broadcast records to all workers.

impl<S: Scope, D: Data> Capture<<S as ScopeParent>::Timestamp, D> for Stream<S, D>

fn capture_into<P: EventPusher<S::Timestamp, D> + 'static>(
    &self,
    event_pusher: P
)

Captures a stream of timestamped data for later replay.

fn capture(&self) -> Receiver<Event<T, D>>

Captures a stream using Rust’s MPSC channels.

impl<S: Clone + Scope, D: Clone> Clone for Stream<S, D> where
    S::Timestamp: Clone, 

fn clone(&self) -> Stream<S, D>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<G: Scope, D: Data> Concat<G, D> for Stream<G, D>

fn concat(&self, other: &Stream<G, D>) -> Stream<G, D>

Merge the contents of two streams.

impl<G: Scope, D: Data> Concatenate<G, D> for Stream<G, D>

fn concatenate<I>(&self, sources: I) -> Stream<G, D> where
    I: IntoIterator<Item = Stream<G, D>>, 

Merge the contents of multiple streams.

impl<G: Scope, D: Data> ConnectLoop<G, D> for Stream<G, D>

fn connect_loop(&self, helper: Handle<G, D>)

Connect a Stream to be the input of a loop variable.

impl<G: Scope, D: Data> Delay<G, D> for Stream<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, T: Timestamp + Refines<G::Timestamp>, D: Data> Enter<G, T, D> for Stream<G, D>

fn enter<'a>(&self, scope: &Child<'a, G, T>) -> Stream<Child<'a, G, T>, D>

Moves the Stream argument into a child of its current Scope.

impl<G: Scope, D: ExchangeData> Exchange<<G as ScopeParent>::Timestamp, D> for Stream<G, D>

fn exchange(&self, route: impl Fn(&D) -> u64 + 'static) -> Stream<G, D>

Exchange records between workers.

impl<G: Scope, D: Data> Filter<D> for Stream<G, D>

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

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

impl<G: Scope, D: Data> Inspect<G, D> for Stream<G, D>

fn inspect_batch(
    &self,
    func: impl FnMut(&G::Timestamp, &[D]) + 'static
) -> Stream<G, D>

Runs a supplied closure on each observed data batch (time and data slice).

fn inspect(&self, func: impl FnMut(&D) + 'static) -> Stream<G, D>

Runs a supplied closure on each observed data element.

fn inspect_time(
    &self,
    func: impl FnMut(&G::Timestamp, &D) + 'static
) -> Stream<G, D>

Runs a supplied closure on each observed data element and associated time.

impl<'a, G: Scope, D: Data, T: Timestamp + Refines<G::Timestamp>> Leave<G, D> for Stream<Child<'a, G, T>, D>

fn leave(&self) -> Stream<G, D>

Moves a Stream to the parent of its current Scope.

impl<S: Scope, D: Data> Map<S, D> for Stream<S, D>

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

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

fn map_in_place<L: FnMut(&mut D) + 'static>(&self, logic: L) -> Stream<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
) -> Stream<S, I::Item> where
    I::Item: Data, 

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

impl<S: Scope, D: Data> OkErr<S, D> for Stream<S, D>

fn ok_err<D1, D2, L>(&self, logic: L) -> (Stream<S, D1>, Stream<S, D2>) where
    D1: Data,
    D2: Data,
    L: FnMut(D) -> Result<D1, D2> + 'static, 

Takes one input stream and splits it into two output streams. For each record, the supplied closure is called with the data. If it returns Ok(x), then x will be sent to the first returned stream; otherwise, if it returns Err(e), then e will be sent to the second.

impl<G: Scope, D1: Data> Operator<G, D1> for Stream<G, D1>

fn unary_frontier<D2, B, L, P>(
    &self,
    pact: P,
    name: &str,
    constructor: B
) -> Stream<G, D2> where
    D2: Data,
    B: FnOnce(Capability<G::Timestamp>, OperatorInfo) -> L,
    L: FnMut(&mut FrontieredInputHandle<'_, G::Timestamp, D1, P::Puller>, &mut OutputHandle<'_, G::Timestamp, D2, Tee<G::Timestamp, D2>>) + 'static,
    P: ParallelizationContract<G::Timestamp, D1>, 

Creates a new dataflow operator that partitions its input stream by a parallelization strategy pact, and repeatedly invokes logic, the function returned by the function passed as constructor. logic can read from the input stream, write to the output stream, and inspect the frontier at the input.

fn unary_notify<D2: Data, L: FnMut(&mut InputHandle<G::Timestamp, D1, P::Puller>, &mut OutputHandle<'_, G::Timestamp, D2, Tee<G::Timestamp, D2>>, &mut Notificator<'_, G::Timestamp>) + 'static, P: ParallelizationContract<G::Timestamp, D1>>(
    &self,
    pact: P,
    name: &str,
    init: impl IntoIterator<Item = G::Timestamp>,
    logic: L
) -> Stream<G, D2>

Creates a new dataflow operator that partitions its input stream by a parallelization strategy pact, and repeatedly invokes logic, the function returned by the function passed as constructor. logic can read from the input stream, write to the output stream, and inspect the frontier at the input.

fn unary<D2, B, L, P>(
    &self,
    pact: P,
    name: &str,
    constructor: B
) -> Stream<G, D2> where
    D2: Data,
    B: FnOnce(Capability<G::Timestamp>, OperatorInfo) -> L,
    L: FnMut(&mut InputHandle<G::Timestamp, D1, P::Puller>, &mut OutputHandle<'_, G::Timestamp, D2, Tee<G::Timestamp, D2>>) + 'static,
    P: ParallelizationContract<G::Timestamp, D1>, 

Creates a new dataflow operator that partitions its input stream by a parallelization strategy pact, and repeatedly invokes logic, the function returned by the function passed as constructor. logic can read from the input stream, and write to the output stream.

fn binary_frontier<D2, D3, B, L, P1, P2>(
    &self,
    other: &Stream<G, D2>,
    pact1: P1,
    pact2: P2,
    name: &str,
    constructor: B
) -> Stream<G, D3> where
    D2: Data,
    D3: Data,
    B: FnOnce(Capability<G::Timestamp>, OperatorInfo) -> L,
    L: FnMut(&mut FrontieredInputHandle<'_, G::Timestamp, D1, P1::Puller>, &mut FrontieredInputHandle<'_, G::Timestamp, D2, P2::Puller>, &mut OutputHandle<'_, G::Timestamp, D3, Tee<G::Timestamp, D3>>) + 'static,
    P1: ParallelizationContract<G::Timestamp, D1>,
    P2: ParallelizationContract<G::Timestamp, D2>, 

Creates a new dataflow operator that partitions its input streams by a parallelization strategy pact, and repeatedly invokes logic, the function returned by the function passed as constructor. logic can read from the input streams, write to the output stream, and inspect the frontier at the inputs.

fn binary_notify<D2: Data, D3: Data, L: FnMut(&mut InputHandle<G::Timestamp, D1, P1::Puller>, &mut InputHandle<G::Timestamp, D2, P2::Puller>, &mut OutputHandle<'_, G::Timestamp, D3, Tee<G::Timestamp, D3>>, &mut Notificator<'_, G::Timestamp>) + 'static, P1: ParallelizationContract<G::Timestamp, D1>, P2: ParallelizationContract<G::Timestamp, D2>>(
    &self,
    other: &Stream<G, D2>,
    pact1: P1,
    pact2: P2,
    name: &str,
    init: impl IntoIterator<Item = G::Timestamp>,
    logic: L
) -> Stream<G, D3>

Creates a new dataflow operator that partitions its input streams by a parallelization strategy pact, and repeatedly invokes logic, the function returned by the function passed as constructor. logic can read from the input streams, write to the output stream, and inspect the frontier at the inputs.

fn binary<D2, D3, B, L, P1, P2>(
    &self,
    other: &Stream<G, D2>,
    pact1: P1,
    pact2: P2,
    name: &str,
    constructor: B
) -> Stream<G, D3> where
    D2: Data,
    D3: Data,
    B: FnOnce(Capability<G::Timestamp>, OperatorInfo) -> L,
    L: FnMut(&mut InputHandle<G::Timestamp, D1, P1::Puller>, &mut InputHandle<G::Timestamp, D2, P2::Puller>, &mut OutputHandle<'_, G::Timestamp, D3, Tee<G::Timestamp, D3>>) + 'static,
    P1: ParallelizationContract<G::Timestamp, D1>,
    P2: ParallelizationContract<G::Timestamp, D2>, 

Creates a new dataflow operator that partitions its input streams by a parallelization strategy pact, and repeatedly invokes logic, the function returned by the function passed as constructor. logic can read from the input streams, write to the output stream, and inspect the frontier at the inputs.

fn sink<L, P>(&self, pact: P, name: &str, logic: L) where
    L: FnMut(&mut FrontieredInputHandle<'_, G::Timestamp, D1, P::Puller>) + 'static,
    P: ParallelizationContract<G::Timestamp, D1>, 

Creates a new dataflow operator that partitions its input stream by a parallelization strategy pact, and repeatedly invokes the function logic which can read from the input stream and inspect the frontier at the input.

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

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

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

impl<G: Scope, D: Data> Probe<G, D> for Stream<G, D>

fn probe(&self) -> Handle<G::Timestamp>

Constructs a progress probe which indicates which timestamps have elapsed at the operator.

fn probe_with(&self, handle: &mut Handle<G::Timestamp>) -> Stream<G, D>

Inserts a progress probe in a stream.

impl<S: Scope, D: Data> Reclock<S, D> for Stream<S, D>

fn reclock(&self, clock: &Stream<S, ()>) -> Stream<S, D>

Delays records until an input is observed on the clock input.

impl<S: Scope, T: Data, E: Data> ResultStream<S, T, E> for Stream<S, Result<T, E>>

fn ok(&self) -> Stream<S, T>

Returns a new instance of self containing only ok records.

fn err(&self) -> Stream<S, E>

Returns a new instance of self containing only err records.

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

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

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

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

fn and_then<T2: Data, L: FnMut(T) -> Result<T2, E> + 'static>(
    &self,
    logic: L
) -> Stream<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) -> Stream<S, T>

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

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

fn state_machine<R: Data, 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
) -> Stream<S, R> where
    S::Timestamp: Hash + Eq, 

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