eu.bandm.tools.ops

Class Collections

java.lang.Object

eu.bandm.tools.ops.Collections

public abstract class Collections
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	Collections.LiteralList<A> Very similar to java.util.Arrays.asList(), but truely immutable.
static interface	Collections.LiteralMap<A,B>
static interface	Collections.LiteralSet<A>

Method Summary

Modifier and Type	Method and Description
static <A,B> Map<A,B>	asGraph(Function<? super A,? extends B> fun, Set<? extends A> things)
static <A,B> Collection<B>	asMap(Function<? super A,? extends B> fun, Collection<? extends A> things)
static <A,B,C extends B> Map<A,B>	castValues(Class<? extends C> cls, Map<A,C> things)
static <A> Collection<A>	concat(Collection<? extends A> some, Collection<? extends A> other)
static <A,B> Map<B,A>	converse(Map<A,B> map)
static <A,B> boolean	doFilterKey(Predicate<? super A> p, Map<A,B> m)
static <A,B> boolean	doFilterValue(Predicate<? super B> p, Map<A,B> m)
static <A> Set<A>	elements(Collection<? extends A> things)
static <A> SortedSet<A>	elements(Collection<? extends A> things, Comparator<? super A> comparator)
static <A,B> SortedMap<A,B>	emptySortedMap()
static <A> SortedSet<A>	emptySortedSet()
static <K,V> Map.Entry<K,V>	entry(K key, V value)
static <A> Collection<A>	flatten(Collection<? extends Collection<A>> colls)
static <A,B> B	fold(GenMonoid<? super A,B> mon, Collection<? extends A> things)
static <A,B> B	fold(GenSemigroup<? super A,B> grp, Collection<? extends A> things)
static <A,B> Function<Map.Entry<? extends A,? extends B>,A>	getKey()
static <A,B> Function<Map.Entry<? extends A,? extends B>,B>	getValue()
static <A> Set<A>	intersection(Collection<? extends A> some, Collection<? extends A> other)
static <T> BiFunction<Set<T>,Set<T>,Set<T>>	intersectionF()
static <A> Collections.LiteralList<A>	literalList() Very similar to java.util.Arrays.asList(), but truely immutable.
static <A> Collections.LiteralList<A>	literalList(A value) Very similar to java.util.Arrays.asList(), but truely immutable.
static <A> Collections.LiteralList<A>	literalList(A value1, A value2) Very similar to java.util.Arrays.asList(), but truely immutable.
static <A> Collections.LiteralList<A>	literalList(A value1, A value2, A value3) Very similar to java.util.Arrays.asList(), but truely immutable.
static <A> Collections.LiteralList<A>	literalList(A value1, A value2, A value3, A value4) Very similar to java.util.Arrays.asList(), but truely immutable.
static <A,B> Collections.LiteralMap<A,B>	literalMap()
static <A,B> Collections.LiteralMap<A,B>	literalMap(A key, B value)
static <A,B> Collections.LiteralMap<A,B>	literalMap(A key1, B value1, A key2, B value2)
static <A,B> Collections.LiteralMap<A,B>	literalMap(A key1, B value1, A key2, B value2, A key3, B value3)
static <A,B> Collections.LiteralMap<A,B>	literalMap(A key1, B value1, A key2, B value2, A key3, B value3, A key4, B value4)
static <A> Collections.LiteralSet<A>	literalSet()
static <A> Collections.LiteralSet<A>	literalSet(A value)
static <A> Collections.LiteralSet<A>	literalSet(A value1, A value2)
static <A> Collections.LiteralSet<A>	literalSet(A value1, A value2, A value3)
static <A> Collections.LiteralSet<A>	literalSet(A value1, A value2, A value3, A value4)
static <A,B> Collection<B>	map(Function<? super A,? extends B> fun, Collection<? extends A> things) Deprecated. use instead or toMap(java.util.function.Function<? super A, ? extends B>, java.util.Collection<? extends A>) instead.
static <A,B,C> Map.Entry<A,C>	map(Function<? super B,? extends C> fun, Map.Entry<A,B> e)
static <A,B,C> Map<A,C>	map(Function<? super B,? extends C> fun, Map<A,B> things)
static <A,B,C> Function<Map.Entry<A,B>,Map.Entry<A,C>>	mapEntry(Function<? super B,? extends C> fun)
static <A,B,C> Function<Map.Entry<A,B>,Map.Entry<A,C>>	mapEntryWithKey(Function<? super Map.Entry<A,B>,? extends C> fun)
static <A,B,C> Map<A,C>	mapWithKey(BiFunction<? super A,? super B,? extends C> fun, Map<A,B> things)
static <A,B,C> Map<A,C>	mapWithKey(Function<? super Map.Entry<A,B>,? extends C> fun, Map<A,B> things)
static <T> T	one(Collection<T> set) Deprecated. use the(java.util.Collection<T>) instead.
static <T> BiFunction<T,T,T>	otherwise()
static <A> Set<A>	setminus(Collection<? extends A> some, Collection<? extends A> other)
static <A extends Comparable<? super A>,B> SortedMap<A,B>	singletonSortedMap(A key, B value)
static <A,B> SortedMap<A,B>	singletonSortedMap(Comparator<? super A> comparator, A key, B value)
static <A extends Comparable<? super A>> SortedSet<A>	singletonSortedSet(A elem)
static <A> SortedSet<A>	singletonSortedSet(Comparator<? super A> comparator, A elem)
static <T> T	some(Collection<T> set)
static <T> T	the(Collection<T> set)
static <A> Collection<A>	toFilter(Predicate<? super A> pred, Collection<? extends A> things)
static <A> List<A>	toFilter(Predicate<? super A> pred, List<A> things)
static <A> Set<A>	toFilter(Predicate<? super A> pred, Set<? extends A> things)
static <A> SortedSet<A>	toFilter(Predicate<? super A> pred, SortedSet<A> things)
static <A,B> Map<A,B>	toGraph(Function<? super A,? extends B> fun, Set<? extends A> dom)
static <A,B> Collection<B>	toMap(Function<? super A,? extends B> fun, Collection<? extends A> things)
static <A,B> Set<B>	toMap(Function<? super A,? extends B> fun, Set<? extends A> things)
static <A,B> SortedSet<B>	toMap(Function<? super A,? extends B> fun, SortedSet<A> things, Comparator<? super B> comparator)
static <A,B,C> Map<B,C>	toSpan(Function<? super A,? extends B> left, Function<? super A,? extends C> right, Collection<? extends A> gen)
static <A> Set<A>	union(Collection<? extends A> some, Collection<? extends A> other)
static <T> BiFunction<Set<T>,Set<T>,Set<T>>	unionF()
static <K,V> Map.Entry<K,V>	unmodifiableEntry(Map.Entry<? extends K,? extends V> entry)
static <A,B,C> Map<A,C>	zip(GenMonoid<B,C> mon, Map<A,B> m, Map<A,B> n)

Methods inherited from class java.lang.Object

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

Method Detail

toFilter

public static <A> Collection<A> toFilter(Predicate<? super A> pred,
                                         Collection<? extends A> things)

toFilter

public static <A> Set<A> toFilter(Predicate<? super A> pred,
                                  Set<? extends A> things)

toFilter

public static <A> SortedSet<A> toFilter(Predicate<? super A> pred,
                                        SortedSet<A> things)

toFilter

public static <A> List<A> toFilter(Predicate<? super A> pred,
                                   List<A> things)

one

@Deprecated
public static <T> T one(Collection<T> set)

Deprecated. use the(java.util.Collection<T>) instead.

the

public static <T> T the(Collection<T> set)

some

public static <T> T some(Collection<T> set)

map

@Deprecated
public static <A,B> Collection<B> map(Function<? super A,? extends B> fun,
                                                  Collection<? extends A> things)

Deprecated. use instead or toMap(java.util.function.Function<? super A, ? extends B>, java.util.Collection<? extends A>) instead.

asMap

public static <A,B> Collection<B> asMap(Function<? super A,? extends B> fun,
                                        Collection<? extends A> things)

toMap

public static <A,B> Collection<B> toMap(Function<? super A,? extends B> fun,
                                        Collection<? extends A> things)

toMap

public static <A,B> Set<B> toMap(Function<? super A,? extends B> fun,
                                 Set<? extends A> things)

toMap

public static <A,B> SortedSet<B> toMap(Function<? super A,? extends B> fun,
                                       SortedSet<A> things,
                                       Comparator<? super B> comparator)

literalSet

public static <A> Collections.LiteralSet<A> literalSet()

literalSet

public static <A> Collections.LiteralSet<A> literalSet(A value)

literalSet

public static <A> Collections.LiteralSet<A> literalSet(A value1,
                                                       A value2)

literalSet

public static <A> Collections.LiteralSet<A> literalSet(A value1,
                                                       A value2,
                                                       A value3)

literalSet

public static <A> Collections.LiteralSet<A> literalSet(A value1,
                                                       A value2,
                                                       A value3,
                                                       A value4)

literalList

public static <A> Collections.LiteralList<A> literalList()

Very similar to java.util.Arrays.asList(), but truely immutable.

literalList

public static <A> Collections.LiteralList<A> literalList(A value)

Very similar to java.util.Arrays.asList(), but truely immutable.

literalList

public static <A> Collections.LiteralList<A> literalList(A value1,
                                                         A value2)

Very similar to java.util.Arrays.asList(), but truely immutable.

literalList

public static <A> Collections.LiteralList<A> literalList(A value1,
                                                         A value2,
                                                         A value3)

Very similar to java.util.Arrays.asList(), but truely immutable.

literalList

public static <A> Collections.LiteralList<A> literalList(A value1,
                                                         A value2,
                                                         A value3,
                                                         A value4)

Very similar to java.util.Arrays.asList(), but truely immutable.

map

public static <A,B,C> Map<A,C> map(Function<? super B,? extends C> fun,
                                   Map<A,B> things)

asGraph

public static <A,B> Map<A,B> asGraph(Function<? super A,? extends B> fun,
                                     Set<? extends A> things)

mapWithKey

public static <A,B,C> Map<A,C> mapWithKey(Function<? super Map.Entry<A,B>,? extends C> fun,
                                          Map<A,B> things)

mapWithKey

public static <A,B,C> Map<A,C> mapWithKey(BiFunction<? super A,? super B,? extends C> fun,
                                          Map<A,B> things)

map

public static <A,B,C> Map.Entry<A,C> map(Function<? super B,? extends C> fun,
                                         Map.Entry<A,B> e)

mapEntry

public static <A,B,C> Function<Map.Entry<A,B>,Map.Entry<A,C>> mapEntry(Function<? super B,? extends C> fun)

mapEntryWithKey

public static <A,B,C> Function<Map.Entry<A,B>,Map.Entry<A,C>> mapEntryWithKey(Function<? super Map.Entry<A,B>,? extends C> fun)

doFilterKey

public static <A,B> boolean doFilterKey(Predicate<? super A> p,
                                        Map<A,B> m)

doFilterValue

public static <A,B> boolean doFilterValue(Predicate<? super B> p,
                                          Map<A,B> m)

zip

public static <A,B,C> Map<A,C> zip(GenMonoid<B,C> mon,
                                   Map<A,B> m,
                                   Map<A,B> n)

toSpan

public static <A,B,C> Map<B,C> toSpan(Function<? super A,? extends B> left,
                                      Function<? super A,? extends C> right,
                                      Collection<? extends A> gen)

toGraph

public static <A,B> Map<A,B> toGraph(Function<? super A,? extends B> fun,
                                     Set<? extends A> dom)

concat

public static <A> Collection<A> concat(Collection<? extends A> some,
                                       Collection<? extends A> other)

union

public static <A> Set<A> union(Collection<? extends A> some,
                               Collection<? extends A> other)

setminus

public static <A> Set<A> setminus(Collection<? extends A> some,
                                  Collection<? extends A> other)

intersection

public static <A> Set<A> intersection(Collection<? extends A> some,
                                      Collection<? extends A> other)

intersectionF

public static final <T> BiFunction<Set<T>,Set<T>,Set<T>> intersectionF()

unionF

public static final <T> BiFunction<Set<T>,Set<T>,Set<T>> unionF()

otherwise

public static final <T> BiFunction<T,T,T> otherwise()

flatten

public static <A> Collection<A> flatten(Collection<? extends Collection<A>> colls)

unmodifiableEntry

public static <K,V> Map.Entry<K,V> unmodifiableEntry(Map.Entry<? extends K,? extends V> entry)

entry

public static <K,V> Map.Entry<K,V> entry(K key,
                                         V value)

getKey

public static <A,B> Function<Map.Entry<? extends A,? extends B>,A> getKey()

getValue

public static <A,B> Function<Map.Entry<? extends A,? extends B>,B> getValue()

fold

public static <A,B> B fold(GenSemigroup<? super A,B> grp,
                           Collection<? extends A> things)

fold

public static <A,B> B fold(GenMonoid<? super A,B> mon,
                           Collection<? extends A> things)

elements

public static <A> Set<A> elements(Collection<? extends A> things)

elements

public static <A> SortedSet<A> elements(Collection<? extends A> things,
                                        Comparator<? super A> comparator)

castValues

public static <A,B,C extends B> Map<A,B> castValues(Class<? extends C> cls,
                                                    Map<A,C> things)

literalMap

public static <A,B> Collections.LiteralMap<A,B> literalMap()

literalMap

public static <A,B> Collections.LiteralMap<A,B> literalMap(A key,
                                                           B value)

literalMap

public static <A,B> Collections.LiteralMap<A,B> literalMap(A key1,
                                                           B value1,
                                                           A key2,
                                                           B value2)

literalMap

public static <A,B> Collections.LiteralMap<A,B> literalMap(A key1,
                                                           B value1,
                                                           A key2,
                                                           B value2,
                                                           A key3,
                                                           B value3)

literalMap

public static <A,B> Collections.LiteralMap<A,B> literalMap(A key1,
                                                           B value1,
                                                           A key2,
                                                           B value2,
                                                           A key3,
                                                           B value3,
                                                           A key4,
                                                           B value4)

emptySortedSet

public static <A> SortedSet<A> emptySortedSet()

singletonSortedSet

public static <A extends Comparable<? super A>> SortedSet<A> singletonSortedSet(A elem)

singletonSortedSet

public static <A> SortedSet<A> singletonSortedSet(Comparator<? super A> comparator,
                                                  A elem)

emptySortedMap

public static <A,B> SortedMap<A,B> emptySortedMap()

singletonSortedMap

public static <A extends Comparable<? super A>,B> SortedMap<A,B> singletonSortedMap(A key,
                                                                                    B value)

singletonSortedMap

public static <A,B> SortedMap<A,B> singletonSortedMap(Comparator<? super A> comparator,
                                                      A key,
                                                      B value)

converse

public static <A,B> Map<B,A> converse(Map<A,B> map)