Uses of Interface
org.aksw.commons.collector.domain.ParallelAggregator
Packages that use ParallelAggregator
-
Uses of ParallelAggregator in org.aksw.commons.collector.core
Classes in org.aksw.commons.collector.core with type parameters of type ParallelAggregatorModifier and TypeClassDescriptionclassAggBuilder<I,E, O, ACC extends Accumulator<I, E, O>, AGG extends ParallelAggregator<I, E, O, ACC>> Builder for parallel aggregators.interfaceAggBuilderFn<XI,E, XO, XACC extends Accumulator<XI, E, XO>, XAGG extends ParallelAggregator<XI, E, XO, XACC>, YI, YO, YACC extends Accumulator<YI, E, YO>, YAGG extends ParallelAggregator<YI, E, YO, YACC>> interfaceAggBuilderFn<XI,E, XO, XACC extends Accumulator<XI, E, XO>, XAGG extends ParallelAggregator<XI, E, XO, XACC>, YI, YO, YACC extends Accumulator<YI, E, YO>, YAGG extends ParallelAggregator<YI, E, YO, YACC>> classAggErrorHandler<I,E, O, SUBACC extends Accumulator<I, E, O>, SUBAGG extends ParallelAggregator<I, E, O, SUBACC>> Wraps another aggregator such that if accumulation fails with an exception an error counter is increased.classAggInputBroadcast<I,E, O1, O2, SUBACC1 extends Accumulator<I, E, O1>, SUBAGG1 extends ParallelAggregator<I, E, O1, SUBACC1>, SUBACC2 extends Accumulator<I, E, O2>, SUBAGG2 extends ParallelAggregator<I, E, O2, SUBACC2>> An aggregator that broadcasts its input to two sub-aggregators that accept the same input.classAggInputBroadcast<I,E, O1, O2, SUBACC1 extends Accumulator<I, E, O1>, SUBAGG1 extends ParallelAggregator<I, E, O1, SUBACC1>, SUBACC2 extends Accumulator<I, E, O2>, SUBAGG2 extends ParallelAggregator<I, E, O2, SUBACC2>> An aggregator that broadcasts its input to two sub-aggregators that accept the same input.classAggInputFilter<I,E, O, SUBACC extends Accumulator<I, E, O>, SUBAGG extends ParallelAggregator<I, E, O, SUBACC>> Wrap an aggregator such that inputs are passed through a predicate.classAggInputFlatMap<I,E, J, O, SUBACC extends Accumulator<J, E, O>, SUBAGG extends ParallelAggregator<J, E, O, SUBACC>> Pass collection valued input to an accumulator that accepts only the individual items For example, pass all nodes of a binding to an accumulator for nodes This operation is a variant of input transform, where the transform target is an iterator.classAggInputSplit<I,E, K, J, O, SUBACC extends Accumulator<J, E, O>, SUBAGG extends ParallelAggregator<J, E, O, SUBACC>> An aggregator that splits the index into a set of keys and forwards the input to the sub-aggregator's accumulator for each key.classAggInputTransform<I,E, J, O, SUBACC extends Accumulator<J, E, O>, SUBAGG extends ParallelAggregator<J, E, O, SUBACC>> classAggOutputTransform<I,E, O, P, SUBACC extends Accumulator<I, E, O>, SUBAGG extends ParallelAggregator<I, E, O, SUBACC>> Classes in org.aksw.commons.collector.core that implement ParallelAggregatorModifier and TypeClassDescriptionclassAggCounting<I,E> Aggregator whose accumulator count the number of seen input objects.classAggErrorHandler<I,E, O, SUBACC extends Accumulator<I, E, O>, SUBAGG extends ParallelAggregator<I, E, O, SUBACC>> Wraps another aggregator such that if accumulation fails with an exception an error counter is increased.classAggFromCollector<I,E, O, A> An aggregator from a collector.classAggInputBroadcast<I,E, O1, O2, SUBACC1 extends Accumulator<I, E, O1>, SUBAGG1 extends ParallelAggregator<I, E, O1, SUBACC1>, SUBACC2 extends Accumulator<I, E, O2>, SUBAGG2 extends ParallelAggregator<I, E, O2, SUBACC2>> An aggregator that broadcasts its input to two sub-aggregators that accept the same input.classAggInputBroadcastMap<I,E, K, O> An aggregator that broadcasts its input to multiple sub-aggregators that accept the same input and have the same structure of the output Serves the purpose to perform two independent type safe aggregations on the same input in a single pass.classAggInputFilter<I,E, O, SUBACC extends Accumulator<I, E, O>, SUBAGG extends ParallelAggregator<I, E, O, SUBACC>> Wrap an aggregator such that inputs are passed through a predicate.classAggInputFlatMap<I,E, J, O, SUBACC extends Accumulator<J, E, O>, SUBAGG extends ParallelAggregator<J, E, O, SUBACC>> Pass collection valued input to an accumulator that accepts only the individual items For example, pass all nodes of a binding to an accumulator for nodes This operation is a variant of input transform, where the transform target is an iterator.classAggInputSplit<I,E, K, J, O, SUBACC extends Accumulator<J, E, O>, SUBAGG extends ParallelAggregator<J, E, O, SUBACC>> An aggregator that splits the index into a set of keys and forwards the input to the sub-aggregator's accumulator for each key.classAggInputTransform<I,E, J, O, SUBACC extends Accumulator<J, E, O>, SUBAGG extends ParallelAggregator<J, E, O, SUBACC>> classAggLcaMap<T,E> Accumulate mappings of least common ancestors Assume a backing tree structure: For each node passed to accumulate assemble a mapping to its LCA with any other lca found so far.classAggNatural<I,E, C extends Collection<I>> Wrapper for a supplier of accumulators with signature I -> Collection<I> This means, that items from the collection can be used as input.classAggOutputTransform<I,E, O, P, SUBACC extends Accumulator<I, E, O>, SUBAGG extends ParallelAggregator<I, E, O, SUBACC>> classAggReduce<I,E> Aggregator whose accumulators apply a reduce operation to their value and their input to compute their new value.Fields in org.aksw.commons.collector.core declared as ParallelAggregatorModifier and TypeFieldDescriptionprotected ParallelAggregator<T,E, R, A> CollectorFromParallelAggregator.aggregatorprotected SUBAGGAggErrorHandler.subAggprotected SUBAGGAggInputFilter.subAggprotected SUBAGGAggInputFlatMap.subAggprotected SUBAGGAggInputSplit.subAggprotected SUBAGGAggInputTransform.subAggprotected SUBAGGAggOutputTransform.subAggprotected SUBAGG1AggInputBroadcast.subAgg1protected SUBAGG2AggInputBroadcast.subAgg2Fields in org.aksw.commons.collector.core with type parameters of type ParallelAggregatorMethods in org.aksw.commons.collector.core with type parameters of type ParallelAggregatorModifier and TypeMethodDescriptiondefault <ZI,ZO, ZACC extends Accumulator<ZI, E, ZO>, ZAGG extends ParallelAggregator<ZI, E, ZO, ZACC>>
AggBuilderFn<XI,E, XO, XACC, XAGG, ZI, ZO, ZACC, ZAGG> static <I,E, O, ACC extends Accumulator<I, E, O>, AGG extends ParallelAggregator<I, E, O, ACC>>
AggErrorHandler<I,E, O, ACC, AGG> AggBuilder.errorHandler(AGG state) Wraps another aggregator such that if accumulation fails with an exception an error counter is increased.static <I,E, O, ACC extends Accumulator<I, E, O>, AGG extends ParallelAggregator<I, E, O, ACC>>
AggErrorHandler<I,E, O, ACC, AGG> AggBuilder.errorHandler(AGG state, boolean accDespiteError, SerializableConsumer<? super Throwable> errorCallback, SerializableFunction<AggErrorHandler.AccError<I, E, O, ACC>, O> errorValueExtractor) Wraps another aggregator such that if accumulation fails with an exception an error counter is increased.static <I,E, O, ACC extends Accumulator<I, E, O>, AGG extends ParallelAggregator<I, E, O, ACC>>
AggInputFilter<I,E, O, ACC, AGG> AggBuilder.inputFilter(SerializablePredicate<? super I> inputFilter, AGG state) Pass on input to sub-acc if the predicate evaluates to truestatic <I,E, O, SUBACC extends Accumulator<I, E, O>, SUBAGG extends ParallelAggregator<I, E, O, SUBACC>>
SerializableFunction<SUBAGG,AggInputFilter<I, E, O, SUBACC, SUBAGG>> AggBuilderFn.inputFilter(SerializablePredicate<? super I> inputFilter) static <I,E, J, O, ACC extends Accumulator<J, E, O>, AGG extends ParallelAggregator<J, E, O, ACC>>
AggInputFlatMap<I,E, J, O, ACC, AGG> AggBuilder.inputFlatMap(SerializableFunction<I, ? extends Iterator<? extends J>> inputTransform, AGG state) static <I,E, J, O, ACC extends Accumulator<J, E, O>, AGG extends ParallelAggregator<J, E, O, ACC>>
AggInputFlatMap<I,E, J, O, ACC, AGG> AggBuilder.inputFlatMap2(SerializableBiFunction<? super I, E, ? extends Iterator<? extends J>> inputTransform, AGG state) static <I,E, K, J, O, ACC extends Accumulator<J, E, O>, AGG extends ParallelAggregator<J, E, O, ACC>>
AggInputSplit<I,E, K, J, O, ACC, AGG> AggBuilder.inputSplit(Set<K> fixedKeys, boolean considerNewKeys, SerializableFunction<? super I, ? extends Set<? extends K>> keyMapper, SerializableBiFunction<? super I, ? super K, ? extends J> valueMapper, AGG state) static <I,E, K, J, O, ACC extends Accumulator<J, E, O>, AGG extends ParallelAggregator<J, E, O, ACC>>
AggInputSplit<I,E, K, J, O, ACC, AGG> AggBuilder.inputSplit(SerializableFunction<? super I, ? extends Set<? extends K>> keyMapper, SerializableBiFunction<? super I, ? super K, ? extends J> valueMapper, AGG state) InputSplit: Create the same accumulator type for each split of the inputstatic <I,E, K, O, ACC extends Accumulator<I, E, O>, AGG extends ParallelAggregator<I, E, O, ACC>>
AggInputSplit<I,E, K, I, O, ACC, AGG> AggBuilder.inputSplit(SerializableFunction<? super I, ? extends K> keyMapper, AGG state) Simple input split: Partition input by a key derived from itstatic <I,E, K, J, O, SUBACC extends Accumulator<J, E, O>, SUBAGG extends ParallelAggregator<J, E, O, SUBACC>>
SerializableFunction<SUBAGG,AggInputSplit<I, E, K, J, O, SUBACC, SUBAGG>> AggBuilderFn.inputSplit(SerializableFunction<? super I, ? extends Set<? extends K>> keyMapper, SerializableBiFunction<? super I, ? super K, ? extends J> valueMapper) static <I,E, J, O, ACC extends Accumulator<J, E, O>, AGG extends ParallelAggregator<J, E, O, ACC>>
AggInputTransform<I,E, J, O, ACC, AGG> AggBuilder.inputTransform(SerializableFunction<? super I, ? extends J> inputTransform, AGG state) static <I,E, J, O, ACC extends Accumulator<J, E, O>, AGG extends ParallelAggregator<J, E, O, ACC>>
AggInputTransform<I,E, J, O, ACC, AGG> AggBuilder.inputTransform2(SerializableBiFunction<? super I, E, ? extends J> inputTransform, AGG state) input transform with support for the environment argument.static <XI,E, XO, XACC extends Accumulator<XI, E, XO>, XAGG extends ParallelAggregator<XI, E, XO, XACC>, YI, YO, YACC extends Accumulator<YI, E, YO>, YAGG extends ParallelAggregator<YI, E, YO, YACC>>
AggBuilderFn<XI,E, XO, XACC, XAGG, YI, YO, YACC, YAGG> AggBuilderFn.of(AggBuilderFn<XI, E, XO, XACC, XAGG, YI, YO, YACC, YAGG> fn) static <XI,E, XO, XACC extends Accumulator<XI, E, XO>, XAGG extends ParallelAggregator<XI, E, XO, XACC>, YI, YO, YACC extends Accumulator<YI, E, YO>, YAGG extends ParallelAggregator<YI, E, YO, YACC>>
AggBuilderFn<XI,E, XO, XACC, XAGG, YI, YO, YACC, YAGG> AggBuilderFn.of(AggBuilderFn<XI, E, XO, XACC, XAGG, YI, YO, YACC, YAGG> fn) static <I,E, O, P, ACC extends Accumulator<I, E, O>, AGG extends ParallelAggregator<I, E, O, ACC>>
AggOutputTransform<I,E, O, P, ACC, AGG> AggBuilder.outputTransform(AGG state, SerializableFunction<? super O, ? extends P> outputTransform) Methods in org.aksw.commons.collector.core that return ParallelAggregatorModifier and TypeMethodDescriptionstatic <T,E> ParallelAggregator<T, E, List<T>, Accumulator<T, E, List<T>>> AggBuilder.arrayListSupplier()static <T,E, C extends Collection<T>>
ParallelAggregator<T,E, C, Accumulator<T, E, C>> AggBuilder.collectionSupplier(SerializableSupplier<? extends C> colSupplier) static <I,E> ParallelAggregator<I, E, Long, Accumulator<I, E, Long>> AggBuilder.counting()static <I,E> ParallelAggregator<I, E, I, Accumulator<I, E, I>> AggBuilder.fold(SerializableSupplier<I> zeroElementSupplier, SerializableBinaryOperator<I> plusOperator) CollectorFromParallelAggregator.getAggregator()static <T,E> ParallelAggregator<T, E, Set<T>, Accumulator<T, E, Set<T>>> AggBuilder.hashSetSupplier()static <I,E, O1, O2>
ParallelAggregator<I,E, Map.Entry<O1, O2>, ?> AggBuilder.inputBroadcast(ParallelAggregator<I, E, O1, ?> agg1, ParallelAggregator<I, E, O2, ?> agg2) An aggregator that broadcasts its input to two sub-aggregators that accept the same input.static <K,V, E> ParallelAggregator<Map.Entry<K, V>, E, SetOverMap<K, V>, Accumulator<Map.Entry<K, V>, E, SetOverMap<K, V>>> AggBuilder.mapSupplier(SerializableSupplier<? extends Map<K, V>> mapSupplier) We provide the SetOverMap collection type which transparently gives access to the underlying map This way we can reuse the collection machinery for accumulation and still type-safely extract the map eventuallystatic <E> ParallelAggregator<Integer,E, Integer, Accumulator<Integer, E, Integer>> AggBuilder.maxInteger()static <E> ParallelAggregator<Long,E, Long, Accumulator<Long, E, Long>> AggBuilder.maxLong()static <T,E, C extends Collection<T>>
ParallelAggregator<T,E, C, Accumulator<T, E, C>> AggBuilder.naturalAccumulator(SerializableSupplier<? extends Accumulator<T, E, C>> accSupplier) static <T,E> ParallelAggregator<T, E, Set<T>, Accumulator<T, E, Set<T>>> AggBuilder.setSupplier(SerializableSupplier<? extends Set<T>> setSupplier) Methods in org.aksw.commons.collector.core with parameters of type ParallelAggregatorModifier and TypeMethodDescriptionstatic <I,E, O, ACC extends Accumulator<I, E, O>>
Collector<I,?, O> ParallelAggregators.createCollector(ParallelAggregator<I, E, O, ACC> agg, E env) Create a serializable java8 collector from a parallel aggregator.static <I,E, O1, O2>
ParallelAggregator<I,E, Map.Entry<O1, O2>, ?> AggBuilder.inputBroadcast(ParallelAggregator<I, E, O1, ?> agg1, ParallelAggregator<I, E, O2, ?> agg2) An aggregator that broadcasts its input to two sub-aggregators that accept the same input.Method parameters in org.aksw.commons.collector.core with type arguments of type ParallelAggregatorModifier and TypeMethodDescriptionstatic <I,E, K, O> AggInputBroadcastMap<I, E, K, O> AggBuilder.inputBroadcastMap(Map<K, ParallelAggregator<I, E, O, ?>> subAggMap) An aggregator that broadcasts its input to multiple sub-aggregators that accept the same inputConstructors in org.aksw.commons.collector.core with parameters of type ParallelAggregatorModifierConstructorDescriptionCollectorFromParallelAggregator(ParallelAggregator<T, E, R, A> aggregator, E env) Constructor parameters in org.aksw.commons.collector.core with type arguments of type ParallelAggregator