Struct JoinBuilder 

pub struct JoinBuilder<O> { /* private fields */ }

Configures a multi-input join transform.

Available on every runtime. The fan-in queue (bounded channel between input forwarders and the trigger loop) lives in core, with capacity 64 on std and wasm32 and 16 on embedded no_std.

Obtain via RecordRegistrar::transform_join.

Implementations

impl<O> JoinBuilder<O>

where O: Send + Sync + Clone + Debug + 'static,

pub fn input<I>(self, key: impl RecordKey) -> Self

where I: Send + Sync + Clone + Debug + 'static,

Add a typed input to the join.

pub fn on_triggers<F, Fut>(self, handler: F) -> JoinPipeline<O>

where F: FnOnce(JoinEventRx, Producer<O>) -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static,

Complete the pipeline by providing an async task that owns the event loop and state.

The closure receives a JoinEventRx to read trigger events and a Producer<O> to emit output values. Both are owned — moved into the async move block — so the closure can freely hold borrows across .await points and maintain any state it needs.

The task runs until all input forwarders close (i.e., all upstream records stop producing).

Illustrative (not compiled: fragment of a transform_join pipeline with user-defined input types):

.on_triggers(|mut rx, producer| async move {
    let mut last_a: Option<f32> = None;
    let mut last_b: Option<f32> = None;
    while let Ok(trigger) = rx.recv().await {
        match trigger.index() {
            0 => last_a = trigger.as_input::<InputA>().copied(),
            1 => last_b = trigger.as_input::<InputB>().copied(),
            _ => {}
        }
        if let (Some(a), Some(b)) = (last_a, last_b) {
            producer.produce(compute(a, b));
        }
    }
})