com.google.cloud.dataflow.sdk.transforms

## Class Combine.BinaryCombineIntegerFn

- java.lang.Object
- - com.google.cloud.dataflow.sdk.transforms.Combine.CombineFn<Integer,int[],Integer>
  - - com.google.cloud.dataflow.sdk.transforms.Combine.BinaryCombineIntegerFn

All Implemented Interfaces:
  CombineFnBase.GlobalCombineFn<Integer,int[],Integer>, HasDisplayData, Serializable

Direct Known Subclasses:
  Sum.SumIntegerFn

Enclosing class:
  Combine

    public abstract static class Combine.BinaryCombineIntegerFn
    extends Combine.CombineFn<Integer,int[],Integer>

An abstract subclass of `Combine.CombineFn` for implementing combiners that are more easily and efficiently expressed as binary operations on `int`s

It uses `int[0]` as the mutable accumulator.

See Also:
  Serialized Form

### Constructor Summary

Constructors
Constructor and Description
`BinaryCombineIntegerFn()`

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`int[]` `addInput(int[] accumulator, Integer input)` Adds the given input value to the given accumulator, returning the new accumulator value.
`abstract int` `apply(int left, int right)` Applies the binary operation to the two operands, returning the result.
`int[]` `createAccumulator()` Returns a new, mutable accumulator value, representing the accumulation of zero input values.
`Integer` `extractOutput(int[] 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<int[]>` `getAccumulatorCoder(CoderRegistry registry, Coder<Integer> inputCoder)` Returns the `Coder` to use for accumulator `AccumT` values, or null if it is not able to be inferred.
`com.google.cloud.dataflow.sdk.util.common.Counter<Integer>` `getCounter(String name)`
`Coder<Integer>` `getDefaultOutputCoder(CoderRegistry registry, Coder<Integer> 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`.
`abstract int` `identity()` Returns the identity element of this operation, i.e.
`int[]` `mergeAccumulators(Iterable<int[]> 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, defaultValue, getOutputType`

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

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

### Constructor Detail

#### BinaryCombineIntegerFn

    public BinaryCombineIntegerFn()

### Method Detail

#### apply

    public abstract int apply(int left,
                              int right)

Applies the binary operation to the two operands, returning the result.

#### identity

    public abstract int identity()

Returns the identity element of this operation, i.e. an element `e` such that `apply(e, x) == apply(x, e) == x` for all values of `x`.

#### createAccumulator

    public int[] createAccumulator()

Description copied from class: `Combine.CombineFn`
Returns a new, mutable accumulator value, representing the accumulation of zero input values.

Specified by:
  `createAccumulator` in class `Combine.CombineFn<Integer,int[],Integer>`

#### addInput

    public int[] addInput(int[] accumulator,
                          Integer 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<Integer,int[],Integer>`

#### mergeAccumulators

    public int[] mergeAccumulators(Iterable<int[]> 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<Integer,int[],Integer>`

#### extractOutput

    public Integer extractOutput(int[] 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<Integer,int[],Integer>`

#### getAccumulatorCoder

    public Coder<int[]> getAccumulatorCoder(CoderRegistry registry,
                                            Coder<Integer> inputCoder)

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<Integer,int[],Integer>`

#### getDefaultOutputCoder

    public Coder<Integer> getDefaultOutputCoder(CoderRegistry registry,
                                                Coder<Integer> inputCoder)

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<Integer,int[],Integer>`

#### getCounter

    public com.google.cloud.dataflow.sdk.util.common.Counter<Integer> getCounter(String name)

#### 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`