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

Class CollectionUtils

java.lang.Object

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

public class CollectionUtils
extends Object

Method Summary

Methods

Modifier and Type	Method and Description
static <R,T> R	aggregate(Collection<T> elements, Aggregator<R,T> aggregator)
static <T> boolean	areDifferent(T... elements) method that determines if any of the inputs is not .equal() the method handles null gracefully: if all elements are null, they are considered equal.
static <T> boolean	areEqual(T... elements) method that determines if all inputs are .equal().
static <T> T[]	combineArrays(T[] original, T... additional)
static boolean	containsAny(Collection container, Collection contained)
static <T> void	filter(Collection<T> items, Criteria<T> criteria)
static Collection	intersect(Collection container, Collection contained)
static boolean	isPrefix(Iterable suspectedPrefix, Iterable container) there's no point in being "type safe" in this method, as the returned value is not typed, and we would like to support any type of iterable comparison.
static <R,T> List<R>	map(Collection<T> elements, Handler<R,T> handler)
static <R,T> Map<T,R>	mapToMap(Collection<T> elements, Handler<R,T> handler)
static <C extends Comparable,T> Map.Entry<T,C>	max(Collection<T> elements, Handler<C,T> handler) sometimes when we want to compare objects according to something that is already comparable, it's easier to write a handler that generates that comparable than to write a comparator.
static Object	nextOrNull(Iterator i)
static <T> Map<T,HashSet<T>>	reverseMap(Map<T,? extends Collection<T>> input)

Methods inherited from class java.lang.Object

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

Method Detail

isPrefix

public static boolean isPrefix(Iterable suspectedPrefix,
               Iterable container)

there's no point in being "type safe" in this method, as the returned value is not typed, and we would like to support any type of iterable comparison.

Parameters:

suspectedPrefix - some iterable whose may be a prefix for container

container - the iterable who may or may not start with suspectedPrefix

Returns:

true iff suspectedPrefix is a prefix of container

areEqual

public static <T> boolean areEqual(T... elements)

method that determines if all inputs are .equal(). the method handles null gracefully: if all elements are null, they are considered equal. the function assumes that equality is transitive, and doesn't all pair permutations. it also assumes that no object .equals(null)

Type Parameters:

T - type of the elements

Parameters:

elements - to check if equal

Returns:

true if all elements are equal or all elements are null. base cases of empty and single element are also considered "equal" in an empty fashion.

areDifferent

public static <T> boolean areDifferent(T... elements)

method that determines if any of the inputs is not .equal() the method handles null gracefully: if all elements are null, they are considered equal. the function assumes that equality is transitive, and doesn't all pair permutations. it also assumes that no object .equals(null)

Type Parameters:

T - type of the elements

Parameters:

elements - to check if different

Returns:

false if all elements are equal or all elements are null. base cases of empty and single element are also considered "equal" in an empty fashion.

nextOrNull

public static Object nextOrNull(Iterator i)

Parameters:

i - an iterator from which we want to retrieve the next element.

Returns:

next element if iterator has more elements, null otherwise.

combineArrays

public static <T> T[] combineArrays(T[] original,
                    T... additional)

Parameters:

original - an array we want to start with as prefix

additional - an array we want to append as suffix

Returns:

a new array consisting from original and afterwards additional

aggregate

public static <R,T> R aggregate(Collection<T> elements,
                Aggregator<R,T> aggregator)

Type Parameters:

R - the resulting value of the aggregation

T - the type of the aggregated collection

Parameters:

elements - the collection we would like to aggregate

aggregator - the aggregation strategy to use when aggregating the collection

Returns:

the result of aggregating elements with aggregator.

map

public static <R,T> List<R> map(Collection<T> elements,
                Handler<R,T> handler)

Type Parameters:

R - the result type of the application of the handler function on each of elements' elements

T - the type of the elements collection and handler function input type

Parameters:

elements - the collection to iterate

handler - the function to apply on each element of elements

Returns:

a list containing the results of applying handler on elements sequentially

mapToMap

public static <R,T> Map<T,R> mapToMap(Collection<T> elements,
                      Handler<R,T> handler)

Type Parameters:

R - the result type of the application of the handler function on each of elements' elements

T - the type of the elements collection and handler function input type

Parameters:

elements - the collection to iterate, each one will be a key in the resulting map

handler - the function to apply on each element of elements in order to create a value

Returns:

a mapping from element -> handler(element)

max

public static <C extends Comparable,T> Map.Entry<T,C> max(Collection<T> elements,
                                          Handler<C,T> handler)

sometimes when we want to compare objects according to something that is already comparable, it's easier to write a handler that generates that comparable than to write a comparator. has performance advantages over mapping and taking max, see MaxAggregator docs below for more details.

Type Parameters:

C - comparable type

T - type of elements

Parameters:

elements - on a transformation of which we wish to find the maximum

handler - to transform each element into a comparable

Returns:

element whose transformation is maximal among all others in elements input collection

See Also:

MaxAggregator

containsAny

public static boolean containsAny(Collection container,
                  Collection contained)

Parameters:

container - the containing collection

contained - the collection with a contained element

Returns:

true if container contains any of the elements in contained. this is the same as asking if the collections intersect. the terminology is just because it's sometimes easier to think of it this way.

intersect

public static Collection intersect(Collection container,
                   Collection contained)

Parameters:

container - a collection

contained - another collection

Returns:

an intersection

filter

public static <T> void filter(Collection<T> items,
              Criteria<T> criteria)

Type Parameters:

T - the type of the collection and input parameter of the criteria function returns nothing, works on the items collection in memory. iterator of collection must support the remove method.

Parameters:

items - collection to filter according to criteria

criteria - to use when filtering the items collection

reverseMap

public static <T> Map<T,HashSet<T>> reverseMap(Map<T,? extends Collection<T>> input)

Type Parameters:

T - type of map and collection

Parameters:

input - map to reverse

Returns:

reversed map with value sets switched with key sets.