com.google.cloud.dataflow.sdk.transforms

## Class Combine.AccumulatingCombineFn<InputT,AccumT extends Combine.AccumulatingCombineFn.Accumulator<InputT,AccumT,OutputT>,OutputT>

- java.lang.Object
- - com.google.cloud.dataflow.sdk.transforms.Combine.CombineFn<InputT,AccumT,OutputT>
  - - com.google.cloud.dataflow.sdk.transforms.Combine.AccumulatingCombineFn<InputT,AccumT,OutputT>

Type Parameters:
  `InputT` - type of input values
  `AccumT` - type of mutable accumulator values
  `OutputT` - type of output values

All Implemented Interfaces:
  CombineFnBase.GlobalCombineFn<InputT,AccumT,OutputT>, HasDisplayData, Serializable

Direct Known Subclasses:
  ApproximateQuantiles.ApproximateQuantilesCombineFn, Top.TopCombineFn

Enclosing class:
  Combine

    public abstract static class Combine.AccumulatingCombineFn<InputT,AccumT extends Combine.AccumulatingCombineFn.Accumulator<InputT,AccumT,OutputT>,OutputT>
    extends Combine.CombineFn<InputT,AccumT,OutputT>

A `CombineFn` that uses a subclass of `Combine.AccumulatingCombineFn.Accumulator` as its accumulator type. By defining the operations of the `Accumulator` helper class, the operations of the enclosing `CombineFn` are automatically provided. This can reduce the code required to implement a `CombineFn`.

For example, the example from `Combine.CombineFn` above can be expressed using `AccumulatingCombineFn` more concisely as follows:

     public class AverageFn
         extends AccumulatingCombineFn<Integer, AverageFn.Accum, Double> {
       public Accum createAccumulator() {
         return new Accum();
       }
       public class Accum
           extends AccumulatingCombineFn<Integer, AverageFn.Accum, Double>
                   .Accumulator {
         private int sum = 0;
         private int count = 0;
         public void addInput(Integer input) {
           sum += input;
           count++;
         }
         public void mergeAccumulator(Accum other) {
           sum += other.sum;
           count += other.count;
         }
         public Double extractOutput() {
           return ((double) sum) / count;
         }
       }
     }
     PCollection<Integer> pc = ...;
     PCollection<Double> average = pc.apply(Combine.globally(new AverageFn()));

See Also:
  Serialized Form

### Nested Class Summary

Nested Classes
`static interface` `Combine.AccumulatingCombineFn.Accumulator<InputT,AccumT,OutputT>` The type of mutable accumulator values used by this `AccumulatingCombineFn`.

### Constructor Summary

Constructors
Constructor and Description
`AccumulatingCombineFn()`

### Method Summary

All Methods Instance Methods Concrete Methods
`AccumT` `addInput(AccumT accumulator, InputT input)` Adds the given input value to the given accumulator, returning the new accumulator value.
`OutputT` `extractOutput(AccumT accumulator)` Returns the output value that is the result of combining all the input values represented by the given accumulator.
`TypeVariable<?>` `getAccumTVariable()` Returns the `TypeVariable` of `AccumT`.
`Coder<AccumT>` `getAccumulatorCoder(CoderRegistry registry, Coder<InputT> inputCoder)` Returns the `Coder` to use for accumulator `AccumT` values, or null if it is not able to be inferred.
`Coder<OutputT>` `getDefaultOutputCoder(CoderRegistry registry, Coder<InputT> inputCoder)` Returns the `Coder` to use by default for output `OutputT` values, or null if it is not able to be inferred.
`String` `getIncompatibleGlobalWindowErrorMessage()` Returns the error message for not supported default values in Combine.globally().
`TypeVariable<?>` `getInputTVariable()` Returns the `TypeVariable` of `InputT`.
`TypeVariable<?>` `getOutputTVariable()` Returns the `TypeVariable` of `OutputT`.
`AccumT` `mergeAccumulators(Iterable<AccumT> accumulators)` Returns an accumulator representing the accumulation of all the input values accumulated in the merging accumulators.
`void` `populateDisplayData(DisplayData.Builder builder)` Register display data for the given transform or component.

### Methods inherited from class com.google.cloud.dataflow.sdk.transforms.Combine.CombineFn

`apply, asKeyedFn, compact, createAccumulator, defaultValue, getOutputType`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### AccumulatingCombineFn

    public AccumulatingCombineFn()

### Method Detail

#### addInput

    public final AccumT addInput(AccumT accumulator,
                                 InputT input)

Description copied from class: `Combine.CombineFn`
Adds the given input value to the given accumulator, returning the new accumulator value.

For efficiency, the input accumulator may be modified and returned.

Specified by:
  `addInput` in class `Combine.CombineFn<InputT,AccumT extends Combine.AccumulatingCombineFn.Accumulator<InputT,AccumT,OutputT>,OutputT>`

#### mergeAccumulators

    public final AccumT mergeAccumulators(Iterable<AccumT> accumulators)

Description copied from class: `Combine.CombineFn`
Returns an accumulator representing the accumulation of all the input values accumulated in the merging accumulators.

May modify any of the argument accumulators. May return a fresh accumulator, or may return one of the (modified) argument accumulators.

Specified by:
  `mergeAccumulators` in class `Combine.CombineFn<InputT,AccumT extends Combine.AccumulatingCombineFn.Accumulator<InputT,AccumT,OutputT>,OutputT>`

#### extractOutput

    public final OutputT extractOutput(AccumT accumulator)

Description copied from class: `Combine.CombineFn`
Returns the output value that is the result of combining all the input values represented by the given accumulator.

Specified by:
  `extractOutput` in class `Combine.CombineFn<InputT,AccumT extends Combine.AccumulatingCombineFn.Accumulator<InputT,AccumT,OutputT>,OutputT>`

#### getAccumulatorCoder

    public Coder<AccumT> getAccumulatorCoder(CoderRegistry registry,
                                             Coder<InputT> inputCoder)
                                      throws CannotProvideCoderException

Description copied from interface: `CombineFnBase.GlobalCombineFn`
Returns the `Coder` to use for accumulator `AccumT` values, or null if it is not able to be inferred.

By default, uses the knowledge of the `Coder` being used for `InputT` values and the enclosing `Pipeline`'s `CoderRegistry` to try to infer the Coder for `AccumT` values.

This is the Coder used to send data through a communication-intensive shuffle step, so a compact and efficient representation may have significant performance benefits.

Specified by:
  `getAccumulatorCoder` in interface `CombineFnBase.GlobalCombineFn<InputT,AccumT,OutputT>`
Throws:
  `CannotProvideCoderException`

#### getDefaultOutputCoder

    public Coder<OutputT> getDefaultOutputCoder(CoderRegistry registry,
                                                Coder<InputT> inputCoder)
                                         throws CannotProvideCoderException

Description copied from interface: `CombineFnBase.GlobalCombineFn`
Returns the `Coder` to use by default for output `OutputT` values, or null if it is not able to be inferred.

By default, uses the knowledge of the `Coder` being used for input `InputT` values and the enclosing `Pipeline`'s `CoderRegistry` to try to infer the Coder for `OutputT` values.

Specified by:
  `getDefaultOutputCoder` in interface `CombineFnBase.GlobalCombineFn<InputT,AccumT,OutputT>`
Throws:
  `CannotProvideCoderException`

#### getIncompatibleGlobalWindowErrorMessage

    public String getIncompatibleGlobalWindowErrorMessage()

Description copied from interface: `CombineFnBase.GlobalCombineFn`
Returns the error message for not supported default values in Combine.globally().

Specified by:
  `getIncompatibleGlobalWindowErrorMessage` in interface `CombineFnBase.GlobalCombineFn<InputT,AccumT,OutputT>`

#### getInputTVariable

    public TypeVariable<?> getInputTVariable()

Returns the `TypeVariable` of `InputT`.

#### getAccumTVariable

    public TypeVariable<?> getAccumTVariable()

Returns the `TypeVariable` of `AccumT`.

#### getOutputTVariable

    public TypeVariable<?> getOutputTVariable()

Returns the `TypeVariable` of `OutputT`.

#### populateDisplayData

    public void populateDisplayData(DisplayData.Builder builder)

Register display data for the given transform or component.

`populateDisplayData(DisplayData.Builder)` is invoked by Pipeline runners to collect display data via `DisplayData.from(HasDisplayData)`. Implementations may call `super.populateDisplayData(builder)` in order to register display data in the current namespace, but should otherwise use `subcomponent.populateDisplayData(builder)` to use the namespace of the subcomponent.

By default, does not register any display data. Implementors may override this method to provide their own display data.

Specified by:
  `populateDisplayData` in interface `HasDisplayData`
Parameters:
  `builder` - The builder to populate with display data.
See Also:
  `HasDisplayData`