Struct erdos::dataflow::operators::SplitOperator

pub struct SplitOperator<D1> where
    D1: Data + for<'a> Deserialize<'a>,  { /* private fields */ }

Splits an incoming stream of type D1 into two different streams of type D1 using the provided condition function. When evaluated to true, sends messages to left stream, and right stream otherwise.

Example

The below example shows how to use a SplitOperator to split an incoming stream of usize messages into two different streams one with messages > 10 (left stream) and one with messages <= 10 (right stream), and send them.

// Add the mapping function as an argument to the operator via the OperatorConfig.
let split_config = OperatorConfig::new().name("SplitOperator");
let (left_stream, right_stream) = erdos::connect_one_in_two_out(
    || -> SplitOperator<usize> { SplitOperator::new(|a: &usize| -> bool { a > &10 }) },
    || {},
    split_config,
    &source_stream,
);

Implementations

impl<D1> SplitOperator<D1> where
    D1: Data + for<'a> Deserialize<'a>, 

pub fn new<F>(split_function: F) -> Self where
    F: 'static + Fn(&D1) -> bool + Send + Sync, 

Trait Implementations

impl<D1> OneInTwoOut<(), D1, D1, D1> for SplitOperator<D1> where
    D1: Data + for<'a> Deserialize<'a>, 

fn on_data(&mut self, ctx: &mut OneInTwoOutContext<'_, (), D1, D1>, data: &D1)

fn on_watermark(&mut self, _ctx: &mut OneInTwoOutContext<'_, (), D1, D1>)

fn setup(&mut self, setup_context: &mut SetupContext<S>)

fn run(
    &mut self,
    config: &OperatorConfig,
    read_stream: &mut ReadStream<T>,
    left_write_stream: &mut WriteStream<U>,
    right_write_stream: &mut WriteStream<V>
)

fn destroy(&mut self)