ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/extra166y/CommonOps.java

Comparing jsr166/src/extra166y/CommonOps.java (file contents):
Revision 1.2 by dl, Mon Jan 12 17:16:36 2009 UTC vs.
Revision 1.6 by jsr166, Wed Jan 16 00:51:11 2013 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7		package extra166y;
#	Line 35 | Line 35 | public class CommonOps {
35		return new Reducer<T>() {
36		public T op(T a, T b) {
37		return (a != null &&
38	<	(b == null || a.compareTo(b) >= 0))? a : b;
38	>	(b == null || a.compareTo(b) >= 0)) ? a : b;
39		}
40		};
41		}
#	Line 49 | Line 49 | public class CommonOps {
49		return new Reducer<T>() {
50		public T op(T a, T b) {
51		return (a != null &&
52	<	(b == null || a.compareTo(b) <= 0))? a : b;
52	>	(b == null || a.compareTo(b) <= 0)) ? a : b;
53		}
54		};
55		}
#	Line 64 | Line 64 | public class CommonOps {
64		return new Reducer<T>() {
65		public T op(T a, T b) {
66		return (a != null &&
67	<	(b == null || comparator.compare(a, b) >= 0))? a : b;
67	>	(b == null || comparator.compare(a, b) >= 0)) ? a : b;
68		}
69		};
70		}
#	Line 79 | Line 79 | public class CommonOps {
79		return new Reducer<T>() {
80		public T op(T a, T b) {
81		return (a != null &&
82	<	(b == null || comparator.compare(a, b) <= 0))? a : b;
82	>	(b == null || comparator.compare(a, b) <= 0)) ? a : b;
83		}
84		};
85		}
#	Line 100 | Line 100 | public class CommonOps {
100
101		/**
102		* Returns a reducer returning maximum of two values, or
103	<	* <tt>null</tt> if both arguments are null, and that casts
103	>	* {@code null} if both arguments are null, and that casts
104		* its arguments as Comparable on each comparison, throwing
105		* ClassCastException on failure.
106		*/
#	Line 112 | Line 112 | public class CommonOps {
112		public Object op(Object a, Object b) {
113		return (a != null &&
114		(b == null ||
115	<	((Comparable)a).compareTo((Comparable)b) >= 0))? a : b;
115	>	((Comparable)a).compareTo((Comparable)b) >= 0)) ? a : b;
116		}
117		}
118
119		/**
120		* Returns a reducer returning minimum of two values, or
121	<	* <tt>null</tt> if both arguments are null, and that casts
121	>	* {@code null} if both arguments are null, and that casts
122		* its arguments as Comparable on each comparison, throwing
123		* ClassCastException on failure.
124		*/
#	Line 130 | Line 130 | public class CommonOps {
130		public Object op(Object a, Object b) {
131		return (a != null &&
132		(b == null ||
133	<	((Comparable)a).compareTo((Comparable)b) <= 0))? a : b;
133	>	((Comparable)a).compareTo((Comparable)b) <= 0)) ? a : b;
134		}
135		}
136
#	Line 187 | Line 187 | public class CommonOps {
187		(final DoubleComparator comparator) {
188		return new DoubleReducer() {
189		public double op(double a, double b) {
190	<	return (comparator.compare(a, b) >= 0)? a : b;
190	>	return (comparator.compare(a, b) >= 0) ? a : b;
191		}
192		};
193		}
#	Line 200 | Line 200 | public class CommonOps {
200		(final DoubleComparator comparator) {
201		return new DoubleReducer() {
202		public double op(double a, double b) {
203	<	return (comparator.compare(a, b) <= 0)? a : b;
203	>	return (comparator.compare(a, b) <= 0) ? a : b;
204		}
205		};
206		}
#	Line 216 | Line 216 | public class CommonOps {
216		static final NaturalLongComparator comparator = new
217		NaturalLongComparator();
218		public int compare(long a, long b) {
219	<	return a < b? -1 : ((a > b)? 1 : 0);
219	>	return (a < b) ? -1 : ((a > b) ? 1 : 0);
220		}
221		}
222
#	Line 232 | Line 232 | public class CommonOps {
232		implements LongReducer {
233		public static final NaturalLongMaxReducer max =
234		new NaturalLongMaxReducer();
235	<	public long op(long a, long b) { return a >= b? a : b; }
235	>	public long op(long a, long b) { return (a >= b) ? a : b; }
236		}
237
238		/**
#	Line 246 | Line 246 | public class CommonOps {
246		implements LongReducer {
247		public static final NaturalLongMinReducer min =
248		new NaturalLongMinReducer();
249	<	public long op(long a, long b) { return a <= b? a : b; }
249	>	public long op(long a, long b) { return (a <= b) ? a : b; }
250		}
251
252		/**
#	Line 257 | Line 257 | public class CommonOps {
257		(final LongComparator comparator) {
258		return new LongReducer() {
259		public long op(long a, long b) {
260	<	return (comparator.compare(a, b) >= 0)? a : b;
260	>	return (comparator.compare(a, b) >= 0) ? a : b;
261		}
262		};
263		}
#	Line 270 | Line 270 | public class CommonOps {
270		(final LongComparator comparator) {
271		return new LongReducer() {
272		public long op(long a, long b) {
273	<	return (comparator.compare(a, b) <= 0)? a : b;
273	>	return (comparator.compare(a, b) <= 0) ? a : b;
274		}
275		};
276		}
#	Line 521 | Line 521 | public class CommonOps {
521		*/
522		public static <T> DoubleOp compoundOp
523		(final DoubleToObject<? extends T> first,
524	<	final ObjectToDouble<? super T>  second) {
524	>	final ObjectToDouble<? super T> second) {
525		return new DoubleOp() {
526		public final double op(double t) { return second.op(first.op(t)); }
527		};
#	Line 533 | Line 533 | public class CommonOps {
533		*/
534		public static <T> LongToDouble compoundOp
535		(final LongToObject<? extends T> first,
536	<	final ObjectToDouble<? super T>  second) {
536	>	final ObjectToDouble<? super T> second) {
537		return new LongToDouble() {
538		public final double op(long t) { return second.op(first.op(t)); }
539		};
#	Line 545 | Line 545 | public class CommonOps {
545		*/
546		public static <T> DoubleToLong compoundOp
547		(final DoubleToObject<? extends T> first,
548	<	final ObjectToLong<? super T>  second) {
548	>	final ObjectToLong<? super T> second) {
549		return new DoubleToLong() {
550		public final long op(double t) { return second.op(first.op(t)); }
551		};
#	Line 557 | Line 557 | public class CommonOps {
557		*/
558		public static <T> LongOp compoundOp
559		(final LongToObject<? extends T> first,
560	<	final ObjectToLong<? super T>  second) {
560	>	final ObjectToLong<? super T> second) {
561		return new LongOp() {
562		public final long op(long t) { return second.op(first.op(t)); }
563		};
#	Line 711 | Line 711 | public class CommonOps {
711		/**
712		* Returns a predicate evaluating to true if its argument is non-null
713		*/
714	<	public static  Predicate<Object> isNonNullPredicate() {
714	>	public static Predicate<Object> isNonNullPredicate() {
715		return IsNonNullPredicate.predicate;
716		}
717		static final class IsNonNullPredicate implements Predicate<Object> {
#	Line 725 | Line 725 | public class CommonOps {
725		/**
726		* Returns a predicate evaluating to true if its argument is null
727		*/
728	<	public static  Predicate<Object> isNullPredicate() {
728	>	public static Predicate<Object> isNullPredicate() {
729		return IsNullPredicate.predicate;
730		}
731		static final class IsNullPredicate implements Predicate<Object> {
#	Line 952 | Line 952 | public class CommonOps {
952
953		/**
954		* Returns a predicate evaluating to true if the
955	<	* first argument <tt>equals</tt> the second
955	>	* first argument {@code equals} the second
956		*/
957		public static BinaryPredicate<Object, Object> equalityPredicate() {
958		return EqualityPredicate.predicate;
#	Line 967 | Line 967 | public class CommonOps {
967
968		/**
969		* Returns a predicate evaluating to true if the
970	<	* first argument <tt>==</tt> the second
970	>	* first argument {@code ==} the second
971		*/
972		public static BinaryPredicate<Object, Object> identityPredicate() {
973		return IdentityPredicate.predicate;
#	Line 982 | Line 982 | public class CommonOps {
982
983		/**
984		* Returns a predicate evaluating to true if the
985	<	* first argument <tt>==</tt> the second
985	>	* first argument {@code ==} the second
986		*/
987		public static BinaryIntPredicate intEqualityPredicate() {
988		return IntEqualityPredicate.predicate;
#	Line 997 | Line 997 | public class CommonOps {
997
998		/**
999		* Returns a predicate evaluating to true if the
1000	<	* first argument <tt>==</tt> the second
1000	>	* first argument {@code ==} the second
1001		*/
1002		public static BinaryLongPredicate longEqualityPredicate() {
1003		return LongEqualityPredicate.predicate;
#	Line 1012 | Line 1012 | public class CommonOps {
1012
1013		/**
1014		* Returns a predicate evaluating to true if the
1015	<	* first argument <tt>==</tt> the second
1015	>	* first argument {@code ==} the second
1016		*/
1017		public static BinaryDoublePredicate doubleEqualityPredicate() {
1018		return DoubleEqualityPredicate.predicate;
#	Line 1028 | Line 1028 | public class CommonOps {
1028
1029		/**
1030		* Returns a predicate evaluating to true if the
1031	<	* first argument <tt>!equals</tt> the second
1031	>	* first argument {@code !equals} the second
1032		*/
1033		public static BinaryPredicate<Object, Object> inequalityPredicate() {
1034		return InequalityPredicate.predicate;
#	Line 1043 | Line 1043 | public class CommonOps {
1043
1044		/**
1045		* Returns a predicate evaluating to true if the
1046	<	* first argument <tt>!=</tt> the second
1046	>	* first argument {@code !=} the second
1047		*/
1048		public static BinaryPredicate<Object, Object> nonidentityPredicate() {
1049		return NonidentityPredicate.predicate;
#	Line 1058 | Line 1058 | public class CommonOps {
1058
1059		/**
1060		* Returns a predicate evaluating to true if the
1061	<	* first argument <tt>!=</tt> the second
1061	>	* first argument {@code !=} the second
1062		*/
1063		public static BinaryIntPredicate intInequalityPredicate() {
1064		return IntInequalityPredicate.predicate;
#	Line 1073 | Line 1073 | public class CommonOps {
1073
1074		/**
1075		* Returns a predicate evaluating to true if the
1076	<	* first argument <tt>==</tt> the second
1076	>	* first argument {@code ==} the second
1077		*/
1078		public static BinaryLongPredicate longInequalityPredicate() {
1079		return LongInequalityPredicate.predicate;
#	Line 1088 | Line 1088 | public class CommonOps {
1088
1089		/**
1090		* Returns a predicate evaluating to true if the
1091	<	* first argument <tt>!=</tt> the second
1091	>	* first argument {@code !=} the second
1092		*/
1093		public static BinaryDoublePredicate doubleInequalityPredicate() {
1094		return DoubleInequalityPredicate.predicate;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines