org.semanticweb.elk.util.collections

Class Operations

java.lang.Object

org.semanticweb.elk.util.collections.Operations

public class Operations
extends Object

Some useful static methods for collections

Author:

"Yevgeny Kazakov", Peter Skocovsky

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	Operations.Functor<I,O> A simple object that transforms objects of type I to objects of type O
static interface	Operations.FunctorEx<I,O> An extension of Operations.Functor which can do the reverse transformation
static interface	Operations.Transformation<I,O> Transformations of input values to output values

Field Summary

Fields

Modifier and Type	Field and Description
static Multimap<?,?>	EMPTY_MULTIMAP

Constructor Summary

Constructors

Constructor and Description
Operations()

Method Summary

Modifier and Type	Method and Description
static <T> Iterable<T>	concat(Iterable<? extends Iterable<? extends T>> inputs) Concatenates several Iterables into one
static <T> Iterable<T>	concat(Iterable<? extends T>... inputs)
static <T> void	dumpDiff(Collection<T> first, Collection<T> second, Writer writer, String prefix) Prints the elements present in the first Collection but not in the second Collection using the given Writer and prefixing all messages with a given prefix.
static <K,V> void	dumpDiff(Multimap<K,V> first, Multimap<K,V> second, Writer writer, String prefix) Prints key-value entries present in the first Multimap but not in the second Multimap using the given Writer and prefixing all messages with a given prefix.
static <S,T> Multimap<S,T>	emptyMultimap()
static <T> Iterable<T>	filter(Iterable<? extends T> input, Condition<? super T> condition)
static <T,S> Iterable<T>	filter(Iterable<S> input, Class<T> type)
static <T> Set<T>	filter(Set<? extends T> input, Condition<? super T> condition, int size) Returns read-only view of the given set consisting of the elements satisfying a given condition, if the number of such elements is known
static <T> Collection<T>	getCollection(Iterable<T> iterable, int size)
static <T> Comparator<? super Iterable<T>>	lexicalOrder(Comparator<? super T> elementComparator)
static <I,O> Collection<O>	map(Collection<I> input, Operations.Transformation<? super I,O> transformation)
static <I,O> Iterable<O>	map(Iterable<I> input, Operations.Transformation<? super I,O> transformation) Transforms elements using a given Operations.Transformation the output elements consist of the result of the transformation in the same order; if the transformation returns null, it is not included in the output
static <I,O> Iterator<O>	map(Iterator<I> input, Operations.Transformation<? super I,O> transformation)
static <I,O> Set<O>	map(Set<? extends I> input, Operations.FunctorEx<I,O> functor) A simple second-order map function for Sets
static <I,O> Iterable<O>	mapConcat(Iterable<I> input, Operations.Transformation<? super I,Iterable<O>> transformation)
static <I,O> Iterator<O>	mapConcat(Iterator<I> input, Operations.Transformation<? super I,Iterable<O>> transformation)
static <T> Iterable<T>	singleton(T element)
static <T> Iterator<T>	singletonIterator(T element)
static <T> Collection<ArrayList<T>>	split(Collection<? extends T> elements, int batchSize) Splits the input Collection on batches with at most given number of elements.
static <T> Iterable<ArrayList<T>>	split(Iterable<? extends T> elements, int batchSize) Splits the input Iterable on batches with at most given number of elements.
static <T> Iterator<T>	synchronize(Iterator<?> first, Iterator<? extends T> second)
static <T> String	toString(Iterable<T> iterable)

Methods inherited from class java.lang.Object

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

Field Detail

EMPTY_MULTIMAP

public static final Multimap<?,?> EMPTY_MULTIMAP

Constructor Detail

Operations

public Operations()

Method Detail

emptyMultimap

public static <S,T> Multimap<S,T> emptyMultimap()

concat

@SafeVarargs
public static <T> Iterable<T> concat(Iterable<? extends T>... inputs)

singletonIterator

public static <T> Iterator<T> singletonIterator(T element)

singleton

public static <T> Iterable<T> singleton(T element)

concat

public static <T> Iterable<T> concat(Iterable<? extends Iterable<? extends T>> inputs)

Concatenates several Iterables into one

Type Parameters:

T - the type of elements of Iterables

Parameters:

inputs - the Iterable of Iterables to be concatenated

Returns:

Iterable consisting of all elements found in input Iterables

synchronize

public static <T> Iterator<T> synchronize(Iterator<?> first,
                                          Iterator<? extends T> second)

Type Parameters:

T - the type of elements of iterators

Parameters:

first - the elements that should come first

second - the elements that should come next

Returns:

an iterator that iterates that advances the two given iterators at the same time and returns the values of the second iterator

split

public static <T> Iterable<ArrayList<T>> split(Iterable<? extends T> elements,
                                               int batchSize)

Splits the input Iterable on batches with at most given number of elements.

Type Parameters:

T - the type of elements in the Iterable

Parameters:

elements - the Iterable to be split

batchSize - the maximal number of elements in batches

Returns:

a Iterable of batches containing elements from the input collection

See Also:

concat(Iterable)

split

public static <T> Collection<ArrayList<T>> split(Collection<? extends T> elements,
                                                 int batchSize)

Splits the input Collection on batches with at most given number of elements.

Type Parameters:

T - the type of elements in the Collection

Parameters:

elements - the Collection to be split

batchSize - the maximal number of elements in batches

Returns:

a Collection of batches containing elements from the input collection

getCollection

public static <T> Collection<T> getCollection(Iterable<T> iterable,
                                              int size)

filter

public static <T> Iterable<T> filter(Iterable<? extends T> input,
                                     Condition<? super T> condition)

Type Parameters:

T - the type of elements

Parameters:

input - the input iterator over these elements

condition - the condition used for filtering

Returns:

the filtered iterator

filter

public static <T,S> Iterable<T> filter(Iterable<S> input,
                                       Class<T> type)

filter

public static <T> Set<T> filter(Set<? extends T> input,
                                Condition<? super T> condition,
                                int size)

Returns read-only view of the given set consisting of the elements satisfying a given condition, if the number of such elements is known

Type Parameters:

T - the type of elements

Parameters:

input - the given set to be filtered

condition - the condition used for filtering the set. Must be consistent with equals() for T, that is: a.equals(b) must imply that holds(a) == holds(b)

size - the number of elements in the filtered set

Returns:

the set consisting of the elements of the input set satisfying the given condition

map

public static <I,O> Iterable<O> map(Iterable<I> input,
                                    Operations.Transformation<? super I,O> transformation)

Transforms elements using a given Operations.Transformation the output elements consist of the result of the transformation in the same order; if the transformation returns null, it is not included in the output

Type Parameters:

I - the type of input of elements

O - the type of output elements

Parameters:

input - the input elements

transformation - the transformation for elements

Returns:

the transformed output elements

mapConcat

public static <I,O> Iterable<O> mapConcat(Iterable<I> input,
                                          Operations.Transformation<? super I,Iterable<O>> transformation)

map

public static <I,O> Collection<O> map(Collection<I> input,
                                      Operations.Transformation<? super I,O> transformation)

map

public static <I,O> Iterator<O> map(Iterator<I> input,
                                    Operations.Transformation<? super I,O> transformation)

mapConcat

public static <I,O> Iterator<O> mapConcat(Iterator<I> input,
                                          Operations.Transformation<? super I,Iterable<O>> transformation)

dumpDiff

public static <K,V> void dumpDiff(Multimap<K,V> first,
                                  Multimap<K,V> second,
                                  Writer writer,
                                  String prefix)
                           throws IOException

Prints key-value entries present in the first Multimap but not in the second Multimap using the given Writer and prefixing all messages with a given prefix.

Type Parameters:

K - the type of the keys of the Multimap

V - the type of the values of the Multimap

Parameters:

first - the entries that should be printed

second - the entries that should be skipped

writer - the writer using which the entries should be printed

prefix - the string to be appended to every line

Throws:

IOException - if any I/O error occurs

dumpDiff

public static <T> void dumpDiff(Collection<T> first,
                                Collection<T> second,
                                Writer writer,
                                String prefix)
                         throws IOException

Prints the elements present in the first Collection but not in the second Collection using the given Writer and prefixing all messages with a given prefix.

Type Parameters:

T - the type of elements

Parameters:

first - the elements to be printed

second - the elements to be skipped

writer - the writer using which the elements should be printed

prefix - the string to be appended to every line

Throws:

IOException - if any I/O error occurs

map

public static <I,O> Set<O> map(Set<? extends I> input,
                               Operations.FunctorEx<I,O> functor)

A simple second-order map function for Sets

Type Parameters:

I - the type of elements of the input Set

O - the type of elements of this Set

Parameters:

input - the input Set to be converted

functor - the Operations.Functor that applies to the input elements

Returns:

a set which contains the results of applying the Operations.Functor to the elements in the input Set

toString

public static <T> String toString(Iterable<T> iterable)

lexicalOrder

public static final <T> Comparator<? super Iterable<T>> lexicalOrder(Comparator<? super T> elementComparator)

Type Parameters:

T - the type of elements

Parameters:

elementComparator - a Comparator on these elements

Returns:

Comparator that compares Iterable according to lexical order w.r.t. element ordering defined by the provided element Comparator.