Trait Operator 

pub trait Operator<I> {
    type Output;

    // Required method
    fn next(&mut self, input: I) -> Self::Output;
}

Operator.

Required Associated Types

type Output

Output type.

Required Methods

fn next(&mut self, input: I) -> Self::Output

Produce the next output.

Implementations on Foreign Types

impl<'a, I, P> Operator<I> for &'a mut P

where P: Operator<I> + ?Sized,

type Output = <P as Operator<I>>::Output

fn next(&mut self, input: I) -> Self::Output

impl<I, P> Operator<I> for Box<P>

where P: Operator<I> + ?Sized,

type Output = <P as Operator<I>>::Output

fn next(&mut self, input: I) -> Self::Output

Implementors

impl<I, I1, I2, P1, P2> Operator<I> for Tuple<I, P1, P2>

where I: Tickable<Value = (I1, I2)>, P1: Operator<TickValue<I1>>, P2: Operator<TickValue<I2>>, P1::Output: Tickable, P2::Output: Tickable,

type Output = TickValue<(<<P1 as Operator<TickValue<I1>>>::Output as Tickable>::Value, <<P2 as Operator<TickValue<I2>>>::Output as Tickable>::Value)>

impl<I, O, F> Operator<Value<I>> for Output<F>

where F: FnMut(I, &mut Context) -> O,

type Output = Value<O>

impl<I, O, F> Operator<I> for indicator::ticked::map::Map<F>

where I: Tickable, F: FnMut(<I as Tickable>::Value) -> O,

type Output = TickValue<O>

impl<I, O, F> Operator<I> for indicator::operator::map::Map<F>

where F: FnMut(I) -> O,

type Output = O

impl<I, O, P> Operator<I> for Op<P>

where P: for<'out> GatOperator<I, Output<'out> = O> + 'static, I: 'static,

type Output = O

impl<I, P1, P2> Operator<I> for indicator::rayon::normal::Facet<I, P1, P2>

where I: Clone + Send, P1: Operator<I> + Send, P2: Operator<I> + Send, P1::Output: Send, P2::Output: Send,

type Output = (<P1 as Operator<I>>::Output, <P2 as Operator<I>>::Output)

impl<I, P1, P2> Operator<I> for indicator::rayon::ticked::Facet<I, P1, P2>

where I: Tickable + Clone + Send, P1: Operator<I> + Send, P2: Operator<I> + Send, P1::Output: Tickable + Send, P2::Output: Tickable + Send, <P1::Output as Tickable>::Value: Send, <P2::Output as Tickable>::Value: Send,

type Output = TickValue<(<<P1 as Operator<I>>::Output as Tickable>::Value, <<P2 as Operator<I>>::Output as Tickable>::Value)>

impl<I, P1, P2> Operator<I> for Then<I, P1, P2>

where P1: Operator<I>, P2: Operator<P1::Output>,

type Output = <P2 as Operator<<P1 as Operator<I>>::Output>>::Output

impl<I, Q, P> Operator<I> for indicator::rayon::normal::FacetMap<I, Q, P>

where I: Clone + Sync, Q: Eq + Hash + Clone + Sync + Send, P: Operator<I> + Send, P::Output: Send,

type Output = HashMap<Q, <P as Operator<I>>::Output>

impl<I, Q, P> Operator<I> for indicator::rayon::ticked::FacetMap<I, Q, P>

where I: Tickable + Clone + Sync, Q: Eq + Hash + Clone + Sync + Send, P: Operator<I> + Send, P::Output: Tickable, <P::Output as Tickable>::Value: Send,

type Output = TickValue<HashMap<Q, <<P as Operator<I>>::Output as Tickable>::Value>>

impl<I, Q, P> Operator<I> for indicator::ticked::facet::FacetMap<I, Q, P>

where I: Tickable + Clone, Q: Eq + Hash + Clone, P: Operator<I>, P::Output: Tickable,

type Output = TickValue<HashMap<Q, <<P as Operator<I>>::Output as Tickable>::Value>>

impl<I, Q, P> Operator<I> for indicator::operator::facet::FacetMap<I, Q, P>

where I: Clone, Q: Eq + Hash + Clone, P: Operator<I>,

type Output = HashMap<Q, <P as Operator<I>>::Output>

impl<I, T, P, const LEN: usize> Operator<I> for Array<I, P, LEN>

where I: Tickable<Value = [T; LEN]>, P: Operator<TickValue<T>>, P::Output: Tickable,

type Output = TickValue<[<<P as Operator<TickValue<T>>>::Output as Tickable>::Value; LEN]>

impl<I: Tickable + Clone, P1, P2> Operator<I> for indicator::ticked::facet::Facet<I, P1, P2>

where P1: Operator<I>, P2: Operator<I>, P1::Output: Tickable, P2::Output: Tickable,

type Output = TickValue<(<<P1 as Operator<I>>::Output as Tickable>::Value, <<P2 as Operator<I>>::Output as Tickable>::Value)>

impl<I: Clone, P1, P2> Operator<I> for indicator::operator::facet::Facet<I, P1, P2>

where P1: Operator<I>, P2: Operator<I>,

type Output = (<P1 as Operator<I>>::Output, <P2 as Operator<I>>::Output)

impl<In, Out, A, B> Operator<Value<In>> for Either<A, B>

where A: ContextOperator<In, Out = Out>, B: ContextOperator<In, Out = Out>,

type Output = Value<Out>

impl<In, P> Operator<In> for ContextedOperator<P>

where P: ContextOperator<In>,

type Output = <P as ContextOperator<In>>::Out

impl<M: TumblingWindow, I: Tickable, Q: QueueCapAtLeast<LEN>, P: TumblingOperation<I::Value, Q, LEN>, const LEN: usize> Operator<I> for TumblingOperator<M, Q, P, LEN>

type Output = TickValue<<P as TumblingOperation<<I as Tickable>::Value, Q, LEN>>::Output>

impl<T> Operator<Value<T>> for Input<T>

type Output = Value<T>

impl<T, I, P> Operator<Value<I>> for AddDataOperator<T, P>

where P: ContextOperator<I>, T: Send + Sync + 'static,

type Output = Value<<P as ContextOperator<I>>::Out>

impl<T, P> Operator<Value<T>> for CacheOperator<P>

where P: ContextOperator<T>,

type Output = Value<<P as ContextOperator<T>>::Out>

impl<T, P, R, Env, Data> Operator<Value<T>> for InsertWithDataOperator<P, R>

where P: ContextOperator<T>, R: for<'a> RefOperator<'a, T, Output = (Env, Option<Data>)>, Env: Send + Sync + 'static, Data: Send + Sync + 'static,

type Output = Value<<P as ContextOperator<T>>::Out>

impl<T, P, R, Out> Operator<Value<T>> for InsertDataOperator<P, R>

where P: ContextOperator<T>, R: for<'a> RefOperator<'a, T, Output = Option<Out>>, Out: Send + Sync + 'static,

type Output = Value<<P as ContextOperator<T>>::Out>

impl<T, P, R, Out> Operator<Value<T>> for InsertOperator<P, R>

where P: ContextOperator<T>, R: for<'a> RefOperator<'a, T, Output = Out>, Out: Send + Sync + 'static,

type Output = Value<<P as ContextOperator<T>>::Out>

impl<T, R, Out> Operator<Value<T>> for InsertEnvAndOutput<R>

where R: for<'a> RefOperator<'a, T, Output = Out>, Out: Clone + Send + Sync + 'static,

type Output = Value<Out>

impl<T, R, Out, Data> Operator<Value<T>> for InsertAndOutput<R>

where R: for<'a> RefOperator<'a, T, Output = (Out, Option<Data>)>, Out: Clone + Send + Sync + 'static, Data: Send + Sync + 'static,

type Output = Value<Out>