@Override
@SuppressWarnings("unchecked")
public final void processElement(StreamRecord<IN> element) throws Exception {
if (setProcessingTime) {
element.replace(element.getValue(), System.currentTimeMillis());
}
Collection<W> elementWindows =
windowAssigner.assignWindows(element.getValue(), element.getTimestamp());
K key = keySelector.getKey(element.getValue());
Map<W, Context> keyWindows = windows.get(key);
if (keyWindows == null) {
keyWindows = new HashMap<>();
windows.put(key, keyWindows);
}
for (W window : elementWindows) {
Context context = keyWindows.get(window);
if (context == null) {
WindowBuffer<IN> windowBuffer = windowBufferFactory.create();
context = new Context(key, window, windowBuffer);
keyWindows.put(window, context);
}
context.windowBuffer.storeElement(element);
Trigger.TriggerResult triggerResult = context.onElement(element);
processTriggerResult(triggerResult, key, window);
}
}
@Override
public void processElement(StreamRecord<T> element) throws Exception {
long newTimestamp = userFunction.extractTimestamp(element.getValue(), element.getTimestamp());
output.collect(element.replace(element.getValue(), newTimestamp));
long watermark = userFunction.extractWatermark(element.getValue(), newTimestamp);
if (watermark > currentWatermark) {
currentWatermark = watermark;
output.emitWatermark(new Watermark(currentWatermark));
}
}
@Override
public void collect(StreamRecord<OUT> record) {
for (Collector<StreamRecord<OUT>> output :
outputSelectorWrapper.getSelectedOutputs(record.getValue())) {
output.collect(record);
}
}
@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public void setKeyContextElement2(StreamRecord record) throws Exception {
if (stateKeySelector2 != null) {
Object key = ((KeySelector) stateKeySelector2).getKey(record.getValue());
getStateBackend().setCurrentKey(key);
}
}
public Trigger.TriggerResult onElement(StreamRecord<IN> element) throws Exception {
Trigger.TriggerResult onElementResult =
trigger.onElement(element.getValue(), element.getTimestamp(), window, this);
if (watermarkTimer > 0 && watermarkTimer <= currentWatermark) {
// fire now and don't wait for the next watermark update
Trigger.TriggerResult onEventTimeResult = onEventTime(watermarkTimer);
return Trigger.TriggerResult.merge(onElementResult, onEventTimeResult);
} else {
return onElementResult;
}
}
@Override
@SuppressWarnings("unchecked")
public void processElement(StreamRecord<IN> element) throws Exception {
Collection<W> elementWindows =
windowAssigner.assignWindows(
element.getValue(), element.getTimestamp(), windowAssignerContext);
final K key = (K) getStateBackend().getCurrentKey();
if (windowAssigner instanceof MergingWindowAssigner) {
MergingWindowSet<W> mergingWindows = getMergingWindowSet();
for (W window : elementWindows) {
// If there is a merge, it can only result in a window that contains our new
// element because we always eagerly merge
final Tuple1<TriggerResult> mergeTriggerResult = new Tuple1<>(TriggerResult.CONTINUE);
// adding the new window might result in a merge, in that case the actualWindow
// is the merged window and we work with that. If we don't merge then
// actualWindow == window
W actualWindow =
mergingWindows.addWindow(
window,
new MergingWindowSet.MergeFunction<W>() {
@Override
public void merge(
W mergeResult,
Collection<W> mergedWindows,
W stateWindowResult,
Collection<W> mergedStateWindows)
throws Exception {
context.key = key;
context.window = mergeResult;
// store for later use
mergeTriggerResult.f0 = context.onMerge(mergedWindows);
for (W m : mergedWindows) {
context.window = m;
context.clear();
deleteCleanupTimer(m);
}
// merge the merged state windows into the newly resulting state window
getStateBackend()
.mergePartitionedStates(
stateWindowResult,
mergedStateWindows,
windowSerializer,
(StateDescriptor<? extends MergingState<?, ?>, ?>)
windowStateDescriptor);
}
});
// check if the window is already inactive
if (isLate(actualWindow)) {
LOG.info(
"Dropped element " + element + " for window " + actualWindow + " due to lateness.");
continue;
}
W stateWindow = mergingWindows.getStateWindow(actualWindow);
ListState<StreamRecord<IN>> windowState =
getPartitionedState(stateWindow, windowSerializer, windowStateDescriptor);
windowState.add(element);
context.key = key;
context.window = actualWindow;
// we might have already fired because of a merge but still call onElement
// on the (possibly merged) window
TriggerResult triggerResult = context.onElement(element);
TriggerResult combinedTriggerResult =
TriggerResult.merge(triggerResult, mergeTriggerResult.f0);
fireOrContinue(combinedTriggerResult, actualWindow, windowState);
if (combinedTriggerResult.isPurge()) {
cleanup(actualWindow, windowState, mergingWindows);
} else {
registerCleanupTimer(actualWindow);
}
}
} else {
for (W window : elementWindows) {
// check if the window is already inactive
if (isLate(window)) {
LOG.info("Dropped element " + element + " for window " + window + " due to lateness.");
continue;
}
ListState<StreamRecord<IN>> windowState =
getPartitionedState(window, windowSerializer, windowStateDescriptor);
windowState.add(element);
context.key = key;
context.window = window;
TriggerResult triggerResult = context.onElement(element);
fireOrContinue(triggerResult, window, windowState);
if (triggerResult.isPurge()) {
cleanup(window, windowState, null);
} else {
registerCleanupTimer(window);
}
}
}
}
@Override
public void processElement2(StreamRecord<IN2> element) throws Exception {
output.collect(element.replace(userFunction.map2(element.getValue())));
}
public TriggerResult onElement(StreamRecord<IN> element) throws Exception {
return trigger.onElement(element.getValue(), element.getTimestamp(), window, this);
}
