Uses of Interface
com.hazelcast.jet.aggregate.AggregateOperation1
Package
Description
Contains
AggregateOperation
and its several variants, as well
as a builder object for the aggregate operations.The Pipeline API is Jet's high-level API to build and execute
distributed computation jobs.
-
Uses of AggregateOperation1 in com.hazelcast.jet.aggregate
Modifier and TypeMethodDescriptionstatic <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 forAggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, TriFunction)
wrapping the three results in aTuple3
.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 forAggregateOperations.allOf(AggregateOperation1, AggregateOperation1, BiFunctionEx)
wrapping the two results in aTuple2
.<R_NEW> AggregateOperation1<T0,
A, R_NEW> AggregateOperationBuilder.Arity1.andExportFinish
(FunctionEx<? super A, ? extends R_NEW> exportFinishFn) AggregateOperationBuilder.Arity1.andFinish
(FunctionEx<? super A, ? extends R> finishFn) Registers thefinish
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 bottomn
items according to the givencomparator
.AllOfAggregationBuilder.build()
Builds and returns the compositeAggregateOperation1
.<R> AggregateOperation1<T,
Object[], R> AllOfAggregationBuilder.build
(FunctionEx<ItemsByTag, R> exportFinishFn) Builds and returns the compositeAggregateOperation1
.AggregateOperations.concatenating()
Returns an aggregate operation that takes string items and concatenates them into a single string.AggregateOperations.concatenating
(CharSequence delimiter) Returns an aggregate operation that takes string items and concatenates them, separated by the givendelimiter
, into a single string.AggregateOperations.concatenating
(CharSequence delimiter, CharSequence prefix, CharSequence suffix) Returns an aggregate operation that takes string items and concatenates them, separated by the givendelimiter
, 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 thefilterFn
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 typeU
to one that takes items of typeT
, by exploding eachT
into a sequence ofU
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 aHashMap
where the key is the result of applyingkeyFn
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 anAggregateOperation1
that accumulates the items into aMap
(as obtained fromcreateMapFn
) where the key is the result of applyingkeyFn
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 aHashMap
where the key is the result of applyingkeyFn
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 typeU
to one that takes items of typeT
, 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 givencomparator
.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 givencomparator
.static <T> AggregateOperation1<T,
PickAnyAccumulator<T>, T> AggregateOperations.pickAny()
Returns an aggregate operation whose result is an arbitrary item it observed, ornull
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 isemptyAccValue
.static <T> AggregateOperation1<T,
ArrayList<T>, List<T>> AggregateOperations.sorting
(ComparatorEx<? super T> comparator) Returns an aggregate operation that accumulates all input items into anArrayList
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 thedouble
values it obtains by applyinggetDoubleValueFn
to each item.static <T> AggregateOperation1<T,
LongAccumulator, Long> AggregateOperations.summingLong
(ToLongFunctionEx<? super T> getLongValueFn) Returns an aggregate operation that computes the sum of thelong
values it obtains by applyinggetLongValueFn
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 aCollection
.static <T> AggregateOperation1<T,
List<T>, List<T>> AggregateOperations.toList()
Returns an aggregate operation that accumulates the items into anArrayList
.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 aHashMap
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 aHashMap
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-suppliedMap
instance.static <T> AggregateOperation1<T,
PriorityQueue<T>, List<T>> AggregateOperations.topN
(int n, ComparatorEx<? super T> comparator) Returns an aggregate operation that finds the topn
items according to the givencomparator
.static <T> AggregateOperation1<T,
Set<T>, Set<T>> AggregateOperations.toSet()
Returns an aggregate operation that accumulates the items into aHashSet
.<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 theaccumulate
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 theaccumulate
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.withIdentityFinish()
Modifier and TypeMethodDescription<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 foraggregateOperation2(aggrOp0, aggrOp1, finishFn)
that outputs aTuple2(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 foraggregateOperation3(aggrOp0, aggrOp1, aggrOp2, finishFn)
that outputs aTuple3(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 forAggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, TriFunction)
wrapping the three results in aTuple3
.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 forAggregateOperations.allOf(AggregateOperation1, AggregateOperation1, BiFunctionEx)
wrapping the two results in aTuple2
.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 thefilterFn
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 typeU
to one that takes items of typeT
, by exploding eachT
into a sequence ofU
s 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 anAggregateOperation1
that accumulates the items into aMap
(as obtained fromcreateMapFn
) where the key is the result of applyingkeyFn
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 aHashMap
where the key is the result of applyingkeyFn
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 typeU
to one that takes items of typeT
, 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 forIMap.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 toStream.collect(Collector)
. -
Uses of AggregateOperation1 in com.hazelcast.jet.pipeline
Modifier and TypeMethodDescription<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 singleTuple2
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 andstage1
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 andstage1
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 andstage1
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 singleTuple3
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 asstage1
andstage2
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 andstage1
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)