Author: henrib
Date: Sat May 21 14:50:56 2011
New Revision: 1125719

URL: http://svn.apache.org/viewvc?rev=1125719&view=rev
Log:
Revisited BigDecimal handling by adding a scale used for coercion / comparisons

Modified:
    
commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlArithmetic.java
    
commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlThreadedArithmetic.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=1125719&r1=1125718&r2=1125719&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
 Sat May 21 14:50:56 2011
@@ -51,17 +51,21 @@ public class JexlArithmetic {
     protected static final BigInteger BIGI_LONG_MAX_VALUE = 
BigInteger.valueOf(Long.MAX_VALUE);
     /** Long.MIN_VALUE as BigInteger. */
     protected static final BigInteger BIGI_LONG_MIN_VALUE = 
BigInteger.valueOf(Long.MIN_VALUE);
+    /** Default BigDecimal scale. */
+    protected static final int BIGD_SCALE = 5;
     /** Whether this JexlArithmetic instance behaves in strict or lenient 
mode. */
     protected final boolean strict;
     /** The big decimal math context. */
     protected final MathContext mathContext;
+    /** The big decimal scale. */
+    protected final int mathScale;
 
     /**
      * Creates a JexlArithmetic.
      * @param lenient whether this arithmetic is lenient or strict
      */
     public JexlArithmetic(boolean lenient) {
-        this(lenient, MathContext.DECIMAL128);
+        this(lenient, MathContext.DECIMAL128, BIGD_SCALE);
     }
 
     /**
@@ -69,9 +73,10 @@ public class JexlArithmetic {
      * @param lenient whether this arithmetic is lenient or strict
      * @param bigdContext the math context instance to use for +,-,/,*,% 
operations on big decimals.
      */
-    public JexlArithmetic(boolean lenient, MathContext bigdContext) {
+    public JexlArithmetic(boolean lenient, MathContext bigdContext, int 
bigdScale) {
         this.strict = !lenient;
         this.mathContext = bigdContext;
+        this.mathScale = bigdScale;
     }
 
     /**
@@ -90,6 +95,23 @@ public class JexlArithmetic {
     public MathContext getMathContext() {
         return mathContext;
     }
+    
+    /**
+     * The BigDecimal scale used for comparison and coericion operations.
+     * @return the scale
+     */
+    public int getMathScale() {
+        return mathScale;
+    }
+    
+    /**
+     * Ensure a big decimal is rounded by this arithmetic scale and rounding 
mode.
+     * @param number the big decimal to round
+     * @return the rounded big decimal
+     */
+    public BigDecimal roundBigDecimal(final BigDecimal number) {
+        return number.setScale(mathScale, mathContext.getRoundingMode());
+    }
 
     /**
      * The result of +,/,-,*,% when both operands are null.
@@ -159,10 +181,10 @@ public class JexlArithmetic {
      */
     protected boolean isNumberable(final Object o) {
         return o instanceof Integer
-            || o instanceof Long
-            || o instanceof Byte
-            || o instanceof Short
-            || o instanceof Character;
+                || o instanceof Long
+                || o instanceof Byte
+                || o instanceof Short
+                || o instanceof Character;
     }
 
     /**
@@ -181,14 +203,14 @@ public class JexlArithmetic {
     protected Number narrowBigInteger(Object lhs, Object rhs, BigInteger bigi) 
{
         //coerce to long if possible
         if (!(lhs instanceof BigInteger || rhs instanceof BigInteger)
-            && bigi.compareTo(BIGI_LONG_MAX_VALUE) <= 0
-            && bigi.compareTo(BIGI_LONG_MIN_VALUE) >= 0) {
+                && bigi.compareTo(BIGI_LONG_MAX_VALUE) <= 0
+                && bigi.compareTo(BIGI_LONG_MIN_VALUE) >= 0) {
             // coerce to int if possible
             long l = bigi.longValue();
             // coerce to int when possible (int being so often used in method 
parms)
             if (!(lhs instanceof Long || rhs instanceof Long)
-                && l <= Integer.MAX_VALUE
-                && l >= Integer.MIN_VALUE) {
+                    && l <= Integer.MAX_VALUE
+                    && l >= Integer.MIN_VALUE) {
                 return Integer.valueOf((int) l);
             }
             return Long.valueOf(l);
@@ -197,6 +219,32 @@ public class JexlArithmetic {
     }
 
     /**
+     * Given a BigDecimal, attempt to narrow it to an Integer or Long if it 
fits if
+     * one of the arguments is a numberable.
+     * </p>
+     * @param lhs the left hand side operand that lead to the bigd result
+     * @param rhs the right hand side operand that lead to the bigd result
+     * @param bigi the BigInteger to narrow
+     * @return an Integer or Long if narrowing is possible, the original 
BigInteger otherwise
+     */
+    protected Number narrowBigDecimal(Object lhs, Object rhs, BigDecimal bigd) 
{
+        if (isNumberable(lhs) || isNumberable(rhs)) {
+            try {
+                long l = bigd.longValueExact();
+                // coerce to int when possible (int being so often used in 
method parms)
+                if (l <= Integer.MAX_VALUE && l >= Integer.MIN_VALUE) {
+                    return Integer.valueOf((int) l);
+                } else {
+                    return Long.valueOf(l);
+                }
+            } catch(ArithmeticException xa) {
+                // ignore, no exact value possible
+            }
+        }
+        return bigd;
+    }
+    
+    /**
      * Given an array of objects, attempt to type it more strictly.
      * <ul>
      * <li>If all objects are of the same type, the array returned will be an 
array of that same type</li>
@@ -232,7 +280,7 @@ public class JexlArithmetic {
                                     commonClass = Object.class;
                                     break;
                                 }
-                            } while(!commonClass.isAssignableFrom(eclass));
+                            } while (!commonClass.isAssignableFrom(eclass));
                         }
                     }
                 } else {
@@ -252,7 +300,7 @@ public class JexlArithmetic {
                 }
                 // allocate and fill up the typed array
                 Object typed = Array.newInstance(commonClass, size);
-                for(int i = 0; i < size; ++i) {
+                for (int i = 0; i < size; ++i) {
                     Array.set(typed, i, untyped[i]);
                 }
                 return typed;
@@ -296,7 +344,7 @@ public class JexlArithmetic {
         if (left == null && right == null) {
             return controlNullNullOperands();
         }
-        
+
         try {
             // if either are floating point (double or float) use double
             if (isFloatingPointNumber(left) || isFloatingPointNumber(right)) {
@@ -304,21 +352,15 @@ public class JexlArithmetic {
                 double r = toDouble(right);
                 return new Double(l + r);
             }
-        
-            // if both are bigintegers use that type
-            if (left instanceof BigInteger && right instanceof BigInteger) {
-                BigInteger l = toBigInteger(left);
-                BigInteger r = toBigInteger(right);
-                return l.add(r);
-            }
-            
+
             // if either are bigdecimal use that type 
             if (left instanceof BigDecimal || right instanceof BigDecimal) {
                 BigDecimal l = toBigDecimal(left);
                 BigDecimal r = toBigDecimal(right);
-                return l.add(r, mathContext);
+                BigDecimal result = l.add(r, mathContext);
+                return narrowBigDecimal(left, right, result);
             }
-            
+
             // otherwise treat as integers
             BigInteger l = toBigInteger(left);
             BigInteger r = toBigInteger(right);
@@ -352,19 +394,12 @@ public class JexlArithmetic {
             return new Double(l / r);
         }
 
-        // if both are bigintegers use that type
-        if (left instanceof BigInteger && right instanceof BigInteger) {
-            BigInteger l = toBigInteger(left);
-            BigInteger r = toBigInteger(right);
-            return l.divide(r);
-        }
-
         // if either are bigdecimal use that type
         if (left instanceof BigDecimal || right instanceof BigDecimal) {
             BigDecimal l = toBigDecimal(left);
             BigDecimal r = toBigDecimal(right);
-            BigDecimal d = l.divide(r, mathContext);
-            return d;
+            BigDecimal result = l.divide(r, mathContext);
+            return narrowBigDecimal(left, right, result);
         }
 
         // otherwise treat as integers
@@ -373,7 +408,7 @@ public class JexlArithmetic {
         BigInteger result = l.divide(r);
         return narrowBigInteger(left, right, result);
     }
-    
+
     /**
      * left value mod right.
      * @param left first value
@@ -396,19 +431,12 @@ public class JexlArithmetic {
             return new Double(l % r);
         }
 
-        // if both are bigintegers use that type
-        if (left instanceof BigInteger && right instanceof BigInteger) {
-            BigInteger l = toBigInteger(left);
-            BigInteger r = toBigInteger(right);
-            return l.mod(r);
-        }
-
         // if either are bigdecimal use that type 
         if (left instanceof BigDecimal || right instanceof BigDecimal) {
             BigDecimal l = toBigDecimal(left);
             BigDecimal r = toBigDecimal(right);
             BigDecimal remainder = l.remainder(r, mathContext);
-            return remainder;
+            return narrowBigDecimal(left, right, remainder);
         }
 
         // otherwise treat as integers
@@ -417,7 +445,7 @@ public class JexlArithmetic {
         BigInteger result = l.mod(r);
         return narrowBigInteger(left, right, result);
     }
-    
+
     /**
      * Multiply the left value by the right.
      * @param left first value
@@ -435,19 +463,13 @@ public class JexlArithmetic {
             double r = toDouble(right);
             return new Double(l * r);
         }
-        
-        // if both are bigintegers use that type
-        if (left instanceof BigInteger && right instanceof BigInteger) {
-            BigInteger l = toBigInteger(left);
-            BigInteger r = toBigInteger(right);
-            return l.multiply(r);
-        }
-        
+
         // if either are bigdecimal use that type 
         if (left instanceof BigDecimal || right instanceof BigDecimal) {
             BigDecimal l = toBigDecimal(left);
             BigDecimal r = toBigDecimal(right);
-            return l.multiply(r, mathContext);
+            BigDecimal result = l.multiply(r, mathContext);
+            return narrowBigDecimal(left, right, result);
         }
 
         // otherwise treat as integers
@@ -456,7 +478,7 @@ public class JexlArithmetic {
         BigInteger result = l.multiply(r);
         return narrowBigInteger(left, right, result);
     }
-    
+
     /**
      * Subtract the right value from the left.
      * @param left first value
@@ -474,19 +496,13 @@ public class JexlArithmetic {
             double r = toDouble(right);
             return new Double(l - r);
         }
-        
-        // if both are bigintegers use that type
-        if (left instanceof BigInteger && right instanceof BigInteger) {
-            BigInteger l = toBigInteger(left);
-            BigInteger r = toBigInteger(right);
-            return l.subtract(r);
-        }
-        
+
         // if either are bigdecimal use that type 
         if (left instanceof BigDecimal || right instanceof BigDecimal) {
             BigDecimal l = toBigDecimal(left);
             BigDecimal r = toBigDecimal(right);
-            return l.subtract(r, mathContext);
+            BigDecimal result = l.subtract(r, mathContext);
+            return narrowBigDecimal(left, right, result);
         }
 
         // otherwise treat as integers
@@ -538,14 +554,14 @@ public class JexlArithmetic {
              * we know both aren't null, therefore L != R
              */
             return false;
-        } else if (left.getClass().equals(right.getClass())) {
-            return left.equals(right);
         } else if (left instanceof BigDecimal || right instanceof BigDecimal) {
             return toBigDecimal(left).compareTo(toBigDecimal(right)) == 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 || right instanceof Number || left 
instanceof Character
-            || right instanceof Character) {
+                || right instanceof Character) {
             return toLong(left) == toLong(right);
         } else if (left instanceof Boolean || right instanceof Boolean) {
             return toBoolean(left) == toBoolean(right);
@@ -556,7 +572,6 @@ public class JexlArithmetic {
         return left.equals(right);
     }
 
-
     /**
      * Test if left < right.
      *
@@ -572,8 +587,8 @@ public class JexlArithmetic {
             double rightDouble = toDouble(right);
             return leftDouble < rightDouble;
         } else if (left instanceof BigDecimal || right instanceof BigDecimal) {
-            BigDecimal l  = toBigDecimal(left);
-            BigDecimal r  = toBigDecimal(right);
+            BigDecimal l = toBigDecimal(left);
+            BigDecimal r = toBigDecimal(right);
             return l.compareTo(r) < 0;
         } else if (isNumberable(left) || isNumberable(right)) {
             long leftLong = toLong(left);
@@ -594,7 +609,7 @@ public class JexlArithmetic {
         }
 
         throw new IllegalArgumentException("Invalid comparison : comparing 
cardinality for left: " + left
-            + " and right: " + right);
+                + " and right: " + right);
 
     }
 
@@ -633,7 +648,7 @@ public class JexlArithmetic {
     public boolean greaterThanOrEqual(Object left, Object right) {
         return equals(left, right) || greaterThan(left, right);
     }
-    
+
     /**
      * Coerce to a boolean (not a java.lang.Boolean).
      *
@@ -680,7 +695,6 @@ public class JexlArithmetic {
                 + val.getClass().getName());
     }
 
-    
     /**
      * Coerce to a long (not a java.lang.Long).
      *
@@ -732,11 +746,11 @@ public class JexlArithmetic {
             int i = ((Character) val).charValue();
             return BigInteger.valueOf(i);
         }
-        
+
         throw new IllegalArgumentException("BigInteger coercion exception. 
Can't coerce type: "
                 + val.getClass().getName());
     }
-    
+
     /**
      * Get a BigDecimal from the object passed.
      * Null and empty string maps to zero.
@@ -746,7 +760,7 @@ public class JexlArithmetic {
      */
     public BigDecimal toBigDecimal(Object val) {
         if (val instanceof BigDecimal) {
-            return (BigDecimal) val;
+            return roundBigDecimal((BigDecimal) val);
         } else if (val == null) {
             controlNullOperand();
             return BigDecimal.ZERO;
@@ -755,18 +769,18 @@ public class JexlArithmetic {
             if ("".equals(string)) {
                 return BigDecimal.valueOf(0);
             }
-            return new BigDecimal(string, mathContext);
+            return roundBigDecimal(new BigDecimal(string,  mathContext));
         } else if (val instanceof Number) {
-            return new BigDecimal(val.toString(), mathContext);
+            return roundBigDecimal(new BigDecimal(val.toString(), 
mathContext));
         } else if (val instanceof Character) {
             int i = ((Character) val).charValue();
             return new BigDecimal(i);
         }
-        
+
         throw new IllegalArgumentException("BigDecimal coercion exception. 
Can't coerce type: "
                 + val.getClass().getName());
     }
-    
+
     /**
      * Coerce to a double.
      *
@@ -803,7 +817,6 @@ public class JexlArithmetic {
                 + val.getClass().getName());
     }
 
-
     /**
      * Coerce to a string.
      *
@@ -852,7 +865,7 @@ public class JexlArithmetic {
                 BigInteger bigi = (BigInteger) original;
                 // if it's bigger than a Long it can't be narrowed
                 if (bigi.compareTo(BIGI_LONG_MAX_VALUE) > 0
-                    || bigi.compareTo(BIGI_LONG_MIN_VALUE) < 0) {
+                        || bigi.compareTo(BIGI_LONG_MIN_VALUE) < 0) {
                     return original;
                 }
             }
@@ -869,5 +882,4 @@ public class JexlArithmetic {
         }
         return result;
     }
-
 }
\ No newline at end of file

Modified: 
commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlThreadedArithmetic.java
URL: 
http://svn.apache.org/viewvc/commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlThreadedArithmetic.java?rev=1125719&r1=1125718&r2=1125719&view=diff
==============================================================================
--- 
commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlThreadedArithmetic.java
 (original)
+++ 
commons/proper/jexl/trunk/src/main/java/org/apache/commons/jexl2/JexlThreadedArithmetic.java
 Sat May 21 14:50:56 2011
@@ -16,13 +16,25 @@
  */
 package org.apache.commons.jexl2;
 
+import java.math.MathContext;
+
 /**
  * A derived arithmetic that allows different threads to operate with
- * different strict/lenient modes using the same JexlEngine.
+ * different strict/lenient/math modes using the same JexlEngine.
  */
 public class JexlThreadedArithmetic extends JexlArithmetic {
-    /** Whether this JexlArithmetic instance behaves in strict or lenient mode 
for this thread. */
-    protected static final ThreadLocal<Boolean> lenient = new 
ThreadLocal<Boolean>();
+    
+    /** Holds the threaded version of some arithmetic features. */
+    static class Features {
+        Features() {
+        }
+        /** Whether this JexlArithmetic instance behaves in strict or lenient 
mode. */
+        Boolean lenient = null;
+        /** The big decimal math context. */
+        MathContext mathContext = null;
+        /** The big decimal scale. */
+        Integer mathScale = null;
+    }
 
     /**
      * Standard ctor.
@@ -31,6 +43,24 @@ public class JexlThreadedArithmetic exte
     public JexlThreadedArithmetic(boolean lenient) {
         super(lenient);
     }
+    
+    /**
+     * Creates a JexlThreadedArithmetic.
+     * @param lenient whether this arithmetic is lenient or strict
+     * @param bigdContext the math context instance to use for +,-,/,*,% 
operations on big decimals.
+     */
+    public JexlThreadedArithmetic(boolean lenient, MathContext bigdContext, 
int bigdScale) {
+        super(lenient, bigdContext, bigdScale);
+    }
+    
+    /** Whether this JexlArithmetic instance behaves in strict or lenient mode 
for this thread. */
+    static final ThreadLocal<Features> features = new ThreadLocal<Features>() {
+        @Override
+        protected synchronized Features initialValue() {
+            return new Features();
+        }
+    };
+
 
     /**
      * Overrides the default behavior and sets whether this JexlArithmetic 
instance triggers errors
@@ -43,13 +73,43 @@ public class JexlThreadedArithmetic exte
      * @param flag true means no JexlException will occur, false allows them, 
null reverts to default behavior
      */
     public static void setLenient(Boolean flag) {
-        lenient.set(flag);
+        features.get().lenient = flag == null? null : flag;
+    }
+    
+    /**
+     * Sets the math scale.
+     * <p>The goal and constraints are the same than for setLenient.</p>
+     * @param scale the scale
+     */
+    public static void setMathScale(Integer scale) {
+        features.get().mathScale = scale;
+    }
+    
+    /**
+     * Sets the math context.
+     * <p>The goal and constraints are the same than for setLenient.</p>
+     * @param mc the math context
+     */
+    public static void setMathContext(MathContext mc) {
+        features.get().mathContext = mc;
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isLenient() {
-        Boolean tl = lenient.get();
-        return tl == null? super.isLenient() : tl.booleanValue();
+        Boolean lenient = features.get().lenient;
+        return lenient == null ? super.isLenient() : lenient.booleanValue();
+    }
+    
+    @Override
+    public int getMathScale() {
+        Integer scale = features.get().mathScale;
+        return scale == null ? super.getMathScale() : scale.intValue();
+    }
+    
+    @Override
+    public MathContext getMathContext() {
+        MathContext mc = features.get().mathContext;
+        return mc == null? super.getMathContext() : mc;
     }
 }


Reply via email to