org.apache.ignite.internal.util.lang

## Class GridFunc

- java.lang.Object
- - org.apache.ignite.internal.util.lang.GridFunc

Direct Known Subclasses:
  F

    public class GridFunc
    extends Object

Contains factory and utility methods for `closures`, `predicates`, and `tuples`. It also contains functional style collection comprehensions.

Most of the methods in this class can be divided into two groups:

- Factory higher-order methods for closures, predicates and tuples, and
- Utility higher-order methods for processing collections with closures and predicates.

Note that contrary to the usual design this class has substantial number of methods (over 200). This design is chosen to simulate a global namespace (like a `Predef` in Scala) to provide general utility and functional programming functionality in a shortest syntactical context using `F` typedef.

Also note, that in all methods with predicates, null predicate has a `true` meaning. So does the empty predicate array.

### Field Summary

Fields
`static IgnitePredicate<Object>` `IS_NOT_NULL`
`static IgnitePredicate<Object>` `IS_NULL`

### Constructor Summary

Constructors
Constructor and Description
`GridFunc()`

### Method Summary

Methods
`static <T,C extends Collection<T>> C` `addAll(C c, Iterable<? extends T> it)`
`static <T,C extends Collection<T>> C` `addAll(C c, Iterator<? extends T> it)`
`static <K,V> V` `addIfAbsent(ConcurrentMap<K,V> map, K key, Callable<V> c)` Gets the value with given key.
`static <K,V> V` `addIfAbsent(ConcurrentMap<K,V> map, K key, V val)` Gets the value with given key.
`static <K,V> V` `addIfAbsent(Map<? super K,V> map, K key, Callable<? extends V> c)` Utility map getter.
`static <K,V> V` `addIfAbsent(Map<K,V> map, K key, V v)` Utility map getter.
`static <T> IgnitePredicate<T>` `alwaysFalse()` Gets predicate that always returns `false`.
`static <T> IgnitePredicate<T>` `alwaysTrue()` Gets predicate that always returns `true`.
`static <T> IgnitePredicate<T>` `and(IgnitePredicate<? super T>... ps)` Get a predicate that evaluates to `true` if each of its component predicates evaluates to `true`.
`static GridAbsClosure` `as(Runnable r)` Converts given runnable to an absolute closure.
`static <T> T[]` `asArray(T... t)` Convenience method to convert multiple elements into array.
`static <T> List<T>` `asList(T... vals)` Converts array to `List`.
`static <T> List<T>` `asList(T t)` Creates read-only list with given values.
`static <K,V> Map<K,V>` `asMap(K k, V v)` Creates map with given values.
`static <K,V> Map<K,V>` `asMap(K k1, V v1, K k2, V v2)` Creates map with given values.
`static <K,V> Map<K,V>` `asMap(K k1, V v1, K k2, V v2, K k3, V v3)` Creates map with given values.
`static <K,V> Map<K,V>` `asMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)` Creates map with given values.
`static <K,V> Map<K,V>` `asMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)` Creates map with given values.
`static <T> Set<T>` `asSet(T... t)` Creates read-only set with given values.
`static <T> Set<T>` `asSet(T t)` Creates read-only set with given value.
`static <T> void` `awaitAll(Collection<IgniteInternalFuture<T>> futs)` Waits until all passed futures will be executed.
`static <T> void` `awaitAll(long timeout, Collection<IgniteInternalFuture<T>> futs)` Waits until all passed futures will be executed.
`static <T,R> R` `awaitAll(long timeout, IgniteReducer<T,R> rdc, Collection<IgniteInternalFuture<T>> futs)` Awaits for all futures to complete and optionally reduces all results into one.
`static <K,V> IgniteClosure<javax.cache.Cache.Entry<K,V>,V>` `cacheEntry2Get()` Gets closure that returns value for an entry.
`static <K,V> IgniteClosure<javax.cache.Cache.Entry<K,V>,K>` `cacheEntry2Key()` Gets closure that returns key for cache entry.
`static <K,V> IgnitePredicate<javax.cache.Cache.Entry<K,V>>` `cacheHasPeekValue()` Gets predicate which returns `true` if entry has peek value.
`static <T> Collection<T>` `concat(boolean cp, Collection<T> c1, Collection<T> c2)` Concatenates 2 collections into one.
`static <T> Collection<T>` `concat(boolean cp, T t, Collection<T> c)` Concatenates an element to a collection.
`static String` `concat(Iterable<String> c, String delim)` Concatenates strings using provided delimiter.
`static <T> Iterator<T>` `concat(Iterator<Iterator<T>> iters)` Concatenates multiple iterators as single one.
`static <T> Iterator<T>` `concat(Iterator<T>... iters)` Concatenates multiple iterators as single one.
`static <T> T[]` `concat(T[] arr, T... obj)` Concatenates an elements to an array.
`static IgniteReducer<String,String>` `concatReducer(String delim)` Gets reducer closure that concatenates strings using provided delimiter.
`static <T> IgnitePredicate<T>` `contains(Collection<T> c)` Provides predicate which returns `true` if it receives an element that is contained in the passed in collection.
`static <T> boolean` `contains(Collection<T> c, T t)` Checks if value is contained in the collection passed in.
`static boolean` `contains(int[] arr, int val)`
`static boolean` `contains(Integer[] arr, int val)`
`static boolean` `contains(long[] arr, long val)`
`static <T> boolean` `containsAll(Collection<? extends T> c1, Iterable<? extends T> c2)` Checks if collection `c1` contains all elements from collection `c2`.
`static <T> boolean` `containsAny(Collection<? extends T> c1, Iterable<? extends T> c2)` Checks if collection `c1` contains any elements from collection `c2`.
`static <T> boolean` `containsAny(Collection<? extends T> c1, T... c2)` Checks if collection `c1` contains any elements from array `c2`.
`static <T> Collection<T>` `copy(Collection<T> to, Iterable<? extends T> from, IgnitePredicate<? super T>... p)` Adds (copies) to given collection using provided predicates.
`static <T> Collection<T>` `copy(Collection<T> to, T... from)` Adds (copies) to given collection all elements in `'from'` array.
`static <T,R> IgniteOutClosure<R>` `curry(IgniteClosure<? super T,R> f, T e)` Curries given closure.
`static <T> GridAbsClosure` `curry(IgniteInClosure<? super T> f, T e)` Curries given closure.
`static <T> Collection<T>` `dedup(Collection<? extends T> c)` Creates new collection by removing duplicates from the given collection.
`static <T> GridIterator<T>` `emptyIterator()` Creates new empty iterator.
`static boolean` `eq(Object o1, Object o2)` Tests whether specified arguments are equal, or both `null`.
`static boolean` `eqArray(Object[] a1, Object[] a2, boolean sorted, boolean dups)` Compares two arrays.
`static boolean` `eqNodes(Object n1, Object n2)` Compares two `ClusterNode` instances for equality.
`static boolean` `eqNotOrdered(Collection<?> c1, Collection<?> c2)` Checks if both collections have equal elements in any order.
`static <K,V> boolean` `eqNotOrdered(Map<K,V> m1, Map<K,V> m2)` Compares two maps.
`static boolean` `eqOrdered(Collection<?> c1, Collection<?> c2)` Checks if both collections have equal elements in the same order.
`static <T> IgnitePredicate<T>` `equalTo(T target)` Gets predicate that evaluates to `true` if its free variable is equal to `target` or both are `null`.
`static <V> boolean` `exist(Iterable<? extends V> c, IgnitePredicate<? super V>... p)` Checks for existence of the element in input collection for which all provided predicates evaluate to `true`.
`static <T> List<T>` `filterList(List<T> c, boolean cp, IgnitePredicate<T>... p)` Loses all elements in input list for which any of the predicates evaluate to `true`.
`static <V> V` `find(Iterable<? extends V> c, V dfltVal, IgnitePredicate<? super V>... p)` Finds and returns first element in given collection for which any of the provided predicates evaluates to `true`.
`static <V,Y> Y` `find(Iterable<? extends V> c, Y dfltVal, IgniteClosure<? super V,Y> f, IgnitePredicate<? super V>... p)` Finds, transforms and returns first element in given collection for which any of the provided predicates evaluates to `true`.
`static <T> T` `first(Iterable<? extends T> c)` Gets first element from given collection or returns `null` if the collection is empty.
`static <T> T` `first(List<? extends T> list)` Gets first element from given list or returns `null` if list is empty.
`static <K,V> Map.Entry<K,V>` `firstEntry(Map<K,V> m)` Gets first key from given map or returns `null` if the map is empty.
`static <K> K` `firstKey(Map<K,?> m)` Gets first key from given map or returns `null` if the map is empty.
`static <V> V` `firstValue(Map<?,V> m)` Gets first value from given map or returns `null` if the map is empty.
`static <T> GridIterator<T>` `flat(Iterable<? extends Iterable<T>> c)` Flattens iterable-of-iterables and returns iterable over the elements of the inner collections.
`static <T> Collection<T>` `flatCollections(Collection<? extends Collection<T>> c)` Flattens collection-of-collections and returns collection over the elements of the inner collections.
`static <T> Iterator<T>` `flatIterators(Iterable<Iterator<T>> c)` Flattens iterable-of-iterators and returns iterator over the elements of the inner collections.
`static <D,B> B` `fold(Iterable<? extends D> c, B b, IgniteBiClosure<? super D,? super B,B>... fs)` Folds-right given collection using provided closure.
`static <V> boolean` `forAll(Iterable<? extends V> c, IgnitePredicate<? super V>... p)` Applies all given predicates to all elements in given input collection and returns `true` if all of them evaluate to `true` for all elements.
`static <K1,K extends K1,V1,V extends V1> boolean` `forAll(Map<K,V> m, IgnitePredicate<? super Map.Entry<K,V>>... p)` Applies given predicates to all entries in given input map and returns `true` if all of them evaluates to `true` for all entries.
`static <V> boolean` `forAny(Iterable<? extends V> c, IgnitePredicate<? super V>... p)` Applies all given predicates to all elements in given input collection and returns `true` if all predicates evaluate to `true` for at least one element.
`static <X> void` `forEach(Iterable<? extends X> c, IgniteInClosure<? super X> f, IgnitePredicate<? super X>... p)` Calls given `side-effect only` closure over the each element of the provided collection.
`static <X> void` `forEach(X[] c, IgniteInClosure<? super X> f, IgnitePredicate<? super X>... p)` Calls given `side-effect only` closure over the each element of the provided array.
`static Collection<String>` `id8s(Collection<UUID> ids)` Convenient utility method that returns collection of node ID8s for a given collection of node IDs.
`static <T> IgniteClosure<T,T>` `identity()` Gets identity closure, i.e. the closure that returns its variable value.
`static <T> IgniteReducer<T,T>` `identityReducer(T elem)` Gets reducer which always returns `true` from `IgniteReducer.collect(Object)` method and passed in `element` from `IgniteReducer.reduce()` method.
`static IgnitePredicate<UUID>` `idForNodeId(UUID nodeId)` Creates `UUID` predicate evaluating on the given node ID.
`static <T> IgnitePredicate<T>` `instanceOf(Class<?> cls)` Gets predicate that evaluates to `true` if its free variable is instance of the given class.
`static <E> boolean` `intersects(Iterable<E> s1, Collection<E>... s2)` Checks if two collections passed in intersect.
`static <T> boolean` `isAll(T t, IgnitePredicate<? super T>... p)` Tests if all provided predicates evaluate to `true` for given value.
`static boolean` `isAlwaysFalse(IgnitePredicate p)` Tests whether or not given predicate is the one returned from `alwaysFalse()` method.
`static boolean` `isAlwaysFalse(IgnitePredicate[] p)` Tests whether or not given set of predicates consists only of one predicate returned from `alwaysFalse()` method.
`static boolean` `isAlwaysTrue(IgnitePredicate p)` Tests whether or not given predicate is the one returned from `alwaysTrue()` method.
`static boolean` `isAlwaysTrue(IgnitePredicate[] p)` Tests whether or not given set of predicates consists only of one predicate returned from `alwaysTrue()` method.
`static <T> boolean` `isAny(T t, IgnitePredicate<? super T>... p)` Tests if any of provided predicates evaluate to `true` for given value.
`static boolean` `isEmpty(byte[] c)` Tests if the given array is either `null` or empty.
`static boolean` `isEmpty(Collection<?> c)` Tests if the given collection is either `null` or empty.
`static boolean` `isEmpty(int[] c)` Tests if the given array is either `null` or empty.
`static boolean` `isEmpty(Iterable<?> c)` Tests if the given collection is either `null` or empty.
`static boolean` `isEmpty(long[] c)` Tests if the given array is either `null` or empty.
`static boolean` `isEmpty(Map<?,?> m)` Tests if the given map is either `null` or empty.
`static boolean` `isEmpty(String s)` Tests if given string is `null` or empty.
`static <T> boolean` `isEmpty(T[] c)` Tests if the given array is either `null` or empty.
`static <T> boolean` `isEmptyOrNulls(T[] c)` Tests if the given array is `null`, empty or contains only `null` values.
`static <T> IgnitePredicate<T>` `isNull()` Gets predicate that evaluates to `true` if its free variable is `null`.
`static <T1,T2> GridIterator<T2>` `iterator(Iterable<? extends T1> c, IgniteClosure<? super T1,T2> trans, boolean readOnly, IgnitePredicate<? super T1>... p)` Creates and returns transforming iterator from given collection and optional filtering predicates.
`static <T1,T2> Iterator<T2>` `iterator(Iterator<? extends T1> c, IgniteClosure<? super T1,T2> trans, boolean readOnly, IgnitePredicate<? super T1>... p)`
`static <T> GridIterator<T>` `iterator0(Iterable<? extends T> c, boolean readOnly, IgnitePredicate<? super T>... p)` Creates and returns iterator from given collection and optional filtering predicates.
`static <T> Collection<T>` `jobResults(Collection<? extends ComputeJobResult> res)` Gets collections of data items from grid job res casted to specified type.
`static <T> T` `last(Iterable<? extends T> c)` Gets last element from given collection or returns `null` if the collection is empty.
`static <T extends ClusterNode> IgnitePredicate<T>` `localNode(UUID locNodeId)` Gets predicate that evaluates to `true` only for given local node ID.
`static <T0,T extends T0> Collection<T>` `lose(Collection<T> c, boolean cp, Collection<T0> filter)` Loses all elements in input collection that are contained in `filter` collection.
`static <T> Collection<T>` `lose(Collection<T> c, boolean cp, IgnitePredicate<? super T>... p)` Loses all elements in input collection that are evaluated to `true` by all given predicates.
`static <K,V> Map<K,V>` `lose(Map<K,V> m, boolean cp, IgnitePredicate<? super Map.Entry<K,V>>... p)` Loses all entries in input map that are evaluated to `true` by all given predicates.
`static <K,V> Map<K,V>` `loseKeys(Map<K,V> m, boolean cp, IgnitePredicate<? super K>... p)` Loses all entries in input map which keys are evaluated to `true` by all given predicates.
`static <T> List<T>` `loseList(List<T> c, boolean cp, Collection<? super T> filter)` Loses all elements in input list that are contained in `filter` collection.
`static <K,V> Map<K,V>` `loseValues(Map<K,V> m, boolean cp, IgnitePredicate<? super V>... p)` Loses all entries in input map which values are evaluated to `true` by all given predicates.
`static IgniteCallable<AtomicBoolean>` `newAtomicBoolean()` Returns a factory closure that creates new `AtomicBoolean` instance initialized to `false`.
`static IgniteCallable<AtomicInteger>` `newAtomicInt()` Returns a factory closure that creates new `AtomicInteger` instance initialized to `zero`.
`static IgniteCallable<AtomicLong>` `newAtomicLong()` Returns a factory closure that creates new `AtomicLong` instance initialized to `zero`.
`static <T> IgniteCallable<AtomicReference<T>>` `newAtomicRef()` Returns a factory closure that creates new `AtomicReference` instance initialized to `null`.
`static <K,V> IgniteCallable<ConcurrentMap<K,V>>` `newCMap()` Returns a factory closure that creates new `ConcurrentMap` instance.
`static <E> IgniteCallable<Set<E>>` `newCSet()` Returns a factory closure that creates new `GridConcurrentHashSet` instance.
`static <T> IgniteCallable<ConcurrentLinkedDeque8<T>>` `newDeque()` Returns a factory closure that creates new `ConcurrentLinkedDeque8` instance.
`static <T> IgniteCallable<LinkedList<T>>` `newLinkedList()` Returns a factory closure that creates new `LinkedList` instance.
`static <T> IgniteCallable<List<T>>` `newList()` Returns a factory closure that creates new `List` instance.
`static <K,V> IgniteCallable<Map<K,V>>` `newMap()` Returns a factory closure that creates new `Map` instance.
`static <T> IgniteCallable<Set<T>>` `newSet()` Returns a factory closure that creates new `Set` instance.
`static IgniteClosure<ClusterNode,UUID>` `node2id()` Gets closure which converts node to node ID.
`static <T extends ClusterNode> IgnitePredicate<T>` `nodeForNodeId(UUID nodeId)` Creates grid node predicate evaluating on the given node ID.
`static <T extends ClusterNode> IgnitePredicate<T>` `nodeForNodeIds(Collection<UUID> nodeIds)` Creates grid node predicate evaluating on the given node IDs.
`static IgnitePredicate<ClusterNode>` `nodeForNodes(ClusterNode... nodes)` Creates predicates that evaluates to `true` for each node in given collection.
`static Collection<String>` `nodeId8s(Collection<? extends ClusterNode> nodes)` Convenient utility method that returns collection of node ID8s for a given collection of grid nodes.
`static Collection<UUID>` `nodeIds(Collection<? extends ClusterNode> nodes)` Convenient utility method that returns collection of node IDs for a given collection of grid nodes.
`static GridAbsClosure` `noop()` Creates an absolute (no-arg) closure that does nothing.
`static <T> IgnitePredicate<T>` `not(IgnitePredicate<? super T>... p)` Negates given predicates.
`static <T> IgnitePredicate<T>` `notContains(Collection<T> c)` Provides predicate which returns `true` if it receives an element that is not contained in the passed in collection.
`static <T> IgnitePredicate<T>` `notEqualTo(T target)` Gets predicate that evaluates to `true` if its free variable is not equal to `target` or both are `null`.
`static <T> IgnitePredicate<T>` `notIn(Collection<? extends T> c)` Gets predicate that returns `true` if its free variable is not contained in given collection.
`static <T> IgnitePredicate<T>` `notNull()` Gets predicate that evaluates to `true` if its free variable is not `null`.
`static <T> IgnitePair<T>` `pair(T t1, T t2)` Creates pair out of given two objects.
`static <V> IgniteBiTuple<Collection<V>,Collection<V>>` `partition(Iterable<? extends V> c, IgnitePredicate<? super V> p)` Partitions input collection in two: first containing elements for which given predicate evaluates to `true` - and second containing the elements for which predicate evaluates to `false`.
`static GridAbsClosure` `println(String msg)` Creates absolute closure that does `System.out.println(msg)`.
`static <T> T` `rand(Collection<? extends T> c)` Gets random value from given collection.
`static <T> T` `rand(List<T> l)` Gets random value from given list.
`static <T> T` `rand(T... c)` Gets random value from given array.
`static List<Integer>` `range(int fromIncl, int toExcl)` Creates a range list containing numbers in given range.
`static <X,Y> Y` `reduce(Iterable<? extends X> c, IgniteReducer<? super X,Y> f)` Reduces collection into single value using given for-all closure.
`static <T extends ClusterNode> IgnitePredicate<T>` `remoteNodes(UUID locNodeId)` Gets predicate that evaluates to `false` for given local node ID.
`static <T0,T extends T0> Collection<T>` `retain(Collection<T> c, boolean cp, Collection<? extends T0> filter)` Retains all elements in input collection that are contained in `filter`.
`static <T> Collection<T>` `retain(Collection<T> c, boolean cp, IgnitePredicate<? super T>... p)` Retains all elements in input collection that are evaluated to `true` by all given predicates.
`static <T> Collection<T>` `retain(Collection<T> c, boolean cp, int num)` Retains only up to first `num` elements in the input collection.
`static <K,V> V` `returnIfAbsent(Map<? extends K,? extends V> map, K key, Callable<V> c)` Utility map getter.
`static <T> int` `size(Collection<? extends T> c, IgnitePredicate<? super T>... p)` Gets size of the given collection with provided optional predicates.
`static <T> int` `size(Iterator<? extends T> it, IgnitePredicate<? super T>... p)` Gets size of the given iterator with provided optional predicates.
`static <T> IgniteClosure<T,String>` `string()` Gets closure that return `toString()` value for its free variable.
`static int` `sumInt(Iterable<Integer> c)` Calculates sum of all elements.
`static IgniteReducer<Integer,Integer>` `sumIntReducer()` Gets reducer closure that calculates sum of integer elements.
`static IgniteReducer<Long,Long>` `sumLongReducer()` Gets reducer closure that calculates sum of long integer elements.
`static <V> GridTuple<V>` `t(V v)` Factory method returning new tuple with given parameter.
`static <V1,V2> IgniteBiTuple<V1,V2>` `t(V1 v1, V2 v2)` Factory method returning new tuple with given parameters.
`static <V1,V2,V3> GridTuple3<V1,V2,V3>` `t(V1 v1, V2 v2, V3 v3)` Factory method returning new tuple with given parameters.
`static <V1,V2,V3,V4> GridTuple4<V1,V2,V3,V4>` `t(V1 v1, V2 v2, V3 v3, V4 v4)` Factory method returning new tuple with given parameters.
`static <V1,V2,V3,V4,V5> GridTuple5<V1,V2,V3,V4,V5>` `t(V1 v1, V2 v2, V3 v3, V4 v4, V5 v5)` Factory method returning new tuple with given parameters.
`static <V1,V2,V3,V4,V5,V6> GridTuple6<V1,V2,V3,V4,V5,V6>` `t(V1 v1, V2 v2, V3 v3, V4 v4, V5 v5, V6 v6)` Factory method returning new tuple with given parameters.
`static <V> GridTuple<V>` `t1()` Factory method returning empty tuple.
`static <V1,V2> IgniteBiTuple<V1,V2>` `t2()` Factory method returning new empty tuple.
`static <V1,V2,V3> GridTuple3<V1,V2,V3>` `t3()` Factory method returning new empty tuple.
`static <V1,V2,V3,V4> GridTuple4<V1,V2,V3,V4>` `t4()` Factory method returning new empty tuple.
`static <V1,V2,V3,V4,V5> GridTuple5<V1,V2,V3,V4,V5>` `t5()` Factory method returning new empty tuple.
`static <V1,V2,V3,V4,V5,V6> GridTuple6<V1,V2,V3,V4,V5,V6>` `t6()` Factory method returning new empty tuple.
`static <X,Y> Collection<Y>` `transform(Collection<? extends X> c, IgniteClosure<? super X,Y> f)` Transforms one collection to another using provided closure.
`static <X,Y> Collection<Y>` `transform(X[] c, IgniteClosure<? super X,Y> f)` Transforms an array to read only collection using provided closure.
`static <T1,T2> List<T2>` `transformList(Collection<? extends T1> c, IgniteClosure<? super T1,T2> trans, IgnitePredicate<? super T1>... p)` Creates a view on given list with provided transformer and predicates.
`static GridTupleV` `tv(Object... objs)` Creates vararg tuple with given values.
`static IgnitePredicate<IgniteInternalFuture<?>>` `unfinishedFutures()` Returns predicate for filtering unfinished futures.
`static <T extends R,R> Collection<R>` `upcast(Collection<T> c)` Upcasts collection type.
`static <T> Collection<T>` `view(Collection<T> c, IgnitePredicate<? super T>... p)` Creates write-through light-weight view on given collection with provided predicates.
`static <K0,K extends K0,V0,V extends V0> Map<K,V>` `view(Map<K,V> m, IgnitePredicate<? super K>... p)` Creates light-weight view on given map with provided predicates.
`static <K0,K extends K0,V0,V extends V0> Map<K,V>` `viewAsMap(Set<K> c, IgniteClosure<? super K,V> mapClo, IgnitePredicate<? super K>... p)` Read-only map view of a collection.
`static <T1,T2> List<T2>` `viewListReadOnly(List<? extends T1> c, IgniteClosure<? super T1,T2> trans)` Creates read-only light-weight view on given list with provided transformation.
`static <T1,T2> Collection<T2>` `viewReadOnly(Collection<? extends T1> c, IgniteClosure<? super T1,T2> trans, IgnitePredicate<? super T1>... p)` Creates read-only light-weight view on given collection with transformation and provided predicates.
`static <K0,K extends K0,V0,V extends V0,V1> Map<K,V1>` `viewReadOnly(Map<K,V> m, IgniteBiClosure<K,V,V1> trans, IgnitePredicate<? super K>... p)` Read-only view on map that supports transformation of values and key filtering.
`static <K0,K extends K0,V0,V extends V0,V1> Map<K,V1>` `viewReadOnly(Map<K,V> m, IgniteClosure<V,V1> trans, IgnitePredicate<? super K>... p)` Read-only view on map that supports transformation of values and key filtering.
`static GridClosureException` `wrap(Throwable e)` Shortcut method that creates an instance of `GridClosureException`.
`static <K,V> Map<K,V>` `zip(Collection<? extends K> keys, V dfltVal)` Converts collection to map using collection values as keys and passed in default value as values.

### Methods inherited from class java.lang.Object

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

### Field Detail

#### IS_NULL

    public static final IgnitePredicate<Object> IS_NULL

#### IS_NOT_NULL

    public static final IgnitePredicate<Object> IS_NOT_NULL

### Constructor Detail

#### GridFunc

    public GridFunc()

### Method Detail

#### localNode

    public static <T extends ClusterNode> IgnitePredicate<T> localNode(UUID locNodeId)

Gets predicate that evaluates to `true` only for given local node ID.

Type Parameters:
  `T` - Type of the node.
Parameters:
  `locNodeId` - Local node ID.
Returns:
  Return `true` only for the node with given local node ID.

#### remoteNodes

    public static <T extends ClusterNode> IgnitePredicate<T> remoteNodes(UUID locNodeId)

Gets predicate that evaluates to `false` for given local node ID.

Type Parameters:
  `T` - Type of the node.
Parameters:
  `locNodeId` - Local node ID.
Returns:
  Return `false` for the given local node ID.

#### dedup

    public static <T> Collection<T> dedup(Collection<? extends T> c)

Creates new collection by removing duplicates from the given collection.

Type Parameters:
  `T` - Type of the collection.
Parameters:
  `c` - Collection to remove duplicates from.
Returns:
  De-duped collection.

#### sumInt

    public static int sumInt(Iterable<Integer> c)

Calculates sum of all elements.

Parameters:
  `c` - Collection of elements.
Returns:
  Sum of all elements.

#### identityReducer

    public static <T> IgniteReducer<T,T> identityReducer(T elem)

Gets reducer which always returns `true` from `IgniteReducer.collect(Object)` method and passed in `element` from `IgniteReducer.reduce()` method.

Type Parameters:
  `T` - Reducer element type.
Parameters:
  `elem` - Element to return from `IgniteReducer.reduce()` method.
Returns:
  Passed in element.

#### sumIntReducer

    public static IgniteReducer<Integer,Integer> sumIntReducer()

Gets reducer closure that calculates sum of integer elements.

Returns:
  Reducer that calculates sum of integer elements.

#### sumLongReducer

    public static IgniteReducer<Long,Long> sumLongReducer()

Gets reducer closure that calculates sum of long integer elements.

Returns:
  Reducer that calculates sum of long integer elements.

#### range

    public static List<Integer> range(int fromIncl,
                      int toExcl)

Creates a range list containing numbers in given range.

Parameters:
  `fromIncl` - Inclusive start of the range.
  `toExcl` - Exclusive stop of the range.
Returns:
  List containing numbers in range.

#### concatReducer

    public static IgniteReducer<String,String> concatReducer(@Nullable
                                             String delim)

Gets reducer closure that concatenates strings using provided delimiter.

Parameters:
  `delim` - Delimiter (optional).
Returns:
  Reducer that concatenates strings using provided delimeter.

#### concat

    public static String concat(Iterable<String> c,
                @Nullable
                String delim)

Concatenates strings using provided delimiter.

Parameters:
  `c` - Input collection.
  `delim` - Delimiter (optional).
Returns:
  Concatenated string.

#### jobResults

    public static <T> Collection<T> jobResults(@Nullable
                               Collection<? extends ComputeJobResult> res)

Gets collections of data items from grid job res casted to specified type.

Here's the typical example of how this method is used in `reduce()` method implementation (this example sums up all the values of `Integer` type):

     public Integer reduce(List<GridComputeJobResult> res) throws IgniteCheckedException {
         return F.sum(F.<Integer>jobResults(res));
     }

Note that this method doesn't create a new collection but simply iterates over the input one.

Type Parameters:
  `T` - Type of the data item to cast to. See `ComputeJobResult.getData()` method.
Parameters:
  `res` - Collection of grid job res.
Returns:
  Collections of data items casted to type `T`.
See Also:
  `ComputeJobResult.getData()`

#### nodeIds

    public static Collection<UUID> nodeIds(@Nullable
                           Collection<? extends ClusterNode> nodes)

Convenient utility method that returns collection of node IDs for a given collection of grid nodes.

Note that this method doesn't create a new collection but simply iterates over the input one.

Parameters:
  `nodes` - Collection of grid nodes.
Returns:
  Collection of node IDs for given collection of grid nodes.

#### nodeId8s

    public static Collection<String> nodeId8s(@Nullable
                              Collection<? extends ClusterNode> nodes)

Convenient utility method that returns collection of node ID8s for a given collection of grid nodes. ID8 is a shorter string representation of node ID, mainly the first 8 characters.

Note that this method doesn't create a new collection but simply iterates over the input one.

Parameters:
  `nodes` - Collection of grid nodes.
Returns:
  Collection of node IDs for given collection of grid nodes.

#### id8s

    public static Collection<String> id8s(@Nullable
                          Collection<UUID> ids)

Convenient utility method that returns collection of node ID8s for a given collection of node IDs. ID8 is a shorter string representation of node ID, mainly the first 8 characters.

Note that this method doesn't create a new collection but simply iterates over the input one.

Parameters:
  `ids` - Collection of nodeIds.
Returns:
  Collection of node IDs for given collection of grid nodes.

#### println

    public static GridAbsClosure println(String msg)

Creates absolute closure that does `System.out.println(msg)`.

Parameters:
  `msg` - Message to print.
Returns:
  Absolute closure that print message.

#### rand

    public static <T> T rand(Collection<? extends T> c)

Gets random value from given collection.

Type Parameters:
  `T` - Type of the collection.
Parameters:
  `c` - Input collection (no `null` and not emtpy).
Returns:
  Random value from the input collection.

#### rand

    public static <T> T rand(List<T> l)

Gets random value from given list. For random-access lists this operation is O(1), otherwise O(n).

Type Parameters:
  `T` - Type of the list elements.
Parameters:
  `l` - Input collection.
Returns:
  Random value from the input list.

#### rand

    public static <T> T rand(T... c)

Gets random value from given array. This operation does not iterate through array elements and returns immediately.

Type Parameters:
  `T` - Type of the collection.
Parameters:
  `c` - Input collection.
Returns:
  Random value from the input collection.

#### concat

    public static <T> Collection<T> concat(boolean cp,
                           @Nullable
                           T t,
                           @Nullable
                           Collection<T> c)

Concatenates an element to a collection. If `copy` flag is `true`, then a new collection will be created and the element and passed in collection will be copied into the new one. The returned collection will be modifiable. If `copy` flag is `false`, then a read-only view will be created over the element and given collections and no copying will happen.

Type Parameters:
  `T` - Element type.
Parameters:
  `cp` - Copy flag.
  `t` - First element.
  `c` - Second collection.
Returns:
  Concatenated collection.

#### concat

    public static <T> Collection<T> concat(boolean cp,
                           @Nullable
                           Collection<T> c1,
                           @Nullable
                           Collection<T> c2)

Concatenates 2 collections into one. If `copy` flag is `true`, then a new collection will be created and these collections will be copied into the new one. The returned collection will be modifiable. If `copy` flag is `false`, then a read-only view will be created over given collections and no copying will happen.

Type Parameters:
  `T` - Element type.
Parameters:
  `cp` - Copy flag.
  `c1` - First collection.
  `c2` - Second collection.
Returns:
  Concatenated `non-null` collection.

#### concat

    public static <T> T[] concat(@Nullable
                 T[] arr,
                 T... obj)

Concatenates an elements to an array.

Parameters:
  `arr` - Array.
  `obj` - One or more elements.
Returns:
  Concatenated array.

#### concat

    public static <T> Iterator<T> concat(Iterator<T>... iters)

Concatenates multiple iterators as single one.

Parameters:
  `iters` - Iterators.
Returns:
  Single iterator.

#### concat

    public static <T> Iterator<T> concat(Iterator<Iterator<T>> iters)

Concatenates multiple iterators as single one.

Parameters:
  `iters` - Iterator over iterators.
Returns:
  Single iterator.

#### lose

    public static <T0,T extends T0> Collection<T> lose(Collection<T> c,
                                       boolean cp,
                                       @Nullable
                                       Collection<T0> filter)

Loses all elements in input collection that are contained in `filter` collection.

Type Parameters:
  `T` - Type of collections.
Parameters:
  `c` - Input collection.
  `cp` - If `true` method creates new collection not modifying input, otherwise does `in-place` modifications.
  `filter` - Filter collection. If `filter` collection is empty or `null` - no elements are lost.
Returns:
  Collection of remaining elements

#### lose

    public static <T> Collection<T> lose(Collection<T> c,
                         boolean cp,
                         @Nullable
                         IgnitePredicate<? super T>... p)

Loses all elements in input collection that are evaluated to `true` by all given predicates.

Type Parameters:
  `T` - Type of collections.
Parameters:
  `c` - Input collection.
  `cp` - If `true` method creates new collection without modifying the input one, otherwise does `in-place` modifications.
  `p` - Predicates to filter by. If no predicates provided - no elements are lost.
Returns:
  Collection of remaining elements.

#### lose

    public static <K,V> Map<K,V> lose(Map<K,V> m,
                      boolean cp,
                      @Nullable
                      IgnitePredicate<? super Map.Entry<K,V>>... p)

Loses all entries in input map that are evaluated to `true` by all given predicates.

Type Parameters:
  `K` - Type of the free variable for the predicate and type of map's keys.
  `V` - Type of the free variable for the predicate and type of map's values.
Parameters:
  `m` - Map to filter.
  `cp` - If `true` method creates new map not modifying input, otherwise does `in-place` modifications.
  `p` - Optional set of predicates to use for filtration. If none provided - original map will (or its copy) be returned.
Returns:
  Filtered map.

#### loseKeys

    public static <K,V> Map<K,V> loseKeys(Map<K,V> m,
                          boolean cp,
                          @Nullable
                          IgnitePredicate<? super K>... p)

Loses all entries in input map which keys are evaluated to `true` by all given predicates.

Type Parameters:
  `K` - Type of the free variable for the predicate and type of map's keys.
  `V` - Type of map's values.
Parameters:
  `m` - Map to filter.
  `cp` - If `true` method creates new map not modifying input, otherwise does `in-place` modifications.
  `p` - Optional set of predicates to use for filtration. If none provided - original map (or its copy) will be returned.
Returns:
  Filtered map.

#### loseValues

    public static <K,V> Map<K,V> loseValues(Map<K,V> m,
                            boolean cp,
                            @Nullable
                            IgnitePredicate<? super V>... p)

Loses all entries in input map which values are evaluated to `true` by all given predicates.

Type Parameters:
  `K` - Type of the free variable for the predicate and type of map's keys.
  `V` - Type of map's values.
Parameters:
  `m` - Map to filter.
  `cp` - If `true` method creates new map not modifying input, otherwise does `in-place` modifications.
  `p` - Optional set of predicates to use for filtration. If none provided - original map (or its copy) will be returned.
Returns:
  Filtered map.

#### loseList

    public static <T> List<T> loseList(List<T> c,
                       boolean cp,
                       @Nullable
                       Collection<? super T> filter)

Loses all elements in input list that are contained in `filter` collection.

Type Parameters:
  `T` - Type of list.
Parameters:
  `c` - Input list.
  `cp` - If `true` method creates new list not modifying input, otherwise does `in-place` modifications.
  `filter` - Filter collection. If `filter` collection is empty or `null` - no elements are lost.
Returns:
  List of remaining elements

#### filterList

    public static <T> List<T> filterList(List<T> c,
                         boolean cp,
                         @Nullable
                         IgnitePredicate<T>... p)

Loses all elements in input list for which any of the predicates evaluate to `true`.

Type Parameters:
  `T` - Type of list.
Parameters:
  `c` - Input list.
  `cp` - If `true` method creates new list not modifying input, otherwise does `in-place` modifications.
  `p` - Looses all elements for which any of the predicates evaluate to `true`.
Returns:
  List of remaining elements

#### node2id

    public static IgniteClosure<ClusterNode,UUID> node2id()

Gets closure which converts node to node ID.

Returns:
  Closure which converts node to node ID.

#### nodeForNodeId

    public static <T extends ClusterNode> IgnitePredicate<T> nodeForNodeId(UUID nodeId)

Creates grid node predicate evaluating on the given node ID.

Parameters:
  `nodeId` - Node ID for which returning predicate will evaluate to `true`.
Returns:
  Grid node predicate evaluating on the given node ID.
See Also:
  `idForNodeId(UUID)`, `nodeIds(Collection)`

#### nodeForNodeIds

    public static <T extends ClusterNode> IgnitePredicate<T> nodeForNodeIds(@Nullable
                                                            Collection<UUID> nodeIds)

Creates grid node predicate evaluating on the given node IDs.

Parameters:
  `nodeIds` - Collection of node IDs.
Returns:
  Grid node predicate evaluating on the given node IDs.
See Also:
  `idForNodeId(UUID)`, `nodeIds(Collection)`

#### idForNodeId

    public static IgnitePredicate<UUID> idForNodeId(UUID nodeId)

Creates `UUID` predicate evaluating on the given node ID.

Parameters:
  `nodeId` - Node ID for which returning predicate will evaluate to `true`.
Returns:
  `UUID` predicate evaluating on the given node ID.
See Also:
  `nodeForNodeId(UUID)`, `nodeIds(Collection)`

#### nodeForNodes

    public static IgnitePredicate<ClusterNode> nodeForNodes(ClusterNode... nodes)

Creates predicates that evaluates to `true` for each node in given collection. Note that if collection is empty the result predicate will always evaluate to `false`. Implementation simply creates `GridNodePredicate` instance.

Parameters:
  `nodes` - Collection of nodes. If none provided - result predicate will always return `false`.
Returns:
  Predicates that evaluates to `true` for each node in given collection.

#### retain

    public static <T0,T extends T0> Collection<T> retain(Collection<T> c,
                                         boolean cp,
                                         @Nullable
                                         Collection<? extends T0> filter)

Retains all elements in input collection that are contained in `filter`.

Type Parameters:
  `T` - Type of collections.
Parameters:
  `c` - Input collection.
  `cp` - If `true` method creates collection not modifying input, otherwise does `in-place` modifications.
  `filter` - Filter collection. If filter collection is `null` or empty - an empty collection will be returned.
Returns:
  Collection of retain elements.

#### retain

    public static <T> Collection<T> retain(Collection<T> c,
                           boolean cp,
                           @Nullable
                           IgnitePredicate<? super T>... p)

Retains all elements in input collection that are evaluated to `true` by all given predicates.

Type Parameters:
  `T` - Type of collections.
Parameters:
  `c` - Input collection.
  `cp` - If `true` method creates collection not modifying input, otherwise does `in-place` modifications.
  `p` - Predicates to filter by. If no predicates provides - all elements will be retained.
Returns:
  Collection of retain elements.

#### retain

    public static <T> Collection<T> retain(Collection<T> c,
                           boolean cp,
                           int num)

Retains only up to first `num` elements in the input collection.

Type Parameters:
  `T` - Type of the collections.
Parameters:
  `c` - Input collection.
  `cp` - If `true` method creates collection not modifying input, otherwise does `in-place` modifications.
  `num` - Maximum number of elements to retain (the actual number can be less if the input collection contains less elements).
Returns:
  Collection contains up to `num` first elements from the input collection.

#### curry

    public static <T,R> IgniteOutClosure<R> curry(IgniteClosure<? super T,R> f,
                                  T e)

Curries given closure.

Type Parameters:
  `T` - Input type.
  `R` - Output type.
Parameters:
  `f` - Closure.
  `e` - Parameter.
Returns:
  Curried closure.

#### curry

    public static <T> GridAbsClosure curry(IgniteInClosure<? super T> f,
                           T e)

Curries given closure.

Type Parameters:
  `T` - Input type.
Parameters:
  `f` - Closure.
  `e` - Parameter.
Returns:
  Curried closure.

#### asList

    public static <T> List<T> asList(@Nullable
                     T... vals)

Converts array to `List`. Note that resulting list cannot be altered in size, as it it based on the passed in array - only current elements can be changed.

Note that unlike `Arrays.asList(Object[])`, this method is `null`-safe. If `null` is passed in, then empty list will be returned.

Type Parameters:
  `T` - Array type.
Parameters:
  `vals` - Array of values
Returns:
  `List` instance for array.

#### emptyIterator

    public static <T> GridIterator<T> emptyIterator()

Creates new empty iterator.

Type Parameters:
  `T` - Type of the iterator.
Returns:
  Newly created empty iterator.

#### flatCollections

    public static <T> Collection<T> flatCollections(@Nullable
                                    Collection<? extends Collection<T>> c)

Flattens collection-of-collections and returns collection over the elements of the inner collections. This method doesn't create any new collections or copies any elements.

Note that due to non-copying nature of implementation, the `size()` method of resulting collection will have to iterate over all elements to produce size. Method `isEmpty()`, however, is constant time and is much more preferable to use instead of `'size()'` method when checking if list is not empty.

Type Parameters:
  `T` - Type of the inner collections.
Parameters:
  `c` - Input collection of collections.
Returns:
  Iterable over the elements of the inner collections.

#### flat

    public static <T> GridIterator<T> flat(@Nullable
                           Iterable<? extends Iterable<T>> c)

Flattens iterable-of-iterables and returns iterable over the elements of the inner collections. This method doesn't create any new collections or copies any elements.

Type Parameters:
  `T` - Type of the inner collections.
Parameters:
  `c` - Input collection of collections.
Returns:
  Iterable over the elements of the inner collections.

#### flatIterators

    public static <T> Iterator<T> flatIterators(@Nullable
                                Iterable<Iterator<T>> c)

Flattens iterable-of-iterators and returns iterator over the elements of the inner collections. This method doesn't create any new collections or copies any elements.

Parameters:
  `c` - Input iterable of iterators.
Returns:
  Iterator over the elements of given iterators.

#### as

    public static GridAbsClosure as(@Nullable
                    Runnable r)

Converts given runnable to an absolute closure.

Parameters:
  `r` - Runnable to convert to closure. If `null` - no-op closure is returned.
Returns:
  Closure that wraps given runnable. Note that wrapping closure always returns `null`.

#### size

    public static <T> int size(@Nullable
               Collection<? extends T> c,
               @Nullable
               IgnitePredicate<? super T>... p)

Gets size of the given collection with provided optional predicates.

Type Parameters:
  `T` - Type of the iterator.
Parameters:
  `c` - Collection to size.
  `p` - Optional predicates that filters out elements from count.
Returns:
  Number of elements in the collection for which all given predicates evaluates to `true`. If no predicates is provided - all elements are counted.

#### size

    public static <T> int size(@Nullable
               Iterator<? extends T> it,
               @Nullable
               IgnitePredicate<? super T>... p)

Gets size of the given iterator with provided optional predicates. Iterator will be traversed to get the count.

Type Parameters:
  `T` - Type of the iterator.
Parameters:
  `it` - Iterator to size.
  `p` - Optional predicates that filters out elements from count.
Returns:
  Number of elements in the iterator for which all given predicates evaluates to `true`. If no predicates is provided - all elements are counted.

#### view

    @SafeVarargs
    public static <T> Collection<T> view(@Nullable
                                     Collection<T> c,
                                     @Nullable
                                     IgnitePredicate<? super T>... p)

Creates write-through light-weight view on given collection with provided predicates. Resulting collection will only "have" elements for which all provided predicates, if any, evaluate to `true`. Note that only wrapping collection will be created and no duplication of data will occur. Also note that if array of given predicates is not empty then method `size()` uses full iteration through the collection.

Type Parameters:
  `T` - Type of the collection.
Parameters:
  `c` - Input collection that serves as a base for the view.
  `p` - Optional predicates. If predicates are not provided - all elements will be in the view.
Returns:
  Light-weight view on given collection with provided predicate.

#### viewReadOnly

    @SafeVarargs
    public static <T1,T2> Collection<T2> viewReadOnly(@Nullable
                                                  Collection<? extends T1> c,
                                                  IgniteClosure<? super T1,T2> trans,
                                                  @Nullable
                                                  IgnitePredicate<? super T1>... p)

Creates read-only light-weight view on given collection with transformation and provided predicates. Resulting collection will only "have" `transformed` elements for which all provided predicate, if any, evaluates to `true`. Note that only wrapping collection will be created and no duplication of data will occur. Also note that if array of given predicates is not empty then method `size()` uses full iteration through the collection.

Type Parameters:
  `T1` - Type of the collection.
Parameters:
  `c` - Input collection that serves as a base for the view.
  `trans` - Transformation closure.
  `p` - Optional predicated. If predicates are not provided - all elements will be in the view.
Returns:
  Light-weight view on given collection with provided predicate.

#### viewListReadOnly

    public static <T1,T2> List<T2> viewListReadOnly(@Nullable
                                    List<? extends T1> c,
                                    IgniteClosure<? super T1,T2> trans)

Creates read-only light-weight view on given list with provided transformation. Resulting list will only "have" `transformed` elements. Note that only wrapping list will be created and no duplication of data will occur.

Type Parameters:
  `T1` - Type of the list.
Parameters:
  `c` - Input list that serves as a base for the view.
  `trans` - Transformation closure.
Returns:
  Light-weight view on given list with provided transformation.

#### transformList

    public static <T1,T2> List<T2> transformList(Collection<? extends T1> c,
                                 IgniteClosure<? super T1,T2> trans,
                                 @Nullable
                                 IgnitePredicate<? super T1>... p)

Creates a view on given list with provided transformer and predicates. Resulting list will only "have" elements for which all provided predicates, if any, evaluate to `true`. Note that a new collection will be created and data will be copied.

Parameters:
  `c` - Input list that serves as a base for the view.
  `trans` - Transforming closure from T1 to T2.
  `p` - Optional predicates. If predicates are not provided - all elements will be in the view.
Returns:
  View on given list with provided predicate.

#### view

    public static <K0,K extends K0,V0,V extends V0> Map<K,V> view(@Nullable
                                                  Map<K,V> m,
                                                  @Nullable
                                                  IgnitePredicate<? super K>... p)

Creates light-weight view on given map with provided predicates. Resulting map will only "have" keys for which all provided predicates, if any, evaluates to `true`. Note that only wrapping map will be created and no duplication of data will occur. Also note that if array of given predicates is not empty then method `size()` uses full iteration through the entry set.

Type Parameters:
  `K` - Type of the key.
  `V` - Type of the value.
Parameters:
  `m` - Input map that serves as a base for the view.
  `p` - Optional predicates. If predicates are not provided - all will be in the view.
Returns:
  Light-weight view on given map with provided predicate.

#### viewReadOnly

    public static <K0,K extends K0,V0,V extends V0,V1> Map<K,V1> viewReadOnly(@Nullable
                                                              Map<K,V> m,
                                                              IgniteClosure<V,V1> trans,
                                                              @Nullable
                                                              IgnitePredicate<? super K>... p)

Read-only view on map that supports transformation of values and key filtering. Resulting map will only "have" keys for which all provided predicates, if any, evaluates to `true`. Note that only wrapping map will be created and no duplication of data will occur. Also note that if array of given predicates is not empty then method `size()` uses full iteration through the entry set.

Type Parameters:
  `K` - Type of the key.
  `V` - Type of the input map value.
  `V1` - Type of the output map value.
Parameters:
  `m` - Input map that serves as a base for the view.
  `trans` - Transformer for map value transformation.
  `p` - Optional predicates. If predicates are not provided - all will be in the view.
Returns:
  Light-weight view on given map with provided predicate and transformer.

#### viewReadOnly

    public static <K0,K extends K0,V0,V extends V0,V1> Map<K,V1> viewReadOnly(@Nullable
                                                              Map<K,V> m,
                                                              IgniteBiClosure<K,V,V1> trans,
                                                              @Nullable
                                                              IgnitePredicate<? super K>... p)

Read-only view on map that supports transformation of values and key filtering. Resulting map will only "have" keys for which all provided predicates, if any, evaluates to `true`. Note that only wrapping map will be created and no duplication of data will occur. Also note that if array of given predicates is not empty then method `size()` uses full iteration through the entry set.

Type Parameters:
  `K` - Type of the key.
  `V` - Type of the input map value.
  `V1` - Type of the output map value.
Parameters:
  `m` - Input map that serves as a base for the view.
  `trans` - Transformer for map value transformation.
  `p` - Optional predicates. If predicates are not provided - all will be in the view.
Returns:
  Light-weight view on given map with provided predicate and transformer.

#### viewAsMap

    public static <K0,K extends K0,V0,V extends V0> Map<K,V> viewAsMap(@Nullable
                                                       Set<K> c,
                                                       IgniteClosure<? super K,V> mapClo,
                                                       @Nullable
                                                       IgnitePredicate<? super K>... p)

Read-only map view of a collection. Resulting map is a lightweight view of an input collection, with filtered elements of an input collection as keys, and closure execution results as values. The map will only contain keys for which all provided predicates, if any, evaluate to `true`. Note that only wrapping map will be created and no duplication of data will occur. Also note that if array of given predicates is not empty then method `size()` uses full iteration through the entry set.

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `c` - Input collection.
  `mapClo` - Mapping closure, that maps key to value.
  `p` - Optional predicates to filter input collection. If predicates are not provided - all elements will be in the view.
Returns:
  Light-weight view on given map with provided predicates and mapping.

#### isEmpty

    public static boolean isEmpty(@Nullable
                  String s)

Tests if given string is `null` or empty.

Parameters:
  `s` - String to test.
Returns:
  Whether or not the given string is `null` or empty.

#### isEmpty

    public static <T> boolean isEmpty(@Nullable
                      T[] c)

Tests if the given array is either `null` or empty.

Parameters:
  `c` - Array to test.
Returns:
  Whether or not the given array is `null` or empty.

#### isEmptyOrNulls

    public static <T> boolean isEmptyOrNulls(@Nullable
                             T[] c)

Tests if the given array is `null`, empty or contains only `null` values.

Parameters:
  `c` - Array to test.
Returns:
  Whether or not the given array is `null`, empty or contains only `null` values.

#### isEmpty

    public static boolean isEmpty(@Nullable
                  int[] c)

Tests if the given array is either `null` or empty.

Parameters:
  `c` - Array to test.
Returns:
  Whether or not the given array is `null` or empty.

#### isEmpty

    public static boolean isEmpty(@Nullable
                  byte[] c)

Tests if the given array is either `null` or empty.

Parameters:
  `c` - Array to test.
Returns:
  Whether or not the given array is `null` or empty.

#### isEmpty

    public static boolean isEmpty(@Nullable
                  long[] c)

Tests if the given array is either `null` or empty.

Parameters:
  `c` - Array to test.
Returns:
  Whether or not the given array is `null` or empty.

#### isEmpty

    public static boolean isEmpty(@Nullable
                  Iterable<?> c)

Tests if the given collection is either `null` or empty.

Parameters:
  `c` - Collection to test.
Returns:
  Whether or not the given collection is `null` or empty.

#### isEmpty

    public static boolean isEmpty(@Nullable
                  Collection<?> c)

Tests if the given collection is either `null` or empty.

Parameters:
  `c` - Collection to test.
Returns:
  Whether or not the given collection is `null` or empty.

#### isEmpty

    public static boolean isEmpty(@Nullable
                  Map<?,?> m)

Tests if the given map is either `null` or empty.

Parameters:
  `m` - Map to test.
Returns:
  Whether or not the given collection is `null` or empty.

#### returnIfAbsent

    @Nullable
    public static <K,V> V returnIfAbsent(Map<? extends K,? extends V> map,
                                  @Nullable
                                  K key,
                                  @Nullable
                                  Callable<V> c)

Utility map getter. This method analogous to `addIfAbsent(Map, Object, Callable)` method but this one doesn't put the default value into the map when key is not found.

Type Parameters:
  `K` - Map key type.
  `V` - Map value type.
Parameters:
  `map` - Map to get value from.
  `key` - Map key (can be `null`).
  `c` - Optional factory closure for the default value to be returned in when `key` is not found. If closure is not provided - `null` will be returned.
Returns:
  Value for the `key` or default value produced by `c` if key is not found (or `null` if key is not found and closure is not provided).
Throws:
  `GridClosureException` - Thrown in case when callable throws exception.
See Also:
  `newLinkedList()`, `newList()`, `newSet()`, `newMap()`, `newAtomicLong()`, `newAtomicInt()`, `newAtomicRef()`, `newAtomicBoolean()`

#### newDeque

    public static <T> IgniteCallable<ConcurrentLinkedDeque8<T>> newDeque()

Returns a factory closure that creates new `ConcurrentLinkedDeque8` instance. Note that this method does not create a new closure but returns a static one.

Type Parameters:
  `T` - Type parameters for the created `List`.
Returns:
  Factory closure that creates new `List` instance every time its `IgniteOutClosure.apply()` method is called.

#### newList

    public static <T> IgniteCallable<List<T>> newList()

Returns a factory closure that creates new `List` instance. Note that this method does not create a new closure but returns a static one.

Type Parameters:
  `T` - Type parameters for the created `List`.
Returns:
  Factory closure that creates new `List` instance every time its `IgniteOutClosure.apply()` method is called.

#### newAtomicInt

    public static IgniteCallable<AtomicInteger> newAtomicInt()

Returns a factory closure that creates new `AtomicInteger` instance initialized to `zero`. Note that this method does not create a new closure but returns a static one.

Returns:
  Factory closure that creates new `AtomicInteger` instance initialized to `zero` every time its `IgniteOutClosure.apply()` method is called.

#### newAtomicLong

    public static IgniteCallable<AtomicLong> newAtomicLong()

Returns a factory closure that creates new `AtomicLong` instance initialized to `zero`. Note that this method does not create a new closure but returns a static one.

Returns:
  Factory closure that creates new `AtomicLong` instance initialized to `zero` every time its `IgniteOutClosure.apply()` method is called.

#### newAtomicRef

    public static <T> IgniteCallable<AtomicReference<T>> newAtomicRef()

Returns a factory closure that creates new `AtomicReference` instance initialized to `null`. Note that this method does not create a new closure but returns a static one.

Type Parameters:
  `T` - Type of the atomic reference.
Returns:
  Factory closure that creates new `AtomicReference` instance initialized to `null` every time its `IgniteOutClosure.apply()` method is called.

#### newAtomicBoolean

    public static IgniteCallable<AtomicBoolean> newAtomicBoolean()

Returns a factory closure that creates new `AtomicBoolean` instance initialized to `false`. Note that this method does not create a new closure but returns a static one.

Returns:
  Factory closure that creates new `AtomicBoolean` instance initialized to `false` every time its `IgniteOutClosure.apply()` method is called.

#### newLinkedList

    public static <T> IgniteCallable<LinkedList<T>> newLinkedList()

Returns a factory closure that creates new `LinkedList` instance. Note that this method does not create a new closure but returns a static one.

Type Parameters:
  `T` - Type parameters for the created `LinkedList`.
Returns:
  Factory closure that creates new `LinkedList` instance every time its `IgniteOutClosure.apply()` method is called.

#### newSet

    public static <T> IgniteCallable<Set<T>> newSet()

Returns a factory closure that creates new `Set` instance. Note that this method does not create a new closure but returns a static one.

Type Parameters:
  `T` - Type parameters for the created `Set`.
Returns:
  Factory closure that creates new `Set` instance every time its `IgniteOutClosure.apply()` method is called.

#### newMap

    public static <K,V> IgniteCallable<Map<K,V>> newMap()

Returns a factory closure that creates new `Map` instance. Note that this method does not create a new closure but returns a static one.

Type Parameters:
  `K` - Type of the key for the created `Map`.
  `V` - Type of the value for the created `Map`.
Returns:
  Factory closure that creates new `Map` instance every time its `IgniteOutClosure.apply()` method is called.

#### newCMap

    public static <K,V> IgniteCallable<ConcurrentMap<K,V>> newCMap()

Returns a factory closure that creates new `ConcurrentMap` instance. Note that this method does not create a new closure but returns a static one.

Type Parameters:
  `K` - Type of the key for the created `ConcurrentMap`.
  `V` - Type of the value for the created `ConcurrentMap`.
Returns:
  Factory closure that creates new `Map` instance every time its `IgniteOutClosure.apply()` method is called.

#### newCSet

    public static <E> IgniteCallable<Set<E>> newCSet()

Returns a factory closure that creates new `GridConcurrentHashSet` instance. Note that this method does not create a new closure but returns a static one.

Returns:
  Factory closure that creates new `GridConcurrentHashSet` instance every time its `IgniteOutClosure.apply()` method is called.

#### iterator0

    public static <T> GridIterator<T> iterator0(Iterable<? extends T> c,
                                boolean readOnly,
                                IgnitePredicate<? super T>... p)

Creates and returns iterator from given collection and optional filtering predicates. Returned iterator will only have elements for which all given predicates evaluates to `true` (if provided). Note that this method will not create new collection but will simply "skip" elements in the provided collection that given predicates doesn't evaluate to `true` for.

Type Parameters:
  `T` - Type of the collection elements.
Parameters:
  `c` - Input collection.
  `readOnly` - If `true`, then resulting iterator will not allow modifications to the underlying collection.
  `p` - Optional filtering predicates.
Returns:
  Iterator from given collection and optional filtering predicate.

#### iterator

    public static <T1,T2> GridIterator<T2> iterator(Iterable<? extends T1> c,
                                    IgniteClosure<? super T1,T2> trans,
                                    boolean readOnly,
                                    @Nullable
                                    IgnitePredicate<? super T1>... p)

Creates and returns transforming iterator from given collection and optional filtering predicates. Returned iterator will only have elements for which all given predicates evaluates to `true` ( if provided). Note that this method will not create new collection but will simply "skip" elements in the provided collection that given predicates doesn't evaluate to `true` for.

Type Parameters:
  `T1` - Type of the collection elements.
  `T2` - Type of returned elements.
Parameters:
  `c` - Input collection.
  `trans` - Transforming closure to convert from T1 to T2.
  `readOnly` - If `true`, then resulting iterator will not allow modifications to the underlying collection.
  `p` - Optional filtering predicates.
Returns:
  Iterator from given collection and optional filtering predicate.

#### iterator

    public static <T1,T2> Iterator<T2> iterator(Iterator<? extends T1> c,
                                IgniteClosure<? super T1,T2> trans,
                                boolean readOnly,
                                @Nullable
                                IgnitePredicate<? super T1>... p)

Parameters:
  `c` - Input iterator.
  `trans` - Transforming closure to convert from T1 to T2.
  `readOnly` - If `true`, then resulting iterator will not allow modifications to the underlying collection.
  `p` - Optional filtering predicates.
Returns:
  Iterator from given iterator and optional filtering predicate.

#### alwaysTrue

    public static <T> IgnitePredicate<T> alwaysTrue()

Gets predicate that always returns `true`. This method returns constant predicate.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Returns:
  Predicate that always returns `true`.

#### alwaysFalse

    public static <T> IgnitePredicate<T> alwaysFalse()

Gets predicate that always returns `false`. This method returns constant predicate.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Returns:
  Predicate that always returns `false`.

#### isAlwaysTrue

    public static boolean isAlwaysTrue(IgnitePredicate p)

Tests whether or not given predicate is the one returned from `alwaysTrue()` method.

Parameters:
  `p` - Predicate to check.
Returns:
  `true` if given predicate is `ALWAYS_TRUE` predicate.

#### isAlwaysTrue

    public static boolean isAlwaysTrue(@Nullable
                       IgnitePredicate[] p)

Tests whether or not given set of predicates consists only of one predicate returned from `alwaysTrue()` method.

Parameters:
  `p` - Predicate to check.
Returns:
  `true` if given contains only `ALWAYS_TRUE` predicate.

#### isAlwaysFalse

    public static boolean isAlwaysFalse(IgnitePredicate p)

Tests whether or not given predicate is the one returned from `alwaysFalse()` method.

Parameters:
  `p` - Predicate to check.
Returns:
  `true` if given predicate is `ALWAYS_FALSE` predicate.

#### isAlwaysFalse

    public static boolean isAlwaysFalse(@Nullable
                        IgnitePredicate[] p)

Tests whether or not given set of predicates consists only of one predicate returned from `alwaysFalse()` method.

Parameters:
  `p` - Predicate to check.
Returns:
  `true` if given contains only `ALWAYS_FALSE` predicate.

#### isNull

    public static <T> IgnitePredicate<T> isNull()

Gets predicate that evaluates to `true` if its free variable is `null`.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Returns:
  Predicate that evaluates to `true` if its free variable is `null`.

#### notNull

    public static <T> IgnitePredicate<T> notNull()

Gets predicate that evaluates to `true` if its free variable is not `null`.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Returns:
  Predicate that evaluates to `true` if its free variable is not `null`.

#### not

    @SafeVarargs
    public static <T> IgnitePredicate<T> not(@Nullable
                                         IgnitePredicate<? super T>... p)

Negates given predicates.

Gets predicate that evaluates to `true` if any of given predicates evaluates to `false`. If all predicates evaluate to `true` the result predicate will evaluate to `false`.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Parameters:
  `p` - Predicate to negate.
Returns:
  Negated predicate.

#### equalTo

    public static <T> IgnitePredicate<T> equalTo(@Nullable
                                 T target)

Gets predicate that evaluates to `true` if its free variable is equal to `target` or both are `null`.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Parameters:
  `target` - Object to compare free variable to.
Returns:
  Predicate that evaluates to `true` if its free variable is equal to `target` or both are `null`.

#### notEqualTo

    public static <T> IgnitePredicate<T> notEqualTo(@Nullable
                                    T target)

Gets predicate that evaluates to `true` if its free variable is not equal to `target` or both are `null`.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Parameters:
  `target` - Object to compare free variable to.
Returns:
  Predicate that evaluates to `true` if its free variable is not equal to `target` or both are `null`.

#### instanceOf

    public static <T> IgnitePredicate<T> instanceOf(Class<?> cls)

Gets predicate that evaluates to `true` if its free variable is instance of the given class.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Parameters:
  `cls` - Class to compare to.
Returns:
  Predicate that evaluates to `true` if its free variable is instance of the given class.

#### first

    public static <T> T first(@Nullable
              Iterable<? extends T> c)

Gets first element from given collection or returns `null` if the collection is empty.

Type Parameters:
  `T` - Type of the collection.
Parameters:
  `c` - A collection.
Returns:
  Collections' first element or `null` in case if the collection is empty.

#### first

    public static <T> T first(List<? extends T> list)

Gets first element from given list or returns `null` if list is empty.

Parameters:
  `list` - List.
Returns:
  List' first element or `null` in case if list is empty.

#### last

    @Nullable
    public static <T> T last(@Nullable
                      Iterable<? extends T> c)

Gets last element from given collection or returns `null` if the collection is empty.

Type Parameters:
  `T` - Type of the collection.
Parameters:
  `c` - A collection.
Returns:
  Collections' first element or `null` in case if the collection is empty.

#### firstValue

    @Nullable
    public static <V> V firstValue(Map<?,V> m)

Gets first value from given map or returns `null` if the map is empty.

Type Parameters:
  `V` - Value type.
Parameters:
  `m` - A map.
Returns:
  Maps' first value or `null` in case if the map is empty.

#### firstKey

    @Nullable
    public static <K> K firstKey(Map<K,?> m)

Gets first key from given map or returns `null` if the map is empty.

Type Parameters:
  `K` - Key type.
Parameters:
  `m` - A map.
Returns:
  Maps' first key or `null` in case if the map is empty.

#### firstEntry

    @Nullable
    public static <K,V> Map.Entry<K,V> firstEntry(Map<K,V> m)

Gets first key from given map or returns `null` if the map is empty.

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `m` - A map.
Returns:
  Map's first entry or `null` in case if the map is empty.

#### and

    public static <T> IgnitePredicate<T> and(@Nullable
                             IgnitePredicate<? super T>... ps)

Get a predicate that evaluates to `true` if each of its component predicates evaluates to `true`. The components are evaluated in order they are supplied. Evaluation will be stopped as soon as first predicate evaluates to `false`. Passed in predicates are NOT copied. If no predicates are passed in the returned predicate will always evaluate to `false`.

Type Parameters:
  `T` - Type of the free variable, i.e. the element the predicate is called on.
Parameters:
  `ps` - Passed in predicate. If none provided - always-`false` predicate is returned.
Returns:
  Predicate that evaluates to `true` if each of its component predicates evaluates to `true`.

#### identity

    public static <T> IgniteClosure<T,T> identity()

Gets identity closure, i.e. the closure that returns its variable value.

Type Parameters:
  `T` - Type of the variable and return value for the closure.
Returns:
  Identity closure, i.e. the closure that returns its variable value.

#### string

    public static <T> IgniteClosure<T,String> string()

Gets closure that return `toString()` value for its free variable.

Type Parameters:
  `T` - Type of the free variable for the closure.
Returns:
  Closure that return `toString()` value for its free variable.

#### notIn

    public static <T> IgnitePredicate<T> notIn(@Nullable
                               Collection<? extends T> c)

Gets predicate that returns `true` if its free variable is not contained in given collection.

Type Parameters:
  `T` - Type of the free variable for the predicate and type of the collection elements.
Parameters:
  `c` - Collection to check for containment.
Returns:
  Predicate that returns `true` if its free variable is not contained in given collection.

#### addAll

    public static <T,C extends Collection<T>> C addAll(C c,
                                       Iterable<? extends T> it)

Parameters:
  `c` - Target collection.
  `it` - Iterable to fetch.
Returns:
  Modified target collection.

#### addAll

    public static <T,C extends Collection<T>> C addAll(C c,
                                       Iterator<? extends T> it)

Parameters:
  `c` - Target collection.
  `it` - Iterator to fetch.
Returns:
  Modified target collection.

#### addIfAbsent

    public static <K,V> V addIfAbsent(ConcurrentMap<K,V> map,
                      K key,
                      @Nullable
                      Callable<V> c)

Gets the value with given key. If that value does not exist, calls given closure to get the default value, puts it into the map and returns it. If closure is `null` return `null`.

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `map` - Concurrent hash map.
  `key` - Key to get the value for.
  `c` - Default value producing closure.
Returns:
  Value for the key or the value produced by the closure if key does not exist in the map. Return `null` if key is not found and closure is `null`.

#### addIfAbsent

    public static <K,V> V addIfAbsent(ConcurrentMap<K,V> map,
                      K key,
                      V val)

Gets the value with given key. If that value does not exist, puts given value into the map and returns it.

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `map` - Map.
  `key` - Key.
  `val` - Value to put if one does not exist.
Returns:
  Current mapping for a given key.

#### addIfAbsent

    @Nullable
    public static <K,V> V addIfAbsent(Map<? super K,V> map,
                               @Nullable
                               K key,
                               @Nullable
                               Callable<? extends V> c)

Utility map getter.

Type Parameters:
  `K` - Map key type.
  `V` - Map value type.
Parameters:
  `map` - Map to get value from.
  `key` - Map key (can be `null`).
  `c` - Optional factory closure for the default value to be put in when `key` is not found. If closure is not provided - `null` will be put into the map.
Returns:
  Value for the `key` or default value produced by `c` if key is not found (or `null` if key is not found and closure is not provided). Note that in case when key is not found the default value will be put into the map.
Throws:
  `GridClosureException` - Thrown in case when callable throws exception.
See Also:
  `newLinkedList()`, `newList()`, `newSet()`, `newMap()`, `newAtomicLong()`, `newAtomicInt()`, `newAtomicRef()`, `newAtomicBoolean()`

#### addIfAbsent

    @Nullable
    public static <K,V> V addIfAbsent(Map<K,V> map,
                               @Nullable
                               K key,
                               @Nullable
                               V v)

Utility map getter.

Type Parameters:
  `K` - Map key type.
  `V` - Map value type.
Parameters:
  `map` - Map to get value from.
  `key` - Map key (can be `null`).
  `v` - Optional value to be put in when `key` is not found. If not provided - `null` will be put into the map.
Returns:
  Value for the `key` or default value `c` if key is not found (or `null` if key is not found and value is not provided). Note that in case when key is not found the default value will be put into the map.

#### reduce

    public static <X,Y> Y reduce(Iterable<? extends X> c,
                 IgniteReducer<? super X,Y> f)

Reduces collection into single value using given for-all closure.

Type Parameters:
  `X` - Type of the free variable for the closure and type of the collection elements.
  `Y` - Type of the closure's return value.
Parameters:
  `c` - Collection to reduce.
  `f` - For-all closure used for reduction.
Returns:
  Single value as a result of collection reduction.

#### forEach

    public static <X> void forEach(Iterable<? extends X> c,
                   IgniteInClosure<? super X> f,
                   @Nullable
                   IgnitePredicate<? super X>... p)

Calls given `side-effect only` closure over the each element of the provided collection.

Type Parameters:
  `X` - Type of the free variable for the closure and type of the collection elements.
Parameters:
  `c` - Collection to call closure over.
  `f` - Side-effect only closure to call over the collection.
  `p` - Optional set of predicates. Only if collection element evaluates to `true` for given predicates the closure will be applied to it. If no predicates provided - closure will be applied to all collection elements.

#### forEach

    public static <X> void forEach(X[] c,
                   IgniteInClosure<? super X> f,
                   @Nullable
                   IgnitePredicate<? super X>... p)

Calls given `side-effect only` closure over the each element of the provided array.

Type Parameters:
  `X` - Type of the free variable for the closure and type of the array elements.
Parameters:
  `c` - Array to call closure over.
  `f` - Side-effect only closure to call over the array.
  `p` - Optional set of predicates. Only if collection element evaluates to `true` for given predicates the closure will be applied to it. If no predicates provided - closure will be applied to all collection elements.

#### copy

    public static <T> Collection<T> copy(Collection<T> to,
                         T... from)

Adds (copies) to given collection all elements in `'from'` array.

Type Parameters:
  `T` - Type of the free variable for the predicate and type of the collection elements.
Parameters:
  `to` - Collection to copy to.
  `from` - Array to copy from.
Returns:
  Collection to copy to.

#### copy

    public static <T> Collection<T> copy(Collection<T> to,
                         Iterable<? extends T> from,
                         @Nullable
                         IgnitePredicate<? super T>... p)

Adds (copies) to given collection using provided predicates. Element is copied if all predicates evaluate to `true`.

Type Parameters:
  `T` - Type of the free variable for the predicate and type of the collection elements.
Parameters:
  `to` - Collection to copy to.
  `from` - Collection to copy from.
  `p` - Optional set of predicates to use for filtration.
Returns:
  Collection to copy to.

#### transform

    public static <X,Y> Collection<Y> transform(Collection<? extends X> c,
                                IgniteClosure<? super X,Y> f)

Transforms one collection to another using provided closure. New collection will be created.

Type Parameters:
  `X` - Type of the free variable for the closure and type of the collection elements.
  `Y` - Type of the closure's return value.
Parameters:
  `c` - Initial collection to transform.
  `f` - Closure to use for transformation.
Returns:
  Transformed newly created collection.

#### upcast

    public static <T extends R,R> Collection<R> upcast(Collection<T> c)

Upcasts collection type.

Parameters:
  `c` - Initial collection.
Returns:
  Resulting collection.

#### transform

    public static <X,Y> Collection<Y> transform(X[] c,
                                IgniteClosure<? super X,Y> f)

Transforms an array to read only collection using provided closure.

Type Parameters:
  `X` - Type of the free variable for the closure and type of the array elements.
  `Y` - Type of the closure's return value.
Parameters:
  `c` - Initial array to transform.
  `f` - Closure to use for transformation.
Returns:
  Transformed read only collection.

#### isAll

    public static <T> boolean isAll(@Nullable
                    T t,
                    @Nullable
                    IgnitePredicate<? super T>... p)

Tests if all provided predicates evaluate to `true` for given value. Note that evaluation will be short-circuit when first predicate evaluated to `false` is found.

Type Parameters:
  `T` - Type of the value and free variable of the predicates.
Parameters:
  `t` - Value to test.
  `p` - Optional set of predicates to use for evaluation. If no predicates provides this method will always return `true`.
Returns:
  Returns `true` if given set of predicates is `null`, is empty, or all predicates evaluate to `true` for given value, `false` otherwise.

#### isAny

    public static <T> boolean isAny(@Nullable
                    T t,
                    @Nullable
                    IgnitePredicate<? super T>... p)

Tests if any of provided predicates evaluate to `true` for given value. Note that evaluation will be short-circuit when first predicate evaluated to `true` is found.

Type Parameters:
  `T` - Type of the value and free variable of the predicates.
Parameters:
  `t` - Value to test.
  `p` - Optional set of predicates to use for evaluation.
Returns:
  Returns `true` if any of predicates evaluates to `true` for given value, `false` otherwise. Returns `false` if given set of predicates is `null` or empty.

#### noop

    public static GridAbsClosure noop()

Creates an absolute (no-arg) closure that does nothing.

Returns:
  Absolute (no-arg) closure that does nothing.

#### find

    @SafeVarargs
    @Nullable
    public static <V> V find(Iterable<? extends V> c,
                                  @Nullable
                                  V dfltVal,
                                  @Nullable
                                  IgnitePredicate<? super V>... p)

Finds and returns first element in given collection for which any of the provided predicates evaluates to `true`.

Type Parameters:
  `V` - Type of the collection elements.
Parameters:
  `c` - Input collection.
  `dfltVal` - Default value to return when no element is found.
  `p` - Optional set of finder predicates.
Returns:
  First element in given collection for which predicate evaluates to `true` - or `null` if such element cannot be found.

#### find

    public static <V,Y> Y find(Iterable<? extends V> c,
               @Nullable
               Y dfltVal,
               IgniteClosure<? super V,Y> f,
               @Nullable
               IgnitePredicate<? super V>... p)

Finds, transforms and returns first element in given collection for which any of the provided predicates evaluates to `true`.

Type Parameters:
  `V` - Type of the collection elements.
Parameters:
  `c` - Input collection.
  `dfltVal` - Default value to return when no element is found.
  `f` - Transforming closure.
  `p` - Optional set of finder predicates.
Returns:
  First element in given collection for which predicate evaluates to `true` - or `null` if such element cannot be found.

#### containsAny

    public static <T> boolean containsAny(@Nullable
                          Collection<? extends T> c1,
                          @Nullable
                          Iterable<? extends T> c2)

Checks if collection `c1` contains any elements from collection `c2`.

Type Parameters:
  `T` - Type of the elements.
Parameters:
  `c1` - Collection to check for containment. If `null` - this method returns `false`.
  `c2` - Collection of elements to check. If `null` - this method returns `false`.
Returns:
  `true` if collection `c1` contains at least one element from collection `c2`.

#### containsAny

    public static <T> boolean containsAny(@Nullable
                          Collection<? extends T> c1,
                          @Nullable
                          T... c2)

Checks if collection `c1` contains any elements from array `c2`.

Type Parameters:
  `T` - Type of the elements.
Parameters:
  `c1` - Collection to check for containment. If `null` - this method returns `false`.
  `c2` - Collection of elements to check. If `null` - this method returns `false`.
Returns:
  `true` if collection `c1` contains at least one element from collection `c2`.

#### containsAll

    public static <T> boolean containsAll(@Nullable
                          Collection<? extends T> c1,
                          @Nullable
                          Iterable<? extends T> c2)

Checks if collection `c1` contains all elements from collection `c2`.

Type Parameters:
  `T` - Type of the elements.
Parameters:
  `c1` - Collection to check for containment. If `null` - this method returns `false`.
  `c2` - Collection of elements to check. If `null` - this method returns `true` meaning that `null`-collection is treated as empty collection.
Returns:
  `true` if collection `c1` contains all elements from collection `c2`.

#### pair

    public static <T> IgnitePair<T> pair(@Nullable
                         T t1,
                         @Nullable
                         T t2)

Creates pair out of given two objects.

Type Parameters:
  `T` - Type of objects in pair.
Parameters:
  `t1` - First object in pair.
  `t2` - Second object in pair.
Returns:
  Pair of objects.

#### partition

    public static <V> IgniteBiTuple<Collection<V>,Collection<V>> partition(Iterable<? extends V> c,
                                                           IgnitePredicate<? super V> p)

Partitions input collection in two: first containing elements for which given predicate evaluates to `true` - and second containing the elements for which predicate evaluates to `false`.

Type Parameters:
  `V` - Type of the collection elements.
Parameters:
  `c` - Input collection.
  `p` - Partitioning predicate.
Returns:
  Tuple of two collections: first containing elements for which given predicate evaluates to `true` - and second containing the elements for which predicate evaluates to `false`.

#### exist

    public static <V> boolean exist(Iterable<? extends V> c,
                    @Nullable
                    IgnitePredicate<? super V>... p)

Checks for existence of the element in input collection for which all provided predicates evaluate to `true`.

Type Parameters:
  `V` - Type of the collection elements.
Parameters:
  `c` - Input collection.
  `p` - Optional set of checking predicates.
Returns:
  `true` if input collection contains element for which all the provided predicates evaluates to `true` - otherwise returns `false`.

#### forAll

    public static <V> boolean forAll(Iterable<? extends V> c,
                     @Nullable
                     IgnitePredicate<? super V>... p)

Applies all given predicates to all elements in given input collection and returns `true` if all of them evaluate to `true` for all elements. Returns `false` otherwise.

Type Parameters:
  `V` - Type of the collection element.
Parameters:
  `c` - Input collection.
  `p` - Optional set of checking predicates. If none provided - `true` is returned.
Returns:
  Returns `true` if all given predicates evaluate to `true` for all elements. Returns `false` otherwise.

#### forAll

    public static <K1,K extends K1,V1,V extends V1> boolean forAll(Map<K,V> m,
                                                   @Nullable
                                                   IgnitePredicate<? super Map.Entry<K,V>>... p)

Applies given predicates to all entries in given input map and returns `true` if all of them evaluates to `true` for all entries. Returns `false` otherwise.

Type Parameters:
  `K` - Type of the map keys.
  `V` - Type of the map values.
Parameters:
  `m` - Input map.
  `p` - Optional set of checking predicate.
Returns:
  Returns `true` if all given predicate evaluates to `true` for all entries. Returns `false` otherwise.

#### forAny

    public static <V> boolean forAny(Iterable<? extends V> c,
                     @Nullable
                     IgnitePredicate<? super V>... p)

Applies all given predicates to all elements in given input collection and returns `true` if all predicates evaluate to `true` for at least one element. Returns `false` otherwise. Processing will short-circuit after first element evaluates to `true` for all predicates.

Type Parameters:
  `V` - Type of the collection element.
Parameters:
  `c` - Input collection.
  `p` - Optional set of checking predicates. If none provided - `true` is returned.
Returns:
  Returns `true` if all given predicates evaluate to `true` for at least one element. Returns `false` otherwise.

#### fold

    @Nullable
    public static <D,B> B fold(Iterable<? extends D> c,
                        @Nullable
                        B b,
                        @Nullable
                        IgniteBiClosure<? super D,? super B,B>... fs)

Folds-right given collection using provided closure. If input collection contains `a1, a2, ..., an` result value will be `...f(f(f(b,a1),a2),a3)...` where `f(x)` is the result of applying each closure from `fs` set to the element `x` of the input collection `c`.

For example:

     ...

     Collection<Integer> nums = new ArrayList<Integer>(size);

     // Search max value.
     Integer max = F.fold(nums, F.first(nums), new C2<Integer, Integer, Integer>() {
         public Integer apply(Integer n, Integer max) { return Math.max(n, max); }
     });

     ...

Type Parameters:
  `D` - Type of the input collection elements and type of the free variable for the closure.
  `B` - Type of the folding value and return type of the closure.
Parameters:
  `c` - Input collection.
  `b` - Optional first folding pair element.
  `fs` - Optional set of folding closures.
Returns:
  Value representing folded collection.

#### t

    public static <V> GridTuple<V> t(@Nullable
                     V v)

Factory method returning new tuple with given parameter.

Type Parameters:
  `V` - Type of the tuple.
Parameters:
  `v` - Parameter for tuple.
Returns:
  Newly created tuple.

#### t1

    public static <V> GridTuple<V> t1()

Factory method returning empty tuple.

Type Parameters:
  `V` - Type of the tuple.
Returns:
  Newly created empty tuple.

#### t

    public static <V1,V2> IgniteBiTuple<V1,V2> t(@Nullable
                                 V1 v1,
                                 @Nullable
                                 V2 v2)

Factory method returning new tuple with given parameters.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
Parameters:
  `v1` - 1st parameter for tuple.
  `v2` - 2nd parameter for tuple.
Returns:
  Newly created tuple.

#### t2

    public static <V1,V2> IgniteBiTuple<V1,V2> t2()

Factory method returning new empty tuple.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
Returns:
  Newly created empty tuple.

#### t

    public static <V1,V2,V3> GridTuple3<V1,V2,V3> t(@Nullable
                                    V1 v1,
                                    @Nullable
                                    V2 v2,
                                    @Nullable
                                    V3 v3)

Factory method returning new tuple with given parameters.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
Parameters:
  `v1` - 1st parameter for tuple.
  `v2` - 2nd parameter for tuple.
  `v3` - 3rd parameter for tuple.
Returns:
  Newly created tuple.

#### t

    public static <V1,V2,V3,V4> GridTuple4<V1,V2,V3,V4> t(@Nullable
                                          V1 v1,
                                          @Nullable
                                          V2 v2,
                                          @Nullable
                                          V3 v3,
                                          @Nullable
                                          V4 v4)

Factory method returning new tuple with given parameters.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
  `V4` - Type of the 4th tuple parameter.
Parameters:
  `v1` - 1st parameter for tuple.
  `v2` - 2nd parameter for tuple.
  `v3` - 3rd parameter for tuple.
  `v4` - 4th parameter for tuple.
Returns:
  Newly created tuple.

#### t

    public static <V1,V2,V3,V4,V5> GridTuple5<V1,V2,V3,V4,V5> t(@Nullable
                                                V1 v1,
                                                @Nullable
                                                V2 v2,
                                                @Nullable
                                                V3 v3,
                                                @Nullable
                                                V4 v4,
                                                @Nullable
                                                V5 v5)

Factory method returning new tuple with given parameters.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
  `V4` - Type of the 4th tuple parameter.
  `V5` - Type of the 5th tuple parameter.
Parameters:
  `v1` - 1st parameter for tuple.
  `v2` - 2nd parameter for tuple.
  `v3` - 3rd parameter for tuple.
  `v4` - 4th parameter for tuple.
  `v5` - 5th parameter for tuple.
Returns:
  Newly created tuple.

#### t

    public static <V1,V2,V3,V4,V5,V6> GridTuple6<V1,V2,V3,V4,V5,V6> t(@Nullable
                                                      V1 v1,
                                                      @Nullable
                                                      V2 v2,
                                                      @Nullable
                                                      V3 v3,
                                                      @Nullable
                                                      V4 v4,
                                                      @Nullable
                                                      V5 v5,
                                                      @Nullable
                                                      V6 v6)

Factory method returning new tuple with given parameters.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
  `V4` - Type of the 4th tuple parameter.
  `V5` - Type of the 5th tuple parameter.
  `V6` - Type of the 6th tuple parameter.
Parameters:
  `v1` - 1st parameter for tuple.
  `v2` - 2nd parameter for tuple.
  `v3` - 3rd parameter for tuple.
  `v4` - 4th parameter for tuple.
  `v5` - 5th parameter for tuple.
  `v6` - 5th parameter for tuple.
Returns:
  Newly created tuple.

#### tv

    public static GridTupleV tv(Object... objs)

Creates vararg tuple with given values.

Parameters:
  `objs` - Values for vararg tuple.
Returns:
  Vararg tuple with given values.

#### t3

    public static <V1,V2,V3> GridTuple3<V1,V2,V3> t3()

Factory method returning new empty tuple.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
Returns:
  Newly created empty tuple.

#### t4

    public static <V1,V2,V3,V4> GridTuple4<V1,V2,V3,V4> t4()

Factory method returning new empty tuple.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
  `V4` - Type of the 4th tuple parameter.
Returns:
  Newly created empty tuple.

#### t5

    public static <V1,V2,V3,V4,V5> GridTuple5<V1,V2,V3,V4,V5> t5()

Factory method returning new empty tuple.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
  `V4` - Type of the 4th tuple parameter.
  `V5` - Type of the 5th tuple parameter.
Returns:
  Newly created empty tuple.

#### t6

    public static <V1,V2,V3,V4,V5,V6> GridTuple6<V1,V2,V3,V4,V5,V6> t6()

Factory method returning new empty tuple.

Type Parameters:
  `V1` - Type of the 1st tuple parameter.
  `V2` - Type of the 2nd tuple parameter.
  `V3` - Type of the 3rd tuple parameter.
  `V4` - Type of the 4th tuple parameter.
  `V5` - Type of the 5th tuple parameter.
  `V6` - Type of the 6th tuple parameter.
Returns:
  Newly created empty tuple.

#### zip

    public static <K,V> Map<K,V> zip(Collection<? extends K> keys,
                     V dfltVal)

Converts collection to map using collection values as keys and passed in default value as values.

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Parameters:
  `keys` - Map keys.
  `dfltVal` - Default value.
Returns:
  Resulting map.

#### asMap

    public static <K,V> Map<K,V> asMap(K k,
                       V v)

Creates map with given values.

Type Parameters:
  `K` - Key's type.
  `V` - Value's type.
Parameters:
  `k` - Key.
  `v` - Value.
Returns:
  Created map.

#### asMap

    public static <K,V> Map<K,V> asMap(K k1,
                       V v1,
                       K k2,
                       V v2)

Creates map with given values.

Type Parameters:
  `K` - Key's type.
  `V` - Value's type.
Parameters:
  `k1` - Key 1.
  `v1` - Value 1.
  `k2` - Key 2.
  `v2` - Value 2.
Returns:
  Created map.

#### asMap

    public static <K,V> Map<K,V> asMap(K k1,
                       V v1,
                       K k2,
                       V v2,
                       K k3,
                       V v3)

Creates map with given values.

Type Parameters:
  `K` - Key's type.
  `V` - Value's type.
Parameters:
  `k1` - Key 1.
  `v1` - Value 1.
  `k2` - Key 2.
  `v2` - Value 2.
  `k3` - Key 3.
  `v3` - Value 3.
Returns:
  Created map.

#### asMap

    public static <K,V> Map<K,V> asMap(K k1,
                       V v1,
                       K k2,
                       V v2,
                       K k3,
                       V v3,
                       K k4,
                       V v4)

Creates map with given values.

Type Parameters:
  `K` - Key's type.
  `V` - Value's type.
Parameters:
  `k1` - Key 1.
  `v1` - Value 1.
  `k2` - Key 2.
  `v2` - Value 2.
  `k3` - Key 3.
  `v3` - Value 3.
  `k4` - Key 4.
  `v4` - Value 4.
Returns:
  Created map.

#### asMap

    public static <K,V> Map<K,V> asMap(K k1,
                       V v1,
                       K k2,
                       V v2,
                       K k3,
                       V v3,
                       K k4,
                       V v4,
                       K k5,
                       V v5)

Creates map with given values.

Type Parameters:
  `K` - Key's type.
  `V` - Value's type.
Parameters:
  `k1` - Key 1.
  `v1` - Value 1.
  `k2` - Key 2.
  `v2` - Value 2.
  `k3` - Key 3.
  `v3` - Value 3.
  `k4` - Key 4.
  `v4` - Value 4.
  `k5` - Key 5.
  `v5` - Value 5.
Returns:
  Created map.

#### asArray

    public static <T> T[] asArray(T... t)

Convenience method to convert multiple elements into array.

Type Parameters:
  `T` - Element type.
Parameters:
  `t` - Elements to convert into array.
Returns:
  Array of elements.

#### asList

    public static <T> List<T> asList(@Nullable
                     T t)

Creates read-only list with given values.

Type Parameters:
  `T` - Element's type.
Parameters:
  `t` - Element (if `null`, then empty list is returned).
Returns:
  Created list.

#### asSet

    public static <T> Set<T> asSet(@Nullable
                   T t)

Creates read-only set with given value.

Type Parameters:
  `T` - Element's type.
Parameters:
  `t` - Element (if `null`, then empty set is returned).
Returns:
  Created set.

#### asSet

    public static <T> Set<T> asSet(@Nullable
                   T... t)

Creates read-only set with given values.

Type Parameters:
  `T` - Element's type.
Parameters:
  `t` - Element (if `null`, then empty set is returned).
Returns:
  Created set.

#### contains

    public static <T> boolean contains(@Nullable
                       Collection<T> c,
                       @Nullable
                       T t)

Checks if value is contained in the collection passed in. If the collection is `null`, then `false` is returned.

Type Parameters:
  `T` - Value type.
Parameters:
  `c` - Collection to check.
  `t` - Value to check for containment.
Returns:
  `True` if collection is not `null` and contains given value, `false` otherwise.

#### contains

    public static <T> IgnitePredicate<T> contains(@Nullable
                                  Collection<T> c)

Provides predicate which returns `true` if it receives an element that is contained in the passed in collection.

Type Parameters:
  `T` - Element type.
Parameters:
  `c` - Collection used for predicate filter.
Returns:
  Predicate which returns `true` if it receives an element that is contained in the passed in collection.

#### notContains

    public static <T> IgnitePredicate<T> notContains(@Nullable
                                     Collection<T> c)

Provides predicate which returns `true` if it receives an element that is not contained in the passed in collection.

Type Parameters:
  `T` - Element type.
Parameters:
  `c` - Collection used for predicate filter.
Returns:
  Predicate which returns `true` if it receives an element that is not contained in the passed in collection.

#### contains

    public static boolean contains(int[] arr,
                   int val)

Parameters:
  `arr` - Array.
  `val` - Value to find.
Returns:
  `True` if array contains given value.

#### contains

    public static boolean contains(Integer[] arr,
                   int val)

Parameters:
  `arr` - Array.
  `val` - Value to find.
Returns:
  `True` if array contains given value.

#### contains

    public static boolean contains(long[] arr,
                   long val)

Parameters:
  `arr` - Array.
  `val` - Value to find.
Returns:
  `True` if array contains given value.

#### eq

    public static boolean eq(@Nullable
             Object o1,
             @Nullable
             Object o2)

Tests whether specified arguments are equal, or both `null`.

Parameters:
  `o1` - Object to compare.
  `o2` - Object to compare.
Returns:
  Returns `true` if the specified arguments are equal, or both `null`.

#### eqOrdered

    public static boolean eqOrdered(@Nullable
                    Collection<?> c1,
                    @Nullable
                    Collection<?> c2)

Checks if both collections have equal elements in the same order.

Parameters:
  `c1` - First collection.
  `c2` - Second collection.
Returns:
  `True` if both collections have equal elements in the same order.

#### eqNotOrdered

    public static boolean eqNotOrdered(@Nullable
                       Collection<?> c1,
                       @Nullable
                       Collection<?> c2)

Checks if both collections have equal elements in any order.

Implementation of this method takes optimization steps based on the actual type of the collections. Dups are allowed in the collection. Note that if collections allow fixed-time random access (implementing `RandomAccess` marker interface - having them pre-sorted dramatically improves the performance.

Parameters:
  `c1` - First collection.
  `c2` - Second collection.
Returns:
  `True` if both collections have equal elements in any order.

#### eqNotOrdered

    public static <K,V> boolean eqNotOrdered(@Nullable
                             Map<K,V> m1,
                             @Nullable
                             Map<K,V> m2)

Compares two maps. Unlike `java.util.AbstractMap#equals(...)` method this implementation checks not only entry sets, but also the keys. Some optimization checks are also used.

Parameters:
  `m1` - First map to check.
  `m2` - Second map to check
Returns:
  `True` is maps are equal, `False` otherwise.

#### eqArray

    public static boolean eqArray(Object[] a1,
                  Object[] a2,
                  boolean sorted,
                  boolean dups)

Compares two arrays. Unlike `Arrays#equals(...)` method this implementation checks two arrays as sets allowing the same elements to be in different indexes.

Parameters:
  `a1` - First array to check.
  `a2` - Second array to check.
  `sorted` - Tells whether or not both arrays are pre-sorted so that binary search could be used instead of iteration.
  `dups` - Tells whether or not arrays can contain duplicates. If arrays contain duplicate the implementation will have to do double work.
Returns:
  `True` if arrays are equal, `false` otherwise.

#### eqNodes

    public static boolean eqNodes(Object n1,
                  Object n2)

Compares two `ClusterNode` instances for equality.

Since introduction of `ClusterNode` in Apache Ignite 3.0 the semantic of equality between grid nodes has changed. Since rich node wraps thin node instance and in the same time implements `ClusterNode` interface, the proper semantic of comparing two grid node is to ignore their runtime types and compare only by their IDs. This method implements this logic.

End users rarely, if ever, need to directly compare two grid nodes for equality. This method is intended primarily for discovery SPI developers that provide implementations of `ClusterNode` interface.

Parameters:
  `n1` - Grid node 1.
  `n2` - Grid node 2
Returns:
  `true` if two grid node have the same IDs (ignoring their runtime types), `false` otherwise.

#### cacheEntry2Key

    public static <K,V> IgniteClosure<javax.cache.Cache.Entry<K,V>,K> cacheEntry2Key()

Gets closure that returns key for cache entry. The closure internally delegates to `Cache.Entry.getKey()` method.

Type Parameters:
  `K` - Key type.
Returns:
  Closure that returns key for an entry.

#### cacheEntry2Get

    public static <K,V> IgniteClosure<javax.cache.Cache.Entry<K,V>,V> cacheEntry2Get()

Gets closure that returns value for an entry. The closure internally delegates to `Cache.get(Object)` method.

Type Parameters:
  `K` - Key type.
  `V` - Value type.
Returns:
  Closure that returns value for an entry.

#### cacheHasPeekValue

    public static <K,V> IgnitePredicate<javax.cache.Cache.Entry<K,V>> cacheHasPeekValue()

Gets predicate which returns `true` if entry has peek value.

Type Parameters:
  `K` - Cache key type.
  `V` - Cache value type.
Returns:
  Predicate which returns `true` if entry has peek value.

#### wrap

    public static GridClosureException wrap(Throwable e)

Shortcut method that creates an instance of `GridClosureException`.

Parameters:
  `e` - Exception to wrap.
Returns:
  Newly created instance of `GridClosureException`.

#### intersects

    public static <E> boolean intersects(Iterable<E> s1,
                         Collection<E>... s2)

Checks if two collections passed in intersect.

Type Parameters:
  `E` - Element type.
Parameters:
  `s1` - Set1.
  `s2` - Set2.
Returns:
  `True` if there is an intersection, `false` otherwise.

#### awaitAll

    public static <T> void awaitAll(@Nullable
                    Collection<IgniteInternalFuture<T>> futs)
                         throws IgniteCheckedException

Waits until all passed futures will be executed.

Parameters:
  `futs` - Futures. If none provided - this method is no-op.
Throws:
  `IgniteCheckedException` - If any of the futures failed.

#### awaitAll

    public static <T> void awaitAll(long timeout,
                    @Nullable
                    Collection<IgniteInternalFuture<T>> futs)
                         throws IgniteCheckedException

Waits until all passed futures will be executed.

Parameters:
  `timeout` - Timeout for waiting (`0` for forever).
  `futs` - Futures. If none provided - this method is no-op.
Throws:
  `IgniteCheckedException` - If any of the futures failed.

#### awaitAll

    @Nullable
    public static <T,R> R awaitAll(long timeout,
                            @Nullable
                            IgniteReducer<T,R> rdc,
                            @Nullable
                            Collection<IgniteInternalFuture<T>> futs)
                      throws IgniteCheckedException

Awaits for all futures to complete and optionally reduces all results into one.

Type Parameters:
  `T` - Return type of the futures.
  `R` - Return type of the reducer.
Parameters:
  `timeout` - Timeout for waiting (`0` for forever).
  `rdc` - Optional reducer. If not `null`, then results will be reduced into one.
  `futs` - List of futures to wait for.
Returns:
  Reduced result if reducer is provided, `null` otherwise.
Throws:
  `IgniteCheckedException` - If any of the futures failed.

#### unfinishedFutures

    public static IgnitePredicate<IgniteInternalFuture<?>> unfinishedFutures()

Returns predicate for filtering unfinished futures.

Returns:
  Predicate for filtering unfinished futures.

2015 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 1.5.0.final
Release Date | : December 29 2015