## Uses of Interface
com.hazelcast.jet.aggregate.AggregateOperation1

- Packages that use AggregateOperation1
  Package | Description
  --- | ---
  com.hazelcast.jet.aggregate | Contains `AggregateOperation` and several its variants, as well as a builder object for the aggregate operations.
  com.hazelcast.jet.core.processor | Contains static utility classes with factories of Jet processors.
  com.hazelcast.jet.pipeline | The Pipeline API is Jet's high-level API to build and execute distributed computation jobs.

- - ### Uses of AggregateOperation1 in com.hazelcast.jet.aggregate

    Methods in com.hazelcast.jet.aggregate that return AggregateOperation1
    Modifier and Type | Method and Description
    --- | ---
    `static <T,A0,A1,A2,R0,R1,R2> AggregateOperation1<T,Tuple3<A0,A1,A2>,Tuple3<R0,R1,R2>>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2)` Convenience for `AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction)` with identity finisher.
    `static <T,A0,A1,A2,R0,R1,R2,R> AggregateOperation1<T,Tuple3<A0,A1,A2>,R>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of three aggregate operations.
    `static <T,A0,A1,R0,R1,R> AggregateOperation1<T,Tuple2<A0,A1>,R>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, DistributedBiFunction<? super R0,? super R1,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of two aggregate operations.
    `static <T,A0,A1,R0,R1> AggregateOperation1<T,Tuple2<A0,A1>,Tuple2<R0,R1>>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,R0> op1, AggregateOperation1<? super T,A1,R1> op2)` Convenience for `AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, DistributedBiFunction)` with identity finish.
    `<R_NEW> AggregateOperation1<T0,A,R_NEW>` | AggregateOperationBuilder.Arity1.`andExportFinish(DistributedFunction<? super A,? extends R_NEW> exportFinishFn)` Registers the supplied function as both the `export` and `finish` primitive.
    `AggregateOperation1<T0,A,R>` | AggregateOperationBuilder.Arity1.`andFinish(DistributedFunction<? super A,? extends R> finishFn)` Registers the supplied function as the `finish` primitive.
    `<R_NEW> AggregateOperation1<T,A,R_NEW>` | AggregateOperation1.`andThen(DistributedFunction<? super R,? extends R_NEW> thenFn)`
    `static <T> AggregateOperation1<T,LongDoubleAccumulator,Double>` | AggregateOperations.`averagingDouble(DistributedToDoubleFunction<? super T> getDoubleValueFn)` Returns an aggregate operation that computes the arithmetic mean of the `double` values it obtains by applying `getDoubleValueFn` to each item.
    `static <T> AggregateOperation1<T,LongLongAccumulator,Double>` | AggregateOperations.`averagingLong(DistributedToLongFunction<? super T> getLongValueFn)` Returns an aggregate operation that computes the arithmetic mean of the `long` values it obtains by applying `getLongValueFn` to each item.
    `static <T> AggregateOperation1<T,PriorityQueue<T>,List<T>>` | AggregateOperations.`bottomN(int n, DistributedComparator<? super T> comparator)` Returns an aggregate operation that computes the bottom `n` items calculated according to the given `comparator`.
    `AggregateOperation1<T,Object[],ItemsByTag>` | AllOfAggregationBuilder.`build()` Builds and returns the composite `AggregateOperation1`.
    `<R> AggregateOperation1<T,Object[],R>` | AllOfAggregationBuilder.`build(DistributedFunction<ItemsByTag,R> exportFinishFn)` Builds and returns the composite `AggregateOperation1`.
    `static AggregateOperation1<CharSequence,StringBuilder,String>` | AggregateOperations.`concatenating()` Returns an aggregate operation that concatenates the input items into a string.
    `static AggregateOperation1<CharSequence,StringBuilder,String>` | AggregateOperations.`concatenating(CharSequence delimiter)` Returns an aggregate operation that concatenates the input items into a string with the given `delimiter`.
    `static AggregateOperation1<CharSequence,StringBuilder,String>` | AggregateOperations.`concatenating(CharSequence delimiter, CharSequence prefix, CharSequence suffix)` Returns an aggregate operation that concatenates the input items into a string with the given `delimiter`.
    `static <T> AggregateOperation1<T,LongAccumulator,Long>` | AggregateOperations.`counting()` Returns an aggregate operation that computes the number of items.
    `static <T,K> AggregateOperation1<T,Map<K,List<T>>,Map<K,List<T>>>` | AggregateOperations.`groupingBy(DistributedFunction<? super T,? extends K> keyFn)` Returns an `AggregateOperation1` that accumulates the items into a `HashMap` where the key is the result of applying `keyFn` and the value is a list of the items with that key.
    `static <T,K,A,R> AggregateOperation1<T,Map<K,A>,Map<K,R>>` | AggregateOperations.`groupingBy(DistributedFunction<? super T,? extends K> keyFn, AggregateOperation1<? super T,A,R> downstream)` Returns an `AggregateOperation1` that accumulates the items into a `HashMap` where the key is the result of applying `keyFn` and the value is the result of applying the downstream aggregate operation to the items with that key.
    `static <T,K,R,A,M extends Map<K,R>> AggregateOperation1<T,Map<K,A>,M>` | AggregateOperations.`groupingBy(DistributedFunction<? super T,? extends K> keyFn, DistributedSupplier<M> createMapFn, AggregateOperation1<? super T,A,R> downstream)` Returns an `AggregateOperation1` that accumulates the items into a `Map` (as obtained from `createMapFn`) where the key is the result of applying `keyFn` and the value is the result of applying the downstream aggregate operation to the items with that key.
    `static <T> AggregateOperation1<T,LinTrendAccumulator,Double>` | AggregateOperations.`linearTrend(DistributedToLongFunction<T> getXFn, DistributedToLongFunction<T> getYFn)` Returns an aggregate operation that computes a linear trend on the items.
    `static <T,U,A,R> AggregateOperation1<T,A,R>` | AggregateOperations.`mapping(DistributedFunction<? super T,? extends U> mapFn, AggregateOperation1<? super U,A,? extends R> downstream)` Adapts an aggregate operation accepting items of type `U` to one accepting items of type `T` by applying a mapping function to each item before accumulation.
    `static <T> AggregateOperation1<T,MutableReference<T>,T>` | AggregateOperations.`maxBy(DistributedComparator<? super T> comparator)` Returns an aggregate operation that computes the maximal item according to the given `comparator`.
    `static <T> AggregateOperation1<T,MutableReference<T>,T>` | AggregateOperations.`minBy(DistributedComparator<? super T> comparator)` Returns an aggregate operation that computes the minimal item according to the given `comparator`.
    `static <T> AggregateOperation1<T,MutableReference<T>,T>` | AggregateOperations.`pickAny()` Returns an aggregate operation whose result is an arbitrary item it observed, or `null` if it observed no items.
    `static <T,A> AggregateOperation1<T,MutableReference<A>,A>` | AggregateOperations.`reducing(A emptyAccValue, DistributedFunction<? super T,? extends A> toAccValueFn, DistributedBinaryOperator<A> combineAccValuesFn, DistributedBinaryOperator<A> deductAccValueFn)` A reducing operation maintains an accumulated value that starts out as `emptyAccValue` and is iteratively transformed by applying `combineAccValuesFn` to it and each stream item's accumulated value, as returned from `toAccValueFn`.
    `static <T> AggregateOperation1<T,ArrayList<T>,List<T>>` | AggregateOperations.`sorting(DistributedComparator<? super T> comparator)` Returns an aggregate operation that accumulates all input items into an `ArrayList` and sorts it with the given comparator.
    `static <T> AggregateOperation1<T,DoubleAccumulator,Double>` | AggregateOperations.`summingDouble(DistributedToDoubleFunction<? super T> getDoubleValueFn)` Returns an aggregate operation that computes the sum of the `double` values it obtains by applying `getDoubleValueFn` to each item.
    `static <T> AggregateOperation1<T,LongAccumulator,Long>` | AggregateOperations.`summingLong(DistributedToLongFunction<? super T> getLongValueFn)` Returns an aggregate operation that computes the sum of the `long` values it obtains by applying `getLongValueFn` to each item.
    `static <T,C extends Collection<T>> AggregateOperation1<T,C,C>` | AggregateOperations.`toCollection(DistributedSupplier<C> createCollectionFn)` Returns an aggregate operation that accumulates the items into a `Collection`.
    `static <T> AggregateOperation1<T,List<T>,List<T>>` | AggregateOperations.`toList()` Returns an aggregate operation that accumulates the items into an `ArrayList`.
    `static <T,K,U> AggregateOperation1<T,Map<K,U>,Map<K,U>>` | AggregateOperations.`toMap(DistributedFunction<? super T,? extends K> keyFn, DistributedFunction<? super T,? extends U> valueFn)` Returns an aggregate operation that accumulates the items into a `HashMap` whose keys and values are the result of applying the provided mapping functions.
    `static <T,K,U> AggregateOperation1<T,Map<K,U>,Map<K,U>>` | AggregateOperations.`toMap(DistributedFunction<? super T,? extends K> keyFn, DistributedFunction<? super T,? extends U> valueFn, DistributedBinaryOperator<U> mergeFn)` Returns an aggregate operation that accumulates the items into a `HashMap` whose keys and values are the result of applying the provided mapping functions.
    `static <T,K,U,M extends Map<K,U>> AggregateOperation1<T,M,M>` | AggregateOperations.`toMap(DistributedFunction<? super T,? extends K> keyFn, DistributedFunction<? super T,? extends U> valueFn, DistributedBinaryOperator<U> mergeFn, DistributedSupplier<M> createMapFn)` Returns an `AggregateOperation1` that accumulates elements into a `Map` whose keys and values are the result of applying the provided mapping functions to the input elements.
    `static <T> AggregateOperation1<T,PriorityQueue<T>,List<T>>` | AggregateOperations.`topN(int n, DistributedComparator<? super T> comparator)` Returns an aggregate operation that computes the top `n` items calculated according to the given `comparator`.
    `static <T> AggregateOperation1<T,Set<T>,Set<T>>` | AggregateOperations.`toSet()` Returns an aggregate operation that accumulates the items into a `HashSet`.
    `<NEW_T> AggregateOperation1<NEW_T,A,R>` | AggregateOperation1.`withAccumulateFn(DistributedBiConsumer<? super A,? super NEW_T> accumulateFn)` Returns a copy of this aggregate operation, but with the `accumulate` primitive replaced with the one supplied here.
    `default <T> AggregateOperation1<T,A,R>` | AggregateOperation.`withCombiningAccumulateFn(DistributedFunction<T,A> getAccFn)` Returns a copy of this aggregate operation, but with the `accumulate` primitive replaced with one that expects to find accumulator objects in the input items and combines them all into a single accumulator of the same type.
    `AggregateOperation1<T,A,A>` | AggregateOperation1.`withIdentityFinish()`

    Methods in com.hazelcast.jet.aggregate with parameters of type AggregateOperation1
    Modifier and Type | Method and Description
    --- | ---
    `<R> Tag<R>` | AllOfAggregationBuilder.`add(AggregateOperation1<? super T,?,R> operation)` Adds the supplied aggregate operation to the composite.
    `<T,R> Tag<R>` | CoAggregateOperationBuilder.`add(Tag<T> tag, AggregateOperation1<? super T,?,? extends R> operation)` Registers the given aggregate operation with the tag corresponding to an input to the co-aggregating operation being built.
    `static <T0,T1,A0,A1,R0,R1> AggregateOperation2<T0,T1,Tuple2<A0,A1>,Tuple2<R0,R1>>` | AggregateOperations.`aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1)` Convenience for `aggregateOperation2(aggrOp0, aggrOp1, finishFn)` that outputs a `Tuple2(result0, result1)`.
    `static <T0,T1,A0,A1,R0,R1> AggregateOperation2<T0,T1,Tuple2<A0,A1>,Tuple2<R0,R1>>` | AggregateOperations.`aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1)` Convenience for `aggregateOperation2(aggrOp0, aggrOp1, finishFn)` that outputs a `Tuple2(result0, result1)`.
    `static <T0,A0,R0,T1,A1,R1,R> AggregateOperation2<T0,T1,Tuple2<A0,A1>,R>` | AggregateOperations.`aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, DistributedBiFunction<? super R0,? super R1,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of two independent aggregate operations, each one accepting its own input.
    `static <T0,A0,R0,T1,A1,R1,R> AggregateOperation2<T0,T1,Tuple2<A0,A1>,R>` | AggregateOperations.`aggregateOperation2(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, DistributedBiFunction<? super R0,? super R1,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of two independent aggregate operations, each one accepting its own input.
    `static <T0,T1,T2,A0,A1,A2,R0,R1,R2> AggregateOperation3<T0,T1,T2,Tuple3<A0,A1,A2>,Tuple3<R0,R1,R2>>` | AggregateOperations.`aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, AggregateOperation1<? super T2,A2,? extends R2> op2)` Convenience for `aggregateOperation3(aggrOp0, aggrOp1, aggrOp2, finishFn)` that outputs a `Tuple3(result0, result1, result2)`.
    `static <T0,T1,T2,A0,A1,A2,R0,R1,R2> AggregateOperation3<T0,T1,T2,Tuple3<A0,A1,A2>,Tuple3<R0,R1,R2>>` | AggregateOperations.`aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, AggregateOperation1<? super T2,A2,? extends R2> op2)` Convenience for `aggregateOperation3(aggrOp0, aggrOp1, aggrOp2, finishFn)` that outputs a `Tuple3(result0, result1, result2)`.
    `static <T0,T1,T2,A0,A1,A2,R0,R1,R2> AggregateOperation3<T0,T1,T2,Tuple3<A0,A1,A2>,Tuple3<R0,R1,R2>>` | AggregateOperations.`aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, AggregateOperation1<? super T2,A2,? extends R2> op2)` Convenience for `aggregateOperation3(aggrOp0, aggrOp1, aggrOp2, finishFn)` that outputs a `Tuple3(result0, result1, result2)`.
    `static <T0,T1,T2,A0,A1,A2,R0,R1,R2,R> AggregateOperation3<T0,T1,T2,Tuple3<A0,A1,A2>,R>` | AggregateOperations.`aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, AggregateOperation1<? super T2,A2,? extends R2> op2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of three independent aggregate operations, each one accepting its own input.
    `static <T0,T1,T2,A0,A1,A2,R0,R1,R2,R> AggregateOperation3<T0,T1,T2,Tuple3<A0,A1,A2>,R>` | AggregateOperations.`aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, AggregateOperation1<? super T2,A2,? extends R2> op2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of three independent aggregate operations, each one accepting its own input.
    `static <T0,T1,T2,A0,A1,A2,R0,R1,R2,R> AggregateOperation3<T0,T1,T2,Tuple3<A0,A1,A2>,R>` | AggregateOperations.`aggregateOperation3(AggregateOperation1<? super T0,A0,? extends R0> op0, AggregateOperation1<? super T1,A1,? extends R1> op1, AggregateOperation1<? super T2,A2,? extends R2> op2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of three independent aggregate operations, each one accepting its own input.
    `static <T,A0,A1,A2,R0,R1,R2> AggregateOperation1<T,Tuple3<A0,A1,A2>,Tuple3<R0,R1,R2>>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2)` Convenience for `AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction)` with identity finisher.
    `static <T,A0,A1,A2,R0,R1,R2> AggregateOperation1<T,Tuple3<A0,A1,A2>,Tuple3<R0,R1,R2>>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2)` Convenience for `AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction)` with identity finisher.
    `static <T,A0,A1,A2,R0,R1,R2> AggregateOperation1<T,Tuple3<A0,A1,A2>,Tuple3<R0,R1,R2>>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2)` Convenience for `AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction)` with identity finisher.
    `static <T,A0,A1,A2,R0,R1,R2,R> AggregateOperation1<T,Tuple3<A0,A1,A2>,R>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of three aggregate operations.
    `static <T,A0,A1,A2,R0,R1,R2,R> AggregateOperation1<T,Tuple3<A0,A1,A2>,R>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of three aggregate operations.
    `static <T,A0,A1,A2,R0,R1,R2,R> AggregateOperation1<T,Tuple3<A0,A1,A2>,R>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, AggregateOperation1<? super T,A2,? extends R2> op2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of three aggregate operations.
    `static <T,A0,A1,R0,R1,R> AggregateOperation1<T,Tuple2<A0,A1>,R>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, DistributedBiFunction<? super R0,? super R1,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of two aggregate operations.
    `static <T,A0,A1,R0,R1,R> AggregateOperation1<T,Tuple2<A0,A1>,R>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,? extends R0> op0, AggregateOperation1<? super T,A1,? extends R1> op1, DistributedBiFunction<? super R0,? super R1,? extends R> exportFinishFn)` Returns an aggregate operation that is a composite of two aggregate operations.
    `static <T,A0,A1,R0,R1> AggregateOperation1<T,Tuple2<A0,A1>,Tuple2<R0,R1>>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,R0> op1, AggregateOperation1<? super T,A1,R1> op2)` Convenience for `AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, DistributedBiFunction)` with identity finish.
    `static <T,A0,A1,R0,R1> AggregateOperation1<T,Tuple2<A0,A1>,Tuple2<R0,R1>>` | AggregateOperations.`allOf(AggregateOperation1<? super T,A0,R0> op1, AggregateOperation1<? super T,A1,R1> op2)` Convenience for `AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, DistributedBiFunction)` with identity finish.
    `static <T,K,A,R> AggregateOperation1<T,Map<K,A>,Map<K,R>>` | AggregateOperations.`groupingBy(DistributedFunction<? super T,? extends K> keyFn, AggregateOperation1<? super T,A,R> downstream)` Returns an `AggregateOperation1` that accumulates the items into a `HashMap` where the key is the result of applying `keyFn` and the value is the result of applying the downstream aggregate operation to the items with that key.
    `static <T,K,R,A,M extends Map<K,R>> AggregateOperation1<T,Map<K,A>,M>` | AggregateOperations.`groupingBy(DistributedFunction<? super T,? extends K> keyFn, DistributedSupplier<M> createMapFn, AggregateOperation1<? super T,A,R> downstream)` Returns an `AggregateOperation1` that accumulates the items into a `Map` (as obtained from `createMapFn`) where the key is the result of applying `keyFn` and the value is the result of applying the downstream aggregate operation to the items with that key.
    `static <T,U,A,R> AggregateOperation1<T,A,R>` | AggregateOperations.`mapping(DistributedFunction<? super T,? extends U> mapFn, AggregateOperation1<? super U,A,? extends R> downstream)` Adapts an aggregate operation accepting items of type `U` to one accepting items of type `T` by applying a mapping function to each item before accumulation.

  - ### Uses of AggregateOperation1 in com.hazelcast.jet.core.processor

    Methods in com.hazelcast.jet.core.processor with parameters of type AggregateOperation1
    Modifier and Type | Method and Description
    --- | ---
    `static <T,K,A,R,OUT> DistributedSupplier<Processor>` | Processors.`rollingAggregateP(DistributedFunction<? super T,? extends K> keyFn, AggregateOperation1<? super T,A,? extends R> aggrOp, DistributedTriFunction<? super T,? super K,? super R,? extends OUT> mapToOutputFn)` Returns a supplier of processors for a vertex that performs a rolling aggregation.

  - ### Uses of AggregateOperation1 in com.hazelcast.jet.pipeline

    Methods in com.hazelcast.jet.pipeline with parameters of type AggregateOperation1
    Modifier and Type | Method and Description
    --- | ---
    `<T,R> Tag<R>` | AggregateBuilder.`add(BatchStage<T> stage, AggregateOperation1<? super T,?,? extends R> aggrOp)` Adds another stage that will contribute its data to the aggregate operation to be performed.
    `<T,R> Tag<R>` | GroupAggregateBuilder.`add(BatchStageWithKey<T,K> stage, AggregateOperation1<? super T,?,? extends R> aggrOp)` Adds another stage that will contribute its data to the aggregate operation to be performed.
    `<T,R> Tag<R>` | WindowAggregateBuilder.`add(StreamStage<T> stage, AggregateOperation1<? super T,?,? extends R> aggrOp)` Adds another stage that will contribute its data to the aggregate operation to be performed.
    `<T,R> Tag<R>` | WindowGroupAggregateBuilder.`add(StreamStageWithKey<T,K> stage, AggregateOperation1<? super T,?,? extends R> aggrOp)` Adds another stage that will contribute its data to the windowed group-and-aggregate stage being constructed.
    `default <R> BatchStage<Map.Entry<K,R>>` | BatchStageWithKey.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` Attaches a stage that performs the given group-and-aggregate operation.
    `<R> BatchStage<R>` | BatchStage.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items it receives.
    `<R,OUT> BatchStage<OUT>` | BatchStageWithKey.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp, DistributedBiFunction<? super K,? super R,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given group-and-aggregate operation.
    `<R,OUT> StreamStage<OUT>` | StageWithKeyAndWindow.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp, KeyedWindowResultFunction<? super K,? super R,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given group-and-aggregate operation over the window described by the window definition captured by this object.
    `<R,OUT> StreamStage<OUT>` | StageWithWindow.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp, WindowResultFunction<? super R,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given aggregate operation over all the items that belong to a given window.
    `default <R> StreamStage<TimestampedItem<R>>` | StageWithWindow.`aggregate(AggregateOperation1<? super T,?,R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items that belong to a given window.
    `default <R> StreamStage<TimestampedEntry<K,R>>` | StageWithKeyAndWindow.`aggregate(AggregateOperation1<? super T,?,R> aggrOp)` Attaches a stage that performs the given group-and-aggregate operation.
    `default <T1,R0,R1> BatchStage<Tuple2<R0,R1>>` | BatchStage.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that co-aggregates the data from this and the supplied stage by performing a separate aggregate operation on each and emitting a `Tuple2` with their results.
    `default <T1,R0,R1> BatchStage<Tuple2<R0,R1>>` | BatchStage.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that co-aggregates the data from this and the supplied stage by performing a separate aggregate operation on each and emitting a `Tuple2` with their results.
    `default <T1,R0,R1,OUT> BatchStage<OUT>` | BatchStage.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, DistributedBiFunction<? super R0,? super R1,? extends OUT> mapToOutputFn)` Attaches a stage that co-aggregates the data from this and the supplied stage by performing a separate aggregate operation on each and then passing both results to `mapToOutputFn`, which transforms them into the final output.
    `default <T1,R0,R1,OUT> BatchStage<OUT>` | BatchStage.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, DistributedBiFunction<? super R0,? super R1,? extends OUT> mapToOutputFn)` Attaches a stage that co-aggregates the data from this and the supplied stage by performing a separate aggregate operation on each and then passing both results to `mapToOutputFn`, which transforms them into the final output.
    `default <T1,R0,R1> BatchStage<Map.Entry<K,Tuple2<R0,R1>>>` | BatchStageWithKey.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<? extends T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1> BatchStage<Map.Entry<K,Tuple2<R0,R1>>>` | BatchStageWithKey.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<? extends T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1> StreamStage<TimestampedItem<Tuple2<R0,R1>>>` | StageWithWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that performs the given co-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1> StreamStage<TimestampedItem<Tuple2<R0,R1>>>` | StageWithWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that performs the given co-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1,OUT> StreamStage<OUT>` | StageWithWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, WindowResult2Function<? super R0,? super R1,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given co-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1,OUT> StreamStage<OUT>` | StageWithWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, WindowResult2Function<? super R0,? super R1,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given co-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1> StreamStage<TimestampedEntry<K,Tuple2<R0,R1>>>` | StageWithKeyAndWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1> StreamStage<TimestampedEntry<K,Tuple2<R0,R1>>>` | StageWithKeyAndWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1,OUT> StreamStage<OUT>` | StageWithKeyAndWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, KeyedWindowResult2Function<? super K,? super R0,? super R1,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1,OUT> StreamStage<OUT>` | StageWithKeyAndWindow.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, KeyedWindowResult2Function<? super K,? super R0,? super R1,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1,OUT> BatchStage<OUT>` | BatchStageWithKey.`aggregate2(AggregateOperation1<? super T,?,R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,R1> aggrOp1, DistributedTriFunction<? super K,? super R0,? super R1,OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from both this stage and `stage1` you supply.
    `default <T1,R0,R1,OUT> BatchStage<OUT>` | BatchStageWithKey.`aggregate2(AggregateOperation1<? super T,?,R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,R1> aggrOp1, DistributedTriFunction<? super K,? super R0,? super R1,OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2> BatchStage<Tuple3<R0,R1,R2>>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and emitting a `Tuple3` with their results.
    `default <T1,T2,R0,R1,R2> BatchStage<Tuple3<R0,R1,R2>>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and emitting a `Tuple3` with their results.
    `default <T1,T2,R0,R1,R2> BatchStage<Tuple3<R0,R1,R2>>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and emitting a `Tuple3` with their results.
    `default <T1,T2,R0,R1,R2,OUT> BatchStage<OUT>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and then passing all three results to `mapToOutputFn`, which transforms them into the final output.
    `default <T1,T2,R0,R1,R2,OUT> BatchStage<OUT>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and then passing all three results to `mapToOutputFn`, which transforms them into the final output.
    `default <T1,T2,R0,R1,R2,OUT> BatchStage<OUT>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, DistributedTriFunction<? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and then passing all three results to `mapToOutputFn`, which transforms them into the final output.
    `default <T1,T2,R0,R1,R2> BatchStage<Map.Entry<K,Tuple3<R0,R1,R2>>>` | BatchStageWithKey.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from this stage as well as `stage1` and `stage2` you supply.
    `default <T1,T2,R0,R1,R2> BatchStage<Map.Entry<K,Tuple3<R0,R1,R2>>>` | BatchStageWithKey.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from this stage as well as `stage1` and `stage2` you supply.
    `default <T1,T2,R0,R1,R2> BatchStage<Map.Entry<K,Tuple3<R0,R1,R2>>>` | BatchStageWithKey.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from this stage as well as `stage1` and `stage2` you supply.
    `default <T1,T2,R0,R1,R2,OUT> BatchStage<OUT>` | BatchStageWithKey.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, DistributedQuadFunction<? super K,? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from this stage as well as `stage1` and `stage2` you supply.
    `default <T1,T2,R0,R1,R2,OUT> BatchStage<OUT>` | BatchStageWithKey.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, DistributedQuadFunction<? super K,? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from this stage as well as `stage1` and `stage2` you supply.
    `default <T1,T2,R0,R1,R2,OUT> BatchStage<OUT>` | BatchStageWithKey.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, DistributedQuadFunction<? super K,? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from this stage as well as `stage1` and `stage2` you supply.
    `default <T1,T2,R0,R1,R2> StreamStage<TimestampedItem<Tuple3<R0,R1,R2>>>` | StageWithWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given aggregate operation over all the items that belong to the same window.
    `default <T1,T2,R0,R1,R2> StreamStage<TimestampedItem<Tuple3<R0,R1,R2>>>` | StageWithWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given aggregate operation over all the items that belong to the same window.
    `default <T1,T2,R0,R1,R2> StreamStage<TimestampedItem<Tuple3<R0,R1,R2>>>` | StageWithWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given aggregate operation over all the items that belong to the same window.
    `default <T1,T2,R0,R1,R2,OUT> StreamStage<OUT>` | StageWithWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, WindowResult3Function<? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given aggregate operation over all the items that belong to the same window.
    `default <T1,T2,R0,R1,R2,OUT> StreamStage<OUT>` | StageWithWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, WindowResult3Function<? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given aggregate operation over all the items that belong to the same window.
    `default <T1,T2,R0,R1,R2,OUT> StreamStage<OUT>` | StageWithWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, WindowResult3Function<? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given aggregate operation over all the items that belong to the same window.
    `default <T1,T2,R0,R1,R2> StreamStage<TimestampedEntry<K,Tuple3<R0,R1,R2>>>` | StageWithKeyAndWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2> StreamStage<TimestampedEntry<K,Tuple3<R0,R1,R2>>>` | StageWithKeyAndWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2> StreamStage<TimestampedEntry<K,Tuple3<R0,R1,R2>>>` | StageWithKeyAndWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2,OUT> StreamStage<OUT>` | StageWithKeyAndWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, KeyedWindowResult3Function<? super K,? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2,OUT> StreamStage<OUT>` | StageWithKeyAndWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, KeyedWindowResult3Function<? super K,? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2,OUT> StreamStage<OUT>` | StageWithKeyAndWindow.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, StreamStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, StreamStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2, KeyedWindowResult3Function<? super K,? super R0,? super R1,? super R2,? extends OUT> mapToOutputFn)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <R0> WindowAggregateBuilder<R0>` | StageWithWindow.`aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp)` Offers a step-by-step API to build a pipeline stage that co-aggregates the data from several input stages.
    `default <R0> WindowGroupAggregateBuilder<K,R0>` | StageWithKeyAndWindow.`aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp0)` Offers a step-by-step API to build a pipeline stage that co-aggregates the data from several input stages.
    `default <R0> GroupAggregateBuilder<K,R0>` | BatchStageWithKey.`aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp0)` Offers a step-by-step API to build a pipeline stage that co-aggregates the data from several input stages.
    `default <R0> AggregateBuilder<R0>` | BatchStage.`aggregateBuilder(AggregateOperation1<? super T,?,? extends R0> aggrOp0)` Offers a step-by-step API to build a pipeline stage that co-aggregates the data from several input stages.
    `default <R> StreamStage<Map.Entry<K,R>>` | StreamStageWithKey.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)`
    `<R> StreamStage<R>` | StreamStage.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)`
    `default <R> GeneralStage<Map.Entry<K,R>>` | GeneralStageWithKey.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` A shortcut for: `aggregateRolling(aggrOp, Util::entry)`.
    `<R> GeneralStage<R>` | GeneralStage.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` Attaches a rolling aggregation stage.
    `default <R> BatchStage<Map.Entry<K,R>>` | BatchStageWithKey.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)`
    `<R> BatchStage<R>` | BatchStage.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)`
    `<R,OUT> StreamStage<OUT>` | StreamStageWithKey.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp, DistributedBiFunction<? super K,? super R,? extends OUT> mapToOutputFn)`
    `<R,OUT> GeneralStage<OUT>` | GeneralStageWithKey.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp, DistributedBiFunction<? super K,? super R,? extends OUT> mapToOutputFn)` Attaches a rolling aggregation stage.
    `<R,OUT> BatchStage<OUT>` | BatchStageWithKey.`rollingAggregate(AggregateOperation1<? super T,?,? extends R> aggrOp, DistributedBiFunction<? super K,? super R,? extends OUT> mapToOutputFn)`

Copyright © 2018. All rights reserved.