Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util;
  
  
  class SafeDecimalParser {

    
Constant 2
  
      protected static final BigDecimal TWO = new BigDecimal(2);

    
Lower allowed value
 
     protected static final BigDecimal LOWER = new BigDecimal("2.22507385850720113605e-308");

    
Upper allowed value
 
     protected static final BigDecimal UPPER = new BigDecimal("2.22507385850720125958e-308");

    
The middle of the bad interval - used for rounding bad values
 
     protected static final BigDecimal MIDDLE = .add().divide();

    
Upper allowed value as Double
 
     private static final Double UPPER_DOUBLE = Double.valueOf(.doubleValue());

    
Lower allowed value as Double
 
     private static final Double LOWER_DOUBLE = Double.valueOf(.doubleValue());

    
Digit sequence to trigger the slow path
 
     private static final String SUSPICIOUS_DIGITS = "22250738585072";

    
Heuristic test if we should look closer at the value

Parameters:
s The non-null input String
Returns:
true if the value is suspicious, false otherwise
 
     final protected static boolean isSuspicious(String s) {
         return digits(s).indexOf() >= 0;
     }

    
Safe parsing of a String into a Double

Parameters:
s The input String, can be null
Returns:
The Double value
 
     final protected static Double decimalValueOf(String s) {
         Double result = null;
         if (s != null) {
             if (isSuspicious(s)) {
                 // take the slow path
                 result = parseSafely(s);
             } else {
                 result = Double.valueOf(s);
             }
         }
         return result;
     }

    
Safe way of getting the double value
prevents BigDecimal from calling Double.parseDouble()

Parameters:
number
Returns:
the double value
 
     final protected static double decimalValue(Number number) {
         double result = 0;
         if (number != null) {
             if (number instanceof BigDecimal) {
                 result = decimalValue((BigDecimal)number);
             } else {
                 result = number.doubleValue();
             }
         }
         return result;
     }

    
Safe way of getting the double value
Prevents BigDecimal from calling Double.parseDouble()

Parameters:
bigDecimal
Returns:
the double value
 
     final protected static double decimalValue(BigDecimal bigDecimal) {
         double result = 0.0;
         if (bigDecimal != null) {
             if (isDangerous(bigDecimal)) {
                 result = decimalValueOf(bigDecimal.toString()).doubleValue();
             } else {
                 result = bigDecimal.doubleValue();
             }
         }
         return result;
     }

    
Slow parsing of a suspicious value

Rounding takes place if the value is inside the bad interval

Parameters:
s The non-null input String
Returns:
the double value
    final private static Double parseSafely(String s) {
        Double result;
        BigDecimal bd = new BigDecimal(s);
        if (isDangerous(bd)) {
            if (bd.compareTo() >= 0) {
                result = ;
            } else {
                result = ;
            }
        } else {
            result = Double.valueOf(s);
        }
        return result;
    }

    
Extract the digits from a numeric string

Parameters:
s The non-null String value
Returns:
A String containing only the digits
    final private static String digits(String s) {
        char[] ca = s.toCharArray();
        int len = ca.length;
        StringBuilder b = new StringBuilder(len);
        for (int i = 0; i < leni++) {
            char c = ca[i];
            if (c >= '0' && c <= '9') {
                b.append(c);
            }
        }
        return b.toString();
    }

    
Tests if the value is in the dangerous interval

Parameters:
bd The big decimal value
Returns:
true if the value is dangerous, false otherwise
    final private static boolean isDangerous(BigDecimal bd) {
        return bd.compareTo() < 0 && bd.compareTo() > 0;
    }
New to GrepCode? Check out our FAQ X