Uses of Interface
org.aksw.commons.collector.domain.ParallelAggregator

Packages that use ParallelAggregator

Package	Description
org.aksw.commons.collector.core

Uses of ParallelAggregator in org.aksw.commons.collector.core

Classes in org.aksw.commons.collector.core with type parameters of type ParallelAggregator

Modifier and Type	Class	Description
class	AggBuilder<I,E,O,ACC extends Accumulator<I,E,O>,AGG extends ParallelAggregator<I,E,O,ACC>>	Builder for parallel aggregators.
interface	AggBuilderFn<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>>
interface	AggBuilderFn<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>>
class	AggErrorHandler<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.
class	AggInputBroadcast<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.
class	AggInputBroadcast<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.
class	AggInputFilter<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.
class	AggInputFlatMap<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.
class	AggInputSplit<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.
class	AggInputTransform<I,E,J,O,SUBACC extends Accumulator<J,E,O>,SUBAGG extends ParallelAggregator<J,E,O,SUBACC>>
class	AggOutputTransform<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 ParallelAggregator

Modifier and Type	Class	Description
class	AggCounting<I,E>	Aggregator whose accumulator count the number of seen input objects.
class	AggErrorHandler<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.
class	AggFromCollector<I,E,O,A>	An aggregator from a collector.
class	AggInputBroadcast<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.
class	AggInputBroadcastMap<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.
class	AggInputFilter<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.
class	AggInputFlatMap<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.
class	AggInputSplit<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.
class	AggInputTransform<I,E,J,O,SUBACC extends Accumulator<J,E,O>,SUBAGG extends ParallelAggregator<J,E,O,SUBACC>>
class	AggLcaMap<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.
class	AggNatural<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.
class	AggOutputTransform<I,E,O,P,SUBACC extends Accumulator<I,E,O>,SUBAGG extends ParallelAggregator<I,E,O,SUBACC>>
class	AggReduce<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 ParallelAggregator

Modifier and Type	Field	Description
protected ParallelAggregator<T,E,R,A>	CollectorFromParallelAggregator.aggregator
protected SUBAGG	AggErrorHandler.subAgg
protected SUBAGG	AggInputFilter.subAgg
protected SUBAGG	AggInputFlatMap.subAgg
protected SUBAGG	AggInputSplit.subAgg
protected SUBAGG	AggInputTransform.subAgg
protected SUBAGG	AggOutputTransform.subAgg
protected SUBAGG1	AggInputBroadcast.subAgg1
protected SUBAGG2	AggInputBroadcast.subAgg2

Fields in org.aksw.commons.collector.core with type parameters of type ParallelAggregator

Modifier and Type	Field	Description
protected Map<K,ParallelAggregator<I,E,O,?>>	AggInputBroadcastMap.subAggMap

Methods in org.aksw.commons.collector.core with type parameters of type ParallelAggregator

Modifier and Type	Method	Description
default <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>	AggBuilderFn.andThen(AggBuilderFn<YI,E,YO,YACC,YAGG,ZI,ZO,ZACC,ZAGG> next)
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 true
static <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 input
static <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 it
static <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 ParallelAggregator

Modifier and Type	Method	Description
static <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)
ParallelAggregator<T,E,R,A>	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 eventually
static <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 ParallelAggregator

Modifier and Type	Method	Description
static <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 ParallelAggregator

Modifier and Type	Method	Description
static <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 input

Constructors in org.aksw.commons.collector.core with parameters of type ParallelAggregator

Modifier	Constructor	Description
	CollectorFromParallelAggregator(ParallelAggregator<T,E,R,A> aggregator, E env)

Constructor parameters in org.aksw.commons.collector.core with type arguments of type ParallelAggregator

Modifier	Constructor	Description
	AggInputBroadcastMap(Map<K,ParallelAggregator<I,E,O,?>> subAggMap)