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.
com.hazelcast.jet.stream	java.util.stream implementation using Hazelcast Jet

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,A1,A2,R1,R2> AggregateOperation1<T,Tuple2<A1,A2>,Tuple2<R1,R2>>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2) Convenience for AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, DistributedBiFunction) with identity finish.
static <T,A1,A2,A3,R1,R2,R3> AggregateOperation1<T,Tuple3<A1,A2,A3>,Tuple3<R1,R2,R3>>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3) Convenience for AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction) with identity finisher.
static <T,A1,A2,A3,R1,R2,R3,R> AggregateOperation1<T,Tuple3<A1,A2,A3>,R>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3, DistributedTriFunction<? super R1,? super R2,? super R3,R> finishFn) Returns composite aggregate operation from 3 other aggregate operations.
static <T,A1,A2,R1,R2,R> AggregateOperation1<T,Tuple2<A1,A2>,R>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, DistributedBiFunction<? super R1,? super R2,R> finishFn) Returns composite aggregate operation from 2 other aggregate operations.
<R> AggregateOperation1<T0,A,R>	AggregateOperationBuilder.Arity1.andFinish(DistributedFunction<? super A,R> finishFn) Constructs and returns an AggregateOperation1 from the current state of the builder and the supplied finish primitive.
AggregateOperation1<T0,A,A>	AggregateOperationBuilder.Arity1.andIdentityFinish() Constructs and returns an AggregateOperation1 from the current state of the builder, with the identity function as the finish primitive.
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.
AggregateOperation1<T,Object[],ItemsByTag>	AllOfAggregationBuilder.build() Builds and returns the composite AggregateOperation1.
<R> AggregateOperation1<T,Object[],R>	AllOfAggregationBuilder.build(DistributedFunction<ItemsByTag,R> finishFn) 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> toKeyFn) Returns an AggregateOperation1 that accumulates the items into a HashMap where the key is the result of applying toKeyFn 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> toKeyFn, AggregateOperation1<? super T,A,R> downstream) Returns an AggregateOperation1 that accumulates the items into a HashMap where the key is the result of applying toKeyFn 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> toKeyFn, 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 toKeyFn 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,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,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,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> toKeyFn, DistributedFunction<? super T,? extends U> toValueFn) 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> toKeyFn, DistributedFunction<? super T,? extends U> toValueFn, 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> toKeyFn, DistributedFunction<? super T,? extends U> toValueFn, 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,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 and will combine them all into a single accumulator of the same type.
<R_NEW> AggregateOperation1<T,A,R_NEW>	AggregateOperation1.withFinishFn(DistributedFunction<? super A,R_NEW> finishFn)

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.
static <T,A1,A2,R1,R2> AggregateOperation1<T,Tuple2<A1,A2>,Tuple2<R1,R2>>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2) Convenience for AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, DistributedBiFunction) with identity finish.
static <T,A1,A2,R1,R2> AggregateOperation1<T,Tuple2<A1,A2>,Tuple2<R1,R2>>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2) Convenience for AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, DistributedBiFunction) with identity finish.
static <T,A1,A2,A3,R1,R2,R3> AggregateOperation1<T,Tuple3<A1,A2,A3>,Tuple3<R1,R2,R3>>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3) Convenience for AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction) with identity finisher.
static <T,A1,A2,A3,R1,R2,R3> AggregateOperation1<T,Tuple3<A1,A2,A3>,Tuple3<R1,R2,R3>>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3) Convenience for AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction) with identity finisher.
static <T,A1,A2,A3,R1,R2,R3> AggregateOperation1<T,Tuple3<A1,A2,A3>,Tuple3<R1,R2,R3>>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3) Convenience for AggregateOperations.allOf(AggregateOperation1, AggregateOperation1, AggregateOperation1, DistributedTriFunction) with identity finisher.
static <T,A1,A2,A3,R1,R2,R3,R> AggregateOperation1<T,Tuple3<A1,A2,A3>,R>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3, DistributedTriFunction<? super R1,? super R2,? super R3,R> finishFn) Returns composite aggregate operation from 3 other aggregate operations.
static <T,A1,A2,A3,R1,R2,R3,R> AggregateOperation1<T,Tuple3<A1,A2,A3>,R>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3, DistributedTriFunction<? super R1,? super R2,? super R3,R> finishFn) Returns composite aggregate operation from 3 other aggregate operations.
static <T,A1,A2,A3,R1,R2,R3,R> AggregateOperation1<T,Tuple3<A1,A2,A3>,R>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, AggregateOperation1<? super T,A3,R3> op3, DistributedTriFunction<? super R1,? super R2,? super R3,R> finishFn) Returns composite aggregate operation from 3 other aggregate operations.
static <T,A1,A2,R1,R2,R> AggregateOperation1<T,Tuple2<A1,A2>,R>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, DistributedBiFunction<? super R1,? super R2,R> finishFn) Returns composite aggregate operation from 2 other aggregate operations.
static <T,A1,A2,R1,R2,R> AggregateOperation1<T,Tuple2<A1,A2>,R>	AggregateOperations.allOf(AggregateOperation1<? super T,A1,R1> op1, AggregateOperation1<? super T,A2,R2> op2, DistributedBiFunction<? super R1,? super R2,R> finishFn) Returns composite aggregate operation from 2 other aggregate operations.
static <T,K,A,R> AggregateOperation1<T,Map<K,A>,Map<K,R>>	AggregateOperations.groupingBy(DistributedFunction<? super T,? extends K> toKeyFn, AggregateOperation1<? super T,A,R> downstream) Returns an AggregateOperation1 that accumulates the items into a HashMap where the key is the result of applying toKeyFn 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> toKeyFn, 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 toKeyFn 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,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.pipeline

Methods in com.hazelcast.jet.pipeline with parameters of type AggregateOperation1

Modifier and Type	Method and Description
<A,R> BatchStage<R>	BatchStage.aggregate(AggregateOperation1<? super T,A,? extends R> aggrOp) Attaches to this stage a stage that performs the given aggregate operation over all the items it receives.
default <A,R> StreamStage<TimestampedItem<R>>	StageWithWindow.aggregate(AggregateOperation1<? super T,A,R> aggrOp) Attaches to this stage a stage that performs the given aggregate operation over all the items that belong to a given window.
<A,R> StreamStage<TimestampedEntry<K,R>>	StageWithGroupingAndWindow.aggregate(AggregateOperation1<? super T,A,R> aggrOp) Attaches to this stage a stage that performs the given group-and-aggregate operation.
default <A,R> BatchStage<Map.Entry<K,R>>	StageWithGrouping.aggregate(AggregateOperation1<? super T,A,R> aggrOp) Attaches to this stage a stage that performs the given group-and-aggregate operation.
<A,R,OUT> BatchStage<Map.Entry<K,R>>	StageWithGrouping.aggregate(AggregateOperation1<? super T,A,R> aggrOp, DistributedBiFunction<? super K,? super R,OUT> mapToOutputFn) Attaches to this stage a stage that performs the given group-and-aggregate operation.
<A,R,OUT> StreamStage<OUT>	StageWithGroupingAndWindow.aggregate(AggregateOperation1<? super T,A,R> aggrOp, KeyedWindowResultFunction<? super K,? super R,OUT> mapToOutputFn) Attaches to this stage a stage that performs the given group-and-aggregate operation over the window described by the window definition captured by this object.
<A,R,OUT> StreamStage<OUT>	StageWithWindow.aggregate(AggregateOperation1<? super T,A,R> aggrOp, WindowResultFunction<? super R,? extends OUT> mapToOutputFn) Attaches to this stage a stage that performs the given aggregate operation over all the items that belong to a given window.

Uses of AggregateOperation1 in com.hazelcast.jet.stream

Methods in com.hazelcast.jet.stream with parameters of type AggregateOperation1

Modifier and Type	Method and Description
static <T,A,R> DistributedCollector<T,A,R>	DistributedCollectors.aggregating(AggregateOperation1<T,A,R> aggregateOp) Returns a collector which performs a distributed aggregation on all the input values using the given AggregateOperation1.