How to use

Combine$CombineFn

in

org.apache.beam.sdk.transforms

@Override
public Coder<Object[]> getAccumulatorCoder(CoderRegistry registry, Coder<DataT> dataCoder)
  throws CannotProvideCoderException {
 List<Coder<Object>> coders = Lists.newArrayList();
 for (int i = 0; i < combineFnCount; ++i) {
  Coder<Object> inputCoder =
    combineInputCoders.get(i).isPresent()
      ? combineInputCoders.get(i).get()
      : registry.getOutputCoder(extractInputFns.get(i), dataCoder);
  coders.add(combineFns.get(i).getAccumulatorCoder(registry, inputCoder));
 }
 return new ComposedAccumulatorCoder(coders);
}

@ProcessElement
public void processElement(ProcessContext context, BoundedWindow window) {
 WindowedStructuralKey<K> key =
   WindowedStructuralKey.create(keyCoder, context.element().getKey(), window);
 AccumT accumulator = accumulators.get(key);
 Instant assignedTs = timestampCombiner.assign(window, context.timestamp());
 if (accumulator == null) {
  accumulator = combineFn.createAccumulator();
  accumulators.put(key, accumulator);
  timestamps.put(key, assignedTs);
 }
 accumulators.put(key, combineFn.addInput(accumulator, context.element().getValue()));
 timestamps.put(key, timestampCombiner.combine(assignedTs, timestamps.get(key)));
}

private static <InputT, AccumT, OutputT> void checkCombineFnShardsIncrementalMerging(
  CombineFn<InputT, AccumT, OutputT> fn,
  List<? extends Iterable<InputT>> shards,
  Matcher<? super OutputT> matcher) {
 AccumT accumulator = shards.isEmpty() ? fn.createAccumulator() : null;
 for (AccumT inputAccum : combineInputs(fn, shards)) {
  if (accumulator == null) {
   accumulator = inputAccum;
  } else {
   accumulator = fn.mergeAccumulators(Arrays.asList(accumulator, inputAccum));
  }
  fn.extractOutput(accumulator); // Extract output to simulate multiple firings
 }
 assertThat(fn.extractOutput(accumulator), matcher);
}

@Override
public AccumT addInput(AccumT accumulator, InputOrAccum<InputT, AccumT> value) {
 if (value.accum == null) {
  return fn.addInput(accumulator, value.input);
 } else {
  return fn.mergeAccumulators(ImmutableList.of(accumulator, value.accum));
 }
}

@Override
public AccumT createAccumulator(Context c) {
 return combineFn.createAccumulator();
}

@Override
public AccumT mergeAccumulators(Iterable<AccumT> accumulators) {
 return fn.mergeAccumulators(accumulators);
}

@Override
public AccumT compact(AccumT accumulator) {
 return fn.compact(accumulator);
}

@Override
public AccumT mergeAccumulators(Iterable<AccumT> accumulators) {
 return fn.mergeAccumulators(accumulators);
}

@Override
public AccumT addInput(AccumT accumulator, InputT input, Context c) {
 return combineFn.addInput(accumulator, input);
}

@Override
public AccumT compact(AccumT accumulator) {
 return fn.compact(accumulator);
}

@Override
public AccumT createAccumulator() {
 return fn.createAccumulator();
}

@Override
public AccumT mergeAccumulators(Iterable<AccumT> accumulators) {
 return combineFn.mergeAccumulators(accumulators);
}

@Override
public AccumT mergeAccumulators(Iterable<AccumT> accumulators) {
 return combineFn.mergeAccumulators(accumulators);
}

@Override
public AccumT addInput(AccumT accumulator, InputT value) {
 return fn.addInput(accumulator, value);
}

@Override
public Object extractOutput(Object accumulator) {
 return combineFn.extractOutput(accumulator);
}

@Override
public OutputT extractOutput(AccumT accumulator, Context c) {
 return combineFn.extractOutput(accumulator);
}

@Override
public AccumT mergeAccumulators(Iterable<AccumT> accumulators) {
 return combineFn.mergeAccumulators(accumulators);
}

@Override
public OutputT extractOutput(AccumT accumulator) {
 return fn.extractOutput(accumulator);
}

@Override
public Object mergeAccumulators(Iterable<Object> accumulators) {
 return combineFn.mergeAccumulators(accumulators);
}

@Override
public AccumT compact(AccumT accumulator, Context c) {
 return combineFn.compact(accumulator);
}