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

Packages that use AggregateOperation1

Package	Description
com.hazelcast.jet.aggregate	Contains AggregateOperation and its several 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	Description
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, 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> 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 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 Us 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, 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, 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> 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,PickAnyAccumulator<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	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, 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, 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, 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, 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> 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 Us and then accumulating all of them.
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, 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, 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	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> 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> 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> StreamStage<KeyedWindowResult<K,R>>	StageWithKeyAndWindow.aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)	Attaches a stage that performs the given group-and-aggregate operation.
<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.
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 emits a single 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> 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<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, 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 emits a single 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> 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<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 <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 <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> 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> 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 <A, R> BatchStage<R>	BatchStage.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)
default <A, R> BatchStage<Map.Entry<K,R>>	BatchStageWithKey.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)
default <A, R> GeneralStage<R>	GeneralStage.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)	Attaches a rolling aggregation stage.
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> StreamStage<R>	StreamStage.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.
default <A, R> StreamStage<Map.Entry<K,R>>	StreamStageWithKey.rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)