public class GridFunc extends Object
closures
, predicates
, and tuples
.
It also contains functional style collection comprehensions.
Most of the methods in this class can be divided into two groups:
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.
Constructor and Description |
---|
GridFunc() |
Modifier and Type | Method and Description |
---|---|
static <T,C extends Collection<T>> |
addAll(C c,
Iterable<? extends T> it)
Deprecated.
|
static <T,C extends Collection<T>> |
addAll(C c,
Iterator<? extends T> it)
Deprecated.
|
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)
Deprecated.
|
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)
Deprecated.
|
static <K,V> Map<K,V> |
asMap(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4)
Deprecated.
|
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)
Deprecated.
|
static <T> Set<T> |
asSet(T... t)
Deprecated.
|
static <T> Set<T> |
asSet(T t)
Deprecated.
|
static <T> void |
awaitAll(Collection<IgniteInternalFuture<T>> futs)
Deprecated.
|
static <T> void |
awaitAll(long timeout,
Collection<IgniteInternalFuture<T>> futs)
Deprecated.
|
static <T,R> R |
awaitAll(long timeout,
IgniteReducer<T,R> rdc,
Collection<IgniteInternalFuture<T>> futs)
Deprecated.
|
static <K,V> IgniteClosure<javax.cache.Cache.Entry<K,V>,V> |
cacheEntry2Get()
Gets closure that returns value for an 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 <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)
Deprecated.
|
static boolean |
contains(long[] arr,
long val)
Deprecated.
|
static <T> boolean |
containsAll(Collection<? extends T> c1,
Iterable<? extends T> c2)
Deprecated.
|
static <T> boolean |
containsAny(Collection<? extends T> c1,
Iterable<? extends T> c2)
Deprecated.
|
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)
Deprecated.
|
static <T> Collection<T> |
copy(Collection<T> to,
T... from)
Deprecated.
|
static <T> Collection<T> |
dedup(Collection<? extends T> c)
Deprecated.
|
static <T> GridIterator<T> |
emptyIterator()
Deprecated.
|
static boolean |
eq(Object o1,
Object o2)
Tests whether specified arguments are equal, or both
null . |
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)
Deprecated.
|
static <T> IgnitePredicate<T> |
equalTo(T target)
Deprecated.
|
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)
Deprecated.
|
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)
Deprecated.
|
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)
Deprecated.
|
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)
Deprecated.
|
static <V> boolean |
forAll(Iterable<? extends V> c,
IgnitePredicate<? super V>... p)
Deprecated.
|
static <K1,K extends K1,V1,V extends V1> |
forAll(Map<K,V> m,
IgnitePredicate<? super Map.Entry<K,V>>... p)
Deprecated.
|
static <V> boolean |
forAny(Iterable<? extends V> c,
IgnitePredicate<? super V>... p)
Deprecated.
|
static <X> void |
forEach(Iterable<? extends X> c,
IgniteInClosure<? super X> f,
IgnitePredicate<? super X>... p)
Deprecated.
|
static <X> void |
forEach(X[] c,
IgniteInClosure<? super X> f,
IgnitePredicate<? super X>... p)
Deprecated.
|
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> boolean |
isAll(T t,
IgnitePredicate<? super T>... p)
Tests if all provided predicates evaluate to
true for given value. |
static boolean |
isAlwaysFalse(IgnitePredicate p)
Deprecated.
|
static boolean |
isAlwaysFalse(IgnitePredicate[] p)
Deprecated.
|
static boolean |
isAlwaysTrue(IgnitePredicate p)
Deprecated.
|
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)
Deprecated.
|
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 <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> T |
last(Iterable<? extends T> c)
Deprecated.
|
static <T extends ClusterNode> |
localNode(UUID locNodeId)
Gets predicate that evaluates to
true only for given local node ID. |
static <T0,T extends T0> |
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)
Deprecated.
|
static <K,V> Map<K,V> |
lose(Map<K,V> m,
boolean cp,
IgnitePredicate<? super Map.Entry<K,V>>... p)
Deprecated.
|
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 IgniteCallable<AtomicInteger> |
newAtomicInt()
Deprecated.
|
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 <K,V> IgniteCallable<Map<K,V>> |
newMap()
Deprecated.
|
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> |
nodeForNodeId(UUID nodeId)
Creates grid node predicate evaluating on the given node ID.
|
static <T extends ClusterNode> |
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<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()
Deprecated.
|
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)
Deprecated.
|
static <V> IgniteBiTuple<Collection<V>,Collection<V>> |
partition(Iterable<? extends V> c,
IgnitePredicate<? super V> p)
Deprecated.
|
static <T> T |
rand(Collection<? extends T> c)
Gets random value from given collection.
|
static <T> T |
rand(List<T> l)
Deprecated.
|
static <T> T |
rand(T... c)
Deprecated.
|
static List<Integer> |
range(int fromIncl,
int toExcl)
Deprecated.
|
static <T extends ClusterNode> |
remoteNodes(UUID locNodeId)
Gets predicate that evaluates to
false for given local node ID. |
static <T0,T extends T0> |
retain(Collection<T> c,
boolean cp,
Collection<? extends T0> filter)
Deprecated.
|
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 <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()
Deprecated.
|
static int |
sumInt(Iterable<Integer> c)
Calculates sum of all elements.
|
static IgniteReducer<Integer,Integer> |
sumIntReducer()
Deprecated.
|
static IgniteReducer<Long,Long> |
sumLongReducer()
Deprecated.
|
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> |
t(V1 v1,
V2 v2,
V3 v3,
V4 v4)
Deprecated.
|
static <V1,V2,V3,V4,V5> |
t(V1 v1,
V2 v2,
V3 v3,
V4 v4,
V5 v5)
Deprecated.
|
static <V1,V2,V3,V4,V5,V6> |
t(V1 v1,
V2 v2,
V3 v3,
V4 v4,
V5 v5,
V6 v6)
Deprecated.
|
static <V> GridTuple<V> |
t1()
Deprecated.
|
static <V1,V2> IgniteBiTuple<V1,V2> |
t2()
Deprecated.
|
static <V1,V2,V3> GridTuple3<V1,V2,V3> |
t3()
Deprecated.
|
static <V1,V2,V3,V4> |
t4()
Deprecated.
|
static <V1,V2,V3,V4,V5> |
t5()
Deprecated.
|
static <V1,V2,V3,V4,V5,V6> |
t6()
Deprecated.
|
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)
Deprecated.
|
static <T1,T2> List<T2> |
transformList(Collection<? extends T1> c,
IgniteClosure<? super T1,T2> trans,
IgnitePredicate<? super T1>... p)
Deprecated.
|
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> |
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> |
viewAsMap(Set<K> c,
IgniteClosure<? super K,V> mapClo,
IgnitePredicate<? super K>... p)
Read-only map view of a collection.
|
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> |
viewReadOnly(Map<K,V> m,
IgniteBiClosure<K,V,V1> trans,
IgnitePredicate<? super K>... p)
Deprecated.
|
static <K0,K extends K0,V0,V extends V0,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)
Deprecated.
|
public static <T extends ClusterNode> IgnitePredicate<T> localNode(UUID locNodeId)
true
only for given local node ID.T
- Type of the node.locNodeId
- Local node ID.true
only for the node with given local node ID.public static <T extends ClusterNode> IgnitePredicate<T> remoteNodes(UUID locNodeId)
false
for given local node ID.T
- Type of the node.locNodeId
- Local node ID.false
for the given local node ID.@Deprecated public static <T> Collection<T> dedup(Collection<? extends T> c)
T
- Type of the collection.c
- Collection to remove duplicates from.public static int sumInt(Iterable<Integer> c)
c
- Collection of elements.public static <T> IgniteReducer<T,T> identityReducer(T elem)
true
from IgniteReducer.collect(Object)
method and passed in element
from IgniteReducer.reduce()
method.T
- Reducer element type.elem
- Element to return from IgniteReducer.reduce()
method.@Deprecated public static IgniteReducer<Integer,Integer> sumIntReducer()
@Deprecated public static IgniteReducer<Long,Long> sumLongReducer()
@Deprecated public static List<Integer> range(int fromIncl, int toExcl)
fromIncl
- Inclusive start of the range.toExcl
- Exclusive stop of the range.public static String concat(Iterable<String> c, @Nullable String delim)
c
- Input collection.delim
- Delimiter (optional).public static Collection<UUID> nodeIds(@Nullable Collection<? extends ClusterNode> nodes)
Note that this method doesn't create a new collection but simply iterates over the input one.
nodes
- Collection of grid nodes.public static <T> T rand(Collection<? extends T> c)
T
- Type of the collection.c
- Input collection (no null
and not emtpy).@Deprecated public static <T> T rand(List<T> l)
T
- Type of the list elements.l
- Input collection.@Deprecated public static <T> T rand(T... c)
T
- Type of the collection.c
- Input collection.public static <T> Collection<T> concat(boolean cp, @Nullable T t, @Nullable Collection<T> c)
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.T
- Element type.cp
- Copy flag.t
- First element.c
- Second collection.public static <T> Collection<T> concat(boolean cp, @Nullable Collection<T> c1, @Nullable Collection<T> c2)
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.T
- Element type.cp
- Copy flag.c1
- First collection.c2
- Second collection.non-null
collection.public static <T> T[] concat(@Nullable T[] arr, T... obj)
arr
- Array.obj
- One or more elements.public static <T> Iterator<T> concat(Iterator<T>... iters)
iters
- Iterators.public static <T> Iterator<T> concat(Iterator<Iterator<T>> iters)
iters
- Iterator over iterators.public static <T0,T extends T0> Collection<T> lose(Collection<T> c, boolean cp, @Nullable Collection<T0> filter)
filter
collection.T
- Type of collections.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.@Deprecated public static <T> Collection<T> lose(Collection<T> c, boolean cp, @Nullable IgnitePredicate<? super T>... p)
true
by
all given predicates.T
- Type of collections.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.@Deprecated public static <K,V> Map<K,V> lose(Map<K,V> m, boolean cp, @Nullable IgnitePredicate<? super Map.Entry<K,V>>... p)
true
by all given predicates.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.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.public static <T> List<T> loseList(List<T> c, boolean cp, @Nullable Collection<? super T> filter)
filter
collection.T
- Type of list.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.@Deprecated public static <T> List<T> filterList(List<T> c, boolean cp, @Nullable IgnitePredicate<T>... p)
true
.T
- Type of list.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
.public static IgniteClosure<ClusterNode,UUID> node2id()
public static <T extends ClusterNode> IgnitePredicate<T> nodeForNodeId(UUID nodeId)
nodeId
- Node ID for which returning predicate will evaluate to true
.idForNodeId(UUID)
,
nodeIds(Collection)
public static <T extends ClusterNode> IgnitePredicate<T> nodeForNodeIds(@Nullable Collection<UUID> nodeIds)
nodeIds
- Collection of node IDs.idForNodeId(UUID)
,
nodeIds(Collection)
public static IgnitePredicate<UUID> idForNodeId(UUID nodeId)
UUID
predicate evaluating on the given node ID.nodeId
- Node ID for which returning predicate will evaluate to true
.UUID
predicate evaluating on the given node ID.nodeForNodeId(UUID)
,
nodeIds(Collection)
public static IgnitePredicate<ClusterNode> nodeForNodes(ClusterNode... nodes)
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.nodes
- Collection of nodes. If none provided - result predicate will always
return false
.true
for each node in given collection.@Deprecated public static <T0,T extends T0> Collection<T> retain(Collection<T> c, boolean cp, @Nullable Collection<? extends T0> filter)
filter
.T
- Type of collections.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.public static <T> Collection<T> retain(Collection<T> c, boolean cp, @Nullable IgnitePredicate<? super T>... p)
true
by all given predicates.T
- Type of collections.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.public static <T> Collection<T> retain(Collection<T> c, boolean cp, int num)
num
elements in the input collection.T
- Type of the collections.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).num
first elements from the input collection.public static <T> List<T> asList(@Nullable T... vals)
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.
T
- Array type.vals
- Array of valuesList
instance for array.@Deprecated public static <T> GridIterator<T> emptyIterator()
T
- Type of the iterator.public static <T> Collection<T> flatCollections(@Nullable Collection<? extends Collection<T>> c)
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.
T
- Type of the inner collections.c
- Input collection of collections.public static <T> GridIterator<T> flat(@Nullable Iterable<? extends Iterable<T>> c)
T
- Type of the inner collections.c
- Input collection of collections.public static <T> Iterator<T> flatIterators(@Nullable Iterable<Iterator<T>> c)
c
- Input iterable of iterators.@Deprecated public static GridAbsClosure as(@Nullable Runnable r)
r
- Runnable to convert to closure. If null
- no-op closure is returned.null
.public static <T> int size(@Nullable Collection<? extends T> c, @Nullable IgnitePredicate<? super T>... p)
T
- Type of the iterator.c
- Collection to size.p
- Optional predicates that filters out elements from count.true
. If no predicates is provided - all elements are counted.public static <T> int size(@Nullable Iterator<? extends T> it, @Nullable IgnitePredicate<? super T>... p)
T
- Type of the iterator.it
- Iterator to size.p
- Optional predicates that filters out elements from count.true
. If no predicates is provided - all elements are counted.@SafeVarargs public static <T> Collection<T> view(@Nullable Collection<T> c, @Nullable IgnitePredicate<? super T>... p)
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.T
- Type of the collection.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.@SafeVarargs public static <T1,T2> Collection<T2> viewReadOnly(@Nullable Collection<? extends T1> c, IgniteClosure<? super T1,T2> trans, @Nullable IgnitePredicate<? super T1>... p)
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.T1
- Type of the collection.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.@Deprecated public static <T1,T2> List<T2> transformList(Collection<? extends T1> c, IgniteClosure<? super T1,T2> trans, @Nullable IgnitePredicate<? super T1>... p)
true
. Note that a new collection will be created and data will
be copied.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.public static <K0,K extends K0,V0,V extends V0> Map<K,V> view(@Nullable Map<K,V> m, @Nullable IgnitePredicate<? super K>... p)
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.K
- Type of the key.V
- Type of the value.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.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)
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.K
- Type of the key.V
- Type of the input map value.V1
- Type of the output map value.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.@Deprecated 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)
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.K
- Type of the key.V
- Type of the input map value.V1
- Type of the output map value.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.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)
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.K
- Key type.V
- Value type.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.public static boolean isEmpty(@Nullable String s)
null
or empty.s
- String to test.null
or empty.public static <T> boolean isEmpty(@Nullable T[] c)
null
or empty.c
- Array to test.null
or empty.public static <T> boolean isEmptyOrNulls(@Nullable T[] c)
null
, empty or contains only null
values.c
- Array to test.null
, empty or contains only null
values.public static boolean isEmpty(@Nullable int[] c)
null
or empty.c
- Array to test.null
or empty.public static boolean isEmpty(@Nullable byte[] c)
null
or empty.c
- Array to test.null
or empty.public static boolean isEmpty(@Nullable long[] c)
null
or empty.c
- Array to test.null
or empty.public static boolean isEmpty(@Nullable Iterable<?> c)
null
or empty.c
- Collection to test.null
or empty.public static boolean isEmpty(@Nullable Collection<?> c)
null
or empty.c
- Collection to test.null
or empty.public static boolean isEmpty(@Nullable Map<?,?> m)
null
or empty.m
- Map to test.null
or empty.public static <T> IgniteCallable<ConcurrentLinkedDeque8<T>> newDeque()
ConcurrentLinkedDeque8
instance.
Note that this method does not create a new closure but returns a static one.T
- Type parameters for the created List
.List
instance every
time its IgniteOutClosure.apply()
method is called.@Deprecated public static IgniteCallable<AtomicInteger> newAtomicInt()
AtomicInteger
instance
initialized to zero
. Note that this method does not create a new
closure but returns a static one.AtomicInteger
instance
initialized to zero
every time its IgniteOutClosure.apply()
method is called.public static <T> IgniteCallable<Set<T>> newSet()
Set
instance. Note that this
method does not create a new closure but returns a static one.T
- Type parameters for the created Set
.Set
instance every time
its IgniteOutClosure.apply()
method is called.@Deprecated public static <K,V> IgniteCallable<Map<K,V>> newMap()
Map
instance. Note
that this method does not create a new closure but returns a static one.K
- Type of the key for the created Map
.V
- Type of the value for the created Map
.Map
instance every
time its IgniteOutClosure.apply()
method is called.public static <K,V> IgniteCallable<ConcurrentMap<K,V>> newCMap()
ConcurrentMap
instance.
Note that this method does not create a new closure but returns a static one.K
- Type of the key for the created ConcurrentMap
.V
- Type of the value for the created ConcurrentMap
.Map
instance every
time its IgniteOutClosure.apply()
method is called.public static <E> IgniteCallable<Set<E>> newCSet()
GridConcurrentHashSet
instance.
Note that this method does not create a new closure but returns a static one.GridConcurrentHashSet
instance every
time its IgniteOutClosure.apply()
method is called.public static <T> GridIterator<T> iterator0(Iterable<? extends T> c, boolean readOnly, IgnitePredicate<? super T>... p)
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.T
- Type of the collection elements.c
- Input collection.readOnly
- If true
, then resulting iterator will not allow modifications
to the underlying collection.p
- Optional filtering predicates.public static <T1,T2> GridIterator<T2> iterator(Iterable<? extends T1> c, IgniteClosure<? super T1,T2> trans, boolean readOnly, @Nullable IgnitePredicate<? super T1>... p)
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.T1
- Type of the collection elements.T2
- Type of returned elements.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.public static <T1,T2> Iterator<T2> iterator(Iterator<? extends T1> c, IgniteClosure<? super T1,T2> trans, boolean readOnly, @Nullable IgnitePredicate<? super T1>... p)
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.public static <T> IgnitePredicate<T> alwaysTrue()
true
. This method returns
constant predicate.T
- Type of the free variable, i.e. the element the predicate is called on.true
.public static <T> IgnitePredicate<T> alwaysFalse()
false
. This method returns
constant predicate.T
- Type of the free variable, i.e. the element the predicate is called on.false
.@Deprecated public static boolean isAlwaysTrue(IgnitePredicate p)
alwaysTrue()
method.p
- Predicate to check.true
if given predicate is ALWAYS_TRUE
predicate.public static boolean isAlwaysTrue(@Nullable IgnitePredicate[] p)
alwaysTrue()
method.p
- Predicate to check.true
if given contains only ALWAYS_TRUE
predicate.@Deprecated public static boolean isAlwaysFalse(IgnitePredicate p)
alwaysFalse()
method.p
- Predicate to check.true
if given predicate is ALWAYS_FALSE
predicate.@Deprecated public static boolean isAlwaysFalse(@Nullable IgnitePredicate[] p)
alwaysFalse()
method.p
- Predicate to check.true
if given contains only ALWAYS_FALSE
predicate.public static <T> IgnitePredicate<T> notNull()
true
if its free variable is not null
.T
- Type of the free variable, i.e. the element the predicate is called on.true
if its free variable is not null
.@SafeVarargs public static <T> IgnitePredicate<T> not(@Nullable IgnitePredicate<? super T>... p)
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
.
T
- Type of the free variable, i.e. the element the predicate is called on.p
- Predicate to negate.@Deprecated public static <T> IgnitePredicate<T> equalTo(@Nullable T target)
true
if its free variable is equal
to target
or both are null
.T
- Type of the free variable, i.e. the element the predicate is called on.target
- Object to compare free variable to.true
if its free variable is equal to
target
or both are null
.public static <T> IgnitePredicate<T> notEqualTo(@Nullable T target)
true
if its free variable is not equal
to target
or both are null
.T
- Type of the free variable, i.e. the element the predicate is called on.target
- Object to compare free variable to.true
if its free variable is not equal
to target
or both are null
.public static <T> T first(@Nullable Iterable<? extends T> c)
null
if the collection is empty.T
- Type of the collection.c
- A collection.null
in case if the collection is empty.public static <T> T first(List<? extends T> list)
null
if list is empty.list
- List.null
in case if list is empty.@Deprecated @Nullable public static <T> T last(@Nullable Iterable<? extends T> c)
null
if the collection is empty.T
- Type of the collection.c
- A collection.null
in case if the collection is empty.@Nullable public static <V> V firstValue(Map<?,V> m)
null
if the map is empty.V
- Value type.m
- A map.null
in case if the map is empty.@Deprecated @Nullable public static <K> K firstKey(Map<K,?> m)
null
if the map is empty.K
- Key type.m
- A map.null
in case if the map is empty.@Nullable public static <K,V> Map.Entry<K,V> firstEntry(Map<K,V> m)
null
if the map is empty.K
- Key type.V
- Value type.m
- A map.null
in case if the map is empty.public static <T> IgnitePredicate<T> and(@Nullable IgnitePredicate<? super T>... ps)
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
.T
- Type of the free variable, i.e. the element the predicate is called on.ps
- Passed in predicate. If none provided - always-false
predicate is
returned.true
if each of its component predicates
evaluates to true
.public static <T> IgniteClosure<T,T> identity()
T
- Type of the variable and return value for the closure.@Deprecated public static <T> IgniteClosure<T,String> string()
toString()
value for its free variable.T
- Type of the free variable for the closure.toString()
value for its free variable.public static <T> IgnitePredicate<T> notIn(@Nullable Collection<? extends T> c)
true
if its free variable is not
contained in given collection.T
- Type of the free variable for the predicate and type of the
collection elements.c
- Collection to check for containment.true
if its free variable is not
contained in given collection.@Deprecated public static <T,C extends Collection<T>> C addAll(C c, Iterable<? extends T> it)
c
- Target collection.it
- Iterable to fetch.@Deprecated public static <T,C extends Collection<T>> C addAll(C c, Iterator<? extends T> it)
c
- Target collection.it
- Iterator to fetch.public static <K,V> V addIfAbsent(ConcurrentMap<K,V> map, K key, @Nullable Callable<V> c)
null
return null
.K
- Key type.V
- Value type.map
- Concurrent hash map.key
- Key to get the value for.c
- Default value producing closure.null
if key is not found and
closure is null
.public static <K,V> V addIfAbsent(ConcurrentMap<K,V> map, K key, V val)
K
- Key type.V
- Value type.map
- Map.key
- Key.val
- Value to put if one does not exist.@Nullable public static <K,V> V addIfAbsent(Map<? super K,V> map, @Nullable K key, @Nullable Callable<? extends V> c)
K
- Map key type.V
- Map value type.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.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.GridClosureException
- Thrown in case when callable throws exception.newSet()
,
newAtomicInt()
@Nullable public static <K,V> V addIfAbsent(Map<K,V> map, @Nullable K key, @Nullable V v)
K
- Map key type.V
- Map value type.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.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.@Deprecated public static <X> void forEach(Iterable<? extends X> c, IgniteInClosure<? super X> f, @Nullable IgnitePredicate<? super X>... p)
side-effect only
closure over the each element of the provided
collection.X
- Type of the free variable for the closure and type of the
collection elements.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.@Deprecated public static <X> void forEach(X[] c, IgniteInClosure<? super X> f, @Nullable IgnitePredicate<? super X>... p)
side-effect only
closure over the each element of the provided array.X
- Type of the free variable for the closure and type of the array
elements.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.@Deprecated public static <T> Collection<T> copy(Collection<T> to, T... from)
T
- Type of the free variable for the predicate and type of the collection elements.to
- Collection to copy to.from
- Array to copy from.@Deprecated public static <T> Collection<T> copy(Collection<T> to, Iterable<? extends T> from, @Nullable IgnitePredicate<? super T>... p)
true
.T
- Type of the free variable for the predicate and type of the collection elements.to
- Collection to copy to.from
- Collection to copy from.p
- Optional set of predicates to use for filtration.public static <X,Y> Collection<Y> transform(Collection<? extends X> c, IgniteClosure<? super X,Y> f)
X
- Type of the free variable for the closure and type of the collection elements.Y
- Type of the closure's return value.c
- Initial collection to transform.f
- Closure to use for transformation.@Deprecated public static <X,Y> Collection<Y> transform(X[] c, IgniteClosure<? super X,Y> f)
X
- Type of the free variable for the closure and type of the array elements.Y
- Type of the closure's return value.c
- Initial array to transform.f
- Closure to use for transformation.public static <T> boolean isAll(@Nullable T t, @Nullable IgnitePredicate<? super T>... p)
true
for given value. Note that
evaluation will be short-circuit when first predicate evaluated to false
is found.T
- Type of the value and free variable of the predicates.t
- Value to test.p
- Optional set of predicates to use for evaluation. If no predicates provides
this method will always return true
.true
if given set of predicates is null
, is empty, or all predicates
evaluate to true
for given value, false
otherwise.@Deprecated public static <T> boolean isAny(@Nullable T t, @Nullable IgnitePredicate<? super T>... p)
true
for given value. Note
that evaluation will be short-circuit when first predicate evaluated to true
is found.T
- Type of the value and free variable of the predicates.t
- Value to test.p
- Optional set of predicates to use for evaluation.true
if any of predicates evaluates to true
for given
value, false
otherwise. Returns false
if given set of predicates
is null
or empty.@Deprecated public static GridAbsClosure noop()
@SafeVarargs @Nullable public static <V> V find(Iterable<? extends V> c, @Nullable V dfltVal, @Nullable IgnitePredicate<? super V>... p)
true
.V
- Type of the collection elements.c
- Input collection.dfltVal
- Default value to return when no element is found.p
- Optional set of finder predicates.true
- or null
if such element cannot be found.@Deprecated public static <V,Y> Y find(Iterable<? extends V> c, @Nullable Y dfltVal, IgniteClosure<? super V,Y> f, @Nullable IgnitePredicate<? super V>... p)
true
.V
- Type of the collection elements.c
- Input collection.dfltVal
- Default value to return when no element is found.f
- Transforming closure.p
- Optional set of finder predicates.true
- or null
if such element cannot be found.@Deprecated public static <T> boolean containsAny(@Nullable Collection<? extends T> c1, @Nullable Iterable<? extends T> c2)
c1
contains any elements from collection c2
.T
- Type of the elements.c1
- Collection to check for containment. If null
- this method returns false
.c2
- Collection of elements to check. If null
- this method returns false
.true
if collection c1
contains at least one element from collection
c2
.public static <T> boolean containsAny(@Nullable Collection<? extends T> c1, @Nullable T... c2)
c1
contains any elements from array c2
.T
- Type of the elements.c1
- Collection to check for containment. If null
- this method returns false
.c2
- Collection of elements to check. If null
- this method returns false
.true
if collection c1
contains at least one element from collection
c2
.@Deprecated public static <T> boolean containsAll(@Nullable Collection<? extends T> c1, @Nullable Iterable<? extends T> c2)
c1
contains all elements from collection c2
.T
- Type of the elements.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.true
if collection c1
contains all elements from collection
c2
.@Deprecated public static <T> IgnitePair<T> pair(@Nullable T t1, @Nullable T t2)
T
- Type of objects in pair.t1
- First object in pair.t2
- Second object in pair.@Deprecated public static <V> IgniteBiTuple<Collection<V>,Collection<V>> partition(Iterable<? extends V> c, IgnitePredicate<? super V> p)
true
- and second containing the elements for which
predicate evaluates to false
.V
- Type of the collection elements.c
- Input collection.p
- Partitioning predicate.true
- and second containing the elements for which predicate
evaluates to false
.public static <V> boolean exist(Iterable<? extends V> c, @Nullable IgnitePredicate<? super V>... p)
true
.V
- Type of the collection elements.c
- Input collection.p
- Optional set of checking predicates.true
if input collection contains element for which all the provided
predicates evaluates to true
- otherwise returns false
.@Deprecated public static <V> boolean forAll(Iterable<? extends V> c, @Nullable IgnitePredicate<? super V>... p)
true
if all of them evaluate to true
for all elements. Returns
false
otherwise.V
- Type of the collection element.c
- Input collection.p
- Optional set of checking predicates. If none provided - true
is returned.true
if all given predicates evaluate to true
for
all elements. Returns false
otherwise.@Deprecated public static <K1,K extends K1,V1,V extends V1> boolean forAll(Map<K,V> m, @Nullable IgnitePredicate<? super Map.Entry<K,V>>... p)
true
if all of them evaluates to true
for all entries. Returns false
otherwise.K
- Type of the map keys.V
- Type of the map values.m
- Input map.p
- Optional set of checking predicate.true
if all given predicate evaluates to true
for all
entries. Returns false
otherwise.@Deprecated public static <V> boolean forAny(Iterable<? extends V> c, @Nullable IgnitePredicate<? super V>... p)
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.V
- Type of the collection element.c
- Input collection.p
- Optional set of checking predicates. If none provided - true
is returned.true
if all given predicates evaluate to true
for
at least one element. Returns false
otherwise.@Deprecated @Nullable public static <D,B> B fold(Iterable<? extends D> c, @Nullable B b, @Nullable IgniteBiClosure<? super D,? super B,B>... fs)
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); } }); ...
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.c
- Input collection.b
- Optional first folding pair element.fs
- Optional set of folding closures.public static <V> GridTuple<V> t(@Nullable V v)
V
- Type of the tuple.v
- Parameter for tuple.@Deprecated public static <V> GridTuple<V> t1()
V
- Type of the tuple.public static <V1,V2> IgniteBiTuple<V1,V2> t(@Nullable V1 v1, @Nullable V2 v2)
V1
- Type of the 1st tuple parameter.V2
- Type of the 2nd tuple parameter.v1
- 1st parameter for tuple.v2
- 2nd parameter for tuple.@Deprecated public static <V1,V2> IgniteBiTuple<V1,V2> t2()
V1
- Type of the 1st tuple parameter.V2
- Type of the 2nd tuple parameter.public static <V1,V2,V3> GridTuple3<V1,V2,V3> t(@Nullable V1 v1, @Nullable V2 v2, @Nullable V3 v3)
V1
- Type of the 1st tuple parameter.V2
- Type of the 2nd tuple parameter.V3
- Type of the 3rd tuple parameter.v1
- 1st parameter for tuple.v2
- 2nd parameter for tuple.v3
- 3rd parameter for tuple.@Deprecated public static <V1,V2,V3,V4> GridTuple4<V1,V2,V3,V4> t(@Nullable V1 v1, @Nullable V2 v2, @Nullable V3 v3, @Nullable V4 v4)
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.v1
- 1st parameter for tuple.v2
- 2nd parameter for tuple.v3
- 3rd parameter for tuple.v4
- 4th parameter for tuple.@Deprecated 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)
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.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.@Deprecated 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)
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.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.@Deprecated public static <V1,V2,V3> GridTuple3<V1,V2,V3> t3()
V1
- Type of the 1st tuple parameter.V2
- Type of the 2nd tuple parameter.V3
- Type of the 3rd tuple parameter.@Deprecated public static <V1,V2,V3,V4> GridTuple4<V1,V2,V3,V4> t4()
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.@Deprecated public static <V1,V2,V3,V4,V5> GridTuple5<V1,V2,V3,V4,V5> t5()
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.@Deprecated public static <V1,V2,V3,V4,V5,V6> GridTuple6<V1,V2,V3,V4,V5,V6> t6()
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.@Deprecated public static <K,V> Map<K,V> zip(Collection<? extends K> keys, V dfltVal)
K
- Key type.V
- Value type.keys
- Map keys.dfltVal
- Default value.public static <K,V> Map<K,V> asMap(K k, V v)
K
- Key's type.V
- Value's type.k
- Key.v
- Value.public static <K,V> Map<K,V> asMap(K k1, V v1, K k2, V v2)
K
- Key's type.V
- Value's type.k1
- Key 1.v1
- Value 1.k2
- Key 2.v2
- Value 2.@Deprecated public static <K,V> Map<K,V> asMap(K k1, V v1, K k2, V v2, K k3, V v3)
K
- Key's type.V
- Value's type.k1
- Key 1.v1
- Value 1.k2
- Key 2.v2
- Value 2.k3
- Key 3.v3
- Value 3.@Deprecated 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
- Key's type.V
- Value's type.k1
- Key 1.v1
- Value 1.k2
- Key 2.v2
- Value 2.k3
- Key 3.v3
- Value 3.k4
- Key 4.v4
- Value 4.@Deprecated 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)
K
- Key's type.V
- Value's type.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.public static <T> T[] asArray(T... t)
T
- Element type.t
- Elements to convert into array.public static <T> List<T> asList(@Nullable T t)
T
- Element's type.t
- Element (if null
, then empty list is returned).@Deprecated public static <T> Set<T> asSet(@Nullable T t)
T
- Element's type.t
- Element (if null
, then empty set is returned).@Deprecated public static <T> Set<T> asSet(@Nullable T... t)
T
- Element's type.t
- Element (if null
, then empty set is returned).public static <T> boolean contains(@Nullable Collection<T> c, @Nullable T t)
null
, then false
is returned.T
- Value type.c
- Collection to check.t
- Value to check for containment.True
if collection is not null
and contains given
value, false
otherwise.public static <T> IgnitePredicate<T> contains(@Nullable Collection<T> c)
true
if it receives an element
that is contained in the passed in collection.T
- Element type.c
- Collection used for predicate filter.true
if it receives an element
that is contained in the passed in collection.public static <T> IgnitePredicate<T> notContains(@Nullable Collection<T> c)
true
if it receives an element
that is not contained in the passed in collection.T
- Element type.c
- Collection used for predicate filter.true
if it receives an element
that is not contained in the passed in collection.public static boolean contains(int[] arr, int val)
arr
- Array.val
- Value to find.True
if array contains given value.@Deprecated public static boolean contains(Integer[] arr, int val)
arr
- Array.val
- Value to find.True
if array contains given value.@Deprecated public static boolean contains(long[] arr, long val)
arr
- Array.val
- Value to find.True
if array contains given value.public static boolean eq(@Nullable Object o1, @Nullable Object o2)
null
.o1
- Object to compare.o2
- Object to compare.true
if the specified arguments are equal, or both null
.@Deprecated public static boolean eqOrdered(@Nullable Collection<?> c1, @Nullable Collection<?> c2)
c1
- First collection.c2
- Second collection.True
if both collections have equal elements in the same order.public static boolean eqNotOrdered(@Nullable Collection<?> c1, @Nullable Collection<?> c2)
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.
c1
- First collection.c2
- Second collection.True
if both collections have equal elements in any order.public static <K,V> boolean eqNotOrdered(@Nullable Map<K,V> m1, @Nullable Map<K,V> m2)
java.util.AbstractMap#equals(...)
method this implementation
checks not only entry sets, but also the keys. Some optimization checks are also used.m1
- First map to check.m2
- Second map to checkTrue
is maps are equal, False
otherwise.public static boolean eqNodes(Object n1, Object n2)
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.
n1
- Grid node 1.n2
- Grid node 2true
if two grid node have the same IDs (ignoring their runtime types),
false
otherwise.public static <K,V> IgniteClosure<javax.cache.Cache.Entry<K,V>,V> cacheEntry2Get()
Cache.get(Object)
method.K
- Key type.V
- Value type.public static <K,V> IgnitePredicate<javax.cache.Cache.Entry<K,V>> cacheHasPeekValue()
true
if entry has peek value.K
- Cache key type.V
- Cache value type.true
if entry has peek value.public static GridClosureException wrap(Throwable e)
GridClosureException
.e
- Exception to wrap.GridClosureException
.@Deprecated public static <T> void awaitAll(@Nullable Collection<IgniteInternalFuture<T>> futs) throws IgniteCheckedException
futs
- Futures. If none provided - this method is no-op.IgniteCheckedException
- If any of the futures failed.@Deprecated public static <T> void awaitAll(long timeout, @Nullable Collection<IgniteInternalFuture<T>> futs) throws IgniteCheckedException
timeout
- Timeout for waiting (0
for forever).futs
- Futures. If none provided - this method is no-op.IgniteCheckedException
- If any of the futures failed.@Deprecated @Nullable public static <T,R> R awaitAll(long timeout, @Nullable IgniteReducer<T,R> rdc, @Nullable Collection<IgniteInternalFuture<T>> futs) throws IgniteCheckedException
T
- Return type of the futures.R
- Return type of the reducer.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.null
otherwise.IgniteCheckedException
- If any of the futures failed.
Follow @ApacheIgnite
Ignite Fabric : ver. 2.0.0 Release Date : April 30 2017