root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Consistent number handling in StandardTypeComparator (BigInteger support, doubleValue fallback) 

Also includes a fix for the Comparable raw type invocation.

Issue: SPR-9913
Issue: SPR-12353
This commit is contained in:
Juergen Hoeller 2014-10-20 17:31:03 +02:00
parent fb08644e46
commit 92ad02ae8f
1 changed files with 33 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
spring-expression/src/main/java/org/springframework/expression/spel/support/StandardTypeComparator.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,6 +17,7 @@
package org.springframework.expression.spel.support;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.springframework.expression.TypeComparator;
import org.springframework.expression.spel.SpelEvaluationException;
@ -75,19 +76,36 @@ public class StandardTypeComparator implements TypeComparator {
else if (leftNumber instanceof Float || rightNumber instanceof Float) {
return Float.compare(leftNumber.floatValue(), rightNumber.floatValue());
}
else if (leftNumber instanceof BigInteger || rightNumber instanceof BigInteger) {
BigInteger leftBigInteger = NumberUtils.convertNumberToTargetClass(leftNumber, BigInteger.class);
BigInteger rightBigInteger = NumberUtils.convertNumberToTargetClass(rightNumber, BigInteger.class);
return leftBigInteger.compareTo(rightBigInteger);
}
else if (leftNumber instanceof Long || rightNumber instanceof Long) {
// Don't call Long.compare here - only available on JDK 1.7+
return compare(leftNumber.longValue(), rightNumber.longValue());
}
else {
else if (leftNumber instanceof Integer || rightNumber instanceof Integer) {
// Don't call Integer.compare here - only available on JDK 1.7+
return compare(leftNumber.intValue(), rightNumber.intValue());
}
else if (leftNumber instanceof Short || rightNumber instanceof Short) {
// Don't call Short.compare here - only available on JDK 1.7+
return compare(leftNumber.shortValue(), rightNumber.shortValue());
}
else if (leftNumber instanceof Byte || rightNumber instanceof Byte) {
// Don't call Short.compare here - only available on JDK 1.7+
return compare(leftNumber.byteValue(), rightNumber.byteValue());
}
else {
// Unknown Number subtypes -> best guess is double multiplication
return Double.compare(leftNumber.doubleValue(), rightNumber.doubleValue());
}
}
try {
if (left instanceof Comparable) {
return ((Comparable) left).compareTo(right);
return ((Comparable<Object>) left).compareTo(right);
}
}
catch (ClassCastException ex) {
@ -98,12 +116,20 @@ public class StandardTypeComparator implements TypeComparator {
}
private static int compare(int x, int y) {
return (x < y ? -1 : (x > y ? 1 : 0));
}
private static int compare(long x, long y) {
return (x < y ? -1 : (x > y ? 1 : 0));
}
private static int compare(int x, int y) {
return (x < y ? -1 : (x > y ? 1 : 0));
}
private static int compare(short x, short y) {
return x - y;
}
private static int compare(byte x, byte y) {
return x - y;
}
}