Struct PunctuatedGenerator 

pub struct PunctuatedGenerator<F>
where
    F: Fn(i64) -> Option<Watermark> + Send,
{ /* private fields */ }

Punctuated watermark generator that emits based on special events.

Uses a predicate function to identify watermark-carrying events. When the predicate returns Some(watermark), that watermark is emitted.

Example

use laminar_core::time::{PunctuatedGenerator, WatermarkGenerator, Watermark};

// Emit watermark on every 1000ms boundary
let mut gen = PunctuatedGenerator::new(|ts| {
    if ts % 1000 == 0 {
        Some(Watermark::new(ts))
    } else {
        None
    }
});

assert_eq!(gen.on_event(999), None);
assert_eq!(gen.on_event(1000), Some(Watermark::new(1000)));

Implementations

impl<F> PunctuatedGenerator<F>

where F: Fn(i64) -> Option<Watermark> + Send,

pub fn new(predicate: F) -> Self

Creates a new punctuated generator with the given predicate.

Arguments

• predicate - Function that returns Some(Watermark) for watermark events

Trait Implementations

impl<F> WatermarkGenerator for PunctuatedGenerator<F>

where F: Fn(i64) -> Option<Watermark> + Send,

fn on_event(&mut self, timestamp: i64) -> Option<Watermark>

Process an event timestamp and potentially emit a new watermark.

fn on_periodic(&mut self) -> Option<Watermark>

Called periodically to emit watermarks based on wall-clock time.

fn current_watermark(&self) -> i64

Returns the current watermark value without advancing it.

fn advance_watermark(&mut self, timestamp: i64) -> Option<Watermark>

Advances the watermark to at least the given timestamp from an external source.

fn is_processing_time(&self) -> bool

Whether the watermark is processing-time based (wall clock), rather than derived from the event-time column. Such a watermark lives in a different time domain than the event timestamps, so comparing the two to drop “late” rows would discard every event — callers skip source-side late-filtering when this is true. Defaults to false (event-time generators).