commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hen...@apache.org
Subject svn commit: r1165652 - /commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlArithmetic.java
Date Tue, 06 Sep 2011 13:01:15 GMT
Author: henrib
Date: Tue Sep  6 13:01:14 2011
New Revision: 1165652

URL: http://svn.apache.org/viewvc?rev=1165652&view=rev
Log:
Simplified arithmetic implementation using a general compare;
Added some checks wrt / 0 (% 0);

Modified:
    commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlArithmetic.java

Modified: commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlArithmetic.java
URL: http://svn.apache.org/viewvc/commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlArithmetic.java?rev=1165652&r1=1165651&r2=1165652&view=diff
==============================================================================
--- commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlArithmetic.java (original)
+++ commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlArithmetic.java Tue
Sep  6 13:01:14 2011
@@ -404,6 +404,9 @@ public class JexlArithmetic {
         if (left instanceof BigDecimal || right instanceof BigDecimal) {
             BigDecimal l = toBigDecimal(left);
             BigDecimal r = toBigDecimal(right);
+            if (BigDecimal.ZERO.equals(r)) {
+                throw new ArithmeticException("/");
+            }
             BigDecimal result = l.divide(r, getMathContext());
             return narrowBigDecimal(left, right, result);
         }
@@ -411,6 +414,9 @@ public class JexlArithmetic {
         // otherwise treat as integers
         BigInteger l = toBigInteger(left);
         BigInteger r = toBigInteger(right);
+        if (BigInteger.ZERO.equals(r)) {
+            throw new ArithmeticException("/");
+        }
         BigInteger result = l.divide(r);
         return narrowBigInteger(left, right, result);
     }
@@ -441,6 +447,9 @@ public class JexlArithmetic {
         if (left instanceof BigDecimal || right instanceof BigDecimal) {
             BigDecimal l = toBigDecimal(left);
             BigDecimal r = toBigDecimal(right);
+            if (BigDecimal.ZERO.equals(r)) {
+                throw new ArithmeticException("%");
+            }
             BigDecimal remainder = l.remainder(r, getMathContext());
             return narrowBigDecimal(left, right, remainder);
         }
@@ -449,6 +458,9 @@ public class JexlArithmetic {
         BigInteger l = toBigInteger(left);
         BigInteger r = toBigInteger(right);
         BigInteger result = l.mod(r);
+        if (BigInteger.ZERO.equals(r)) {
+            throw new ArithmeticException("%");
+        }
         return narrowBigInteger(left, right, result);
     }
 
@@ -524,32 +536,34 @@ public class JexlArithmetic {
      * @return the negated value
      */
     public Object negate(Object val) {
-        if (val instanceof Byte) {
-            byte valueAsByte = ((Byte) val).byteValue();
-            return Byte.valueOf((byte) -valueAsByte);
-        } else if (val instanceof Short) {
-            short valueAsShort = ((Short) val).shortValue();
-            return Short.valueOf((short) -valueAsShort);
-        } else if (val instanceof Integer) {
+        if (val instanceof Integer) {
             int valueAsInt = ((Integer) val).intValue();
             return Integer.valueOf(-valueAsInt);
-        } else if (val instanceof Long) {
-            long valueAsLong = -((Long) val).longValue();
-            return Long.valueOf(valueAsLong);
-        } else if (val instanceof Float) {
-            float valueAsFloat = ((Float) val).floatValue();
-            return new Float(-valueAsFloat);
         } else if (val instanceof Double) {
             double valueAsDouble = ((Double) val).doubleValue();
             return new Double(-valueAsDouble);
+        } else if (val instanceof Long) {
+            long valueAsLong = -((Long) val).longValue();
+            return Long.valueOf(valueAsLong);
         } else if (val instanceof BigDecimal) {
             BigDecimal valueAsBigD = (BigDecimal) val;
             return valueAsBigD.negate();
         } else if (val instanceof BigInteger) {
             BigInteger valueAsBigI = (BigInteger) val;
             return valueAsBigI.negate();
+        } else if (val instanceof Float) {
+            float valueAsFloat = ((Float) val).floatValue();
+            return new Float(-valueAsFloat);
+        } else if (val instanceof Short) {
+            short valueAsShort = ((Short) val).shortValue();
+            return Short.valueOf((short) -valueAsShort);
+        } else if (val instanceof Byte) {
+            byte valueAsByte = ((Byte) val).byteValue();
+            return Byte.valueOf((byte) -valueAsByte);
+        } else if (val instanceof Boolean) {
+            return ((Boolean) val).booleanValue()? Boolean.FALSE : Boolean.TRUE;
         }
-        throw new IllegalArgumentException(val.toString() + ": negate can only be applied
to a number");
+        throw new ArithmeticException("Object negation:(" + val + ")");
     }
 
     /**
@@ -577,6 +591,60 @@ public class JexlArithmetic {
     }
 
     /**
+     * Performs a comparison.
+     * @param left the left operand
+     * @param right the right operator
+     * @param operator the operator
+     * @return -1 if left  < right; +1 if left &gt > right; 0 if left == right
+     */
+    protected int compare(Object left, Object right, String operator) {
+        if (left != null && right != null) {
+            if (left instanceof BigDecimal || right instanceof BigDecimal) {
+                BigDecimal l = toBigDecimal(left);
+                BigDecimal r = toBigDecimal(right);
+                return l.compareTo(r);
+            } else if (left instanceof BigInteger || right instanceof BigInteger) {
+                BigInteger l = toBigInteger(left);
+                BigInteger r = toBigInteger(right);
+                return l.compareTo(r);
+            } else if (isFloatingPoint(left) || isFloatingPoint(right)) {
+                double lhs = toDouble(left);
+                double rhs = toDouble(right);
+                if (lhs < rhs) {
+                    return -1;
+                } else if (lhs > rhs) {
+                    return +1;
+                } else {
+                    return 0;
+                }
+            } else if (isNumberable(left) || isNumberable(right)) {
+                long lhs = toLong(left);
+                long rhs = toLong(right);
+                if (lhs < rhs) {
+                    return -1;
+                } else if (lhs > rhs) {
+                    return +1;
+                } else {
+                    return 0;
+                }
+            } else if (left instanceof String || right instanceof String) {
+                return toString(left).compareTo(toString(right));
+            } else if ("==".equals(operator)) {
+                return left.equals(right) ? 0 : -1;
+            } else if (left instanceof Comparable<?>) {
+                @SuppressWarnings("unchecked") // OK because of instanceof check above
+                final Comparable<Object> comparable = (Comparable<Object>) left;
+                return comparable.compareTo(right);
+            } else if (right instanceof Comparable<?>) {
+                @SuppressWarnings("unchecked") // OK because of instanceof check above
+                final Comparable<Object> comparable = (Comparable<Object>) right;
+                return comparable.compareTo(left);
+            }
+        }
+        throw new ArithmeticException("Object comparison:(" + left + " " + operator + " "
+ right + ")");
+    }
+
+    /**
      * Test if left and right are equal.
      *
      * @param left first value
@@ -584,34 +652,15 @@ public class JexlArithmetic {
      * @return test result.
      */
     public boolean equals(Object left, Object right) {
-        if (left == null && right == null) {
-            /*
-             * if both are null L == R
-             */
+        if (left == right) {
             return true;
         } else if (left == null || right == null) {
-            /*
-             * we know both aren't null, therefore L != R
-             */
             return false;
-        } else if (left instanceof BigDecimal || right instanceof BigDecimal) {
-            BigDecimal lhs = toBigDecimal(left);
-            BigDecimal rhs = toBigDecimal(right);
-            return lhs.compareTo(rhs) == 0;
-        } else if (left.getClass().equals(right.getClass())) {
-            return left.equals(right);
-        } else if (isFloatingPointType(left, right)) {
-            return toDouble(left) == toDouble(right);
-        } else if ((left instanceof Number || left instanceof Character)
-                && (right instanceof Character || right instanceof Number)) {
-            return toLong(left) == toLong(right);
         } else if (left instanceof Boolean || right instanceof Boolean) {
             return toBoolean(left) == toBoolean(right);
-        } else if (left instanceof java.lang.String || right instanceof String) {
-            return left.toString().equals(right.toString());
+        } else {
+            return compare(left, right, "==") == 0;
         }
-
-        return left.equals(right);
     }
 
     /**
@@ -624,35 +673,10 @@ public class JexlArithmetic {
     public boolean lessThan(Object left, Object right) {
         if ((left == right) || (left == null) || (right == null)) {
             return false;
-        } else if (isFloatingPoint(left) || isFloatingPoint(right)) {
-            double leftDouble = toDouble(left);
-            double rightDouble = toDouble(right);
-            return leftDouble < rightDouble;
-        } else if (left instanceof BigDecimal || right instanceof BigDecimal) {
-            BigDecimal l = toBigDecimal(left);
-            BigDecimal r = toBigDecimal(right);
-            return l.compareTo(r) < 0;
-        } else if (isNumberable(left) || isNumberable(right)) {
-            long leftLong = toLong(left);
-            long rightLong = toLong(right);
-            return leftLong < rightLong;
-        } else if (left instanceof String || right instanceof String) {
-            String leftString = left.toString();
-            String rightString = right.toString();
-            return leftString.compareTo(rightString) < 0;
-        } else if (left instanceof Comparable<?>) {
-            @SuppressWarnings("unchecked") // OK because of instanceof check above
-            final Comparable<Object> comparable = (Comparable<Object>) left;
-            return comparable.compareTo(right) < 0;
-        } else if (right instanceof Comparable<?>) {
-            @SuppressWarnings("unchecked") // OK because of instanceof check above
-            final Comparable<Object> comparable = (Comparable<Object>) right;
-            return comparable.compareTo(left) > 0;
+        } else {
+            return compare(left, right, "<") < 0;
         }
 
-        throw new IllegalArgumentException("Invalid comparison : comparing cardinality for
left: " + left
-                + " and right: " + right);
-
     }
 
     /**
@@ -663,10 +687,11 @@ public class JexlArithmetic {
      * @return test result.
      */
     public boolean greaterThan(Object left, Object right) {
-        if (left == null || right == null) {
+        if ((left == right) || left == null || right == null) {
             return false;
+        } else {
+            return compare(left, right, ">") > 0;
         }
-        return !equals(left, right) && !lessThan(left, right);
     }
 
     /**
@@ -677,7 +702,13 @@ public class JexlArithmetic {
      * @return test result.
      */
     public boolean lessThanOrEqual(Object left, Object right) {
-        return equals(left, right) || lessThan(left, right);
+        if (left == right) {
+            return true;
+        } else if (left == null || right == null) {
+            return false;
+        } else {
+            return compare(left, right, "<=") <= 0;
+        }
     }
 
     /**
@@ -688,7 +719,13 @@ public class JexlArithmetic {
      * @return test result.
      */
     public boolean greaterThanOrEqual(Object left, Object right) {
-        return equals(left, right) || greaterThan(left, right);
+        if (left == right) {
+            return true;
+        } else if (left == null || right == null) {
+            return false;
+        } else {
+            return compare(left, right, ">=") >= 0;
+        }
     }
 
     /**
@@ -729,7 +766,7 @@ public class JexlArithmetic {
             } else {
                 return ((Double) val).intValue();
             }
-        }  else if (val instanceof Number) {
+        } else if (val instanceof Number) {
             return ((Number) val).intValue();
         } else if (val instanceof String) {
             if ("".equals(val)) {
@@ -742,8 +779,8 @@ public class JexlArithmetic {
             return ((Character) val).charValue();
         }
 
-        throw new IllegalArgumentException("Integer coercion exception. Can't coerce type:
"
-                + val.getClass().getName());
+        throw new ArithmeticException("Integer coercion: "
+                + val.getClass().getName() + ":(" +val+")");
     }
 
     /**
@@ -776,7 +813,8 @@ public class JexlArithmetic {
             return ((Character) val).charValue();
         }
 
-        throw new IllegalArgumentException("Long coercion exception. Can't coerce type: "
+ val.getClass().getName());
+        throw new ArithmeticException("Long coercion: "
+                + val.getClass().getName() + ":(" +val+")");
     }
 
     /**
@@ -807,13 +845,13 @@ public class JexlArithmetic {
             } else {
                 return new BigInteger(string);
             }
-        }else if (val instanceof Character) {
+        } else if (val instanceof Character) {
             int i = ((Character) val).charValue();
             return BigInteger.valueOf(i);
         }
 
-        throw new IllegalArgumentException("BigInteger coercion exception. Can't coerce type:
"
-                + val.getClass().getName());
+        throw new ArithmeticException("BigInteger coercion: "
+                + val.getClass().getName() + ":(" +val+")");
     }
 
     /**
@@ -848,8 +886,8 @@ public class JexlArithmetic {
             return new BigDecimal(i);
         }
 
-        throw new IllegalArgumentException("BigDecimal coercion exception. Can't coerce type:
"
-                + val.getClass().getName());
+        throw new ArithmeticException("BigDecimal coercion: "
+                + val.getClass().getName() + ":(" +val+")");
     }
 
     /**
@@ -884,8 +922,8 @@ public class JexlArithmetic {
             return i;
         }
 
-        throw new IllegalArgumentException("Double coercion exception. Can't coerce type:
"
-                + val.getClass().getName());
+        throw new ArithmeticException("Double coercion: "
+                + val.getClass().getName() + ":(" +val+")");
     }
 
     /**



Mime
View raw message