org.op4j.functions
Class FnArrayOf<T>

Object
  org.op4j.functions.FnArrayOf<T>

Direct Known Subclasses:

FnArrayOfArrayOf, FnArrayOfListOf, FnArrayOfSetOf

public class FnArrayOf<T>
extends Object

Since:

1.0

Author:

Daniel Fernández

Field Summary

protected org.javaruntype.type.Type<T>

type

Constructor Summary

protected

FnArrayOf(org.javaruntype.type.Type<T> type)

Method Summary

Function<T[],T[]>	add(T... newElements)
Function<T[],T[]>	addAll(Collection<T> collection)
Function<T[],Boolean>	all(IFunction<? super T,Boolean> eval)
Function<T[],Boolean>	any(IFunction<? super T,Boolean> eval)
Function<T[],Boolean>	contains(T object)
Function<T[],Boolean>	containsAll(T... objects)
Function<T[],Boolean>	containsAny(T... objects)
Function<T[],Boolean>	containsNone(T... objects)
Function<T[],Integer>	count()
Function<T[],Map<T,T>>	couple()
Function<T[],Map<T,T[]>>	coupleAndGroup()
protected static <K,V> Map<K,V[]>	createFromMapOfList(org.javaruntype.type.Type<V> type, Map<K,List<V>> mapOfList)
Function<T[],T[]>	distinct()
protected static <T> T[]	fromList(Class<?> arrayClass, List<T> object)
Function<T[],T[]>	insert(int position, T... newElements)
Function<T[],Boolean>	notContains(T object)
Function<T[],T[]>	removeAllEqual(T... values)
Function<T[],T[]>	removeAllFalse(IFunction<? super T,Boolean> eval)
Function<T[],T[]>	removeAllIndexes(int... indexes)
Function<T[],T[]>	removeAllIndexesNot(int... indexes)
Function<T[],T[]>	removeAllNotNullAndFalse(IFunction<? super T,Boolean> eval)
Function<T[],T[]>	removeAllNotNullAndTrue(IFunction<? super T,Boolean> eval)
Function<T[],T[]>	removeAllNull()
Function<T[],T[]>	removeAllNullOrFalse(IFunction<? super T,Boolean> eval)
Function<T[],T[]>	removeAllNullOrTrue(IFunction<? super T,Boolean> eval)
Function<T[],T[]>	removeAllTrue(IFunction<? super T,Boolean> eval)
Function<T[],T[]>	reverse()
Function<T[],T[]>	sort()
Function<T[],T[]>	sort(Comparator<? super T> comparator)
Function<T[],T[]>	sortBy(IFunction<? super T,?> by)
<K,V> Function<T[],Map<K,V[]>>	toGroupMapOf(org.javaruntype.type.Type<V> valueType, IFunction<? super T,K> keyFunction, IFunction<? super T,V> valueFunction)
<K,V> Function<T[],Map<K,V[]>>	toGroupMapOf(org.javaruntype.type.Type<V> valueType, IFunction<? super T,Map.Entry<K,V>> mapBuilder)
Function<T[],List<T>>	toList()
<K,V> Function<T[],Map<K,V>>	toMap(IFunction<? super T,K> keyFunction, IFunction<? super T,V> valueFunction)
<K,V> Function<T[],Map<K,V>>	toMap(IFunction<? super T,Map.Entry<K,V>> mapBuilder)
Function<T[],Set<T>>	toSet()
<K> Function<T[],Map<K,T[]>>	zipAndGroupKeys(K... keys)
<K> Function<T[],Map<K,T[]>>	zipAndGroupKeysBy(IFunction<? super T,K> eval)
<K> Function<T[],Map<K,T[]>>	zipAndGroupKeysFrom(Collection<K> keys)
<K> Function<T[],Map<K,T[]>>	zipAndGroupKeysFrom(K[] keys)
<V> Function<T[],Map<T,V[]>>	zipAndGroupValues(org.javaruntype.type.Type<V> valueType, V... values)
<V> Function<T[],Map<T,V[]>>	zipAndGroupValuesBy(org.javaruntype.type.Type<V> valueType, IFunction<? super T,V> eval)
<V> Function<T[],Map<T,V[]>>	zipAndGroupValuesFrom(org.javaruntype.type.Type<V> valueType, Collection<V> values)
<V> Function<T[],Map<T,V[]>>	zipAndGroupValuesFrom(org.javaruntype.type.Type<V> valueType, V[] values)
<K> Function<T[],Map<K,T>>	zipKeys(K... keys)
<K> Function<T[],Map<K,T>>	zipKeysBy(IFunction<? super T,K> eval)
<K> Function<T[],Map<K,T>>	zipKeysFrom(Collection<K> keys)
<K> Function<T[],Map<K,T>>	zipKeysFrom(K[] keys)
<V> Function<T[],Map<T,V>>	zipValues(V... values)
<V> Function<T[],Map<T,V>>	zipValuesBy(IFunction<? super T,V> eval)
<V> Function<T[],Map<T,V>>	zipValuesFrom(Collection<V> values)
<V> Function<T[],Map<T,V>>	zipValuesFrom(V[] values)

Methods inherited from class Object

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

Field Detail

type

protected final org.javaruntype.type.Type<T> type

Constructor Detail

FnArrayOf

protected FnArrayOf(org.javaruntype.type.Type<T> type)

Method Detail

sort

public final Function<T[],T[]> sort()

sort

public final Function<T[],T[]> sort(Comparator<? super T> comparator)

sortBy

public final Function<T[],T[]> sortBy(IFunction<? super T,?> by)

distinct

public final Function<T[],T[]> distinct()

add

public final Function<T[],T[]> add(T... newElements)

insert

public final Function<T[],T[]> insert(int position,
                                      T... newElements)

addAll

public final Function<T[],T[]> addAll(Collection<T> collection)

removeAllIndexes

public final Function<T[],T[]> removeAllIndexes(int... indexes)

removeAllEqual

public final Function<T[],T[]> removeAllEqual(T... values)

removeAllTrue

public final Function<T[],T[]> removeAllTrue(IFunction<? super T,Boolean> eval)

removeAllFalse

public final Function<T[],T[]> removeAllFalse(IFunction<? super T,Boolean> eval)

removeAllIndexesNot

public final Function<T[],T[]> removeAllIndexesNot(int... indexes)

removeAllNull

public final Function<T[],T[]> removeAllNull()

removeAllNotNullAndTrue

public final Function<T[],T[]> removeAllNotNullAndTrue(IFunction<? super T,Boolean> eval)

removeAllNotNullAndFalse

public final Function<T[],T[]> removeAllNotNullAndFalse(IFunction<? super T,Boolean> eval)

removeAllNullOrTrue

public final Function<T[],T[]> removeAllNullOrTrue(IFunction<? super T,Boolean> eval)

removeAllNullOrFalse

public final Function<T[],T[]> removeAllNullOrFalse(IFunction<? super T,Boolean> eval)

toList

public final Function<T[],List<T>> toList()

toSet

public final Function<T[],Set<T>> toSet()

zipKeysBy

public final <K> Function<T[],Map<K,T>> zipKeysBy(IFunction<? super T,K> eval)

zipValuesBy

public final <V> Function<T[],Map<T,V>> zipValuesBy(IFunction<? super T,V> eval)

zipKeys

public final <K> Function<T[],Map<K,T>> zipKeys(K... keys)

zipValues

public final <V> Function<T[],Map<T,V>> zipValues(V... values)

zipKeysFrom

public final <K> Function<T[],Map<K,T>> zipKeysFrom(Collection<K> keys)

zipValuesFrom

public final <V> Function<T[],Map<T,V>> zipValuesFrom(Collection<V> values)

zipKeysFrom

public final <K> Function<T[],Map<K,T>> zipKeysFrom(K[] keys)

zipValuesFrom

public final <V> Function<T[],Map<T,V>> zipValuesFrom(V[] values)

toMap

public final <K,V> Function<T[],Map<K,V>> toMap(IFunction<? super T,Map.Entry<K,V>> mapBuilder)

toMap

public final <K,V> Function<T[],Map<K,V>> toMap(IFunction<? super T,K> keyFunction,
                                                IFunction<? super T,V> valueFunction)

toGroupMapOf

public final <K,V> Function<T[],Map<K,V[]>> toGroupMapOf(org.javaruntype.type.Type<V> valueType,
                                                         IFunction<? super T,Map.Entry<K,V>> mapBuilder)

toGroupMapOf

public final <K,V> Function<T[],Map<K,V[]>> toGroupMapOf(org.javaruntype.type.Type<V> valueType,
                                                         IFunction<? super T,K> keyFunction,
                                                         IFunction<? super T,V> valueFunction)

couple

public final Function<T[],Map<T,T>> couple()

zipAndGroupKeysBy

public final <K> Function<T[],Map<K,T[]>> zipAndGroupKeysBy(IFunction<? super T,K> eval)

zipAndGroupValuesBy

public final <V> Function<T[],Map<T,V[]>> zipAndGroupValuesBy(org.javaruntype.type.Type<V> valueType,
                                                              IFunction<? super T,V> eval)

zipAndGroupKeys

public final <K> Function<T[],Map<K,T[]>> zipAndGroupKeys(K... keys)

zipAndGroupValues

public final <V> Function<T[],Map<T,V[]>> zipAndGroupValues(org.javaruntype.type.Type<V> valueType,
                                                            V... values)

zipAndGroupKeysFrom

public final <K> Function<T[],Map<K,T[]>> zipAndGroupKeysFrom(Collection<K> keys)

zipAndGroupValuesFrom

public final <V> Function<T[],Map<T,V[]>> zipAndGroupValuesFrom(org.javaruntype.type.Type<V> valueType,
                                                                Collection<V> values)

zipAndGroupKeysFrom

public final <K> Function<T[],Map<K,T[]>> zipAndGroupKeysFrom(K[] keys)

zipAndGroupValuesFrom

public final <V> Function<T[],Map<T,V[]>> zipAndGroupValuesFrom(org.javaruntype.type.Type<V> valueType,
                                                                V[] values)

coupleAndGroup

public final Function<T[],Map<T,T[]>> coupleAndGroup()

all

public final Function<T[],Boolean> all(IFunction<? super T,Boolean> eval)

any

public final Function<T[],Boolean> any(IFunction<? super T,Boolean> eval)

count

public final Function<T[],Integer> count()

contains

public final Function<T[],Boolean> contains(T object)

notContains

public final Function<T[],Boolean> notContains(T object)

containsAll

public final Function<T[],Boolean> containsAll(T... objects)

containsAny

public final Function<T[],Boolean> containsAny(T... objects)

containsNone

public final Function<T[],Boolean> containsNone(T... objects)

reverse

public final Function<T[],T[]> reverse()

fromList

protected static final <T> T[] fromList(Class<?> arrayClass,
                                        List<T> object)

createFromMapOfList

protected static final <K,V> Map<K,V[]> createFromMapOfList(org.javaruntype.type.Type<V> type,
                                                            Map<K,List<V>> mapOfList)