Struct timely::dataflow::stream::Stream [−][src]
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>
[src]
pub fn connect_to<P: Push<Bundle<S::Timestamp, D>> + 'static>(
&self,
target: Target,
pusher: P,
identifier: usize
)
[src]
&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
[src]
Allocates a Stream
from a supplied Source
name and rendezvous point.
pub fn name(&self) -> &Source
[src]
The name of the stream’s source operator.
pub fn scope(&self) -> S
[src]
The scope immediately containing the stream.
Trait Implementations
impl<G: Scope, D: Data> Accumulate<G, D> for Stream<G, D>
[src]
fn accumulate<A: Data>(
&self,
default: A,
logic: impl Fn(&mut A, RefOrMut<'_, Vec<D>>) + 'static
) -> Stream<G, A>
[src]
&self,
default: A,
logic: impl Fn(&mut A, RefOrMut<'_, Vec<D>>) + 'static
) -> Stream<G, A>
fn count(&self) -> Stream<G, usize>
[src]
impl<S: Scope, K: ExchangeData + Hash + Eq, V: ExchangeData> Aggregate<S, K, V> for Stream<S, (K, V)>
[src]
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,
[src]
&self,
fold: F,
emit: E,
hash: H
) -> Stream<S, R> where
S::Timestamp: Eq,
impl<S: Scope, D: Data> Branch<S, D> for Stream<S, D>
[src]
fn branch(
&self,
condition: impl Fn(&S::Timestamp, &D) -> bool + 'static
) -> (Stream<S, D>, Stream<S, D>)
[src]
&self,
condition: impl Fn(&S::Timestamp, &D) -> bool + 'static
) -> (Stream<S, D>, Stream<S, D>)
impl<S: Scope, D: Data> BranchWhen<S, D> for Stream<S, D>
[src]
fn branch_when(
&self,
condition: impl Fn(&S::Timestamp) -> bool + 'static
) -> (Stream<S, D>, Stream<S, D>)
[src]
&self,
condition: impl Fn(&S::Timestamp) -> bool + 'static
) -> (Stream<S, D>, Stream<S, D>)
impl<G: Scope, D: ExchangeData> Broadcast<D> for Stream<G, D>
[src]
impl<S: Scope, D: Data> Capture<<S as ScopeParent>::Timestamp, D> for Stream<S, D>
[src]
fn capture_into<P: EventPusher<S::Timestamp, D> + 'static>(
&self,
event_pusher: P
)
[src]
&self,
event_pusher: P
)
fn capture(&self) -> Receiver<Event<T, D>>
[src]
impl<S: Clone + Scope, D: Clone> Clone for Stream<S, D> where
S::Timestamp: Clone,
[src]
S::Timestamp: Clone,
impl<G: Scope, D: Data> Concat<G, D> for Stream<G, D>
[src]
impl<G: Scope, D: Data> Concatenate<G, D> for Stream<G, D>
[src]
fn concatenate<I>(&self, sources: I) -> Stream<G, D> where
I: IntoIterator<Item = Stream<G, D>>,
[src]
I: IntoIterator<Item = Stream<G, D>>,
impl<G: Scope, D: Data> ConnectLoop<G, D> for Stream<G, D>
[src]
fn connect_loop(&self, helper: Handle<G, D>)
[src]
impl<G: Scope, D: Data> Delay<G, D> for Stream<G, D>
[src]
fn delay<L: FnMut(&D, &G::Timestamp) -> G::Timestamp + 'static>(
&self,
func: L
) -> Self
[src]
&self,
func: L
) -> Self
fn delay_total<L: FnMut(&D, &G::Timestamp) -> G::Timestamp + 'static>(
&self,
func: L
) -> Self where
G::Timestamp: TotalOrder,
[src]
&self,
func: L
) -> Self where
G::Timestamp: TotalOrder,
fn delay_batch<L: FnMut(&G::Timestamp) -> G::Timestamp + 'static>(
&self,
func: L
) -> Self
[src]
&self,
func: L
) -> Self
impl<G: Scope, T: Timestamp + Refines<G::Timestamp>, D: Data> Enter<G, T, D> for Stream<G, D>
[src]
impl<G: Scope, D: ExchangeData> Exchange<<G as ScopeParent>::Timestamp, D> for Stream<G, D>
[src]
impl<G: Scope, D: Data> Filter<D> for Stream<G, D>
[src]
impl<G: Scope, D: Data> Inspect<G, D> for Stream<G, D>
[src]
fn inspect_batch(
&self,
func: impl FnMut(&G::Timestamp, &[D]) + 'static
) -> Stream<G, D>
[src]
&self,
func: impl FnMut(&G::Timestamp, &[D]) + 'static
) -> Stream<G, D>
fn inspect(&self, func: impl FnMut(&D) + 'static) -> Stream<G, D>
[src]
fn inspect_time(
&self,
func: impl FnMut(&G::Timestamp, &D) + 'static
) -> Stream<G, D>
[src]
&self,
func: impl FnMut(&G::Timestamp, &D) + 'static
) -> Stream<G, D>
impl<'a, G: Scope, D: Data, T: Timestamp + Refines<G::Timestamp>> Leave<G, D> for Stream<Child<'a, G, T>, D>
[src]
impl<S: Scope, D: Data> Map<S, D> for Stream<S, D>
[src]
fn map<D2: Data, L: FnMut(D) -> D2 + 'static>(&self, logic: L) -> Stream<S, D2>
[src]
fn map_in_place<L: FnMut(&mut D) + 'static>(&self, logic: L) -> Stream<S, D>
[src]
fn flat_map<I: IntoIterator, L: FnMut(D) -> I + 'static>(
&self,
logic: L
) -> Stream<S, I::Item> where
I::Item: Data,
[src]
&self,
logic: L
) -> Stream<S, I::Item> where
I::Item: Data,
impl<S: Scope, D: Data> OkErr<S, D> for Stream<S, D>
[src]
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,
[src]
D1: Data,
D2: Data,
L: FnMut(D) -> Result<D1, D2> + 'static,
impl<G: Scope, D1: Data> Operator<G, D1> for Stream<G, D1>
[src]
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>,
[src]
&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>,
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>
[src]
&self,
pact: P,
name: &str,
init: impl IntoIterator<Item = G::Timestamp>,
logic: L
) -> Stream<G, D2>
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>,
[src]
&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>,
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>,
[src]
&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>,
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>
[src]
&self,
other: &Stream<G, D2>,
pact1: P1,
pact2: P2,
name: &str,
init: impl IntoIterator<Item = G::Timestamp>,
logic: L
) -> Stream<G, D3>
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>,
[src]
&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>,
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>,
[src]
L: FnMut(&mut FrontieredInputHandle<'_, G::Timestamp, D1, P::Puller>) + 'static,
P: ParallelizationContract<G::Timestamp, D1>,
impl<G: Scope, D: Data, D2: Data, F: Fn(D) -> (u64, D2) + 'static> Partition<G, D, D2, F> for Stream<G, D>
[src]
impl<G: Scope, D: Data> Probe<G, D> for Stream<G, D>
[src]
fn probe(&self) -> Handle<G::Timestamp>
[src]
fn probe_with(&self, handle: &mut Handle<G::Timestamp>) -> Stream<G, D>
[src]
impl<S: Scope, D: Data> Reclock<S, D> for Stream<S, D>
[src]
impl<S: Scope, T: Data, E: Data> ResultStream<S, T, E> for Stream<S, Result<T, E>>
[src]
fn ok(&self) -> Stream<S, T>
[src]
fn err(&self) -> Stream<S, E>
[src]
fn map_ok<T2: Data, L: FnMut(T) -> T2 + 'static>(
&self,
logic: L
) -> Stream<S, Result<T2, E>>
[src]
&self,
logic: L
) -> Stream<S, Result<T2, E>>
fn map_err<E2: Data, L: FnMut(E) -> E2 + 'static>(
&self,
logic: L
) -> Stream<S, Result<T, E2>>
[src]
&self,
logic: L
) -> Stream<S, Result<T, E2>>
fn and_then<T2: Data, L: FnMut(T) -> Result<T2, E> + 'static>(
&self,
logic: L
) -> Stream<S, Result<T2, E>>
[src]
&self,
logic: L
) -> Stream<S, Result<T2, E>>
fn unwrap_or_else<L: FnMut(E) -> T + 'static>(&self, logic: L) -> Stream<S, T>
[src]
impl<S: Scope, K: ExchangeData + Hash + Eq, V: ExchangeData> StateMachine<S, K, V> for Stream<S, (K, V)>
[src]
Auto Trait Implementations
impl<S, D> !RefUnwindSafe for Stream<S, D>
impl<S, D> !Send for Stream<S, D>
impl<S, D> !Sync for Stream<S, D>
impl<S, D> Unpin for Stream<S, D> where
S: Unpin,
S: Unpin,
impl<S, D> !UnwindSafe for Stream<S, D>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Data for T where
T: 'static + Clone,
[src]
T: 'static + Clone,
impl<G, T, D, E> EnterAt<G, T, D> for E where
T: Timestamp,
D: Data,
G: Scope,
E: Enter<G, Product<<G as ScopeParent>::Timestamp, T>, D>,
[src]
T: Timestamp,
D: Data,
G: Scope,
E: Enter<G, Product<<G as ScopeParent>::Timestamp, T>, D>,
pub fn enter_at<F>(
&Self,
&Child<'a, G, Product<<G as ScopeParent>::Timestamp, T>>,
F
) -> Stream<Child<'a, G, Product<<G as ScopeParent>::Timestamp, T>>, D> where
F: 'static + FnMut(&D) -> T,
[src]
&Self,
&Child<'a, G, Product<<G as ScopeParent>::Timestamp, T>>,
F
) -> Stream<Child<'a, G, Product<<G as ScopeParent>::Timestamp, T>>, D> where
F: 'static + FnMut(&D) -> T,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,