Favor convertValue(Object, TypeDescriptor) where possible and TypedValue(Object); check with Andy on Selection and Projection TypedValue usage

Keith Donald · Keith Donald · commit 71e60f455186 · 2011-01-07T06:32:21.000Z
diff --git a/org.springframework.core/src/main/java/org/springframework/core/convert/support/ConversionUtils.java b/org.springframework.core/src/main/java/org/springframework/core/convert/support/ConversionUtils.java
@@ -16,8 +16,6 @@
 
 package org.springframework.core.convert.support;
 
-import java.util.Map;
-
 import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.converter.GenericConverter;
@@ -43,24 +41,4 @@ public static Object invokeConverter(GenericConverter converter, Object source,
 		}
 	}
 
-	public static TypeDescriptor[] getMapEntryTypes(Map<?, ?> sourceMap) {
-		Class<?> keyType = null;
-		Class<?> valueType = null;
-		for (Object entry : sourceMap.entrySet()) {
-			Map.Entry<?, ?> mapEntry = (Map.Entry<?, ?>) entry;
-			Object key = mapEntry.getKey();
-			if (keyType == null && key != null) {
-				keyType = key.getClass();
-			}
-			Object value = mapEntry.getValue();
-			if (valueType == null && value != null) {
-				valueType = value.getClass();
-			}
-			if (keyType!= null && valueType != null) {
-				break;
-			}
-		}
-		return new TypeDescriptor[] { TypeDescriptor.valueOf(keyType), TypeDescriptor.valueOf(valueType) };
-	}
-
 }
diff --git a/org.springframework.core/src/test/java/org/springframework/core/convert/support/DefaultConversionTests.java b/org.springframework.core/src/test/java/org/springframework/core/convert/support/DefaultConversionTests.java
@@ -457,8 +457,7 @@ public void convertStringToCollection() {
 
 	@Test
 	public void convertStringToCollectionWithElementConversion() throws Exception {
-		List result = (List) conversionService.convert("1,2,3", TypeDescriptor.valueOf(String.class),
-				new TypeDescriptor(getClass().getField("genericList")));
+		List result = (List) conversionService.convert("1,2,3", new TypeDescriptor(getClass().getField("genericList")));
 		assertEquals(3, result.size());
 		assertEquals(new Integer(1), result.get(0));
 		assertEquals(new Integer(2), result.get(1));
@@ -494,8 +493,7 @@ public void convertObjectToCollection() {
 
 	@Test
 	public void convertObjectToCollectionWithElementConversion() throws Exception {
-		List<Integer> result = (List<Integer>) conversionService.convert(3L, TypeDescriptor.valueOf(Long.class),
-				new TypeDescriptor(getClass().getField("genericList")));
+		List<Integer> result = (List<Integer>) conversionService.convert(3L, new TypeDescriptor(getClass().getField("genericList")));
 		assertEquals(1, result.size());
 		assertEquals(new Integer(3), result.get(0));
 	}
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/TypeConverter.java b/org.springframework.expression/src/main/java/org/springframework/expression/TypeConverter.java
@@ -49,5 +49,9 @@ public interface TypeConverter {
 	 * @throws EvaluationException if conversion is not possible
 	 */
 	Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType);
+
+	// 3.1 additions for encapsulation of TypeDescriptor.forObject(value);
+	
+	Object convertValue(Object value, TypeDescriptor targetType);
 	
 }
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java
@@ -141,7 +141,7 @@ public Object convertValue(Object value, TypeDescriptor targetTypeDescriptor) th
 	}
 	
 	public Object convertValue(TypedValue value, TypeDescriptor targetTypeDescriptor) throws EvaluationException {
-		return this.relatedContext.getTypeConverter().convertValue(value.getValue(), TypeDescriptor.forObject(value.getValue()), targetTypeDescriptor);
+		return this.relatedContext.getTypeConverter().convertValue(value.getValue(), targetTypeDescriptor);
 	}
 
 	/*
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java
@@ -322,8 +322,7 @@ private void populateReferenceTypeArray(ExpressionState state, Object newArray,
 		for (int i = 0; i < newObjectArray.length; i++) {
 			SpelNode elementNode = initializer.getChild(i);
 			Object arrayEntry = elementNode.getValue(state);
-			newObjectArray[i] = typeConverter.convertValue(arrayEntry, TypeDescriptor.forObject(arrayEntry),
-					toTypeDescriptor);
+			newObjectArray[i] = typeConverter.convertValue(arrayEntry, toTypeDescriptor);
 		}
 	}
 
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Projection.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Projection.java
@@ -23,7 +23,6 @@
 import java.util.List;
 import java.util.Map;
 
-import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.expression.EvaluationException;
 import org.springframework.expression.TypedValue;
 import org.springframework.expression.spel.ExpressionState;
@@ -85,7 +84,7 @@ else if (operand instanceof Collection || operandIsArray) {
 			Class<?> arrayElementType = null;
 			for (Object element : data) {
 				try {
-					state.pushActiveContextObject(new TypedValue(element ,TypeDescriptor.valueOf(op.getTypeDescriptor().getType())));
+					state.pushActiveContextObject(new TypedValue(element));
 					state.enterScope("index", idx);
 					Object value = children[0].getValueInternal(state).getValue();
 					if (value != null && operandIsArray) {
@@ -105,9 +104,9 @@ else if (operand instanceof Collection || operandIsArray) {
 				}
 				Object resultArray = Array.newInstance(arrayElementType, result.size());
 				System.arraycopy(result.toArray(), 0, resultArray, 0, result.size());
-				return new TypedValue(resultArray, op.getTypeDescriptor());
+				return new TypedValue(resultArray);
 			}
-			return new TypedValue(result, op.getTypeDescriptor());
+			return new TypedValue(result);
 		}
 		else {
 			if (operand==null) {
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Selection.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Selection.java
@@ -24,7 +24,6 @@
 import java.util.List;
 import java.util.Map;
 
-import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.expression.EvaluationException;
 import org.springframework.expression.TypedValue;
 import org.springframework.expression.spel.ExpressionState;
@@ -101,9 +100,9 @@ public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
 				Map resultMap = new HashMap();
 				Object lastValue = result.get(lastKey);
 				resultMap.put(lastKey,lastValue);
-				return new TypedValue(resultMap,TypeDescriptor.valueOf(Map.class));
+				return new TypedValue(resultMap);
 			}
-			return new TypedValue(result,op.getTypeDescriptor());
+			return new TypedValue(result);
 		} else if ((operand instanceof Collection) || ObjectUtils.isArray(operand)) {
 			List<Object> data = new ArrayList<Object>();
 			Collection<?> c = (operand instanceof Collection) ?
@@ -113,13 +112,13 @@ public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
 			int idx = 0;
 			for (Object element : data) {
 				try {
-					state.pushActiveContextObject(new TypedValue(element, op.getTypeDescriptor().getElementTypeDescriptor()));
+					state.pushActiveContextObject(new TypedValue(element));
 					state.enterScope("index", idx);
 					Object o = selectionCriteria.getValueInternal(state).getValue();
 					if (o instanceof Boolean) {
 						if (((Boolean) o).booleanValue() == true) {
 							if (variant == FIRST) {
-								return new TypedValue(element, op.getTypeDescriptor().getElementTypeDescriptor());
+								return new TypedValue(element);
 							}
 							result.add(element);
 						}
@@ -137,16 +136,16 @@ public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
 				return TypedValue.NULL;
 			}
 			if (variant == LAST) {
-				return new TypedValue(result.get(result.size() - 1), op.getTypeDescriptor().getElementTypeDescriptor());
+				return new TypedValue(result.get(result.size() - 1));
 			}
 			if (operand instanceof Collection) {
-				return new TypedValue(result,op.getTypeDescriptor());
+				return new TypedValue(result);
 			}
 			else {
 				Class<?> elementType = ClassUtils.resolvePrimitiveIfNecessary(op.getTypeDescriptor().getElementType());
 				Object resultArray = Array.newInstance(elementType, result.size());
 				System.arraycopy(result.toArray(), 0, resultArray, 0, result.size());
-				return new TypedValue(resultArray, op.getTypeDescriptor());
+				return new TypedValue(resultArray);
 			}
 		} else {
 			if (operand==null) {
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java
@@ -241,8 +241,7 @@ static void convertArguments(TypeConverter converter, Object[] arguments, Object
 			else {
 				targetType = new TypeDescriptor(MethodParameter.forMethodOrConstructor(methodOrCtor, argPosition));
 			}
-			arguments[argPosition] = converter.convertValue(
-					arguments[argPosition], TypeDescriptor.forObject(arguments[argPosition]), targetType);
+			arguments[argPosition] = converter.convertValue(arguments[argPosition], targetType);
 		}
 	}
 
@@ -279,7 +278,7 @@ public static void convertAllArguments(TypeConverter converter, Object[] argumen
 					if (converter == null) {
 						throw new SpelEvaluationException(SpelMessage.TYPE_CONVERSION_ERROR, argument.getClass().getName(), targetType);
 					}
-					arguments[argPosition] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
+					arguments[argPosition] = converter.convertValue(argument, targetType);
 				}
 			}
 			catch (EvaluationException ex) {
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java
@@ -218,7 +218,7 @@ public void write(EvaluationContext context, Object target, String name, Object
 		TypeDescriptor typeDescriptor = getTypeDescriptor(context, target, name);
 		if (typeDescriptor != null) {
 			try {
-				possiblyConvertedNewValue = context.getTypeConverter().convertValue(newValue, TypeDescriptor.forObject(newValue), typeDescriptor);
+				possiblyConvertedNewValue = context.getTypeConverter().convertValue(newValue, typeDescriptor);
 			}
 			catch (EvaluationException evaluationException) {
 				throw new AccessException("Type conversion failure",evaluationException);
diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/support/StandardTypeConverter.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/support/StandardTypeConverter.java
@@ -75,4 +75,8 @@ public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescript
 		}
 	}
 
+	public Object convertValue(Object value, TypeDescriptor targetType) {
+		return convertValue(value, TypeDescriptor.forObject(value), targetType);
+	}	
+
 }
diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/ExpressionTestsUsingCoreConversionService.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/ExpressionTestsUsingCoreConversionService.java
@@ -121,8 +121,7 @@ public int sum(Collection<Integer> numbers) {
 		assertTrue(evaluationContext.getTypeConverter()
 				.canConvert(TypeDescriptor.valueOf(String.class), collectionType));
 		// ... and it can be done successfully
-		assertEquals("[1, 2, 3, 4]", evaluationContext.getTypeConverter().convertValue("1,2,3,4",
-				TypeDescriptor.valueOf(String.class), collectionType).toString());
+		assertEquals("[1, 2, 3, 4]", evaluationContext.getTypeConverter().convertValue("1,2,3,4", collectionType).toString());
 
 
 		evaluationContext.setVariable("target", new TestTarget());
@@ -153,6 +152,7 @@ public boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)
 		public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) throws EvaluationException {
 			return this.service.convert(value, sourceType, targetType);
 		}
+		
 	}
 
 }
diff --git a/org.springframework.integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java b/org.springframework.integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java
@@ -87,5 +87,10 @@ public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescript
 		}
 		return delegate.convertIfNecessary(value, targetType.getType());
 	}
+	
+	public Object convertValue(Object value, TypeDescriptor targetType) {
+		return convertValue(value, TypeDescriptor.forObject(value), targetType);
+	}	
+
 
 }

Original file line number	Diff line number	Diff line change
`@@ -49,5 +49,9 @@ public interface TypeConverter {`
`49`	`49`	`* @throws EvaluationException if conversion is not possible`
`50`	`50`	`*/`
`51`	`51`	`Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType);`
	`52`	`+`
	`53`	`+ // 3.1 additions for encapsulation of TypeDescriptor.forObject(value);`
	`54`	`+`
	`55`	`+ Object convertValue(Object value, TypeDescriptor targetType);`
`52`	`56`
`53`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ public Object convertValue(Object value, TypeDescriptor targetTypeDescriptor) th`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`public Object convertValue(TypedValue value, TypeDescriptor targetTypeDescriptor) throws EvaluationException {`
`144`		`- return this.relatedContext.getTypeConverter().convertValue(value.getValue(), TypeDescriptor.forObject(value.getValue()), targetTypeDescriptor);`
	`144`	`+ return this.relatedContext.getTypeConverter().convertValue(value.getValue(), targetTypeDescriptor);`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`/*`
Original file line number	Diff line number	Diff line change
`@@ -322,8 +322,7 @@ private void populateReferenceTypeArray(ExpressionState state, Object newArray,`
`322`	`322`	`for (int i = 0; i < newObjectArray.length; i++) {`
`323`	`323`	`SpelNode elementNode = initializer.getChild(i);`
`324`	`324`	`Object arrayEntry = elementNode.getValue(state);`
`325`		`- newObjectArray[i] = typeConverter.convertValue(arrayEntry, TypeDescriptor.forObject(arrayEntry),`
`326`		`- toTypeDescriptor);`
	`325`	`+ newObjectArray[i] = typeConverter.convertValue(arrayEntry, toTypeDescriptor);`
`327`	`326`	`}`
`328`	`327`	`}`
`329`	`328`
Original file line number	Diff line number	Diff line change
`@@ -241,8 +241,7 @@ static void convertArguments(TypeConverter converter, Object[] arguments, Object`
`241`	`241`	`else {`
`242`	`242`	`targetType = new TypeDescriptor(MethodParameter.forMethodOrConstructor(methodOrCtor, argPosition));`
`243`	`243`	`}`
`244`		`- arguments[argPosition] = converter.convertValue(`
`245`		`- arguments[argPosition], TypeDescriptor.forObject(arguments[argPosition]), targetType);`
	`244`	`+ arguments[argPosition] = converter.convertValue(arguments[argPosition], targetType);`
`246`	`245`	`}`
`247`	`246`	`}`
`248`	`247`
`@@ -279,7 +278,7 @@ public static void convertAllArguments(TypeConverter converter, Object[] argumen`
`279`	`278`	`if (converter == null) {`
`280`	`279`	`throw new SpelEvaluationException(SpelMessage.TYPE_CONVERSION_ERROR, argument.getClass().getName(), targetType);`
`281`	`280`	`}`
`282`		`- arguments[argPosition] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);`
	`281`	`+ arguments[argPosition] = converter.convertValue(argument, targetType);`
`283`	`282`	`}`
`284`	`283`	`}`
`285`	`284`	`catch (EvaluationException ex) {`
Original file line number	Diff line number	Diff line change
`@@ -218,7 +218,7 @@ public void write(EvaluationContext context, Object target, String name, Object`
`218`	`218`	`TypeDescriptor typeDescriptor = getTypeDescriptor(context, target, name);`
`219`	`219`	`if (typeDescriptor != null) {`
`220`	`220`	`try {`
`221`		`- possiblyConvertedNewValue = context.getTypeConverter().convertValue(newValue, TypeDescriptor.forObject(newValue), typeDescriptor);`
	`221`	`+ possiblyConvertedNewValue = context.getTypeConverter().convertValue(newValue, typeDescriptor);`
`222`	`222`	`}`
`223`	`223`	`catch (EvaluationException evaluationException) {`
`224`	`224`	`throw new AccessException("Type conversion failure",evaluationException);`
Original file line number	Diff line number	Diff line change
`@@ -75,4 +75,8 @@ public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescript`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
	`78`	`+ public Object convertValue(Object value, TypeDescriptor targetType) {`
	`79`	`+ return convertValue(value, TypeDescriptor.forObject(value), targetType);`
	`80`	`+ }`
	`81`	`+`
`78`	`82`	`}`