You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by sc...@apache.org on 2002/08/17 14:06:56 UTC
cvs commit: jakarta-commons/collections/src/java/org/apache/commons/collections ComparatorUtils.java
scolebourne 2002/08/17 05:06:56
Modified: collections/src/java/org/apache/commons/collections
ComparatorUtils.java
Log:
Rename methods
Add chainedComparator
Revision Changes Path
1.4 +143 -77 jakarta-commons/collections/src/java/org/apache/commons/collections/ComparatorUtils.java
Index: ComparatorUtils.java
===================================================================
RCS file: /home/cvs/jakarta-commons/collections/src/java/org/apache/commons/collections/ComparatorUtils.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- ComparatorUtils.java 13 Aug 2002 00:46:25 -0000 1.3
+++ ComparatorUtils.java 17 Aug 2002 12:06:56 -0000 1.4
@@ -51,117 +51,180 @@
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
-
package org.apache.commons.collections;
-
+import java.util.Collection;
import java.util.Comparator;
+
import org.apache.commons.collections.comparators.ComparableComparator;
-import org.apache.commons.collections.comparators.ReverseComparator;
+import org.apache.commons.collections.comparators.ComparatorChain;
import org.apache.commons.collections.comparators.NullComparator;
+import org.apache.commons.collections.comparators.ReverseComparator;
import org.apache.commons.collections.comparators.TransformingComparator;
-
-
/**
- * Provides convenient static utility methods for <Code>Comparator</Code>
- * objects.<P>
- *
- * Most of the utility in this class can also be found in the
- * <Code>comparators</Code> package; this class merely provides a
- * convenient central place if you have use for more than one class
- * in the <Code>comparators</Code> subpackage.<P>
+ * Provides convenient static utility methods for <Code>Comparator</Code>
+ * objects.
+ * <p>
+ * Most of the utility in this class can also be found in the
+ * <code>comparators</code> package. This class merely provides a
+ * convenient central place if you have use for more than one class
+ * in the <code>comparators</code> subpackage.
+ * <p>
+ * Note that <i>every</i> method in this class allows you to specify
+ * <code>null</code> instead of a comparator, in which case
+ * {@link #NATURAL} will be used.
*
- * Note that <I>every</I> method in this class allows you to specify
- * <Code>null</Code> instead of a comparator, in which case
- * {@link #NATURAL} will be used.
- *
- * @author Paul Jack
- * @version $Id$
- * @since 2.1
+ * @since 2.1
+ * @author Paul Jack
+ * @author <a href="mailto:scolebourne@joda.org">Stephen Colebourne</a>
+ * @version $Id$
*/
public class ComparatorUtils {
-
+ /**
+ * Restrictive constructor
+ */
private ComparatorUtils() {
}
-
/**
- * Comparator for natural sort order.
+ * Comparator for natural sort order.
*
- * @see ComparableComparator#getInstance
+ * @see ComparableComparator#getInstance
*/
- final public static Comparator NATURAL =
- ComparableComparator.getInstance();
-
+ final public static Comparator NATURAL = ComparableComparator.getInstance();
/**
- * Returns a comparator that reverses the order of the given
- * comparator.
+ * Gets a comparator that uses the natural order of the objects.
*
- * @param comparator the comparator whose order to reverse
- * @return a comparator who reverses that order
- * @see ReverseComparator
+ * @return a comparator which uses natural order
*/
- public static Comparator reverse(Comparator comparator) {
- if (comparator == null) comparator = NATURAL;
- return new ReverseComparator(comparator);
+ public static Comparator naturalComparator() {
+ return NATURAL;
}
+ /**
+ * Gets a comparator that compares using two {@link Comparator}s.
+ * <p>
+ * The second comparator is used if the first comparator returns
+ * that equal.
+ *
+ * @param comparator1 the first comparator to use, not null
+ * @param comparator2 the first comparator to use, not null
+ * @return a combination comparator over the comparators
+ * @throws NullPointerException if either comparator is null
+ */
+ public static Comparator chainedComparator(Comparator comparator1, Comparator comparator2) {
+ return chainedComparator(new Comparator[] {comparator1, comparator2});
+ }
/**
- * Allows the given comparator to compare <Code>null</Code> values.<P>
+ * Gets a comparator that compares using an array of {@link Comparator}s.
+ * <p>
+ * The second comparator is used if the first comparator returns
+ * that equal and so on.
*
- * The returned comparator will consider a null value to be less than
- * any nonnull value, and equal to any other null value. Two nonnull
- * values will be evaluated with the given comparator.<P>
- *
- * @param comparator the comparator that wants to allow nulls
- * @return a version of that comparator that allows nulls
- * @see NullComparator
+ * @param iterators the comparators to use, not null or empty or contain nulls
+ * @return a combination comparator over the comparators
+ * @throws NullPointerException if comparators array is null or contains a null
*/
- public static Comparator nullLow(Comparator comparator) {
- if (comparator == null) comparator = NATURAL;
- return new NullComparator(comparator, false);
+ public static Comparator chainedComparator(Comparator[] comparators) {
+ ComparatorChain chain = new ComparatorChain();
+ for (int i = 0; i < comparators.length; i++) {
+ if (comparators[i] == null) {
+ throw new NullPointerException("Comparator cannot be null");
+ }
+ chain.addComparator(comparators[i]);
+ }
+ return chain;
}
+ /**
+ * Gets a comparator that compares using a collection of {@link Comparator}s.
+ * <p>
+ * The second comparator is used if the first comparator returns
+ * that equal and so on.
+ *
+ * @param comparators the comparators to use, not null or empty or contain nulls
+ * @return a combination comparator over the comparators
+ * @throws NullPointerException if comparators collection is null or contains a null
+ * @throws ClassCastException if the comparators collection contains the wrong object type
+ */
+ public static Comparator chainedComparator(Collection comparators) {
+ return chainedComparator(
+ (Comparator[]) comparators.toArray(new Comparator[comparators.size()])
+ );
+ }
/**
- * Allows the given comparator to compare <Code>null</Code> values.<P>
+ * Gets a comparator that reverses the order of the given
+ * comparator.
*
- * The returned comparator will consider a null value to be greater than
- * any nonnull value, and equal to any other null value. Two nonnull
- * values will be evaluated with the given comparator.<P>
- *
- * @param comparator the comparator that wants to allow nulls
- * @return a version of that comparator that allows nulls
- * @see NullComparator
+ * @param comparator the comparator whose order to reverse
+ * @return a comparator who reverses that order
+ * @see ReverseComparator
*/
- public static Comparator nullHigh(Comparator comparator) {
- if (comparator == null) comparator = NATURAL;
- return new NullComparator(comparator, true);
+ public static Comparator reversedComparator(Comparator comparator) {
+ if (comparator == null) {
+ comparator = NATURAL;
+ }
+ return new ReverseComparator(comparator);
}
+ /**
+ * Gets a Comparator that controls the comparison of <code>null</code> values.
+ * <p>
+ * The returned comparator will consider a null value to be less than
+ * any nonnull value, and equal to any other null value. Two nonnull
+ * values will be evaluated with the given comparator.<P>
+ *
+ * @param comparator the comparator that wants to allow nulls
+ * @return a version of that comparator that allows nulls
+ * @see NullComparator
+ */
+ public static Comparator nullLowComparator(Comparator comparator) {
+ if (comparator == null) {
+ comparator = NATURAL;
+ }
+ return new NullComparator(comparator, false);
+ }
-
/**
- * Passes transformed objects to the given comparator.<P>
- *
- * Objects passed to the returned comparator will first be transformed
- * by the given transformer before they are compared by the given
- * comparator.<P>
- *
- * @param comparator the sort order to use
- * @param t the transformer to use
- * @return a comparator that transforms its input objects before
- * comparing them
- * @see TransformingComparator
- */
- public static Comparator transform(Comparator comparator, Transformer t) {
- if (comparator == null) comparator = NATURAL;
- return new TransformingComparator(t, comparator);
+ * Gets a Comparator that controls the comparison of <code>null</code> values.
+ * <p>
+ * The returned comparator will consider a null value to be greater than
+ * any nonnull value, and equal to any other null value. Two nonnull
+ * values will be evaluated with the given comparator.<P>
+ *
+ * @param comparator the comparator that wants to allow nulls
+ * @return a version of that comparator that allows nulls
+ * @see NullComparator
+ */
+ public static Comparator nullHighComparator(Comparator comparator) {
+ if (comparator == null) {
+ comparator = NATURAL;
+ }
+ return new NullComparator(comparator, true);
}
+ /**
+ * Gets a Comparator that passes transformed objects to the given comparator.
+ * <p>
+ * Objects passed to the returned comparator will first be transformed
+ * by the given transformer before they are compared by the given
+ * comparator.
+ *
+ * @param comparator the sort order to use
+ * @param transformer the transformer to use
+ * @return a comparator that transforms its input objects before comparing them
+ * @see TransformingComparator
+ */
+ public static Comparator transformedComparator(Comparator comparator, Transformer transformer) {
+ if (comparator == null) {
+ comparator = NATURAL;
+ }
+ return new TransformingComparator(transformer, comparator);
+ }
/**
* Returns the smaller of the given objects according to the given
@@ -173,12 +236,13 @@
* @return the smaller of the two objects
*/
public static Object min(Object o1, Object o2, Comparator comparator) {
- if (comparator == null) comparator = NATURAL;
+ if (comparator == null) {
+ comparator = NATURAL;
+ }
int c = comparator.compare(o1, o2);
- return (c < 0) ? o1 : o2;
+ return (c < 0) ? o1 : o2;
}
-
/**
* Returns the smaller of the given objects according to the given
* comparator.
@@ -189,8 +253,10 @@
* @return the smaller of the two objects
*/
public static Object max(Object o1, Object o2, Comparator comparator) {
- if (comparator == null) comparator = NATURAL;
+ if (comparator == null) {
+ comparator = NATURAL;
+ }
int c = comparator.compare(o1, o2);
- return (c > 0) ? o1 : o2;
+ return (c > 0) ? o1 : o2;
}
}
--
To unsubscribe, e-mail: <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>