Polishing

Author: jhoeller

spring-expression/src/main/java/org/springframework/expression/TypeComparator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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,30 +17,32 @@
 package org.springframework.expression;
 
 /**
- * Instances of a type comparator should be able to compare pairs of objects for equality, the specification of the
- * return value is the same as for {@link Comparable}.
+ * Instances of a type comparator should be able to compare pairs of objects for equality.
+ * The specification of the return value is the same as for {@link java.lang.Comparable}.
  *
  * @author Andy Clement
  * @since 3.0
+ * @see java.lang.Comparable
  */
 public interface TypeComparator {
 
 	/**
-	 * Compare two objects.
+	 * Return {@code true} if the comparator can compare these two objects.
 	 * @param firstObject the first object
 	 * @param secondObject the second object
-	 * @return 0 if they are equal, <0 if the first is smaller than the second, or >0 if the first is larger than the
-	 * second
-	 * @throws EvaluationException if a problem occurs during comparison (or they are not comparable)
+	 * @return {@code true} if the comparator can compare these objects
 	 */
-	int compare(Object firstObject, Object secondObject) throws EvaluationException;
+	boolean canCompare(Object firstObject, Object secondObject);
 
 	/**
-	 * Return true if the comparator can compare these two objects
+	 * Compare two given objects.
 	 * @param firstObject the first object
 	 * @param secondObject the second object
-	 * @return true if the comparator can compare these objects
+	 * @return 0 if they are equal, <0 if the first is smaller than the second,
+	 * or >0 if the first is larger than the second
+	 * @throws EvaluationException if a problem occurs during comparison
+	 * (or if they are not comparable in the first place)
 	 */
-	boolean canCompare(Object firstObject, Object secondObject);
+	int compare(Object firstObject, Object secondObject) throws EvaluationException;
 
 }

spring-expression/src/main/java/org/springframework/expression/TypeConverter.java

@@ -35,22 +35,23 @@ public interface TypeConverter {
 	 * to the desired target type.
 	 * @param sourceType a type descriptor that describes the source type
 	 * @param targetType a type descriptor that describes the requested result type
-	 * @return true if that conversion can be performed
+	 * @return {@code true} if that conversion can be performed
 	 */
 	boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType);
 
 	/**
-	 * Convert (may coerce) a value from one type to another, for example from a boolean
-	 * to a string. The typeDescriptor parameter enables support for typed collections -
-	 * if the caller really wishes they can have a List<Integer> for example, rather
-	 * than simply a List.
+	 * Convert (or coerce) a value from one type to another, for example from a
+	 * {@code boolean} to a {@code String}.
+	 * <p>The {@link TypeDescriptor} parameters enable support for typed collections:
+	 * A caller may prefer a {@code List&lt;Integer&gt;}, for example, rather than
+	 * simply any {@code List}.
 	 * @param value the value to be converted
 	 * @param sourceType a type descriptor that supplies extra information about the
 	 * source object
 	 * @param targetType a type descriptor that supplies extra information about the
 	 * requested result type
 	 * @return the converted value
-	 * @throws EvaluationException if conversion is not possible
+	 * @throws EvaluationException if conversion failed or is not possible to begin with
 	 */
 	Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType);
 

spring-expression/src/main/java/org/springframework/expression/TypeLocator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2013 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,21 +17,25 @@
 package org.springframework.expression;
 
 /**
- * Implementors of this interface are expected to be able to locate types. They may use custom classloaders
- * or the and deal with common package prefixes (java.lang, etc) however they wish. See
- * {@link org.springframework.expression.spel.support.StandardTypeLocator} for an example implementation.
+ * Implementers of this interface are expected to be able to locate types.
+ * They may use a custom {@link ClassLoader} and/or deal with common
+ * package prefixes (e.g. {@code java.lang}) however they wish.
+ *
+ * <p>See {@link org.springframework.expression.spel.support.StandardTypeLocator}
+ * for an example implementation.
  *
  * @author Andy Clement
  * @since 3.0
  */
 public interface TypeLocator {
 
 	/**
-	 * Find a type by name. The name may or may not be fully qualified (eg. String or java.lang.String)
-	 * @param typename the type to be located
-	 * @return the class object representing that type
-	 * @throws EvaluationException if there is a problem finding it
+	 * Find a type by name. The name may or may not be fully qualified
+	 * (e.g. {@code String} or {@code java.lang.String}).
+	 * @param typeName the type to be located
+	 * @return the {@code Class} object representing that type
+	 * @throws EvaluationException if there is a problem finding the type
 	 */
-	Class<?> findType(String typename) throws EvaluationException;
+	Class<?> findType(String typeName) throws EvaluationException;
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -21,68 +21,78 @@
 import org.springframework.expression.spel.SpelMessage;
 
 /**
- * A simple basic TypeComparator implementation. It supports comparison of numbers and types implementing Comparable.
+ * A simple basic {@link TypeComparator} implementation.
+ * It supports comparison of Numbers and types implementing Comparable.
  *
  * @author Andy Clement
  * @author Juergen Hoeller
  * @since 3.0
  */
 public class StandardTypeComparator implements TypeComparator {
 
+	public boolean canCompare(Object left, Object right) {
+		if (left == null || right == null) {
+			return true;
+		}
+		if (left instanceof Number && right instanceof Number) {
+			return true;
+		}
+		if (left instanceof Comparable) {
+			return true;
+		}
+		return false;
+	}
+
 	@SuppressWarnings("unchecked")
 	public int compare(Object left, Object right) throws SpelEvaluationException {
 		// If one is null, check if the other is
 		if (left == null) {
-			return right == null ? 0 : -1;
-		} else if (right == null) {
-			return 1; // left cannot be null
+			return (right == null ? 0 : -1);
+		}
+		else if (right == null) {
+			return 1;  // left cannot be null at this point
 		}
 
 		// Basic number comparisons
 		if (left instanceof Number && right instanceof Number) {
 			Number leftNumber = (Number) left;
 			Number rightNumber = (Number) right;
+
 			if (leftNumber instanceof Double || rightNumber instanceof Double) {
-				double d1 = leftNumber.doubleValue();
-				double d2 = rightNumber.doubleValue();
-				return Double.compare(d1,d2);
-			} else if (leftNumber instanceof Float || rightNumber instanceof Float) {
-				float f1 = leftNumber.floatValue();
-				float f2 = rightNumber.floatValue();
-				return Float.compare(f1,f2);
-			} else if (leftNumber instanceof Long || rightNumber instanceof Long) {
-				Long l1 = leftNumber.longValue();
-				Long l2 = rightNumber.longValue();
-				return l1.compareTo(l2);
-			} else {
-				Integer i1 = leftNumber.intValue();
-				Integer i2 = rightNumber.intValue();
-				return i1.compareTo(i2);
+				return Double.compare(leftNumber.doubleValue(), rightNumber.doubleValue());
+			}
+			else if (leftNumber instanceof Float || rightNumber instanceof Float) {
+				return Float.compare(leftNumber.floatValue(), rightNumber.floatValue());
+			}
+			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 {
+				// Don't call Integer.compare here - only available on JDK 1.7+
+				return compare(leftNumber.intValue(), rightNumber.intValue());
 			}
 		}
 
 		try {
 			if (left instanceof Comparable) {
 				return ((Comparable) left).compareTo(right);
 			}
-		} catch (ClassCastException cce) {
-			throw new SpelEvaluationException(cce, SpelMessage.NOT_COMPARABLE, left.getClass(), right.getClass());
+		}
+		catch (ClassCastException ex) {
+			throw new SpelEvaluationException(ex, SpelMessage.NOT_COMPARABLE, left.getClass(), right.getClass());
 		}
 
 		throw new SpelEvaluationException(SpelMessage.NOT_COMPARABLE, left.getClass(), right.getClass());
 	}
 
-	public boolean canCompare(Object left, Object right) {
-		if (left == null || right == null) {
-			return true;
-		}
-		if (left instanceof Number && right instanceof Number) {
-			return true;
-		}
-		if (left instanceof Comparable) {
-			return true;
-		}
-		return false;
+
+	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));
 	}
 
 }

spring-expression/src/main/java/org/springframework/expression/spel/support/StandardTypeConverter.java

@@ -18,7 +18,6 @@
 
 import org.springframework.core.convert.ConversionException;
 import org.springframework.core.convert.ConversionService;
-import org.springframework.core.convert.ConverterNotFoundException;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.expression.TypeConverter;
@@ -27,8 +26,8 @@
 import org.springframework.util.Assert;
 
 /**
- * Default implementation of the {@link TypeConverter} interface, delegating to a core
- * Spring {@link ConversionService}.
+ * Default implementation of the {@link TypeConverter} interface,
+ * delegating to a core Spring {@link ConversionService}.
  *
  * @author Juergen Hoeller
  * @author Andy Clement
@@ -42,6 +41,9 @@ public class StandardTypeConverter implements TypeConverter {
 	private final ConversionService conversionService;
 
 
+	/**
+	 * Create a StandardTypeConverter for the default ConversionService.
+	 */
 	public StandardTypeConverter() {
 		synchronized (this) {
 			if (defaultConversionService == null) {
@@ -51,6 +53,10 @@ public StandardTypeConverter() {
 		this.conversionService = defaultConversionService;
 	}
 
+	/**
+	 * Create a StandardTypeConverter for the given ConversionService.
+	 * @param conversionService the ConversionService to delegate to
+	 */
 	public StandardTypeConverter(ConversionService conversionService) {
 		Assert.notNull(conversionService, "ConversionService must not be null");
 		this.conversionService = conversionService;
@@ -65,10 +71,6 @@ public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescript
 		try {
 			return this.conversionService.convert(value, sourceType, targetType);
 		}
-		catch (ConverterNotFoundException ex) {
-			throw new SpelEvaluationException(
-					ex, SpelMessage.TYPE_CONVERSION_ERROR, sourceType.toString(), targetType.toString());
-		}
 		catch (ConversionException ex) {
 			throw new SpelEvaluationException(
 					ex, SpelMessage.TYPE_CONVERSION_ERROR, sourceType.toString(), targetType.toString());