Struct FlatMap 

pub struct FlatMap<IN, OUTS, F, S>
where
    IN: ArconType,
    OUTS: IntoIterator,
    OUTS::Item: ArconType,
    F: Fn(IN, &mut S) -> ArconResult<OUTS> + ArconFnBounds,
    S: ArconState,
{ /* private fields */ }

Implementations

impl<IN, OUTS> FlatMap<IN, OUTS, fn(IN, &mut EmptyState) -> ArconResult<OUTS>, EmptyState>

where IN: ArconType, OUTS: IntoIterator + 'static, OUTS::Item: ArconType,

pub fn new( udf: impl Fn(IN) -> OUTS + ArconFnBounds, ) -> FlatMap<IN, OUTS, impl Fn(IN, &mut EmptyState) -> ArconResult<OUTS> + ArconFnBounds, EmptyState>

impl<IN, OUTS, F, S> FlatMap<IN, OUTS, F, S>

where IN: ArconType, OUTS: IntoIterator + 'static, OUTS::Item: ArconType, F: Fn(IN, &mut S) -> ArconResult<OUTS> + ArconFnBounds, S: ArconState,

pub fn stateful(udf: F) -> Self

Trait Implementations

impl<IN, OUTS, F, S> Operator for FlatMap<IN, OUTS, F, S>

where IN: ArconType, OUTS: IntoIterator + 'static, OUTS::Item: ArconType, F: Fn(IN, &mut S) -> ArconResult<OUTS> + ArconFnBounds, S: ArconState,

type IN = IN

The type of input elements this operator processes

type OUT = <OUTS as IntoIterator>::Item

The type of output elements this operator produces

type TimerState = ArconNever

Storage state type for timer facilities

type OperatorState = S

State type for the Operator

type ElementIterator = Box<dyn Iterator<Item = ArconElement<<FlatMap<IN, OUTS, F, S> as Operator>::OUT>>>

Iterator that produces outgoing elements

fn handle_element( &mut self, element: ArconElement<IN>, ctx: &mut OperatorContext<Self::TimerState, Self::OperatorState>, ) -> ArconResult<Self::ElementIterator>

Determines how the Operator processes Elements

fn handle_timeout( &mut self, _timeout: Self::TimerState, _ctx: &mut OperatorContext<Self::TimerState, Self::OperatorState>, ) -> ArconResult<Option<Self::ElementIterator>>

Determines how the Operator handles timeouts it registered earlier when they are triggered

fn on_start( &mut self, _ctx: &mut OperatorContext<Self::TimerState, Self::OperatorState>, ) -> ArconResult<()>

Determines what the Operator runs before beginning to process Elements