com.hp.mercury.ci.jenkins.plugins.oo.utils

Class MaxAggregator<C extends Comparable,T>

java.lang.Object

com.hp.mercury.ci.jenkins.plugins.oo.utils.MaxAggregator<C,T>

Type Parameters:

C - the result - largest comparable in the aggregated collection

T - the type of the collection being aggregated

All Implemented Interfaces:

Aggregator<Map.Entry<T,C>,T>

public class MaxAggregator<C extends Comparable,T>
extends Object
implements Aggregator<Map.Entry<T,C>,T>

aggregator calculating the max element of a collection after a transformation has been applied to make the element comparable. usually it would be enough to map the elements to comparables, and then use Collection.max() - but then you'll get the max comparable and not the original element, which sometimes complicates things. also, you'll need to iterate the collection twice, and also store the entire comparable collection - that's a performance issue. so you could instead just implement a comparator and use collection.max, but sometimes it's simpler to use a class' pre-existing comparator or "natural ordering". for example, if your element can easily be transformed to an Integer.

Constructor Summary

Constructors

Constructor and Description
MaxAggregator(Handler<C,T> comparifier)

Method Summary

Methods

Modifier and Type	Method and Description
void	aggregate(T element)
Map.Entry<T,C>	finish()
void	init(Collection<T> elements)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MaxAggregator

public MaxAggregator(Handler<C,T> comparifier)

Parameters:

comparifier - the function that turns the aggregated collection elements to comparables. it is assumed that it does not return null.

Method Detail

init

public void init(Collection<T> elements)

Specified by:

init in interface Aggregator<Map.Entry<T,C extends Comparable>,T>

Parameters:

elements - the container that's about to be iterated. use this function to initialize the aggregation process. for example, you might need to create a "result" collection and you can set it's size according to elements.size() for performance reasons.

aggregate

public void aggregate(T element)

Specified by:

aggregate in interface Aggregator<Map.Entry<T,C extends Comparable>,T>

Parameters:

element - the currently iterated element that you should add to the aggregation. if the aggregator implementation is to create a sum of integers, then an implementation for this method would be sum += element;

finish

public Map.Entry<T,C> finish()

Specified by:

finish in interface Aggregator<Map.Entry<T,C extends Comparable>,T>

Returns:

null if no aggregated collection was empty, or the largest comparable otherwise.