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

Packages that use Accumulator

Package	Description
org.aksw.commons.collector.core
org.aksw.commons.collector.domain

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

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

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.
static interface	AggErrorHandler.AccError<I, E, O, SUBACC extends Accumulator<I,E,O>>
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.
static interface	AggInputBroadcast.AccInputBroadcast<I, E, O1, O2, SUBACC1 extends Accumulator<I,E,O1>, SUBACC2 extends Accumulator<I,E,O2>>
static interface	AggInputBroadcast.AccInputBroadcast<I, E, O1, O2, SUBACC1 extends Accumulator<I,E,O1>, SUBACC2 extends Accumulator<I,E,O2>>
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.
static interface	AggInputFilter.AccInputFilter<I, E, O, SUBACC extends Accumulator<I,E,O>>
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.
static interface	AggInputFlatMap.AccInputFlatMap<I, E, J, O, SUBACC extends Accumulator<J,E,O>>
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.
static interface	AggInputSplit.AccInputSplit<I, E, K, J, O, SUBACC extends Accumulator<J,E,O>>
class	AggInputTransform<I, E, J, O, SUBACC extends Accumulator<J,E,O>, SUBAGG extends ParallelAggregator<J,E,O,SUBACC>>
static interface	AggInputTransform.AccInputTransform<I, E, J, O, SUBACC extends Accumulator<J,E,O>>
class	AggOutputTransform<I, E, O, P, SUBACC extends Accumulator<I,E,O>, SUBAGG extends ParallelAggregator<I,E,O,SUBACC>>
static interface	AggOutputTransform.AccOutputTransform<I, E, O, P, SUBACC extends Accumulator<I,E,O>>
class	CollectorFromParallelAggregator<T, E, R, A extends Accumulator<T,E,R>>

Subinterfaces of Accumulator in org.aksw.commons.collector.core

Modifier and Type	Interface	Description
interface	AccWrapper<I,E,O,SUBACC>
static interface	AggErrorHandler.AccError<I, E, O, SUBACC extends Accumulator<I,E,O>>
static interface	AggFromCollector.AccFromCollector<I,E,O,A>
static interface	AggInputBroadcast.AccInputBroadcast<I, E, O1, O2, SUBACC1 extends Accumulator<I,E,O1>, SUBACC2 extends Accumulator<I,E,O2>>
static interface	AggInputBroadcastMap.AccInputBroadcastMap<I,E,K,O>
static interface	AggInputFilter.AccInputFilter<I, E, O, SUBACC extends Accumulator<I,E,O>>
static interface	AggInputFlatMap.AccInputFlatMap<I, E, J, O, SUBACC extends Accumulator<J,E,O>>
static interface	AggInputSplit.AccInputSplit<I, E, K, J, O, SUBACC extends Accumulator<J,E,O>>
static interface	AggInputTransform.AccInputTransform<I, E, J, O, SUBACC extends Accumulator<J,E,O>>
static interface	AggOutputTransform.AccOutputTransform<I, E, O, P, SUBACC extends Accumulator<I,E,O>>

Classes in org.aksw.commons.collector.core that implement Accumulator

Modifier and Type	Class	Description
class	AccCollection<I, E, C extends Collection<I>>	Can be used with AggNatural
class	AccumulatorSynchronized<I,E,O>
class	AggCounting.AccCounting
class	AggErrorHandler.AccErrorImpl
static class	AggFinish.AccFinish<I,E,O,V>
class	AggFromCollector.AccFromCollectorImpl
class	AggInputBroadcast.AccInputBroadcastImpl
class	AggInputBroadcastMap.AccInputBroadcastMapImpl
class	AggInputFilter.AccFilterInputImpl
class	AggInputFlatMap.AccTransformInputImpl
class	AggInputSplit.AccSplitInputImpl
class	AggInputTransform.AccTransformInputImpl
static class	AggLcaMap.AccLcaMap<T,E>
class	AggOutputTransform.AccOutputTransformImpl
class	AggReduce.AccReduceImpl

Classes in org.aksw.commons.collector.core that implement interfaces with type arguments of type Accumulator

Modifier and Type	Class	Description
class	AggCounting<I,E>	Aggregator whose accumulator count the number of seen input objects.
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	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 Accumulator

Modifier and Type	Field	Description
protected Accumulator<I,E,O>	AccumulatorSynchronized.delegate
protected SUBACC	AggErrorHandler.AccErrorImpl.subAcc
protected Accumulator<I,E,O>	AggFinish.AccFinish.subAcc
protected SUBACC	AggInputFilter.AccFilterInputImpl.subAcc
protected SUBACC	AggInputFlatMap.AccTransformInputImpl.subAcc
protected SUBACC	AggInputTransform.AccTransformInputImpl.subAcc
protected SUBACC	AggOutputTransform.AccOutputTransformImpl.subAcc
protected SUBACC1	AggInputBroadcast.AccInputBroadcastImpl.subAcc1
protected SUBACC2	AggInputBroadcast.AccInputBroadcastImpl.subAcc2

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

Modifier and Type	Field	Description
protected Supplier<? extends Accumulator<I,E,C>>	AggNatural.accSupplier
protected Map<K, Accumulator<I,E,O>>	AggInputBroadcastMap.AccInputBroadcastMapImpl.keyToSubAcc

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

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>> 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, 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 Accumulator

Modifier and Type	Method	Description
Accumulator<I,E,Long>	AggCounting.combine(Accumulator<I,E,Long> a, Accumulator<I,E,Long> b)
Accumulator<T,E,Map<T,T>>	AggLcaMap.combine(Accumulator<T,E,Map<T,T>> a, Accumulator<T,E,Map<T,T>> b)
Accumulator<I,E,C>	AggNatural.combine(Accumulator<I,E,C> a, Accumulator<I,E,C> b)
Accumulator<I,E,I>	AggReduce.combine(Accumulator<I,E,I> a, Accumulator<I,E,I> b)
static <T, E, V, C extends Collection<V>> Accumulator<T,E,C>	ParallelAggregators.combineAccumulators(Accumulator<T,E,C> needle, Accumulator<T,E,C> haystack, UnaryOperator<Accumulator<T,E,C>> accumulatorCloner, Function<? super V, ? extends T> valueToItem, E env)	Merge two accumulators.
Accumulator<I,E,Long>	AggCounting.createAccumulator()
Accumulator<B,E,O>	AggFinish.createAccumulator()
Accumulator<T,E,Map<T,T>>	AggLcaMap.createAccumulator()
Accumulator<I,E,C>	AggNatural.createAccumulator()
Accumulator<I,E,I>	AggReduce.createAccumulator()
Accumulator<I,E,O>	AggFinish.AccFinish.getSubAcc()
static <I,E,O> Accumulator<I,E,O>	Accumulators.synchronize(Accumulator<I,E,O> accumulator)

Methods in org.aksw.commons.collector.core that return types with arguments of type Accumulator

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)
Map<K, Accumulator<I,E,O>>	AggInputBroadcastMap.AccInputBroadcastMap.getSubAccMap()
Map<K, Accumulator<I,E,O>>	AggInputBroadcastMap.AccInputBroadcastMapImpl.getSubAccMap()
static <T,E> ParallelAggregator<T, E, Set<T>, Accumulator<T,E,Set<T>>>	AggBuilder.hashSetSupplier()
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 Accumulator

Modifier and Type	Method	Description
Accumulator<I,E,Long>	AggCounting.combine(Accumulator<I,E,Long> a, Accumulator<I,E,Long> b)
Accumulator<T,E,Map<T,T>>	AggLcaMap.combine(Accumulator<T,E,Map<T,T>> a, Accumulator<T,E,Map<T,T>> b)
Accumulator<I,E,C>	AggNatural.combine(Accumulator<I,E,C> a, Accumulator<I,E,C> b)
Accumulator<I,E,I>	AggReduce.combine(Accumulator<I,E,I> a, Accumulator<I,E,I> b)
static <T, E, V, C extends Collection<V>> Accumulator<T,E,C>	ParallelAggregators.combineAccumulators(Accumulator<T,E,C> needle, Accumulator<T,E,C> haystack, UnaryOperator<Accumulator<T,E,C>> accumulatorCloner, Function<? super V, ? extends T> valueToItem, E env)	Merge two accumulators.
static <I,E,O> Accumulator<I,E,O>	Accumulators.synchronize(Accumulator<I,E,O> accumulator)

Method parameters in org.aksw.commons.collector.core with type arguments of type Accumulator

Modifier and Type	Method	Description
static <T, E, V, C extends Collection<V>> Accumulator<T,E,C>	ParallelAggregators.combineAccumulators(Accumulator<T,E,C> needle, Accumulator<T,E,C> haystack, UnaryOperator<Accumulator<T,E,C>> accumulatorCloner, Function<? super V, ? extends T> valueToItem, E env)	Merge two accumulators.
static <T, E, C extends Collection<T>> ParallelAggregator<T, E, C, Accumulator<T,E,C>>	AggBuilder.naturalAccumulator(SerializableSupplier<? extends Accumulator<T,E,C>> accSupplier)

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

Modifier	Constructor	Description
	AccFinish(Accumulator<I,E,O> subAcc, Function<? super O, V> transform)
	AccumulatorSynchronized(Accumulator<I,E,O> delegate)

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

Modifier	Constructor	Description
	AccInputBroadcastMapImpl(Map<K, Accumulator<I,E,O>> keyToSubAcc)
	AggNatural(SerializableSupplier<? extends Accumulator<I,E,C>> accSupplier)

Uses of Accumulator in org.aksw.commons.collector.domain

Classes in org.aksw.commons.collector.domain with type parameters of type Accumulator

Modifier and Type	Interface	Description
interface	ParallelAggregator<I, E, O, ACC extends Accumulator<I,E,O>>	Aggregator suitable for parallel processing.

Methods in org.aksw.commons.collector.domain that return Accumulator

Modifier and Type	Method	Description
Accumulator<B,E,T>	Aggregator.createAccumulator()