revised core conversion package for BeanWrapper/BeanFactory integration

Author: jhoeller

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

@@ -20,24 +20,23 @@
 
 /**
  * A type converter can convert values between different types encountered
- * during expression evaluation.
+ * during expression evaluation. This is an SPI for the expression parser;
+ * see {@link org.springframework.core.convert.ConversionService} for the
+ * primary user API to Spring's conversion facilities.
  *
  * @author Andy Clement
+ * @author Juergen Hoeller
  * @since 3.0
  */
 public interface TypeConverter {
-	// TODO replace this stuff with Keiths spring-binding conversion code
-	// TODO should ExpressionException be thrown for lost precision in the case of coercion?
-	// TODO could remove the methods where the target is Class and just keep the TypeDescriptor variants
 
 	/**
-	 * Convert (may coerce) a value from one type to another, for example from a boolean to a string.
-	 * @param value the value to be converted
-	 * @param targetType the type that the value should be converted to if possible
-	 * @return the converted value
-	 * @throws EvaluationException if conversion is not possible
+	 * Return true if the type converter can convert the specified type to the desired target type.
+	 * @param sourceType the type to be converted from
+	 * @param targetType the type to be converted to
+	 * @return true if that conversion can be performed
 	 */
-	<T> T convertValue(Object value, Class<T> targetType) throws EvaluationException;
+	boolean canConvert(Class<?> sourceType, Class<?> targetType);
 
 	/**
 	 * Convert (may coerce) a value from one type to another, for example from a boolean to a string.
@@ -50,20 +49,4 @@ public interface TypeConverter {
 	 */
 	Object convertValue(Object value, TypeDescriptor typeDescriptor) throws EvaluationException;
 
-	/**
-	 * Return true if the type converter can convert the specified type to the desired target type.
-	 * @param sourceType the type to be converted from
-	 * @param targetType the type to be converted to
-	 * @return true if that conversion can be performed
-	 */
-	boolean canConvert(Class<?> sourceType, Class<?> targetType);
-
-	/**
-	 * Return true if the type converter can convert the specified type to the desired target type.
-	 * @param sourceType the type to be converted from
-	 * @param typeDescriptor a type descriptor that supplies extra information about the requested result type
-	 * @return true if that conversion can be performed
-	 */
-	boolean canConvert(Class<?> sourceType, TypeDescriptor typeDescriptor);
-
 }

org.springframework.expression/src/main/java/org/springframework/expression/common/ExpressionUtils.java

@@ -16,6 +16,7 @@
 
 package org.springframework.expression.common;
 
+import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.expression.EvaluationContext;
 import org.springframework.expression.EvaluationException;
 import org.springframework.util.ClassUtils;
@@ -47,7 +48,7 @@ public static <T> T convert(EvaluationContext context, Object value, Class<T> ta
 			return (T) value;
 		}
 		if (context != null) {
-			return context.getTypeConverter().convertValue(value, targetType);
+			return (T) context.getTypeConverter().convertValue(value, TypeDescriptor.valueOf(targetType));
 		}
 		throw new EvaluationException("Cannot convert value '" + value + "' to type '" + targetType.getName() + "'");
 	}

org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpression.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2004-2008 the original author or authors.
+ * Copyright 2002-2009 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.
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.expression.spel;
 
 import org.springframework.core.convert.TypeDescriptor;
@@ -74,7 +75,7 @@ public <T> T getValue(EvaluationContext context, Class<T> expectedResultType) th
 			Class<?> resultType = result.getClass();
 			if (!expectedResultType.isAssignableFrom(resultType)) {
 				// Attempt conversion to the requested type, may throw an exception
-				result = context.getTypeConverter().convertValue(result, expectedResultType);
+				result = context.getTypeConverter().convertValue(result, TypeDescriptor.valueOf(expectedResultType));
 			}
 		}
 		return (T) result;
@@ -98,8 +99,7 @@ public TypeDescriptor getValueTypeDescriptor() throws EvaluationException {
 	public TypeDescriptor getValueTypeDescriptor(EvaluationContext context) throws EvaluationException {
 		Assert.notNull(context, "The EvaluationContext is required");
 		ExpressionState eState = new ExpressionState(context, configuration);
-		TypeDescriptor typeDescriptor = ast.getValueInternal(eState).getTypeDescriptor();
-		return typeDescriptor;
+		return ast.getValueInternal(eState).getTypeDescriptor();
 	}
 
 	public String getExpressionString() {

org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/CommonTypeDescriptors.java

@@ -55,7 +55,7 @@ public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
 		if (targetObject instanceof Map && (children[0] instanceof PropertyOrFieldReference)) {
 			PropertyOrFieldReference reference = (PropertyOrFieldReference)children[0];
 			index = reference.getName();
-			indexValue = new TypedValue(index,CommonTypeDescriptors.STRING_TYPE_DESCRIPTOR);
+			indexValue = new TypedValue(index, TypeDescriptor.valueOf(String.class));
 		} else {
 			// In case the map key is unqualified, we want it evaluated against the root object so 
 			// temporarily push that on whilst evaluating the key
@@ -85,7 +85,7 @@ public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
 			}
 			Object o = ((Map<?, ?>) targetObject).get(possiblyConvertedKey);
 			TypeDescriptor resultDescriptor = targetObjectTypeDescriptor.isMapEntryTypeKnown()?
-					TypeDescriptor.valueOf(targetObjectTypeDescriptor.getMapValueType()):CommonTypeDescriptors.OBJECT_TYPE_DESCRIPTOR;
+					TypeDescriptor.valueOf(targetObjectTypeDescriptor.getMapValueType()): TypeDescriptor.valueOf(Object.class);
 			return new TypedValue(o,resultDescriptor);
 		}
 

org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java

@@ -24,15 +24,28 @@
 import org.springframework.expression.spel.SpelMessage;
 import org.springframework.expression.spel.SpelNode;
 import org.springframework.expression.spel.support.StandardEvaluationContext;
+import org.springframework.core.convert.TypeDescriptor;
 
 /**
  * The common supertype of all AST nodes in a parsed Spring Expression Language format expression.
  *
  * @author Andy Clement
  * @since 3.0
  */
-public abstract class SpelNodeImpl implements SpelNode, CommonTypeDescriptors {
-	
+public abstract class SpelNodeImpl implements SpelNode {
+
+	static TypeDescriptor BOOLEAN_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Boolean.class);
+	static TypeDescriptor INTEGER_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Integer.class);
+	static TypeDescriptor CHARACTER_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Character.class);
+	static TypeDescriptor LONG_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Long.class);
+	static TypeDescriptor SHORT_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Short.class);
+	static TypeDescriptor BYTE_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Byte.class);
+	static TypeDescriptor FLOAT_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Float.class);
+	static TypeDescriptor DOUBLE_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Double.class);
+	static TypeDescriptor STRING_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(String.class);
+	static TypeDescriptor CLASS_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Class.class);
+	static TypeDescriptor OBJECT_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Object.class);
+
 	private static SpelNodeImpl[] NO_CHILDREN = new SpelNodeImpl[0];
 
 	protected int pos; // start = top 16bits, end = bottom 16bits

org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/SpelNodeImpl.java

@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.expression.spel.support;
 
 import org.springframework.expression.TypedValue;
-import org.springframework.expression.spel.ast.CommonTypeDescriptors;
+import org.springframework.core.convert.TypeDescriptor;
 
 /**
  * @author Andy Clement
@@ -28,7 +29,7 @@ public class BooleanTypedValue extends TypedValue {
 	public static final BooleanTypedValue False = new BooleanTypedValue(false);
 
 	private BooleanTypedValue(boolean b) {
-		super(b,CommonTypeDescriptors.BOOLEAN_TYPE_DESCRIPTOR);
+		super(b, TypeDescriptor.valueOf(Boolean.class));
 	}
 
 	public static BooleanTypedValue forValue(boolean b) {

org.springframework.expression/src/main/java/org/springframework/expression/spel/support/BooleanTypedValue.java

@@ -20,6 +20,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.expression.EvaluationException;
 import org.springframework.expression.TypeConverter;
 import org.springframework.expression.spel.SpelEvaluationException;
@@ -228,7 +229,7 @@ public static void convertArguments(Class[] requiredParameterTypes, boolean isVa
 			} else {
 				targetType = requiredParameterTypes[argPosition];
 			}
-			arguments[argPosition] = converter.convertValue(arguments[argPosition], targetType);
+			arguments[argPosition] = converter.convertValue(arguments[argPosition], TypeDescriptor.valueOf(targetType));
 		}
 	}
 
@@ -267,7 +268,7 @@ public static void convertAllArguments(Class[] parameterTypes, boolean isVarargs
 					if (converter == null) {
 						throw new SpelEvaluationException(SpelMessage.TYPE_CONVERSION_ERROR, arguments[i].getClass().getName(),targetType);
 					}
-					arguments[i] = converter.convertValue(arguments[i], targetType);
+					arguments[i] = converter.convertValue(arguments[i], TypeDescriptor.valueOf(targetType));
 				}
 			} catch (EvaluationException ex) {
 				// allows for another type converter throwing a different kind of EvaluationException

org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java

@@ -23,6 +23,7 @@
 import org.springframework.expression.ConstructorExecutor;
 import org.springframework.expression.EvaluationContext;
 import org.springframework.expression.TypedValue;
+import org.springframework.util.ReflectionUtils;
 
 /**
  * A simple ConstructorExecutor implementation that runs a constructor using reflective invocation.
@@ -32,33 +33,35 @@
  */
 class ReflectiveConstructorExecutor implements ConstructorExecutor {
 
-	private final Constructor<?> c;
+	private final Constructor<?> ctor;
 
 	// When the constructor was found, we will have determined if arguments need to be converted for it
 	// to be invoked. Conversion won't be cheap so let's only do it if necessary.
 	private final int[] argsRequiringConversion;
 
 
-	public ReflectiveConstructorExecutor(Constructor<?> constructor, int[] argsRequiringConversion) {
-		c = constructor;
+	public ReflectiveConstructorExecutor(Constructor<?> ctor, int[] argsRequiringConversion) {
+		this.ctor = ctor;
 		this.argsRequiringConversion = argsRequiringConversion;
 	}
 
 	public TypedValue execute(EvaluationContext context, Object... arguments) throws AccessException {
 		try {
 			if (argsRequiringConversion != null && arguments != null) {
-				ReflectionHelper.convertArguments(c.getParameterTypes(), c.isVarArgs(),
-						context.getTypeConverter(), argsRequiringConversion, arguments);
+				ReflectionHelper.convertArguments(this.ctor.getParameterTypes(),
+						this.ctor.isVarArgs(), context.getTypeConverter(),
+						this.argsRequiringConversion, arguments);
 			}
-			if (c.isVarArgs()) {
-				arguments = ReflectionHelper.setupArgumentsForVarargsInvocation(c.getParameterTypes(), arguments);
+			if (this.ctor.isVarArgs()) {
+				arguments = ReflectionHelper.setupArgumentsForVarargsInvocation(
+						this.ctor.getParameterTypes(), arguments);
 			}
-			if (!c.isAccessible()) {
-				c.setAccessible(true);
-			}
-			return new TypedValue(c.newInstance(arguments),TypeDescriptor.valueOf(c.getClass()));
-		} catch (Exception ex) {
-			throw new AccessException("Problem invoking constructor: " + c, ex);
+			ReflectionUtils.makeAccessible(this.ctor);
+			return new TypedValue(this.ctor.newInstance(arguments),
+					TypeDescriptor.valueOf(this.ctor.getClass()));
+		}
+		catch (Exception ex) {
+			throw new AccessException("Problem invoking constructor: " + this.ctor, ex);
 		}
 	}
 

org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorExecutor.java

@@ -16,58 +16,55 @@
 
 package org.springframework.expression.spel.support;
 
-import org.springframework.core.convert.ConvertException;
+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.DefaultTypeConverter;
+import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.expression.EvaluationException;
 import org.springframework.expression.TypeConverter;
 import org.springframework.expression.spel.SpelEvaluationException;
 import org.springframework.expression.spel.SpelMessage;
 import org.springframework.util.Assert;
 
 /**
+ * Default implementation of the {@link TypeConverter} interface,
+ * delegating to a core Spring {@link ConversionService}.
+ *
  * @author Juergen Hoeller
  * @author Andy Clement
  * @since 3.0
+ * @see org.springframework.core.convert.ConversionService
  */
 public class StandardTypeConverter implements TypeConverter {
 
-	private org.springframework.core.convert.TypeConverter typeConverter;
-	
+	private final ConversionService typeConverter;
+
+
 	public StandardTypeConverter() {
-		this.typeConverter = new DefaultTypeConverter();
+		this.typeConverter = new DefaultConversionService();
 	}
 
-	public StandardTypeConverter(org.springframework.core.convert.TypeConverter typeConverter) {
-		Assert.notNull(typeConverter, "TypeConverter must not be null");
+	public StandardTypeConverter(ConversionService typeConverter) {
+		Assert.notNull(typeConverter, "ConversionService must not be null");
 		this.typeConverter = typeConverter;
 	}
 
-	@SuppressWarnings("unchecked")
-	public <T> T convertValue(Object value, Class<T> targetType) throws EvaluationException {
-		return (T) convertValue(value, TypeDescriptor.valueOf(targetType));
+
+	public boolean canConvert(Class<?> sourceType, Class<?> targetType) {
+		return this.typeConverter.canConvert(sourceType, targetType);
 	}
 
-	@SuppressWarnings("unchecked")
 	public Object convertValue(Object value, TypeDescriptor typeDescriptor) throws EvaluationException {
 		try {
 			return this.typeConverter.convert(value, typeDescriptor);
 		}
 		catch (ConverterNotFoundException cenfe) {
 			throw new SpelEvaluationException(cenfe, SpelMessage.TYPE_CONVERSION_ERROR, value.getClass(), typeDescriptor.asString());
 		}
-		catch (ConvertException ce) {
+		catch (ConversionException ce) {
 			throw new SpelEvaluationException(ce, SpelMessage.TYPE_CONVERSION_ERROR, value.getClass(), typeDescriptor.asString());
 		}
 	}
 
-	public boolean canConvert(Class<?> sourceType, Class<?> targetType) {
-		return canConvert(sourceType, TypeDescriptor.valueOf(targetType));
-	}
-
-	public boolean canConvert(Class<?> sourceType, TypeDescriptor targetType) {
-		return this.typeConverter.canConvert(sourceType, targetType);
-	}
-
 }