## 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.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, TriFunction)` wrapping the three results in a `Tuple3`.
    `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, TriFunction<? 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, BiFunctionEx<? 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, BiFunctionEx)` wrapping the two results in a `Tuple2`.
    `<R_NEW> AggregateOperation1<T0,A,R_NEW>` | AggregateOperationBuilder.Arity1.`andExportFinish(FunctionEx<? super A,? extends R_NEW> exportFinishFn)` Registers the supplied function as both the `export` and `finish` primitive.
    `AggregateOperation1<T0,A,R>` | AggregateOperationBuilder.Arity1.`andFinish(FunctionEx<? super A,? extends R> finishFn)` Registers the supplied function as the `finish` primitive.
    `<R_NEW> AggregateOperation1<T,A,R_NEW>` | AggregateOperation1.`andThen(FunctionEx<? super R,? extends R_NEW> thenFn)`
    `static <T> AggregateOperation1<T,LongDoubleAccumulator,Double>` | AggregateOperations.`averagingDouble(ToDoubleFunctionEx<? super T> getDoubleValueFn)` Returns an aggregate operation that finds the arithmetic mean (aka.
    `static <T> AggregateOperation1<T,LongLongAccumulator,Double>` | AggregateOperations.`averagingLong(ToLongFunctionEx<? super T> getLongValueFn)` Returns an aggregate operation that finds the arithmetic mean (aka.
    `static <T> AggregateOperation1<T,PriorityQueue<T>,List<T>>` | AggregateOperations.`bottomN(int n, ComparatorEx<? super T> comparator)` Returns an aggregate operation that finds the bottom `n` items according to the given `comparator`.
    `AggregateOperation1<T,Object[],ItemsByTag>` | AllOfAggregationBuilder.`build()` Builds and returns the composite `AggregateOperation1`.
    `<R> AggregateOperation1<T,Object[],R>` | AllOfAggregationBuilder.`build(FunctionEx<ItemsByTag,R> exportFinishFn)` Builds and returns the composite `AggregateOperation1`.
    `static AggregateOperation1<CharSequence,StringBuilder,String>` | AggregateOperations.`concatenating()` Returns an aggregate operation that takes string items and concatenates them into a single string.
    `static AggregateOperation1<CharSequence,StringBuilder,String>` | AggregateOperations.`concatenating(CharSequence delimiter)` Returns an aggregate operation that takes string items and concatenates them, separated by the given `delimiter`, into a single string.
    `static AggregateOperation1<CharSequence,StringBuilder,String>` | AggregateOperations.`concatenating(CharSequence delimiter, CharSequence prefix, CharSequence suffix)` Returns an aggregate operation that takes string items and concatenates them, separated by the given `delimiter`, into a single string.
    `static <T> AggregateOperation1<T,LongAccumulator,Long>` | AggregateOperations.`counting()` Returns an aggregate operation that counts the items it observes.
    `static <T,A,R> AggregateOperation1<T,A,R>` | AggregateOperations.`filtering(PredicateEx<? super T> filterFn, AggregateOperation1<? super T,A,? extends R> downstream)` Adapts an aggregate operation so that it accumulates only the items passing the `filterFn` and ignores others.
    `static <T,U,A,R> AggregateOperation1<T,A,R>` | AggregateOperations.`flatMapping(FunctionEx<? super T,? extends Traverser<? extends U>> flatMapFn, AggregateOperation1<? super U,A,? extends R> downstream)` Adapts an aggregate operation that takes items of type `U` to one that takes items of type `T`, by exploding each `T` into a sequence of `U`s and then accumulating all of them.
    `static <T,K> AggregateOperation1<T,Map<K,List<T>>,Map<K,List<T>>>` | AggregateOperations.`groupingBy(FunctionEx<? super T,? extends K> keyFn)` Returns an aggregate operation 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(FunctionEx<? super T,? extends K> keyFn, AggregateOperation1<? super T,A,R> downstream)` Returns an aggregate operation 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(FunctionEx<? super T,? extends K> keyFn, SupplierEx<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(ToLongFunctionEx<T> getXFn, ToLongFunctionEx<T> getYFn)` Returns an aggregate operation that computes a linear trend over the items.
    `static <T,U,A,R> AggregateOperation1<T,A,R>` | AggregateOperations.`mapping(FunctionEx<? super T,? extends U> mapFn, AggregateOperation1<? super U,A,? extends R> downstream)` Adapts an aggregate operation that takes items of type `U` to one that takes items of type `T`, by applying the given mapping function to each item.
    `static <T> AggregateOperation1<T,MutableReference<T>,T>` | AggregateOperations.`maxBy(ComparatorEx<? super T> comparator)` Returns an aggregate operation that computes the greatest item according to the given `comparator`.
    `static <T> AggregateOperation1<T,MutableReference<T>,T>` | AggregateOperations.`minBy(ComparatorEx<? super T> comparator)` Returns an aggregate operation that computes the least 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, FunctionEx<? super T,? extends A> toAccValueFn, BinaryOperatorEx<A> combineAccValuesFn, BinaryOperatorEx<A> deductAccValueFn)` Returns an aggregate operation that constructs the result through the process of immutable reduction: The initial accumulated value is `emptyAccValue`.
    `static <T> AggregateOperation1<T,ArrayList<T>,List<T>>` | AggregateOperations.`sorting(ComparatorEx<? 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(ToDoubleFunctionEx<? 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(ToLongFunctionEx<? 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(SupplierEx<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(FunctionEx<? super T,? extends K> keyFn, FunctionEx<? 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(FunctionEx<? super T,? extends K> keyFn, FunctionEx<? super T,? extends U> valueFn, BinaryOperatorEx<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(FunctionEx<? super T,? extends K> keyFn, FunctionEx<? super T,? extends U> valueFn, BinaryOperatorEx<U> mergeFn, SupplierEx<M> createMapFn)` Returns an aggregate operation that accumulates elements into a user-supplied `Map` instance.
    `static <T> AggregateOperation1<T,PriorityQueue<T>,List<T>>` | AggregateOperations.`topN(int n, ComparatorEx<? super T> comparator)` Returns an aggregate operation that finds the top `n` items 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(BiConsumerEx<? 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(FunctionEx<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, BiFunctionEx<? 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, BiFunctionEx<? 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, TriFunction<? 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, TriFunction<? 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, TriFunction<? 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, TriFunction)` wrapping the three results in a `Tuple3`.
    `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, TriFunction)` wrapping the three results in a `Tuple3`.
    `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, TriFunction)` wrapping the three results in a `Tuple3`.
    `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, TriFunction<? 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, TriFunction<? 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, TriFunction<? 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, BiFunctionEx<? 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, BiFunctionEx<? 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, BiFunctionEx)` wrapping the two results in a `Tuple2`.
    `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, BiFunctionEx)` wrapping the two results in a `Tuple2`.
    `static <T,A,R> AggregateOperation1<T,A,R>` | AggregateOperations.`filtering(PredicateEx<? super T> filterFn, AggregateOperation1<? super T,A,? extends R> downstream)` Adapts an aggregate operation so that it accumulates only the items passing the `filterFn` and ignores others.
    `static <T,U,A,R> AggregateOperation1<T,A,R>` | AggregateOperations.`flatMapping(FunctionEx<? super T,? extends Traverser<? extends U>> flatMapFn, AggregateOperation1<? super U,A,? extends R> downstream)` Adapts an aggregate operation that takes items of type `U` to one that takes items of type `T`, by exploding each `T` into a sequence of `U`s and then accumulating all of them.
    `static <T,K,A,R> AggregateOperation1<T,Map<K,A>,Map<K,R>>` | AggregateOperations.`groupingBy(FunctionEx<? super T,? extends K> keyFn, AggregateOperation1<? super T,A,R> downstream)` Returns an aggregate operation 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(FunctionEx<? super T,? extends K> keyFn, SupplierEx<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(FunctionEx<? super T,? extends U> mapFn, AggregateOperation1<? super U,A,? extends R> downstream)` Adapts an aggregate operation that takes items of type `U` to one that takes items of type `T`, by applying the given mapping function to each item.
    `static <T,A,R> Aggregator<T,R>` | AggregateOperations.`toAggregator(AggregateOperation1<? super T,A,? extends R> aggrOp)` Adapts this aggregate operation to be used for `IMap.aggregate(Aggregator)` calls.
    `static <T,A,R> Collector<T,A,R>` | AggregateOperations.`toCollector(AggregateOperation1<? super T,A,? extends R> aggrOp)` Adapts this aggregate operation to a collector which can be passed to `Stream.collect(Collector)`.

  - ### 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.
    `<R> StreamStage<WindowResult<R>>` | StageWithWindow.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items that belong to a given window.
    `<R> StreamStage<KeyedWindowResult<K,R>>` | StageWithKeyAndWindow.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` Attaches a stage that performs the given group-and-aggregate operation.
    `<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.
    `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> 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<WindowResult<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 operations over the items from this stage and `stage1` you supply.
    `default <T1,R0,R1> StreamStage<WindowResult<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 operations over the items from this stage and `stage1` you supply.
    `default <T1,R0,R1> StreamStage<KeyedWindowResult<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<KeyedWindowResult<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,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> 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> StreamStage<WindowResult<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<WindowResult<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<WindowResult<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<KeyedWindowResult<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<KeyedWindowResult<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<KeyedWindowResult<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 <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 <A,R> StreamStage<Map.Entry<K,R>>` | StreamStageWithKey.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)`
    `default <A,R> StreamStage<R>` | StreamStage.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)`
    `default <A,R> GeneralStage<Map.Entry<K,R>>` | GeneralStageWithKey.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)` Attaches a rolling aggregation stage.
    `default <A,R> GeneralStage<R>` | GeneralStage.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)` Attaches a rolling aggregation stage.
    `default <A,R> BatchStage<Map.Entry<K,R>>` | BatchStageWithKey.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)`
    `default <A,R> BatchStage<R>` | BatchStage.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)`
    `default <A,R> StreamStage<Map.Entry<K,R>>` | StreamStageWithKey.`rollingAggregate(long ttl, AggregateOperation1<? super T,A,? extends R> aggrOp)` Attaches a rolling aggregation stage.

Copyright © 2019. All rights reserved.