You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by sb...@apache.org on 2015/05/08 12:58:24 UTC
[44/50] incubator-ignite git commit: # Remove unused methods from
GridFunc.
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/942abe45/modules/core/src/main/java/org/apache/ignite/internal/util/lang/GridFunc.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/lang/GridFunc.java b/modules/core/src/main/java/org/apache/ignite/internal/util/lang/GridFunc.java
index c86c5a4..6f544e0 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/util/lang/GridFunc.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/util/lang/GridFunc.java
@@ -20,10 +20,8 @@ package org.apache.ignite.internal.util.lang;
import org.apache.ignite.*;
import org.apache.ignite.cluster.*;
import org.apache.ignite.compute.*;
-import org.apache.ignite.events.*;
import org.apache.ignite.internal.*;
import org.apache.ignite.internal.util.*;
-import org.apache.ignite.internal.util.future.*;
import org.apache.ignite.internal.util.typedef.*;
import org.apache.ignite.internal.util.typedef.internal.*;
import org.apache.ignite.lang.*;
@@ -31,9 +29,6 @@ import org.jetbrains.annotations.*;
import org.jsr166.*;
import javax.cache.*;
-import java.io.*;
-import java.lang.reflect.*;
-import java.math.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
@@ -74,13 +69,6 @@ public class GridFunc {
};
/** */
- private static final IgnitePredicate<Boolean> IDENTITY_PRED = new P1<Boolean>() {
- @Override public boolean apply(Boolean e) {
- return e;
- }
- };
-
- /** */
private static final IgnitePredicate<Object> ALWAYS_TRUE = new P1<Object>() {
@Override public boolean apply(Object e) {
return true;
@@ -128,34 +116,6 @@ public class GridFunc {
};
/** */
- public static final IgnitePredicate<String> EMPTY_STRING = new P1<String>() {
- @Override public boolean apply(String s) {
- return isEmpty(s);
- }
- };
-
- /** */
- public static final IgnitePredicate<String> NOT_EMPTY_STRING = new P1<String>() {
- @Override public boolean apply(String s) {
- return !isEmpty(s);
- }
- };
-
- /** */
- public static final IgnitePredicate EMPTY_COLLECTION = new P1<Collection>() {
- @Override public boolean apply(Collection c) {
- return isEmpty(c);
- }
- };
-
- /** */
- public static final IgnitePredicate NOT_EMPTY_COLLECTION = new P1<Collection>() {
- @Override public boolean apply(Collection c) {
- return !isEmpty(c);
- }
- };
-
- /** */
private static final IgniteCallable<?> LIST_FACTORY = new IgniteCallable<List>() {
@Override public List call() {
return new ArrayList();
@@ -266,84 +226,6 @@ public class GridFunc {
};
/** */
- private static final IgniteInClosure<?> PRINTLN = new CI1() {
- @Override public void apply(Object o) {
- System.out.println(o);
- }
-
- @Override public String toString() {
- return "Print line closure.";
- }
- };
-
- /** */
- private static final IgniteInClosure<?> PRINT = new CI1() {
- @Override public void apply(Object o) {
- System.out.print(o);
- }
-
- @Override public String toString() {
- return "Print closure.";
- }
- };
-
- /** */
- private static final IgniteOutClosure<?> NILL = new CO() {
- @Nullable @Override public Object apply() {
- return null;
- }
-
- @Override public String toString() {
- return "Nill closure.";
- }
- };
-
- /** */
- private static final IgniteClosure<Runnable, GridAbsClosure> R2C = new C1<Runnable, GridAbsClosure>() {
- @Override public GridAbsClosure apply(Runnable r) {
- return as(r);
- }
-
- @Override public String toString() {
- return "Runnable to absolute closure transformer.";
- }
- };
-
- /** */
- private static final IgniteClosure<ClusterGroup, IgnitePredicate<ClusterNode>> P2P =
- new C1<ClusterGroup, IgnitePredicate<ClusterNode>>() {
- @Override public IgnitePredicate<ClusterNode> apply(ClusterGroup e) {
- return e.predicate();
- }
-
- @Override public String toString() {
- return "Projection to its predicate transformer closure.";
- }
- };
-
- /** */
- private static final IgniteClosure<Object, Class<?>> CLAZZ = new C1<Object, Class<?>>() {
- @Override public Class<?> apply(Object o) {
- return o.getClass();
- }
-
- @Override public String toString() {
- return "Object to class transformer closure.";
- }
- };
-
- /** */
- private static final IgniteClosure MAP_ENTRY_KEY = new IgniteClosure() {
- @Override public Object apply(Object o) {
- return ((Map.Entry)o).getKey();
- }
-
- @Override public String toString() {
- return "Map entry to key transformer closure.";
- }
- };
-
- /** */
private static final IgniteClosure CACHE_ENTRY_KEY = new IgniteClosure() {
@Override public Object apply(Object o) {
return ((Cache.Entry)o).getKey();
@@ -354,16 +236,6 @@ public class GridFunc {
}
};
- /** */
- private static final IgniteClosure MAP_ENTRY_VAL = new IgniteClosure() {
- @Override public Object apply(Object o) {
- return ((Map.Entry)o).getValue();
- }
-
- @Override public String toString() {
- return "Map entry to value transformer closure.";
- }
- };
/** */
private static final IgniteClosure CACHE_ENTRY_VAL_GET = new IgniteClosure() {
@@ -390,18 +262,6 @@ public class GridFunc {
};
/** */
- private static final IgnitePredicate CACHE_ENTRY_NO_PEEK_VAL = new IgnitePredicate() {
- @SuppressWarnings({"unchecked"})
- @Override public boolean apply(Object o) {
- return ((Cache.Entry)o).getValue() == null;
- }
-
- @Override public String toString() {
- return "Cache entry no-peek-value predicate.";
- }
- };
-
- /** */
private static final IgniteClosure<ClusterNode, UUID> NODE2ID = new IgniteClosure<ClusterNode, UUID>() {
@Override public UUID apply(ClusterNode n) {
return n.id();
@@ -442,44 +302,6 @@ public class GridFunc {
};
/**
- * Gets breaker predicate which will return a predicate that will
- * evaluate to {@code firstVal} when checked the first time,
- * but then will always evaluate to the opposite value.
- *
- * @param firstVal First value.
- * @param <T> Predicate type.
- * @return Breaker predicate.
- */
- public static <T> IgnitePredicate<T> breaker(final boolean firstVal) {
- return new IgnitePredicate<T>() {
- private boolean b = true;
-
- @Override public boolean apply(T e) {
- if (b) {
- b = false;
-
- return firstVal;
- }
-
- return !firstVal;
- }
-
- @Override public String toString() {
- return "Breaker predicate.";
- }
- };
- }
-
- /**
- * Gets closure that transform a grid projection into its predicate.
- *
- * @return Closure transforming a grid projection into its predicate.
- */
- public static IgniteClosure<ClusterGroup, IgnitePredicate<ClusterNode>> predicate() {
- return P2P;
- }
-
- /**
* Gets predicate that evaluates to {@code true} only for given local node ID.
*
* @param locNodeId Local node ID.
@@ -510,4868 +332,2608 @@ public class GridFunc {
}
/**
- * Returns out closure that always returns {@code null}.
- *
- * @return Out closure that always returns {@code null}.
- */
- @SuppressWarnings("unchecked")
- public static <T> IgniteOutClosure<T> nill() {
- return (IgniteOutClosure<T>)NILL;
- }
-
- /**
- * Creates closure that will reflectively call a method with the given name on
- * closure's argument and return result of that call.
- * <p>
- * Method reflects the typedef for {@link org.apache.ignite.lang.IgniteClosure} which is {@link C1}.
+ * Creates new collection by removing duplicates from the given collection.
*
- * @param mtdName Method name.
- * @param args Optional set of arguments for the method call.
- * @param <R> Type of closure return value.
- * @param <T> Type of closure argument.
- * @return Reflective closure.
- * @throws GridClosureException Thrown in case of any reflective invocation errors.
+ * @param c Collection to remove duplicates from.
+ * @param <T> Type of the collection.
+ * @return De-duped collection.
*/
- public static <T, R> IgniteClosure<T, R> cInvoke(final String mtdName, final Object... args) {
- A.notNull(mtdName, "mtdName");
-
- return new C1<T, R>() {
- private Method mtd;
+ public static <T> Collection<T> dedup(Collection<? extends T> c) {
+ A.notNull(c, "c");
- @SuppressWarnings("unchecked")
- @Override public R apply(T t) {
- try {
- // No synchronization allows for double creation - ignoring...
- if (mtd == null) {
- mtd = method(t.getClass(), mtdName, args);
+ Collection<T> set = new GridLeanSet<>();
- mtd.setAccessible(true);
- }
+ set.addAll(c);
- return (R)mtd.invoke(t, args);
- }
- catch (Exception e) {
- throw wrap(e);
- }
- }
- };
+ return set;
}
/**
- * Creates in closure that will reflectively call a method with the given name on
- * closure's argument.
+ * Calculates sum of all elements.
* <p>
- * Method reflects the typedef for {@link org.apache.ignite.lang.IgniteClosure} which is {@link C1}.
+ * <img src="{@docRoot}/img/sum.png">
*
- * @param mtdName Method name.
- * @param args Optional set of arguments for the method call.
- * @param <T> Type of closure argument.
- * @return Reflective in closure.
- * @throws GridClosureException Thrown in case of any reflective invocation errors.
+ * @param c Collection of elements.
+ * @return Sum of all elements.
*/
- public static <T> IgniteInClosure<T> ciInvoke(final String mtdName, final Object... args) {
- A.notNull(mtdName, "mtdName");
-
- return new CI1<T>() {
- private Method mtd;
+ public static int sumInt(Iterable<Integer> c) {
+ A.notNull(c, "c");
- @Override public void apply(T t) {
- try {
- // No synchronization allows for double creation - ignoring...
- if (mtd == null) {
- mtd = method(t.getClass(), mtdName, args);
+ int sum = 0;
- mtd.setAccessible(true);
- }
+ for (int t : c)
+ sum += t;
- mtd.invoke(t, args);
- }
- catch (Exception e) {
- throw wrap(e);
- }
- }
- };
+ return sum;
}
/**
- * Creates out closure that will reflectively call a method with the given name on provided
- * object and return result of that call.
- * <p>
- * Method reflects the typedef for {@link org.apache.ignite.lang.IgniteOutClosure} which is {@link CO}.
+ * Gets reducer which always returns {@code true} from {@link org.apache.ignite.lang.IgniteReducer#collect(Object)}
+ * method and passed in {@code element} from {@link org.apache.ignite.lang.IgniteReducer#reduce()} method.
*
- * @param o Target object to call the method on.
- * @param mtdName Method name.
- * @param args Optional set of arguments for the method call.
- * @param <R> Type of closure return value.
- * @return Reflective out closure.
- * @throws GridClosureException Thrown in case of any reflective invocation errors.
+ * @param elem Element to return from {@link org.apache.ignite.lang.IgniteReducer#reduce()} method.
+ * @param <T> Reducer element type.
+ * @return Passed in element.
*/
- public static <R> IgniteOutClosure<R> coInvoke(final Object o, final String mtdName, final Object... args) {
- A.notNull(o, "o", mtdName, "mtdName");
-
- return new CO<R>() {
- private Method mtd;
-
- @SuppressWarnings("unchecked")
- @Override public R apply() {
- try {
- // No synchronization allows for double creation - ignoring...
- if (mtd == null) {
- mtd = method(o.getClass(), mtdName, args);
-
- mtd.setAccessible(true);
- }
+ public static <T> IgniteReducer<T, T> identityReducer(final T elem) {
+ return new R1<T, T>() {
+ @Override public boolean collect(T e) {
+ return true;
+ }
- return (R)mtd.invoke(o, args);
- }
- catch (Exception e) {
- throw wrap(e);
- }
+ @Override public T reduce() {
+ return elem;
}
};
}
/**
- * Creates absolute closure that will reflectively call a method with the given name on provided object.
+ * Gets reducer closure that calculates sum of integer elements.
* <p>
- * Method reflects the typedef for {@link GridAbsClosure} which is {@link CA}.
+ * <img src="{@docRoot}/img/sum.png">
*
- * @param o Target object to call the method on.
- * @param mtdName Method name.
- * @param args Optional set of arguments for the method call.
- * @return Reflective absolute closure.
- * @throws GridClosureException Thrown in case of any reflective invocation errors.
+ * @return Reducer that calculates sum of integer elements.
*/
- public static GridAbsClosure caInvoke(final Object o, final String mtdName, @Nullable final Object... args) {
- A.notNull(o, "o", mtdName, "mtdName");
-
- return new CA() {
- /** */
- private Method mtd;
+ public static IgniteReducer<Integer, Integer> sumIntReducer() {
+ return new R1<Integer, Integer>() {
+ private AtomicInteger sum = new AtomicInteger(0);
- @SuppressWarnings("unchecked")
- @Override public void apply() {
- try {
- // No synchronization allows for double creation - ignoring...
- if (mtd == null) {
- mtd = method(o.getClass(), mtdName, args);
+ @Override public boolean collect(Integer e) {
+ if (e != null)
+ sum.addAndGet(e);
- mtd.setAccessible(true);
- }
+ return true;
+ }
- mtd.invoke(o, args);
- }
- catch (Exception e) {
- throw wrap(e);
- }
+ @Override public Integer reduce() {
+ return sum.get();
}
};
}
/**
- * Creates out closure that will reflectively call a static method with the given name
- * and return result of that call.
+ * Gets reducer closure that calculates sum of long integer elements.
* <p>
- * Method reflects the typedef for {@link org.apache.ignite.lang.IgniteOutClosure} which is {@link CO}.
+ * <img src="{@docRoot}/img/sum.png">
*
- * @param cls Class to call a static method on.
- * @param mtdName Method name.
- * @param args Optional set of arguments for the method call.
- * @param <R> Type of closure return value.
- * @return Reflective out closure.
- * @throws GridClosureException Thrown in case of any reflective invocation errors.
+ * @return Reducer that calculates sum of long integer elements.
*/
- public static <R> IgniteOutClosure<R> coInvoke(final Class<?> cls, final String mtdName,
- @Nullable final Object... args) {
- A.notNull(cls, "cls", mtdName, "mtdName");
-
- return new CO<R>() {
- /** */
- private Method mtd;
+ public static IgniteReducer<Long, Long> sumLongReducer() {
+ return new R1<Long, Long>() {
+ private AtomicLong sum = new AtomicLong(0);
- @SuppressWarnings("unchecked")
- @Override public R apply() {
- try {
- // No synchronization allows for double creation - ignoring...
- if (mtd == null) {
- mtd = method(cls, mtdName, args);
+ @Override public boolean collect(Long e) {
+ if (e != null)
+ sum.addAndGet(e);
- mtd.setAccessible(true);
- }
+ return true;
+ }
- return (R)mtd.invoke(null, args);
- }
- catch (Exception e) {
- throw wrap(e);
- }
+ @Override public Long reduce() {
+ return sum.get();
}
};
}
/**
- * Creates absolute closure that will reflectively call a static method with the given name.
- * <p>
- * Method reflects the typedef for {@link GridAbsClosure} which is {@link CA}.
+ * Creates a range list containing numbers in given range.
*
- * @param cls Class to call a static method on.
- * @param mtdName Method name.
- * @param args Optional set of arguments for the method call.
- * @return Reflective absolute closure.
- * @throws GridClosureException Thrown in case of any reflective invocation errors.
+ * @param fromIncl Inclusive start of the range.
+ * @param toExcl Exclusive stop of the range.
+ * @return List containing numbers in range.
*/
- public static GridAbsClosure caInvoke(final Class<?> cls, final String mtdName, @Nullable final Object... args) {
- A.notNull(cls, "cls", mtdName, "mtdName");
+ public static List<Integer> range(int fromIncl, int toExcl) {
+ A.ensure(fromIncl >= 0, "fromIncl >= 0");
+ A.ensure(toExcl >= 0, "toExcl >= 0");
+ A.ensure(toExcl >= fromIncl, "toExcl > fromIncl");
- return new CA() {
- /** */
- private Method mtd;
+ if (toExcl == fromIncl)
+ return Collections.emptyList();
- @SuppressWarnings("unchecked")
- @Override public void apply() {
- try {
- // No synchronization allows for double creation - ignoring...
- if (mtd == null) {
- mtd = method(cls, mtdName, args);
+ List<Integer> list = new ArrayList<>(toExcl - fromIncl);
- mtd.setAccessible(true);
- }
+ for (int i = fromIncl; i < toExcl; i++)
+ list.add(i);
- mtd.invoke(null, args);
- }
- catch (Exception e) {
- throw wrap(e);
- }
- }
- };
+ return list;
}
/**
- * Looks up the method with given parameters.
+ * Gets reducer closure that concatenates strings using provided delimiter.
*
- * @param cls Class to look up in.
- * @param mtdName Method name to look up.
- * @param args Optional set of method parameters.
- * @return Method instance.
- * @throws Exception Thrown in case of any reflective errors.
+ * @param delim Delimiter (optional).
+ * @return Reducer that concatenates strings using provided delimeter.
*/
- private static Method method(Class<?> cls, String mtdName, @Nullable Object... args) throws Exception {
- assert cls != null;
- assert mtdName != null;
-
- int cnt = 0;
-
- Method m = null;
-
- for (Method mtd : cls.getDeclaredMethods())
- if (mtd.getName().equals(mtdName)) {
- cnt++;
-
- m = mtd;
- }
+ public static IgniteReducer<String, String> concatReducer(@Nullable final String delim) {
+ return new R1<String, String>() {
+ private SB sb = new SB();
- if (cnt == 0)
- throw new NoSuchMethodException(cls.getName() + '#' + mtdName);
+ private boolean first = true;
- // If there is only one method with provided name we
- // don't use lookup that requires parameters' types since
- // it is a lot more complex to deal with type inheritance there.
- if (cnt == 1)
- return m;
+ private final Object lock = new Object();
- if (!isEmpty(args)) {
- assert args != null;
+ @Override public boolean collect(String s) {
+ synchronized (lock) {
+ if (!first && !isEmpty(delim))
+ sb.a(delim);
- Class<?>[] types = new Class[args.length];
+ sb.a(s);
- int i = 0;
+ first = false;
+ }
- for (Object arg : args) {
- // This is not going to work in cases when method expects
- // an interface or supertype. Accept this limitation for now...
- types[i++] = arg.getClass();
+ return true;
}
- return cls.getDeclaredMethod(mtdName, types);
- }
- else
- return cls.getDeclaredMethod(mtdName);
+ @Override public String reduce() {
+ synchronized (lock) {
+ return sb.toString();
+ }
+ }
+ };
}
/**
- * Gets closure that converts object to its runtime class.
+ * Concatenates strings using provided delimiter.
*
- * @return Closure that converts object to its runtime class.
- */
- public static IgniteClosure<Object, Class<?>> clazz() {
- return CLAZZ;
- }
-
- /**
- * Creates new collection by removing duplicates from the given collection.
- *
- * @param c Collection to remove duplicates from.
- * @param <T> Type of the collection.
- * @return De-duped collection.
+ * @param c Input collection.
+ * @param delim Delimiter (optional).
+ * @return Concatenated string.
*/
- public static <T> Collection<T> dedup(Collection<? extends T> c) {
+ public static String concat(Iterable<String> c, @Nullable String delim) {
A.notNull(c, "c");
- Collection<T> set = new GridLeanSet<>();
-
- set.addAll(c);
-
- return set;
+ return reduce(c, concatReducer(delim));
}
/**
- * Calculates sum of all elements.
+ * Gets collections of data items from grid job res casted to specified type.
* <p>
- * <img src="{@docRoot}/img/sum.png">
- *
- * @param c Collection of elements.
- * @return Sum of all elements.
- */
- public static int sumInt(Iterable<Integer> c) {
- A.notNull(c, "c");
-
- int sum = 0;
-
- for (int t : c) {
- sum += t;
- }
-
- return sum;
- }
-
- /**
- * Calculates sum of all elements.
+ * Here's the typical example of how this method is used in {@code reduce()} method
+ * implementation (this example sums up all the values of {@code Integer} type):
+ * <pre name="code" class="java">
+ * public Integer reduce(List<GridComputeJobResult> res) throws IgniteCheckedException {
+ * return F.sum(F.<Integer>jobResults(res));
+ * }
+ * </pre>
* <p>
- * <img src="{@docRoot}/img/sum.png">
+ * Note that this method doesn't create a new collection but simply iterates over the input one.
*
- * @param c Collection of elements.
- * @return Sum of all elements.
+ * @param res Collection of grid job res.
+ * @param <T> Type of the data item to cast to. See {@link org.apache.ignite.compute.ComputeJobResult#getData()} method.
+ * @return Collections of data items casted to type {@code T}.
+ * @see org.apache.ignite.compute.ComputeJobResult#getData()
*/
- public static double sumDouble(Iterable<Double> c) {
- A.notNull(c, "c");
+ public static <T> Collection<T> jobResults(@Nullable Collection<? extends ComputeJobResult> res) {
+ if (isEmpty(res))
+ return Collections.emptyList();
- double sum = 0;
+ assert res != null;
- for (double t : c) {
- sum += t;
- }
+ Collection<T> c = new ArrayList<>(res.size());
- return sum;
+ for (ComputeJobResult r : res)
+ c.add(r.<T>getData());
+
+ return c;
}
/**
- * Calculates sum of all elements.
+ * Convenient utility method that returns collection of node IDs for a given
+ * collection of grid nodes.
* <p>
- * <img src="{@docRoot}/img/sum.png">
+ * Note that this method doesn't create a new collection but simply iterates
+ * over the input one.
*
- * @param c Collection of elements.
- * @return Sum of all elements.
+ * @param nodes Collection of grid nodes.
+ * @return Collection of node IDs for given collection of grid nodes.
*/
- public static BigDecimal sumBigDecimal(Iterable<BigDecimal> c) {
- A.notNull(c, "c");
-
- BigDecimal sum = BigDecimal.ZERO;
-
- for (BigDecimal t : c) {
- sum = sum.add(t);
- }
+ public static Collection<UUID> nodeIds(@Nullable Collection<? extends ClusterNode> nodes) {
+ if (nodes == null || nodes.isEmpty())
+ return Collections.emptyList();
- return sum;
+ return F.viewReadOnly(nodes, node2id());
}
/**
- * Calculates sum of all elements.
+ * 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.
* <p>
- * <img src="{@docRoot}/img/sum.png">
+ * Note that this method doesn't create a new collection but simply iterates
+ * over the input one.
*
- * @param c Collection of elements.
- * @return Sum of all elements.
+ * @param nodes Collection of grid nodes.
+ * @return Collection of node IDs for given collection of grid nodes.
*/
- public static BigInteger sumBigInt(Iterable<BigInteger> c) {
- A.notNull(c, "c");
-
- BigInteger sum = BigInteger.ZERO;
-
- for (BigInteger t : c) {
- sum = sum.add(t);
- }
+ public static Collection<String> nodeId8s(@Nullable Collection<? extends ClusterNode> nodes) {
+ if (nodes == null || nodes.isEmpty())
+ return Collections.emptyList();
- return sum;
+ return F.viewReadOnly(nodes, NODE2ID8);
}
/**
- * Calculates arithmetic mean.
+ * 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.
* <p>
- * <img src="{@docRoot}/img/avg.png">
+ * Note that this method doesn't create a new collection but simply iterates
+ * over the input one.
*
- * @param c Input collection.
- * @return Arithmetic mean of the input collection.
+ * @param ids Collection of nodeIds.
+ * @return Collection of node IDs for given collection of grid nodes.
*/
- public static double avg(Iterable<? extends Number> c) {
- A.notNull(c, "c");
-
- double sum = 0;
-
- int i = 0;
-
- for (Number t : c) {
- sum += t.doubleValue();
-
- i++;
- }
+ public static Collection<String> id8s(@Nullable Collection<UUID> ids) {
+ if (ids == null || ids.isEmpty())
+ return Collections.emptyList();
- return sum / i;
+ return F.viewReadOnly(ids, ID2ID8);
}
/**
- * Gets reducer closure that calculates arithmetic mean.
- * <p>
- * <img src="{@docRoot}/img/avg.png">
+ * Creates absolute closure that does <tt>System.out.println(msg)</tt>.
*
- * @return Reducer closure that calculated arithmetic mean.
+ * @param msg Message to print.
+ * @return Absolute closure that print message.
*/
- public static <T extends Number> IgniteReducer<T, Double> avgReducer() {
- return new R1<T, Double>() {
- private double sum;
- private int i;
-
- private final Object lock = new Object();
-
- @Override public boolean collect(T e) {
- if (e != null)
- synchronized (lock) {
- sum += e.doubleValue();
- i++;
- }
-
- return true;
- }
-
- @Override public Double reduce() {
- synchronized (lock) {
- return sum / i;
- }
+ public static GridAbsClosure println(final String msg) {
+ return new CA() {
+ @Override public void apply() {
+ System.out.println(msg);
}
};
}
/**
- * Calculates quadratic mean.
- * <p>
- * <img src="{@docRoot}/img/qavg.png">
+ * Gets random value from given collection.
*
- * @param c Input collection.
- * @return Quadratic mean of the input collection.
+ * @param c Input collection (no {@code null} and not emtpy).
+ * @param <T> Type of the collection.
+ * @return Random value from the input collection.
*/
- public static double qavg(Iterable<? extends Number> c) {
+ @SuppressWarnings("UnusedDeclaration")
+ public static <T> T rand(Collection<? extends T> c) {
A.notNull(c, "c");
- double sum = 0;
+ int n = ThreadLocalRandom8.current().nextInt(c.size());
int i = 0;
- for (Number t : c) {
- double d = t.doubleValue();
-
- sum += d * d;
-
- i++;
+ for (T t : c) {
+ if (i++ == n)
+ return t;
}
- return Math.sqrt(sum / i);
+ throw new ConcurrentModificationException();
}
/**
- * Gets reducer closure that calculates quadratic mean.
- * <p>
- * <img src="{@docRoot}/img/qavg.png">
+ * Gets random value from given list. For random-access lists this
+ * operation is O(1), otherwise O(n).
*
- * @return Reducer closure that calculated quadratic mean.
+ * @param l Input collection.
+ * @param <T> Type of the list elements.
+ * @return Random value from the input list.
*/
- public static <T extends Number> IgniteReducer<T, Double> qavgReducer() {
- return new R1<T, Double>() {
- private double sum;
- private int i;
-
- private final Object lock = new Object();
-
- @Override public boolean collect(T e) {
- if (e != null) {
- double d = e.doubleValue();
-
- synchronized (lock) {
- sum += d * d;
-
- i++;
- }
- }
-
- return true;
- }
+ public static <T> T rand(List<T> l) {
+ A.notNull(l, "l");
- @Override public Double reduce() {
- synchronized (lock) {
- return Math.sqrt(sum / i);
- }
- }
- };
+ return l.get(ThreadLocalRandom8.current().nextInt(l.size()));
}
/**
- * Calculates geometric mean.
- * <p>
- * <img src="{@docRoot}/img/gavg.png">
+ * Gets random value from given array. This operation
+ * does not iterate through array elements and returns immediately.
*
* @param c Input collection.
- * @return Geometric mean of the input collection.
+ * @param <T> Type of the collection.
+ * @return Random value from the input collection.
*/
- public static double gavg(Iterable<? extends Number> c) {
+ public static <T> T rand(T... c) {
A.notNull(c, "c");
- double sum = 0;
-
- int i = 0;
-
- for (Number t : c) {
- sum *= t.doubleValue();
-
- i++;
- }
-
- return Math.pow(sum, 1f / i);
+ return c[ThreadLocalRandom8.current().nextInt(c.length)];
}
/**
- * Gets reducer closure that calculates geometric mean.
- * <p>
- * <img src="{@docRoot}/img/gavg.png">
+ * Concatenates an element to a collection. If {@code copy} flag is {@code 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 {@code copy}
+ * flag is {@code false}, then a read-only view will be created over the element and given
+ * collections and no copying will happen.
*
- * @return Reducer closure that calculated geometric mean.
+ * @param cp Copy flag.
+ * @param t First element.
+ * @param c Second collection.
+ * @param <T> Element type.
+ * @return Concatenated collection.
*/
- public static <T extends Number> IgniteReducer<T, Double> gavgReducer() {
- return new R1<T, Double>() {
- private double sum;
- private int i;
+ public static <T> Collection<T> concat(boolean cp, @Nullable final T t, @Nullable final Collection<T> c) {
+ if (cp) {
+ if (isEmpty(c)) {
+ Collection<T> l = new ArrayList<>(1);
- private final Object lock = new Object();
+ l.add(t);
- @Override public boolean collect(T e) {
- if (e != null)
- synchronized (lock) {
- sum *= e.doubleValue();
+ return l;
+ }
- i++;
- }
+ assert c != null;
- return true;
- }
+ Collection<T> ret = new ArrayList<>(c.size() + 1);
- @Override public Double reduce() {
- synchronized (lock) {
- return Math.pow(sum, 1f / i);
- }
- }
- };
- }
+ ret.add(t);
+ ret.addAll(c);
- /**
- * Calculates weighted mean.
- * <p>
- * <img src="{@docRoot}/img/wavg.png">
- *
- * @param c Collection of elements.
- * @param w Collection of weights.
- * @return Weighted mean of the input collection.
- */
- public static double wavg(Collection<? extends Number> c, Collection<? extends Number> w) {
- A.notNull(c, "c", w, "w");
- A.ensure(c.size() == w.size(), "c.size() == w.size()");
+ return ret;
+ }
+ else {
+ if (isEmpty(c))
+ return Collections.singletonList(t);
- double sumC = 0;
- double sumW = 0;
+ assert c != null;
- Iterator<? extends Number> iterC = c.iterator();
- Iterator<? extends Number> iterW = w.iterator();
+ return new GridSerializableCollection<T>() {
+ @NotNull
+ @Override public Iterator<T> iterator() {
+ return new GridSerializableIterator<T>() {
+ private Iterator<T> it;
- while (iterC.hasNext()) {
- assert iterW.hasNext();
+ @Override public boolean hasNext() {
+ return it == null || it.hasNext();
+ }
- double dc = iterC.next().doubleValue();
- double dw = iterW.next().doubleValue();
+ @Nullable @Override public T next() {
+ if (it == null) {
+ it = c.iterator();
- sumW += dw;
- sumC += dw * dc;
- }
+ return t;
+ }
- return sumC / sumW;
- }
+ return it.next();
+ }
- /**
- * Calculates harmonic mean.
- * <p>
- * <img src="{@docRoot}/img/havg.png">
+ @Override public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ };
+ }
+
+ @Override public int size() {
+ return c.size() + 1;
+ }
+
+ @Override public boolean equals(Object obj) {
+ return obj instanceof Collection && eqNotOrdered(this, (Collection)obj);
+ }
+ };
+ }
+ }
+
+ /**
+ * Concatenates 2 collections into one. If {@code copy} flag is {@code 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 {@code copy} flag is
+ * {@code false}, then a read-only view will be created over given collections
+ * and no copying will happen.
*
- * @param c Input collection.
- * @return Harmonic mean of the input collection.
+ * @param cp Copy flag.
+ * @param c1 First collection.
+ * @param c2 Second collection.
+ * @param <T> Element type.
+ * @return Concatenated {@code non-null} collection.
*/
- public static double havg(Iterable<? extends Number> c) {
- A.notNull(c, "c");
+ public static <T> Collection<T> concat(boolean cp, @Nullable final Collection<T> c1,
+ @Nullable final Collection<T> c2) {
+ if (cp) {
+ if (isEmpty(c1) && isEmpty(c2))
+ return new ArrayList<>(0);
- double sum = 0;
+ if (isEmpty(c1))
+ return new ArrayList<>(c2);
- int i = 0;
+ if (isEmpty(c2))
+ return new ArrayList<>(c1);
- for (Number t : c) {
+ Collection<T> c = new ArrayList<>(c1.size() + c2.size());
- sum += 1 / t.doubleValue();
+ c.addAll(c1);
+ c.addAll(c2);
- i++;
+ return c;
}
+ else {
+ if (isEmpty(c1) && isEmpty(c2))
+ return Collections.emptyList();
- return i / sum;
- }
-
- /**
- * Gets reducer closure that collects only a single value and returns it
- * without any transformations.
- *
- * @return Reducer closure that collects and returns single value.
- */
- public static <T> IgniteReducer<T, T> singleReducer() {
- return new R1<T, T>() {
- private T obj;
+ if (isEmpty(c1) || isEmpty(c2)) {
+ Collection<T> c = isEmpty(c1) ? c2 : c1;
- @Override public boolean collect(T e) {
- // No synchronization needed here.
- obj = e;
+ assert c != null;
- return false;
+ return c;
}
- @Override public T reduce() {
- return obj;
- }
- };
+ return new GridSerializableCollection<T>() {
+ @NotNull
+ @Override public Iterator<T> iterator() {
+ return new GridSerializableIterator<T>() {
+ private Iterator<T> it1 = c1.iterator();
+ private Iterator<T> it2 = c2.iterator();
+
+ @Override public boolean hasNext() {
+ if (it1 != null)
+ if (!it1.hasNext())
+ it1 = null;
+ else
+ return true;
+
+ return it2.hasNext();
+ }
+
+ @Override public T next() {
+ return it1 != null ? it1.next() : it2.next();
+ }
+
+ @Override public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ };
+ }
+
+ @Override public boolean contains(Object o) {
+ return c1.contains(o) || c2.contains(o);
+ }
+
+ @Override public int size() {
+ return c1.size() + c2.size();
+ }
+
+ @Override public boolean equals(Object obj) {
+ return obj instanceof Collection && eqNotOrdered(this, (Collection<?>)obj);
+ }
+ };
+ }
}
/**
- * Gets reducer which always returns {@code true} from {@link org.apache.ignite.lang.IgniteReducer#collect(Object)}
- * method and passed in {@code element} from {@link org.apache.ignite.lang.IgniteReducer#reduce()} method.
+ * Concatenates an elements to an array.
*
- * @param elem Element to return from {@link org.apache.ignite.lang.IgniteReducer#reduce()} method.
- * @param <T> Reducer element type.
- * @param <R> Return element type.
- * @return Passed in element.
+ * @param arr Array.
+ * @param obj One or more elements.
+ * @return Concatenated array.
*/
- public static <T, R> IgniteReducer<T, R> continuousReducer(final R elem) {
- return new R1<T, R>() {
- @Override public boolean collect(T e) {
- return true;
- }
+ public static <T> T[] concat(@Nullable T[] arr, T... obj) {
+ T[] newArr;
- @Override public R reduce() {
- return elem;
- }
- };
+ if (arr == null || arr.length == 0)
+ newArr = obj;
+ else {
+ newArr = Arrays.copyOf(arr, arr.length + obj.length);
+
+ System.arraycopy(obj, 0, newArr, arr.length, obj.length);
+ }
+
+ return newArr;
}
/**
- * Gets reducer which always returns {@code true} from {@link org.apache.ignite.lang.IgniteReducer#collect(Object)}
- * method and passed in {@code element} from {@link org.apache.ignite.lang.IgniteReducer#reduce()} method.
+ * Concatenates multiple iterators as single one.
*
- * @param elem Element to return from {@link org.apache.ignite.lang.IgniteReducer#reduce()} method.
- * @param <T> Reducer element type.
- * @return Passed in element.
+ * @param iters Iterators.
+ * @return Single iterator.
*/
- public static <T> IgniteReducer<T, T> identityReducer(final T elem) {
- return new R1<T, T>() {
- @Override public boolean collect(T e) {
- return true;
- }
+ @SuppressWarnings("unchecked")
+ public static <T> Iterator<T> concat(Iterator<T> ... iters) {
+ if (iters.length == 1)
+ return iters[0];
- @Override public T reduce() {
- return elem;
- }
- };
+ return concat(asList(iters).iterator());
}
/**
- * Gets reducer closure that calculates harmonic mean.
- * <p>
- * <img src="{@docRoot}/img/havg.png">
+ * Concatenates multiple iterators as single one.
*
- * @return Reducer closure that calculated harmonic mean.
+ * @param iters Iterator over iterators.
+ * @return Single iterator.
*/
- public static <T extends Number> IgniteReducer<T, Double> havgReducer() {
- return new R1<T, Double>() {
- private double sum;
- private int i;
+ @SuppressWarnings("unchecked")
+ public static <T> Iterator<T> concat(final Iterator<Iterator<T>> iters) {
+ if (!iters.hasNext())
+ return Collections.<T>emptySet().iterator();
- private final Object lock = new Object();
+ return new Iterator<T>() {
+ private Iterator<T> it = iters.next();
- @Override public boolean collect(T e) {
- if (e != null)
- synchronized (lock) {
- sum += 1 / e.doubleValue();
+ private Iterator<T> last;
- i++;
- }
+ private T next;
- return true;
+ {
+ advance();
}
- @Override public Double reduce() {
- synchronized (lock) {
- return i / sum;
- }
- }
- };
- }
+ private void advance() {
+ for (;;) {
+ if (it.hasNext()) {
+ next = it.next();
- /**
- * Gets reducer closure that calculates sum of integer elements.
- * <p>
- * <img src="{@docRoot}/img/sum.png">
- *
- * @return Reducer that calculates sum of integer elements.
- */
- public static IgniteReducer<Integer, Integer> sumIntReducer() {
- return new R1<Integer, Integer>() {
- private AtomicInteger sum = new AtomicInteger(0);
+ assert next != null;
- @Override public boolean collect(Integer e) {
- if (e != null)
- sum.addAndGet(e);
+ return;
+ }
- return true;
- }
+ if (!iters.hasNext())
+ return;
- @Override public Integer reduce() {
- return sum.get();
+ it = iters.next();
+ }
}
- };
- }
-
- /**
- * Gets reducer closure that calculates sum of long integer elements.
- * <p>
- * <img src="{@docRoot}/img/sum.png">
- *
- * @return Reducer that calculates sum of long integer elements.
- */
- public static IgniteReducer<Long, Long> sumLongReducer() {
- return new R1<Long, Long>() {
- private AtomicLong sum = new AtomicLong(0);
- @Override public boolean collect(Long e) {
- if (e != null)
- sum.addAndGet(e);
-
- return true;
+ @Override public boolean hasNext() {
+ return next != null;
}
- @Override public Long reduce() {
- return sum.get();
- }
- };
- }
+ @Override public T next() {
+ T res = next;
- /**
- * Gets reducer closure that calculates sum of all elements.
- * <p>
- * <img src="{@docRoot}/img/sum.png">
- *
- * @return Reducer that calculates sum of all elements.
- */
- @SuppressWarnings("unchecked")
- public static IgniteReducer<Double, Double> sumDoubleReducer() {
- return new R1<Double, Double>() {
- private double sum;
+ if (res == null)
+ throw new NoSuchElementException();
- private final Object lock = new Object();
+ next = null;
- @Override public boolean collect(Double e) {
- if (e != null)
- synchronized (lock) {
- sum += e;
- }
+ last = it;
- return true;
+ advance();
+
+ return res;
}
- @Override public Double reduce() {
- synchronized (lock) {
- return sum;
- }
+ @Override public void remove() {
+ if (last == null)
+ throw new IllegalStateException();
+
+ last.remove();
}
};
}
/**
- * Creates a range list containing numbers in given range.
+ * Loses all elements in input collection that are contained in {@code filter} collection.
*
- * @param fromIncl Inclusive start of the range.
- * @param toExcl Exclusive stop of the range.
- * @return List containing numbers in range.
+ * @param c Input collection.
+ * @param cp If {@code true} method creates new collection not modifying input,
+ * otherwise does <tt>in-place</tt> modifications.
+ * @param filter Filter collection. If {@code filter} collection is empty or
+ * {@code null} - no elements are lost.
+ * @param <T> Type of collections.
+ * @return Collection of remaining elements
*/
- public static List<Integer> range(int fromIncl, int toExcl) {
- A.ensure(fromIncl >= 0, "fromIncl >= 0");
- A.ensure(toExcl >= 0, "toExcl >= 0");
- A.ensure(toExcl >= fromIncl, "toExcl > fromIncl");
-
- if (toExcl == fromIncl)
- return Collections.emptyList();
-
- List<Integer> list = new ArrayList<>(toExcl - fromIncl);
-
- for (int i = fromIncl; i < toExcl; i++)
- list.add(i);
+ public static <T0, T extends T0> Collection<T> lose(Collection<T> c, boolean cp,
+ @Nullable Collection<T0> filter) {
+ A.notNull(c, "c");
- return list;
+ return lose(c, cp, F0.in(filter));
}
/**
- * Gets reducer closure that calculates sum of all elements.
- * <p>
- * <img src="{@docRoot}/img/sum.png">
+ * Loses all elements in input collection that are evaluated to {@code true} by
+ * all given predicates.
*
- * @return Reducer that calculates sum of all elements.
+ * @param c Input collection.
+ * @param cp If {@code true} method creates new collection without modifying the input one,
+ * otherwise does <tt>in-place</tt> modifications.
+ * @param p Predicates to filter by. If no predicates provided - no elements are lost.
+ * @param <T> Type of collections.
+ * @return Collection of remaining elements.
*/
- @SuppressWarnings("unchecked")
- public static IgniteReducer<BigDecimal, BigDecimal> sumBigDecimalReducer() {
- return new R1<BigDecimal, BigDecimal>() {
- private BigDecimal sum = BigDecimal.ZERO;
+ public static <T> Collection<T> lose(Collection<T> c, boolean cp, @Nullable IgnitePredicate<? super T>... p) {
+ A.notNull(c, "c");
- private final Object lock = new Object();
+ Collection<T> res;
- @Override public boolean collect(BigDecimal e) {
- if (e != null)
- synchronized (lock) {
- sum = sum.add(e);
- }
+ if (!cp) {
+ res = c;
- return true;
- }
+ if (isEmpty(p))
+ res.clear();
+ else if (!isAlwaysFalse(p))
+ for (Iterator<T> iter = res.iterator(); iter.hasNext();)
+ if (isAll(iter.next(), p))
+ iter.remove();
+ }
+ else {
+ res = new LinkedList<>();
- @Override public BigDecimal reduce() {
- synchronized (lock) {
- return sum;
- }
- }
- };
+ if (!isEmpty(p) && !isAlwaysTrue(p))
+ for (T t : c)
+ if (!isAll(t, p))
+ res.add(t);
+ }
+
+ return res;
}
/**
- * Gets reducer closure that calculates sum of all elements.
- * <p>
- * <img src="{@docRoot}/img/sum.png">
+ * Loses all entries in input map that are evaluated to {@code true} by all given predicates.
*
- * @return Reducer that calculates sum of all elements.
+ * @param m Map to filter.
+ * @param cp If {@code true} method creates new map not modifying input, otherwise does
+ * <tt>in-place</tt> modifications.
+ * @param p Optional set of predicates to use for filtration. If none provided - original map
+ * will (or its copy) be returned.
+ * @param <K> Type of the free variable for the predicate and type of map's keys.
+ * @param <V> Type of the free variable for the predicate and type of map's values.
+ * @return Filtered map.
*/
- @SuppressWarnings("unchecked")
- public static IgniteReducer<BigInteger, BigInteger> sumBigIntegerReducer() {
- return new R1<BigInteger, BigInteger>() {
- private BigInteger sum = BigInteger.ZERO;
+ @SuppressWarnings({"unchecked"})
+ public static <K, V> Map<K, V> lose(Map<K, V> m, boolean cp,
+ @Nullable IgnitePredicate<? super Map.Entry<K, V>>... p) {
+ A.notNull(m, "m");
- private final Object lock = new Object();
+ Map<K, V> res;
- @Override public boolean collect(BigInteger e) {
- if (e != null)
- synchronized (lock) {
- sum = sum.add(e);
- }
+ if (!cp) {
+ res = m;
- return true;
- }
+ if (isEmpty(p))
+ res.clear();
+ else if (!isAlwaysFalse(p))
+ for (Iterator<Map.Entry<K, V>> iter = m.entrySet().iterator(); iter.hasNext();)
+ if (isAll(iter.next(), p))
+ iter.remove();
+ }
+ else {
+ res = U.newHashMap(m.size());
- @Override public BigInteger reduce() {
- synchronized (lock) {
- return sum;
- }
- }
- };
+ if (!isEmpty(p) && !isAlwaysTrue(p))
+ for (Map.Entry<K, V> e : m.entrySet())
+ if (!F.isAll(e, p))
+ res.put(e.getKey(), e.getValue());
+ }
+
+ return res;
}
/**
- * Gets reducer closure that concatenates strings using provided delimiter.
+ * Loses all entries in input map which keys are evaluated to {@code true} by all
+ * given predicates.
*
- * @param delim Delimiter (optional).
- * @return Reducer that concatenates strings using provided delimeter.
+ * @param m Map to filter.
+ * @param cp If {@code true} method creates new map not modifying input, otherwise does
+ * <tt>in-place</tt> modifications.
+ * @param p Optional set of predicates to use for filtration. If none provided - original
+ * map (or its copy) will be returned.
+ * @param <K> Type of the free variable for the predicate and type of map's keys.
+ * @param <V> Type of map's values.
+ * @return Filtered map.
*/
- public static IgniteReducer<String, String> concatReducer(@Nullable final String delim) {
- return new R1<String, String>() {
- private SB sb = new SB();
-
- private boolean first = true;
-
- private final Object lock = new Object();
-
- @Override public boolean collect(String s) {
- synchronized (lock) {
- if (!first && !isEmpty(delim))
- sb.a(delim);
-
- sb.a(s);
-
- first = false;
- }
-
- return true;
- }
-
- @Override public String reduce() {
- synchronized (lock) {
- return sb.toString();
- }
+ public static <K, V> Map<K, V> loseKeys(
+ Map<K, V> m,
+ boolean cp,
+ @Nullable final IgnitePredicate<? super K>... p
+ ) {
+ return lose(m, cp, new P1<Map.Entry<K, V>>() {
+ @Override public boolean apply(Map.Entry<K, V> e) {
+ return isAll(e.getKey(), p);
}
- };
+ });
}
/**
- * Concatenates strings using provided delimiter.
+ * Loses all entries in input map which values are evaluated to {@code true} by all
+ * given predicates.
*
- * @param c Input collection.
- * @param delim Delimiter (optional).
- * @return Concatenated string.
+ * @param m Map to filter.
+ * @param cp If {@code true} method creates new map not modifying input, otherwise does
+ * <tt>in-place</tt> modifications.
+ * @param p Optional set of predicates to use for filtration. If none provided - original
+ * map (or its copy) will be returned.
+ * @param <K> Type of the free variable for the predicate and type of map's keys.
+ * @param <V> Type of map's values.
+ * @return Filtered map.
*/
- public static String concat(Iterable<String> c, @Nullable String delim) {
- A.notNull(c, "c");
-
- return reduce(c, concatReducer(delim));
+ public static <K, V> Map<K, V> loseValues(Map<K, V> m, boolean cp,
+ @Nullable final IgnitePredicate<? super V>... p) {
+ return lose(m, cp, new P1<Map.Entry<K, V>>() {
+ @Override public boolean apply(Map.Entry<K, V> e) {
+ return isAll(e.getValue(), p);
+ }
+ });
}
/**
- * Gets collections of data items from grid job res casted to specified type.
- * <p>
- * Here's the typical example of how this method is used in {@code reduce()} method
- * implementation (this example sums up all the values of {@code Integer} type):
- * <pre name="code" class="java">
- * public Integer reduce(List<GridComputeJobResult> res) throws IgniteCheckedException {
- * return F.sum(F.<Integer>jobResults(res));
- * }
- * </pre>
- * <p>
- * Note that this method doesn't create a new collection but simply iterates over the input one.
+ * Loses all elements in input list that are contained in {@code filter} collection.
*
- * @param res Collection of grid job res.
- * @param <T> Type of the data item to cast to. See {@link org.apache.ignite.compute.ComputeJobResult#getData()} method.
- * @return Collections of data items casted to type {@code T}.
- * @see org.apache.ignite.compute.ComputeJobResult#getData()
+ * @param c Input list.
+ * @param cp If {@code true} method creates new list not modifying input,
+ * otherwise does <tt>in-place</tt> modifications.
+ * @param filter Filter collection. If {@code filter} collection is empty or
+ * {@code null} - no elements are lost.
+ * @param <T> Type of list.
+ * @return List of remaining elements
*/
- public static <T> Collection<T> jobResults(@Nullable Collection<? extends ComputeJobResult> res) {
- if (isEmpty(res))
- return Collections.emptyList();
+ public static <T> List<T> loseList(List<T> c, boolean cp, @Nullable Collection<? super T> filter) {
+ A.notNull(c, "c");
- assert res != null;
+ List<T> res;
- Collection<T> c = new ArrayList<>(res.size());
+ if (!cp) {
+ res = c;
- for (ComputeJobResult r : res)
- c.add(r.<T>getData());
+ if (filter != null)
+ res.removeAll(filter);
+ }
+ else {
+ res = new LinkedList<>();
- return c;
+ for (T t : c) {
+ if (filter == null || !filter.contains(t))
+ res.add(t);
+ }
+ }
+
+ return res;
}
/**
- * Convenient utility method that returns collection of node IDs for a given
- * collection of grid nodes.
- * <p>
- * Note that this method doesn't create a new collection but simply iterates
- * over the input one.
+ * Loses all elements in input list for which any of the predicates evaluate to {@code true}.
*
- * @param nodes Collection of grid nodes.
- * @return Collection of node IDs for given collection of grid nodes.
+ * @param c Input list.
+ * @param cp If {@code true} method creates new list not modifying input,
+ * otherwise does <tt>in-place</tt> modifications.
+ * @param p Looses all elements for which any of the predicates evaluate to {@code true}.
+ * @param <T> Type of list.
+ * @return List of remaining elements
*/
- public static Collection<UUID> nodeIds(@Nullable Collection<? extends ClusterNode> nodes) {
- if (nodes == null || nodes.isEmpty())
- return Collections.emptyList();
+ public static <T> List<T> filterList(List<T> c, boolean cp, @Nullable IgnitePredicate<T>... p) {
+ A.notNull(c, "c");
- return F.viewReadOnly(nodes, node2id());
- }
+ List<T> res;
- /**
- * 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.
- * <p>
- * Note that this method doesn't create a new collection but simply iterates
- * over the input one.
- *
- * @param nodes Collection of grid nodes.
- * @return Collection of node IDs for given collection of grid nodes.
- */
- public static Collection<String> nodeId8s(@Nullable Collection<? extends ClusterNode> nodes) {
- if (nodes == null || nodes.isEmpty())
- return Collections.emptyList();
+ if (!cp) {
+ res = c;
- return F.viewReadOnly(nodes, node2id8());
- }
+ if (p != null)
+ for (Iterator<T> it = c.iterator(); it.hasNext();)
+ if (isAny(it.next(), p))
+ it.remove();
+ }
+ else {
+ res = new ArrayList<>(c.size());
- /**
- * 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.
- * <p>
- * Note that this method doesn't create a new collection but simply iterates
- * over the input one.
- *
- * @param ids Collection of nodeIds.
- * @return Collection of node IDs for given collection of grid nodes.
- */
- public static Collection<String> id8s(@Nullable Collection<UUID> ids) {
- if (ids == null || ids.isEmpty())
- return Collections.emptyList();
+ for (T t : c)
+ if (!isAny(t, p))
+ res.add(t);
+ }
- return F.viewReadOnly(ids, id2id8());
+ return res;
}
/**
- * Convenient utility method that returns collection of node attributes for a given
- * collection of grid nodes.
- * <p>
- * Note that this method doesn't create a new collection but simply iterates over the input one.
+ * Gets closure which converts node to node ID.
*
- * @param nodes Collection of grid nodes.
- * @param attr Name of the attribute to return from each node.
- * @param <T> Type of the attribute.
- * @return Collection of node attributes for given collection of grid nodes.
+ * @return Closure which converts node to node ID.
*/
- public static <T> Collection<T> nodeAttributes(Collection<? extends ClusterNode> nodes, String attr) {
- A.notNull(nodes, "nodes", attr, "attr");
-
- Collection<T> c = new ArrayList<>(nodes.size());
-
- for (ClusterNode n : nodes)
- c.add(n.<T>attribute(attr));
-
- return c;
+ public static IgniteClosure<ClusterNode, UUID> node2id() {
+ return NODE2ID;
}
/**
- * Gets closure that calls {@code System.out.println()} on its bound variable.
+ * Creates grid node predicate evaluating on the given node ID.
*
- * @param <T> Type of the bound variable.
- * @return Closure that calls {@code System.out.println()} on its bound variable.
+ * @param nodeId Node ID for which returning predicate will evaluate to {@code true}.
+ * @return Grid node predicate evaluating on the given node ID.
+ * @see #idForNodeId(UUID)
+ * @see #nodeIds(Collection)
*/
- @SuppressWarnings("unchecked")
- public static <T> IgniteInClosure<T> println() {
- return (IgniteInClosure<T>)PRINTLN;
- }
+ public static <T extends ClusterNode> IgnitePredicate<T> nodeForNodeId(final UUID nodeId) {
+ A.notNull(nodeId, "nodeId");
- /**
- * Creates absolute closure that does <tt>System.out.println(msg)</tt>.
- *
- * @param msg Message to print.
- * @return Absolute closure that print message.
- */
- public static GridAbsClosure println(final String msg) {
- return new CA() {
- @Override public void apply() {
- System.out.println(msg);
+ return new P1<T>() {
+ @Override public boolean apply(ClusterNode e) {
+ return e.id().equals(nodeId);
}
};
}
/**
- * Creates absolute closure that does <tt>System.out.print(msg)</tt>.
+ * Creates grid node predicate evaluating on the given node IDs.
*
- * @param msg Message to print.
- * @return Absolute closure that print message.
+ * @param nodeIds Collection of node IDs.
+ * @return Grid node predicate evaluating on the given node IDs.
+ * @see #idForNodeId(UUID)
+ * @see #nodeIds(Collection)
*/
- public static GridAbsClosure print(final String msg) {
- return new CA() {
- @Override public void apply() {
- System.out.print(msg);
- }
- };
- }
+ public static <T extends ClusterNode> IgnitePredicate<T> nodeForNodeIds(@Nullable final Collection<UUID>
+ nodeIds) {
+ if (isEmpty(nodeIds))
+ return alwaysFalse();
- /**
- * Gets closure that prints out its bound variable.
- *
- * @param pre String value to print before each variable.
- * @param post String value to print after each variable.
- * @param <T> Type of the bound variable.
- * @return Closure that calls {@code System.out.print(pre); System.out.print(t); System.out.println(post)}
- * on its bound variable.
- */
- public static <T> IgniteInClosure<T> println(@Nullable final String pre, @Nullable final String post) {
- return new CI1<T>() {
- @Override public void apply(T t) {
- String sPre = pre == null ? "" : pre;
- String sPost = post == null ? "" : post;
+ assert nodeIds != null;
- System.out.println(sPre + t + sPost);
+ return new P1<T>() {
+ @Override public boolean apply(ClusterNode e) {
+ return nodeIds.contains(e.id());
}
};
}
/**
- * Gets closure that prints out its bound variable.
+ * Creates {@link UUID} predicate evaluating on the given node ID.
*
- * @param fmt Format string as for {@link PrintStream#printf(String, Object...)} method.
- * @param <T> Type of the bound variable.
- * @return Closure that prints out its bound variable.
+ * @param nodeId Node ID for which returning predicate will evaluate to {@code true}.
+ * @return {@link UUID} predicate evaluating on the given node ID.
+ * @see #nodeForNodeId(UUID)
+ * @see #nodeIds(Collection)
*/
- public static <T> IgniteInClosure<T> printf(final String fmt) {
- return new CI1<T>() {
- @Override public void apply(T t) {
- System.out.printf(fmt, t);
+ public static IgnitePredicate<UUID> idForNodeId(final UUID nodeId) {
+ A.notNull(nodeId, "nodeId");
+
+ return new P1<UUID>() {
+ @Override public boolean apply(UUID id) {
+ return id.equals(nodeId);
}
};
}
/**
- * Gets closure that prints out its bound variable
+ * Creates predicates that evaluates to {@code true} for each node in given collection.
+ * Note that if collection is empty the result predicate will always evaluate to {@code false}.
+ * Implementation simply creates {@link GridNodePredicate} instance.
*
- * @return Closure that prints out its bound variable.
+ * @param nodes Collection of nodes. If none provided - result predicate will always
+ * return {@code false}.
+ * @return Predicates that evaluates to {@code true} for each node in given collection.
*/
- @SuppressWarnings("unchecked")
- public static <T> IgniteInClosure<T> print() {
- return (IgniteInClosure<T>)PRINT;
+ public static IgnitePredicate<ClusterNode> nodeForNodes(ClusterNode... nodes) {
+ return new GridNodePredicate(nodes);
}
/**
- * Gets closure that prints out its bound variable.
+ * Retains all elements in input collection that are contained in {@code filter}.
*
- * @param pre String value to print before each variable.
- * @param post String value to print after each variable.
- * @return Closure that prints out its bound variable.
+ * @param c Input collection.
+ * @param cp If {@code true} method creates collection not modifying input, otherwise does
+ * <tt>in-place</tt> modifications.
+ * @param filter Filter collection. If filter collection is {@code null} or empty -
+ * an empty collection will be returned.
+ * @param <T> Type of collections.
+ * @return Collection of retain elements.
*/
- public static <T> IgniteInClosure<T> print(@Nullable final String pre, @Nullable final String post) {
- return new CI1<T>() {
- @Override public void apply(T t) {
- String sPre = pre == null ? "" : pre;
- String sPost = post == null ? "" : post;
+ public static <T0, T extends T0> Collection<T> retain(Collection<T> c, boolean cp,
+ @Nullable Collection<? extends T0> filter) {
+ A.notNull(c, "c");
- System.out.print(sPre + t + sPost);
- }
- };
+ return retain(c, cp, F0.in(filter));
}
/**
- * Gets random value from given collection.
+ * Retains all elements in input collection that are evaluated to {@code true}
+ * by all given predicates.
*
- * @param c Input collection (no {@code null} and not emtpy).
- * @param <T> Type of the collection.
- * @return Random value from the input collection.
+ * @param c Input collection.
+ * @param cp If {@code true} method creates collection not modifying input, otherwise does
+ * <tt>in-place</tt> modifications.
+ * @param p Predicates to filter by. If no predicates provides - all elements
+ * will be retained.
+ * @param <T> Type of collections.
+ * @return Collection of retain elements.
*/
- @SuppressWarnings("UnusedDeclaration")
- public static <T> T rand(Collection<? extends T> c) {
+ public static <T> Collection<T> retain(Collection<T> c, boolean cp, @Nullable IgnitePredicate<? super T>... p) {
A.notNull(c, "c");
- int n = ThreadLocalRandom8.current().nextInt(c.size());
-
- int i = 0;
-
- for (T t : c) {
- if (i++ == n)
- return t;
- }
-
- throw new ConcurrentModificationException();
+ return lose(c, cp, not(p));
}
/**
- * Gets random value from given collection which may be modified concurrently.
+ * Retains only up to first {@code num} elements in the input collection.
*
* @param c Input collection.
- * @param <T> Type of the collection.
- * @return Random value from the input collection.
+ * @param cp If {@code true} method creates collection not modifying input, otherwise does
+ * <tt>in-place</tt> modifications.
+ * @param num Maximum number of elements to retain (the actual number can be
+ * less if the input collection contains less elements).
+ * @param <T> Type of the collections.
+ * @return Collection contains up to {@code num} first elements from the input collection.
*/
- @Nullable public static <T> T randConcurrent(Collection<? extends T> c) {
+ public static <T> Collection<T> retain(Collection<T> c, boolean cp, int num) {
A.notNull(c, "c");
+ A.ensure(num >= 0, "num >= 0");
- int size = c.size();
+ Collection<T> res;
- if (size == 0)
- return null;
+ if (!cp) {
+ res = c;
- int n = ThreadLocalRandom8.current().nextInt(size);
+ if (num < res.size()) {
+ int i = 0;
- int i = 0;
+ for (Iterator<T> iter = res.iterator(); iter.hasNext();) {
+ iter.next();
- T res = null;
+ if (i++ >= num)
+ iter.remove();
+ }
+ }
+ }
+ else {
+ res = new ArrayList<>(num);
- for (T t : c) {
- if (i++ == n)
- return t;
+ Iterator<? extends T> iter = c.iterator();
- res = t;
+ for (int i = 0; i < num && iter.hasNext(); i++)
+ res.add(iter.next());
}
return res;
}
/**
- * Gets random value from given list. For random-access lists this
- * operation is O(1), otherwise O(n).
+ * Curries given closure.
*
- * @param l Input collection.
- * @param <T> Type of the list elements.
- * @return Random value from the input list.
+ * @param f Closure.
+ * @param e Parameter.
+ * @param <T> Input type.
+ * @param <R> Output type.
+ * @return Curried closure.
*/
- public static <T> T rand(List<T> l) {
- A.notNull(l, "l");
-
- return l.get(ThreadLocalRandom8.current().nextInt(l.size()));
+ public static <T, R> IgniteOutClosure<R> curry(final IgniteClosure<? super T, R> f, final T e) {
+ return new IgniteOutClosure<R>() {
+ @Override public R apply() {
+ return f.apply(e);
+ }
+ };
}
/**
- * Gets random value from given array. This operation
- * does not iterate through array elements and returns immediately.
+ * Curries given closure.
*
- * @param c Input collection.
- * @param <T> Type of the collection.
- * @return Random value from the input collection.
+ * @param f Closure.
+ * @param e Parameter.
+ * @param <T> Input type.
+ * @return Curried closure.
*/
- public static <T> T rand(T... c) {
- A.notNull(c, "c");
-
- return c[ThreadLocalRandom8.current().nextInt(c.length)];
+ public static <T> GridAbsClosure curry(final IgniteInClosure<? super T> f, final T e) {
+ return new GridAbsClosure() {
+ @Override public void apply() {
+ f.apply(e);
+ }
+ };
}
/**
- * Concatenates an element to a collection. If {@code copy} flag is {@code 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 {@code copy}
- * flag is {@code false}, then a read-only view will be created over the element and given
- * collections and no copying will happen.
+ * Converts array to {@link 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.
+ * <p>
+ * Note that unlike {@link Arrays#asList(Object[])}, this method is
+ * {@code null}-safe. If {@code null} is passed in, then empty list
+ * will be returned.
*
- * @param cp Copy flag.
- * @param t First element.
- * @param c Second collection.
- * @param <T> Element type.
- * @return Concatenated collection.
+ * @param vals Array of values
+ * @param <T> Array type.
+ * @return {@link List} instance for array.
*/
- public static <T> Collection<T> concat(boolean cp, @Nullable final T t, @Nullable final Collection<T> c) {
- if (cp) {
- if (isEmpty(c)) {
- Collection<T> l = new ArrayList<>(1);
+ public static <T> List<T> asList(@Nullable T... vals) {
+ return isEmpty(vals) ? Collections.<T>emptyList() : Arrays.asList(vals);
+ }
- l.add(t);
+ /**
+ * Creates new empty iterator.
+ *
+ * @param <T> Type of the iterator.
+ * @return Newly created empty iterator.
+ */
+ public static <T> GridIterator<T> emptyIterator() {
+ return new GridEmptyIterator<>();
+ }
- return l;
+ /**
+ * 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.
+ * <p>
+ * Note that due to non-copying nature of implementation, the
+ * {@link Collection#size() size()} method of resulting collection will have to
+ * iterate over all elements to produce size. Method {@link Collection#isEmpty() isEmpty()},
+ * however, is constant time and is much more preferable to use instead
+ * of {@code 'size()'} method when checking if list is not empty.
+ *
+ * @param c Input collection of collections.
+ * @param <T> Type of the inner collections.
+ * @return Iterable over the elements of the inner collections.
+ */
+ public static <T> Collection<T> flatCollections(@Nullable final Collection<? extends Collection<T>> c) {
+ if (F.isEmpty(c))
+ return Collections.emptyList();
+
+ return new GridSerializableCollection<T>() {
+ @NotNull
+ @Override public Iterator<T> iterator() {
+ return flat((Iterable<? extends Iterable<T>>)c);
}
- assert c != null;
+ @Override public int size() {
+ return F.size(iterator());
+ }
- Collection<T> ret = new ArrayList<>(c.size() + 1);
+ @Override public boolean isEmpty() {
+ return !iterator().hasNext();
+ }
+ };
+ }
- ret.add(t);
- ret.addAll(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.
+ *
+ * @param c Input collection of collections.
+ * @param <T> Type of the inner collections.
+ * @return Iterable over the elements of the inner collections.
+ */
+ public static <T> GridIterator<T> flat(@Nullable final Iterable<? extends Iterable<T>> c) {
+ return isEmpty(c) ? GridFunc.<T>emptyIterator() : new GridIteratorAdapter<T>() {
+ /** */
+ private Iterator<? extends Iterable<T>> a = c.iterator();
- return ret;
- }
- else {
- if (isEmpty(c))
- return Collections.singletonList(t);
+ /** */
+ private Iterator<T> b;
- assert c != null;
+ /** */
+ private boolean moved = true;
- return new GridSerializableCollection<T>() {
- @NotNull
- @Override public Iterator<T> iterator() {
- return new GridSerializableIterator<T>() {
- private Iterator<T> it;
+ /** */
+ private boolean more;
- @Override public boolean hasNext() {
- return it == null || it.hasNext();
- }
+ @Override public boolean hasNextX() {
+ if (!moved)
+ return more;
- @Nullable @Override public T next() {
- if (it == null) {
- it = c.iterator();
+ moved = false;
- return t;
- }
+ if (b != null && b.hasNext())
+ return more = true;
- return it.next();
- }
+ while (a.hasNext()) {
+ b = a.next().iterator();
- @Override public void remove() {
- throw new UnsupportedOperationException();
- }
- };
+ if (b.hasNext())
+ return more = true;
}
- @Override public int size() {
- return c.size() + 1;
- }
+ return more = false;
+ }
- @Override public boolean equals(Object obj) {
- return obj instanceof Collection && eqNotOrdered(this, (Collection)obj);
+ @Override public T nextX() {
+ if (hasNext()) {
+ moved = true;
+
+ return b.next();
}
- };
- }
+
+ throw new NoSuchElementException();
+ }
+
+ @Override public void removeX() {
+ assert b != null;
+
+ b.remove();
+ }
+ };
}
/**
- * Concatenates 2 collections into one. If {@code copy} flag is {@code 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 {@code copy} flag is
- * {@code false}, then a read-only view will be created over given collections
- * and no copying will happen.
+ * 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.
*
- * @param cp Copy flag.
- * @param c1 First collection.
- * @param c2 Second collection.
- * @param <T> Element type.
- * @return Concatenated {@code non-null} collection.
+ * @param c Input iterable of iterators.
+ * @return Iterator over the elements of given iterators.
*/
- public static <T> Collection<T> concat(boolean cp, @Nullable final Collection<T> c1,
- @Nullable final Collection<T> c2) {
- if (cp) {
- if (isEmpty(c1) && isEmpty(c2))
- return new ArrayList<>(0);
+ public static <T> Iterator<T> flatIterators(@Nullable final Iterable<Iterator<T>> c) {
+ return isEmpty(c) ? GridFunc.<T>emptyIterator() : new GridIteratorAdapter<T>() {
+ /** */
+ private Iterator<? extends Iterator<T>> a = c.iterator();
- if (isEmpty(c1))
- return new ArrayList<>(c2);
+ /** */
+ private Iterator<T> b;
- if (isEmpty(c2))
- return new ArrayList<>(c1);
+ /** */
+ private boolean moved = true;
- assert c1 != null && c2 != null;
+ /** */
+ private boolean more;
- Collection<T> c = new ArrayList<>(c1.size() + c2.size());
+ @Override public boolean hasNextX() {
+ if (!moved)
+ return more;
- c.addAll(c1);
- c.addAll(c2);
+ moved = false;
- return c;
- }
- else {
- if (isEmpty(c1) && isEmpty(c2))
- return Collections.emptyList();
+ if (b != null && b.hasNext())
+ return more = true;
- if (isEmpty(c1) || isEmpty(c2)) {
- Collection<T> c = isEmpty(c1) ? c2 : c1;
+ while (a.hasNext()) {
+ b = a.next();
- assert c != null;
+ if (b.hasNext())
+ return more = true;
+ }
- return c;
+ return more = false;
}
- assert c1 != null && c2 != null;
-
- return new GridSerializableCollection<T>() {
- @NotNull
- @Override public Iterator<T> iterator() {
- return new GridSerializableIterator<T>() {
- private Iterator<T> it1 = c1.iterator();
- private Iterator<T> it2 = c2.iterator();
-
- @Override public boolean hasNext() {
- if (it1 != null)
- if (!it1.hasNext())
- it1 = null;
- else
- return true;
-
- return it2.hasNext();
- }
-
- @Override public T next() {
- return it1 != null ? it1.next() : it2.next();
- }
+ @Override public T nextX() {
+ if (hasNext()) {
+ moved = true;
- @Override public void remove() {
- throw new UnsupportedOperationException();
- }
- };
+ return b.next();
}
- @Override public boolean contains(Object o) {
- return c1.contains(o) || c2.contains(o);
- }
+ throw new NoSuchElementException();
+ }
- @Override public int size() {
- return c1.size() + c2.size();
- }
+ @Override public void removeX() {
+ assert b != null;
- @Override public boolean equals(Object obj) {
- return obj instanceof Collection && eqNotOrdered(this, (Collection<?>)obj);
- }
- };
- }
+ b.remove();
+ }
+ };
}
/**
- * Concatenates an elements to an array.
+ * Converts given runnable to an absolute closure.
*
- * @param arr Array.
- * @param obj One or more elements.
- * @return Concatenated array.
+ * @param r Runnable to convert to closure. If {@code null} - no-op closure is returned.
+ * @return Closure that wraps given runnable. Note that wrapping closure always returns {@code null}.
*/
- public static <T> T[] concat(@Nullable T[] arr, T... obj) {
- T[] newArr;
-
- if (arr == null || arr.length == 0)
- newArr = obj;
- else {
- newArr = Arrays.copyOf(arr, arr.length + obj.length);
-
- System.arraycopy(obj, 0, newArr, arr.length, obj.length);
- }
-
- return newArr;
- }
+ public static GridAbsClosure as(@Nullable final Runnable r) {
+ return new CA() {
+ @Override public void apply() {
+ if (r != null)
+ r.run();
+ }
+ };
+ }
/**
- * Concatenates multiple iterators as single one.
+ * Gets size of the given collection with provided optional predicates.
*
- * @param iters Iterators.
- * @return Single iterator.
+ * @param c Collection to size.
+ * @param p Optional predicates that filters out elements from count.
+ * @param <T> Type of the iterator.
+ * @return Number of elements in the collection for which all given predicates
+ * evaluates to {@code true}. If no predicates is provided - all elements are counted.
*/
- @SuppressWarnings("unchecked")
- public static <T> Iterator<T> concat(Iterator<T> ... iters) {
- if (iters.length == 1)
- return iters[0];
-
- return concat(asList(iters).iterator());
+ public static <T> int size(@Nullable Collection<? extends T> c, @Nullable IgnitePredicate<? super T>... p) {
+ return c == null || c.isEmpty() ? 0 : isEmpty(p) || isAlwaysTrue(p) ? c.size() : size(c.iterator(), p);
}
/**
- * Concatenates multiple iterators as single one.
+ * Gets size of the given iterator with provided optional predicates. Iterator
+ * will be traversed to get the count.
*
- * @param iters Iterator over iterators.
- * @return Single iterator.
+ * @param it Iterator to size.
+ * @param p Optional predicates that filters out elements from count.
+ * @param <T> Type of the iterator.
+ * @return Number of elements in the iterator for which all given predicates
+ * evaluates to {@code true}. If no predicates is provided - all elements are counted.
*/
- @SuppressWarnings("unchecked")
- public static <T> Iterator<T> concat(final Iterator<Iterator<T>> iters) {
- if (!iters.hasNext())
- return Collections.<T>emptySet().iterator();
-
- return new Iterator<T>() {
- privat
<TRUNCATED>