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

renamed TypeDescriptor to BindingPoint 

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@1190 50f2f4bb-b051-0410-bef5-90022cba6387
This commit is contained in:
Keith Donald 2009-05-15 17:30:03 +00:00
parent 948cf56514
commit a2f085d87c
20 changed files with 105 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
org.springframework.context/src/main/java/org/springframework/context/expression/BeanExpressionContextAccessor.java
View File

@ -17,7 +17,7 @@
package org.springframework.context.expression; package org.springframework.context.expression;
import org.springframework.beans.factory.config.BeanExpressionContext; import org.springframework.beans.factory.config.BeanExpressionContext;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.AccessException; import org.springframework.expression.AccessException;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.PropertyAccessor; import org.springframework.expression.PropertyAccessor;

2
org.springframework.context/src/main/java/org/springframework/context/expression/BeanFactoryAccessor.java
View File

@ -17,7 +17,7 @@
package org.springframework.context.expression; package org.springframework.context.expression;
import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactory;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.AccessException; import org.springframework.expression.AccessException;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.PropertyAccessor; import org.springframework.expression.PropertyAccessor;

6
org.springframework.expression/src/main/java/org/springframework/expression/TypeConverter.java
View File

@ -16,7 +16,7 @@
package org.springframework.expression; package org.springframework.expression;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
/** /**
* A type converter can convert values between different types encountered * A type converter can convert values between different types encountered
@ -48,7 +48,7 @@ public interface TypeConverter {
* @return the converted value * @return the converted value
* @throws EvaluationException if conversion is not possible * @throws EvaluationException if conversion is not possible
*/ */
Object convertValue(Object value, TypeDescriptor typeDescriptor) throws EvaluationException; Object convertValue(Object value, BindingPoint typeDescriptor) throws EvaluationException;
/** /**
* Return true if the type converter can convert the specified type to the desired target type. * Return true if the type converter can convert the specified type to the desired target type.
@ -64,6 +64,6 @@ public interface TypeConverter {
* @param typeDescriptor a type descriptor that supplies extra information about the requested result type * @param typeDescriptor a type descriptor that supplies extra information about the requested result type
* @return true if that conversion can be performed * @return true if that conversion can be performed
*/ */
boolean canConvert(Class<?> sourceType, TypeDescriptor typeDescriptor); boolean canConvert(Class<?> sourceType, BindingPoint typeDescriptor);
} }

12
org.springframework.expression/src/main/java/org/springframework/expression/TypedValue.java
View File

@ -15,7 +15,7 @@
*/ */
package org.springframework.expression; package org.springframework.expression;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
/** /**
* Encapsulates an object and a type descriptor that describes it. * Encapsulates an object and a type descriptor that describes it.
@ -28,9 +28,9 @@ import org.springframework.core.convert.TypeDescriptor;
public class TypedValue { public class TypedValue {
private Object value; private Object value;
private TypeDescriptor typeDescriptor; private BindingPoint typeDescriptor;
public static final TypedValue NULL_TYPED_VALUE = new TypedValue(null, TypeDescriptor.NULL_TYPE_DESCRIPTOR); public static final TypedValue NULL_TYPED_VALUE = new TypedValue(null, BindingPoint.NULL_TYPE_DESCRIPTOR);
/** /**
* Create a TypedValue for a simple object. The type descriptor is inferred * Create a TypedValue for a simple object. The type descriptor is inferred
@ -39,7 +39,7 @@ public class TypedValue {
*/ */
public TypedValue(Object value) { public TypedValue(Object value) {
this.value = value; this.value = value;
this.typeDescriptor = TypeDescriptor.forObject(value); this.typeDescriptor = BindingPoint.forObject(value);
} }
/** /**
@ -47,7 +47,7 @@ public class TypedValue {
* @param value the object value * @param value the object value
* @param typeDescriptor a type descriptor describing the type of the value * @param typeDescriptor a type descriptor describing the type of the value
*/ */
public TypedValue(Object value, TypeDescriptor typeDescriptor) { public TypedValue(Object value, BindingPoint typeDescriptor) {
this.value = value; this.value = value;
this.typeDescriptor = typeDescriptor; this.typeDescriptor = typeDescriptor;
} }
@ -56,7 +56,7 @@ public class TypedValue {
return this.value; return this.value;
} }
public TypeDescriptor getTypeDescriptor() { public BindingPoint getTypeDescriptor() {
return this.typeDescriptor; return this.typeDescriptor;
} }

10
org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java
View File

@ -20,7 +20,7 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Stack; import java.util.Stack;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.Operation; import org.springframework.expression.Operation;
@ -99,7 +99,7 @@ public class ExpressionState {
if (value==null) { if (value==null) {
return TypedValue.NULL_TYPED_VALUE; return TypedValue.NULL_TYPED_VALUE;
} else { } else {
return new TypedValue(value,TypeDescriptor.forObject(value)); return new TypedValue(value,BindingPoint.forObject(value));
} }
} }
@ -111,11 +111,11 @@ public class ExpressionState {
return this.relatedContext.getTypeLocator().findType(type); return this.relatedContext.getTypeLocator().findType(type);
} }
public Object convertValue(Object value, TypeDescriptor targetTypeDescriptor) throws EvaluationException { public Object convertValue(Object value, BindingPoint targetTypeDescriptor) throws EvaluationException {
return this.relatedContext.getTypeConverter().convertValue(value, targetTypeDescriptor); return this.relatedContext.getTypeConverter().convertValue(value, targetTypeDescriptor);
} }
public Object convertValue(TypedValue value, TypeDescriptor targetTypeDescriptor) throws EvaluationException { public Object convertValue(TypedValue value, BindingPoint targetTypeDescriptor) throws EvaluationException {
return this.relatedContext.getTypeConverter().convertValue(value.getValue(), targetTypeDescriptor); return this.relatedContext.getTypeConverter().convertValue(value.getValue(), targetTypeDescriptor);
} }
@ -153,7 +153,7 @@ public class ExpressionState {
OperatorOverloader overloader = this.relatedContext.getOperatorOverloader(); OperatorOverloader overloader = this.relatedContext.getOperatorOverloader();
if (overloader.overridesOperation(op, left, right)) { if (overloader.overridesOperation(op, left, right)) {
Object returnValue = overloader.operate(op, left, right); Object returnValue = overloader.operate(op, left, right);
return new TypedValue(returnValue,TypeDescriptor.forObject(returnValue)); return new TypedValue(returnValue,BindingPoint.forObject(returnValue));
} }
else { else {
String leftType = (left==null?"null":left.getClass().getName()); String leftType = (left==null?"null":left.getClass().getName());

24
org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/CommonTypeDescriptors.java
View File

@ -15,7 +15,7 @@
*/ */
package org.springframework.expression.spel.ast; package org.springframework.expression.spel.ast;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
/** /**
* @author Andy Clement * @author Andy Clement
@ -23,16 +23,16 @@ import org.springframework.core.convert.TypeDescriptor;
*/ */
public interface CommonTypeDescriptors { public interface CommonTypeDescriptors {
// TODO push into TypeDescriptor? // TODO push into TypeDescriptor?
static TypeDescriptor BOOLEAN_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Boolean.class); static BindingPoint BOOLEAN_TYPE_DESCRIPTOR = BindingPoint.valueOf(Boolean.class);
static TypeDescriptor INTEGER_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Integer.class); static BindingPoint INTEGER_TYPE_DESCRIPTOR = BindingPoint.valueOf(Integer.class);
static TypeDescriptor CHARACTER_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Character.class); static BindingPoint CHARACTER_TYPE_DESCRIPTOR = BindingPoint.valueOf(Character.class);
static TypeDescriptor LONG_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Long.class); static BindingPoint LONG_TYPE_DESCRIPTOR = BindingPoint.valueOf(Long.class);
static TypeDescriptor SHORT_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Short.class); static BindingPoint SHORT_TYPE_DESCRIPTOR = BindingPoint.valueOf(Short.class);
static TypeDescriptor BYTE_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Byte.class); static BindingPoint BYTE_TYPE_DESCRIPTOR = BindingPoint.valueOf(Byte.class);
static TypeDescriptor FLOAT_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Float.class); static BindingPoint FLOAT_TYPE_DESCRIPTOR = BindingPoint.valueOf(Float.class);
static TypeDescriptor DOUBLE_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Double.class); static BindingPoint DOUBLE_TYPE_DESCRIPTOR = BindingPoint.valueOf(Double.class);
static TypeDescriptor STRING_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(String.class); static BindingPoint STRING_TYPE_DESCRIPTOR = BindingPoint.valueOf(String.class);
static TypeDescriptor CLASS_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Class.class); static BindingPoint CLASS_TYPE_DESCRIPTOR = BindingPoint.valueOf(Class.class);
static TypeDescriptor OBJECT_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(Object.class); static BindingPoint OBJECT_TYPE_DESCRIPTOR = BindingPoint.valueOf(Object.class);
} }

4
org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java
View File

@ -22,7 +22,7 @@ import java.lang.reflect.Modifier;
import org.antlr.runtime.Token; import org.antlr.runtime.Token;
import org.springframework.core.MethodParameter; import org.springframework.core.MethodParameter;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.TypeConverter; import org.springframework.expression.TypeConverter;
import org.springframework.expression.TypedValue; import org.springframework.expression.TypedValue;
@ -104,7 +104,7 @@ public class FunctionReference extends SpelNodeImpl {
try { try {
ReflectionUtils.makeAccessible(m); ReflectionUtils.makeAccessible(m);
Object result = m.invoke(m.getClass(), functionArgs); Object result = m.invoke(m.getClass(), functionArgs);
return new TypedValue(result, new TypeDescriptor(new MethodParameter(m,-1))); return new TypedValue(result, new BindingPoint(new MethodParameter(m,-1)));
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
throw new SpelException(getCharPositionInLine(), e, SpelMessages.EXCEPTION_DURING_FUNCTION_CALL, name, e throw new SpelException(getCharPositionInLine(), e, SpelMessages.EXCEPTION_DURING_FUNCTION_CALL, name, e
.getMessage()); .getMessage());

22
org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java
View File

@ -21,7 +21,7 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import org.antlr.runtime.Token; import org.antlr.runtime.Token;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.TypedValue; import org.springframework.expression.TypedValue;
import org.springframework.expression.spel.ExpressionState; import org.springframework.expression.spel.ExpressionState;
@ -47,15 +47,15 @@ public class Indexer extends SpelNodeImpl {
public TypedValue getValueInternal(ExpressionState state) throws EvaluationException { public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
TypedValue context = state.getActiveContextObject(); TypedValue context = state.getActiveContextObject();
Object targetObject = context.getValue(); Object targetObject = context.getValue();
TypeDescriptor targetObjectTypeDescriptor = context.getTypeDescriptor(); BindingPoint targetObjectTypeDescriptor = context.getTypeDescriptor();
TypedValue indexValue = getChild(0).getValueInternal(state); TypedValue indexValue = getChild(0).getValueInternal(state);
Object index = indexValue.getValue(); Object index = indexValue.getValue();
// Indexing into a Map // Indexing into a Map
if (targetObject instanceof Map) { if (targetObject instanceof Map) {
Object possiblyConvertedKey = state.convertValue(indexValue,TypeDescriptor.valueOf(targetObjectTypeDescriptor.getMapKeyType())); Object possiblyConvertedKey = state.convertValue(indexValue,BindingPoint.valueOf(targetObjectTypeDescriptor.getMapKeyType()));
Object o = ((Map<?, ?>) targetObject).get(possiblyConvertedKey); Object o = ((Map<?, ?>) targetObject).get(possiblyConvertedKey);
return new TypedValue(o,TypeDescriptor.valueOf(targetObjectTypeDescriptor.getMapValueType())); return new TypedValue(o,BindingPoint.valueOf(targetObjectTypeDescriptor.getMapValueType()));
} }
int idx = (Integer)state.convertValue(index, INTEGER_TYPE_DESCRIPTOR); int idx = (Integer)state.convertValue(index, INTEGER_TYPE_DESCRIPTOR);
@ -65,7 +65,7 @@ public class Indexer extends SpelNodeImpl {
} }
if (targetObject.getClass().isArray()) { if (targetObject.getClass().isArray()) {
return new TypedValue(accessArrayElement(targetObject, idx),TypeDescriptor.valueOf(targetObjectTypeDescriptor.getElementType())); return new TypedValue(accessArrayElement(targetObject, idx),BindingPoint.valueOf(targetObjectTypeDescriptor.getElementType()));
} else if (targetObject instanceof Collection) { } else if (targetObject instanceof Collection) {
Collection<?> c = (Collection<?>) targetObject; Collection<?> c = (Collection<?>) targetObject;
if (idx >= c.size()) { if (idx >= c.size()) {
@ -74,7 +74,7 @@ public class Indexer extends SpelNodeImpl {
int pos = 0; int pos = 0;
for (Object o : c) { for (Object o : c) {
if (pos == idx) { if (pos == idx) {
return new TypedValue(o,TypeDescriptor.valueOf(targetObjectTypeDescriptor.getElementType())); return new TypedValue(o,BindingPoint.valueOf(targetObjectTypeDescriptor.getElementType()));
} }
pos++; pos++;
} }
@ -99,7 +99,7 @@ public class Indexer extends SpelNodeImpl {
public void setValue(ExpressionState state, Object newValue) throws EvaluationException { public void setValue(ExpressionState state, Object newValue) throws EvaluationException {
TypedValue contextObject = state.getActiveContextObject(); TypedValue contextObject = state.getActiveContextObject();
Object targetObject = contextObject.getValue(); Object targetObject = contextObject.getValue();
TypeDescriptor targetObjectTypeDescriptor = contextObject.getTypeDescriptor(); BindingPoint targetObjectTypeDescriptor = contextObject.getTypeDescriptor();
TypedValue index = getChild(0).getValueInternal(state); TypedValue index = getChild(0).getValueInternal(state);
if (targetObject == null) { if (targetObject == null) {
@ -108,8 +108,8 @@ public class Indexer extends SpelNodeImpl {
// Indexing into a Map // Indexing into a Map
if (targetObjectTypeDescriptor.isMap()) { if (targetObjectTypeDescriptor.isMap()) {
Map map = (Map)targetObject; Map map = (Map)targetObject;
Object possiblyConvertedKey = state.convertValue(index.getValue(),TypeDescriptor.valueOf(targetObjectTypeDescriptor.getMapKeyType())); Object possiblyConvertedKey = state.convertValue(index.getValue(),BindingPoint.valueOf(targetObjectTypeDescriptor.getMapKeyType()));
Object possiblyConvertedValue = state.convertValue(newValue,TypeDescriptor.valueOf(targetObjectTypeDescriptor.getMapValueType())); Object possiblyConvertedValue = state.convertValue(newValue,BindingPoint.valueOf(targetObjectTypeDescriptor.getMapValueType()));
map.put(possiblyConvertedKey,possiblyConvertedValue); map.put(possiblyConvertedKey,possiblyConvertedValue);
return; return;
} }
@ -125,7 +125,7 @@ public class Indexer extends SpelNodeImpl {
} }
if (targetObject instanceof List) { if (targetObject instanceof List) {
List list = (List)targetObject; List list = (List)targetObject;
Object possiblyConvertedValue = state.convertValue(newValue,TypeDescriptor.valueOf(targetObjectTypeDescriptor.getElementType())); Object possiblyConvertedValue = state.convertValue(newValue,BindingPoint.valueOf(targetObjectTypeDescriptor.getElementType()));
list.set(idx,possiblyConvertedValue); list.set(idx,possiblyConvertedValue);
} else { } else {
throw new SpelException(SpelMessages.INDEXING_NOT_SUPPORTED_FOR_TYPE, contextObject.getClass().getName()); throw new SpelException(SpelMessages.INDEXING_NOT_SUPPORTED_FOR_TYPE, contextObject.getClass().getName());
@ -185,7 +185,7 @@ public class Indexer extends SpelNodeImpl {
} else { } else {
Object[] array = (Object[]) ctx; Object[] array = (Object[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
array[idx] = state.convertValue(newValue, TypeDescriptor.valueOf(clazz)); array[idx] = state.convertValue(newValue, BindingPoint.valueOf(clazz));
} }
} }

4
org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorDivide.java
View File

@ -17,7 +17,7 @@
package org.springframework.expression.spel.ast; package org.springframework.expression.spel.ast;
import org.antlr.runtime.Token; import org.antlr.runtime.Token;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.Operation; import org.springframework.expression.Operation;
import org.springframework.expression.TypedValue; import org.springframework.expression.TypedValue;
@ -56,7 +56,7 @@ public class OperatorDivide extends Operator {
} }
} }
Object result = state.operate(Operation.DIVIDE, operandOne, operandTwo); Object result = state.operate(Operation.DIVIDE, operandOne, operandTwo);
return new TypedValue(result,TypeDescriptor.forObject(result)); return new TypedValue(result,BindingPoint.forObject(result));
} }
} }

8
org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Projection.java
View File

@ -22,7 +22,7 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import org.antlr.runtime.Token; import org.antlr.runtime.Token;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.TypedValue; import org.springframework.expression.TypedValue;
import org.springframework.expression.spel.ExpressionState; import org.springframework.expression.spel.ExpressionState;
@ -60,13 +60,13 @@ public class Projection extends SpelNodeImpl {
List<Object> result = new ArrayList<Object>(); List<Object> result = new ArrayList<Object>();
for (Map.Entry entry : mapdata.entrySet()) { for (Map.Entry entry : mapdata.entrySet()) {
try { try {
state.pushActiveContextObject(new TypedValue(entry,TypeDescriptor.valueOf(Map.Entry.class))); state.pushActiveContextObject(new TypedValue(entry,BindingPoint.valueOf(Map.Entry.class)));
result.add(getChild(0).getValueInternal(state).getValue()); result.add(getChild(0).getValueInternal(state).getValue());
} finally { } finally {
state.popActiveContextObject(); state.popActiveContextObject();
} }
} }
return new TypedValue(result,TypeDescriptor.valueOf(List.class)); // TODO unable to build correct type descriptor return new TypedValue(result,BindingPoint.valueOf(List.class)); // TODO unable to build correct type descriptor
} else if (operand instanceof List) { } else if (operand instanceof List) {
List<Object> data = new ArrayList<Object>(); List<Object> data = new ArrayList<Object>();
data.addAll((Collection<?>) operand); data.addAll((Collection<?>) operand);
@ -74,7 +74,7 @@ public class Projection extends SpelNodeImpl {
int idx = 0; int idx = 0;
for (Object element : data) { for (Object element : data) {
try { try {
state.pushActiveContextObject(new TypedValue(element,TypeDescriptor.valueOf(op.getTypeDescriptor().getType()))); state.pushActiveContextObject(new TypedValue(element,BindingPoint.valueOf(op.getTypeDescriptor().getType())));
state.enterScope("index", idx); state.enterScope("index", idx);
result.add(getChild(0).getValueInternal(state).getValue()); result.add(getChild(0).getValueInternal(state).getValue());
} finally { } finally {

14
org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Selection.java
View File

@ -23,7 +23,7 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import org.antlr.runtime.Token; import org.antlr.runtime.Token;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.TypedValue; import org.springframework.expression.TypedValue;
import org.springframework.expression.spel.ExpressionState; import org.springframework.expression.spel.ExpressionState;
@ -66,7 +66,7 @@ public class Selection extends SpelNodeImpl {
for (Map.Entry entry : mapdata.entrySet()) { for (Map.Entry entry : mapdata.entrySet()) {
try { try {
lastKey = entry.getKey(); lastKey = entry.getKey();
TypedValue kvpair = new TypedValue(entry,TypeDescriptor.valueOf(Map.Entry.class)); TypedValue kvpair = new TypedValue(entry,BindingPoint.valueOf(Map.Entry.class));
state.pushActiveContextObject(kvpair); state.pushActiveContextObject(kvpair);
Object o = selectionCriteria.getValueInternal(state).getValue(); Object o = selectionCriteria.getValueInternal(state).getValue();
if (o instanceof Boolean) { if (o instanceof Boolean) {
@ -86,13 +86,13 @@ public class Selection extends SpelNodeImpl {
} }
} }
if ((variant == FIRST || variant == LAST) && result.size() == 0) { if ((variant == FIRST || variant == LAST) && result.size() == 0) {
return new TypedValue(null,TypeDescriptor.NULL_TYPE_DESCRIPTOR); return new TypedValue(null,BindingPoint.NULL_TYPE_DESCRIPTOR);
} }
if (variant == LAST) { if (variant == LAST) {
Map resultMap = new HashMap(); Map resultMap = new HashMap();
Object lastValue = result.get(lastKey); Object lastValue = result.get(lastKey);
resultMap.put(lastKey,lastValue); resultMap.put(lastKey,lastValue);
return new TypedValue(resultMap,TypeDescriptor.valueOf(Map.class)); return new TypedValue(resultMap,BindingPoint.valueOf(Map.class));
} }
return new TypedValue(result,op.getTypeDescriptor()); return new TypedValue(result,op.getTypeDescriptor());
} else if (operand instanceof Collection) { } else if (operand instanceof Collection) {
@ -102,13 +102,13 @@ public class Selection extends SpelNodeImpl {
int idx = 0; int idx = 0;
for (Object element : data) { for (Object element : data) {
try { try {
state.pushActiveContextObject(new TypedValue(element,TypeDescriptor.valueOf(op.getTypeDescriptor().getElementType()))); state.pushActiveContextObject(new TypedValue(element,BindingPoint.valueOf(op.getTypeDescriptor().getElementType())));
state.enterScope("index", idx); state.enterScope("index", idx);
Object o = selectionCriteria.getValueInternal(state).getValue(); Object o = selectionCriteria.getValueInternal(state).getValue();
if (o instanceof Boolean) { if (o instanceof Boolean) {
if (((Boolean) o).booleanValue() == true) { if (((Boolean) o).booleanValue() == true) {
if (variant == FIRST) { if (variant == FIRST) {
return new TypedValue(element,TypeDescriptor.valueOf(op.getTypeDescriptor().getElementType())); return new TypedValue(element,BindingPoint.valueOf(op.getTypeDescriptor().getElementType()));
} }
result.add(element); result.add(element);
} }
@ -126,7 +126,7 @@ public class Selection extends SpelNodeImpl {
return TypedValue.NULL_TYPED_VALUE; return TypedValue.NULL_TYPED_VALUE;
} }
if (variant == LAST) { if (variant == LAST) {
return new TypedValue(result.get(result.size() - 1),TypeDescriptor.valueOf(op.getTypeDescriptor().getElementType())); return new TypedValue(result.get(result.size() - 1),BindingPoint.valueOf(op.getTypeDescriptor().getElementType()));
} }
return new TypedValue(result,op.getTypeDescriptor()); return new TypedValue(result,op.getTypeDescriptor());
} else { } else {

4
org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorExecutor.java
View File

@ -18,7 +18,7 @@ package org.springframework.expression.spel.support;
import java.lang.reflect.Constructor; import java.lang.reflect.Constructor;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.AccessException; import org.springframework.expression.AccessException;
import org.springframework.expression.ConstructorExecutor; import org.springframework.expression.ConstructorExecutor;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
@ -56,7 +56,7 @@ class ReflectiveConstructorExecutor implements ConstructorExecutor {
if (!c.isAccessible()) { if (!c.isAccessible()) {
c.setAccessible(true); c.setAccessible(true);
} }
return new TypedValue(c.newInstance(arguments),TypeDescriptor.valueOf(c.getClass())); return new TypedValue(c.newInstance(arguments),BindingPoint.valueOf(c.getClass()));
} catch (Exception ex) { } catch (Exception ex) {
throw new AccessException("Problem invoking constructor: " + c, ex); throw new AccessException("Problem invoking constructor: " + c, ex);
} }

4
org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectiveMethodExecutor.java
View File

@ -19,7 +19,7 @@ package org.springframework.expression.spel.support;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import org.springframework.core.MethodParameter; import org.springframework.core.MethodParameter;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.AccessException; import org.springframework.expression.AccessException;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.MethodExecutor; import org.springframework.expression.MethodExecutor;
@ -55,7 +55,7 @@ class ReflectiveMethodExecutor implements MethodExecutor {
arguments = ReflectionHelper.setupArgumentsForVarargsInvocation(this.method.getParameterTypes(), arguments); arguments = ReflectionHelper.setupArgumentsForVarargsInvocation(this.method.getParameterTypes(), arguments);
} }
ReflectionUtils.makeAccessible(this.method); ReflectionUtils.makeAccessible(this.method);
return new TypedValue(this.method.invoke(target, arguments), new TypeDescriptor(new MethodParameter(method,-1))); return new TypedValue(this.method.invoke(target, arguments), new BindingPoint(new MethodParameter(method,-1)));
} catch (Exception ex) { } catch (Exception ex) {
throw new AccessException("Problem invoking method: " + this.method, ex); throw new AccessException("Problem invoking method: " + this.method, ex);
} }

26
org.springframework.expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyResolver.java
View File

@ -25,7 +25,7 @@ import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.springframework.core.MethodParameter; import org.springframework.core.MethodParameter;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.AccessException; import org.springframework.expression.AccessException;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
@ -48,7 +48,7 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
protected final Map<CacheKey, Member> writerCache = new ConcurrentHashMap<CacheKey, Member>(); protected final Map<CacheKey, Member> writerCache = new ConcurrentHashMap<CacheKey, Member>();
protected final Map<CacheKey, TypeDescriptor> typeDescriptorCache = new ConcurrentHashMap<CacheKey,TypeDescriptor>(); protected final Map<CacheKey, BindingPoint> typeDescriptorCache = new ConcurrentHashMap<CacheKey,BindingPoint>();
/** /**
* @return null which means this is a general purpose accessor * @return null which means this is a general purpose accessor
@ -72,14 +72,14 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
Method method = findGetterForProperty(name, type, target instanceof Class); Method method = findGetterForProperty(name, type, target instanceof Class);
if (method != null) { if (method != null) {
this.readerCache.put(cacheKey, method); this.readerCache.put(cacheKey, method);
this.typeDescriptorCache.put(cacheKey, new TypeDescriptor(new MethodParameter(method,-1))); this.typeDescriptorCache.put(cacheKey, new BindingPoint(new MethodParameter(method,-1)));
return true; return true;
} }
else { else {
Field field = findField(name, type, target instanceof Class); Field field = findField(name, type, target instanceof Class);
if (field != null) { if (field != null) {
this.readerCache.put(cacheKey, field); this.readerCache.put(cacheKey, field);
this.typeDescriptorCache.put(cacheKey, new TypeDescriptor(field)); this.typeDescriptorCache.put(cacheKey, new BindingPoint(field));
return true; return true;
} }
} }
@ -96,7 +96,7 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
if (target instanceof Class) { if (target instanceof Class) {
throw new AccessException("Cannot access length on array class itself"); throw new AccessException("Cannot access length on array class itself");
} }
return new TypedValue(Array.getLength(target),TypeDescriptor.valueOf(Integer.TYPE)); return new TypedValue(Array.getLength(target),BindingPoint.valueOf(Integer.TYPE));
} }
CacheKey cacheKey = new CacheKey(type, name); CacheKey cacheKey = new CacheKey(type, name);
@ -114,7 +114,7 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
if (method != null) { if (method != null) {
try { try {
ReflectionUtils.makeAccessible(method); ReflectionUtils.makeAccessible(method);
TypeDescriptor resultTypeDescriptor = new TypeDescriptor(new MethodParameter(method,-1)); BindingPoint resultTypeDescriptor = new BindingPoint(new MethodParameter(method,-1));
return new TypedValue(method.invoke(target),resultTypeDescriptor); return new TypedValue(method.invoke(target),resultTypeDescriptor);
} }
catch (Exception ex) { catch (Exception ex) {
@ -135,7 +135,7 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
if (field != null) { if (field != null) {
try { try {
ReflectionUtils.makeAccessible(field); ReflectionUtils.makeAccessible(field);
return new TypedValue(field.get(target),new TypeDescriptor(field)); return new TypedValue(field.get(target),new BindingPoint(field));
} }
catch (Exception ex) { catch (Exception ex) {
throw new AccessException("Unable to access field: " + name, ex); throw new AccessException("Unable to access field: " + name, ex);
@ -158,14 +158,14 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
Method method = findSetterForProperty(name, type, target instanceof Class); Method method = findSetterForProperty(name, type, target instanceof Class);
if (method != null) { if (method != null) {
this.writerCache.put(cacheKey, method); this.writerCache.put(cacheKey, method);
this.typeDescriptorCache.put(cacheKey, new TypeDescriptor(new MethodParameter(method,0))); this.typeDescriptorCache.put(cacheKey, new BindingPoint(new MethodParameter(method,0)));
return true; return true;
} }
else { else {
Field field = findField(name, type, target instanceof Class); Field field = findField(name, type, target instanceof Class);
if (field != null) { if (field != null) {
this.writerCache.put(cacheKey, field); this.writerCache.put(cacheKey, field);
this.typeDescriptorCache.put(cacheKey, new TypeDescriptor(field)); this.typeDescriptorCache.put(cacheKey, new BindingPoint(field));
return true; return true;
} }
} }
@ -179,7 +179,7 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
Class<?> type = (target instanceof Class ? (Class<?>) target : target.getClass()); Class<?> type = (target instanceof Class ? (Class<?>) target : target.getClass());
Object possiblyConvertedNewValue = newValue; Object possiblyConvertedNewValue = newValue;
TypeDescriptor typeDescriptor = getTypeDescriptor(context, target, name); BindingPoint typeDescriptor = getTypeDescriptor(context, target, name);
if (typeDescriptor != null) { if (typeDescriptor != null) {
try { try {
possiblyConvertedNewValue = context.getTypeConverter().convertValue(newValue, typeDescriptor); possiblyConvertedNewValue = context.getTypeConverter().convertValue(newValue, typeDescriptor);
@ -236,17 +236,17 @@ public class ReflectivePropertyResolver implements PropertyAccessor {
throw new AccessException("Neither setter nor field found for property '" + name + "'"); throw new AccessException("Neither setter nor field found for property '" + name + "'");
} }
private TypeDescriptor getTypeDescriptor(EvaluationContext context, Object target, String name) { private BindingPoint getTypeDescriptor(EvaluationContext context, Object target, String name) {
if (target == null) { if (target == null) {
return null; return null;
} }
Class<?> type = (target instanceof Class ? (Class<?>) target : target.getClass()); Class<?> type = (target instanceof Class ? (Class<?>) target : target.getClass());
if (type.isArray() && name.equals("length")) { if (type.isArray() && name.equals("length")) {
return TypeDescriptor.valueOf(Integer.TYPE); return BindingPoint.valueOf(Integer.TYPE);
} }
CacheKey cacheKey = new CacheKey(type, name); CacheKey cacheKey = new CacheKey(type, name);
TypeDescriptor typeDescriptor = this.typeDescriptorCache.get(cacheKey); BindingPoint typeDescriptor = this.typeDescriptorCache.get(cacheKey);
if (typeDescriptor == null) { if (typeDescriptor == null) {
// attempt to populate the cache entry // attempt to populate the cache entry
try { try {

6
org.springframework.expression/src/main/java/org/springframework/expression/spel/support/StandardEvaluationContext.java
View File

@ -22,7 +22,7 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.ConstructorResolver; import org.springframework.expression.ConstructorResolver;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.MethodResolver; import org.springframework.expression.MethodResolver;
@ -75,10 +75,10 @@ public class StandardEvaluationContext implements EvaluationContext {
} }
public void setRootObject(Object rootObject) { public void setRootObject(Object rootObject) {
this.rootObject = new TypedValue(rootObject,TypeDescriptor.forObject(rootObject)); this.rootObject = new TypedValue(rootObject,BindingPoint.forObject(rootObject));
} }
public void setRootObject(Object rootObject, TypeDescriptor typeDescriptor) { public void setRootObject(Object rootObject, BindingPoint typeDescriptor) {
this.rootObject = new TypedValue(rootObject,typeDescriptor); this.rootObject = new TypedValue(rootObject,typeDescriptor);
} }

14
org.springframework.expression/src/main/java/org/springframework/expression/spel/support/StandardTypeConverter.java
View File

@ -18,8 +18,8 @@ package org.springframework.expression.spel.support;
import org.springframework.core.convert.ConvertException; import org.springframework.core.convert.ConvertException;
import org.springframework.core.convert.ConverterNotFoundException; import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.core.convert.support.DefaultConversionService; import org.springframework.core.convert.support.DefaultTypeConverter;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.TypeConverter; import org.springframework.expression.TypeConverter;
import org.springframework.expression.spel.SpelException; import org.springframework.expression.spel.SpelException;
@ -36,7 +36,7 @@ public class StandardTypeConverter implements TypeConverter {
private org.springframework.core.convert.TypeConverter typeConverter; private org.springframework.core.convert.TypeConverter typeConverter;
public StandardTypeConverter() { public StandardTypeConverter() {
this.typeConverter = new DefaultConversionService(); this.typeConverter = new DefaultTypeConverter();
} }
public StandardTypeConverter(org.springframework.core.convert.TypeConverter typeConverter) { public StandardTypeConverter(org.springframework.core.convert.TypeConverter typeConverter) {
@ -46,11 +46,11 @@ public class StandardTypeConverter implements TypeConverter {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public <T> T convertValue(Object value, Class<T> targetType) throws EvaluationException { public <T> T convertValue(Object value, Class<T> targetType) throws EvaluationException {
return (T) convertValue(value, TypeDescriptor.valueOf(targetType)); return (T) convertValue(value, BindingPoint.valueOf(targetType));
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Object convertValue(Object value, TypeDescriptor typeDescriptor) throws EvaluationException { public Object convertValue(Object value, BindingPoint typeDescriptor) throws EvaluationException {
try { try {
return this.typeConverter.convert(value, typeDescriptor); return this.typeConverter.convert(value, typeDescriptor);
} }
@ -63,10 +63,10 @@ public class StandardTypeConverter implements TypeConverter {
} }
public boolean canConvert(Class<?> sourceType, Class<?> targetType) { public boolean canConvert(Class<?> sourceType, Class<?> targetType) {
return canConvert(sourceType, TypeDescriptor.valueOf(targetType)); return canConvert(sourceType, BindingPoint.valueOf(targetType));
} }
public boolean canConvert(Class<?> sourceType, TypeDescriptor targetType) { public boolean canConvert(Class<?> sourceType, BindingPoint targetType) {
return this.typeConverter.canConvert(sourceType, targetType); return this.typeConverter.canConvert(sourceType, targetType);
} }

6
org.springframework.expression/src/test/java/org/springframework/expression/spel/ExpressionLanguageScenarioTests.java
View File

@ -23,7 +23,7 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.AccessException; import org.springframework.expression.AccessException;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
@ -236,7 +236,7 @@ public class ExpressionLanguageScenarioTests extends ExpressionTestCase {
private static class FruitColourAccessor implements PropertyAccessor { private static class FruitColourAccessor implements PropertyAccessor {
private static Map<String,Color> propertyMap = new HashMap<String,Color>(); private static Map<String,Color> propertyMap = new HashMap<String,Color>();
private static TypeDescriptor mapElementTypeDescriptor = TypeDescriptor.valueOf(Color.class); private static BindingPoint mapElementTypeDescriptor = BindingPoint.valueOf(Color.class);
static { static {
propertyMap.put("banana",Color.yellow); propertyMap.put("banana",Color.yellow);
@ -295,7 +295,7 @@ public class ExpressionLanguageScenarioTests extends ExpressionTestCase {
} }
public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException { public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
return new TypedValue(propertyMap.get(name),TypeDescriptor.valueOf(Color.class)); return new TypedValue(propertyMap.get(name),BindingPoint.valueOf(Color.class));
} }
public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException { public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException {

8
org.springframework.expression/src/test/java/org/springframework/expression/spel/ExpressionStateTests.java
View File

@ -18,7 +18,7 @@ package org.springframework.expression.spel;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.Operation; import org.springframework.expression.Operation;
@ -117,7 +117,7 @@ public class ExpressionStateTests extends ExpressionTestCase {
assertEquals(TypedValue.NULL_TYPED_VALUE,state.getRootContextObject()); assertEquals(TypedValue.NULL_TYPED_VALUE,state.getRootContextObject());
((StandardEvaluationContext)state.getEvaluationContext()).setRootObject(null,TypeDescriptor.NULL_TYPE_DESCRIPTOR); ((StandardEvaluationContext)state.getEvaluationContext()).setRootObject(null,BindingPoint.NULL_TYPE_DESCRIPTOR);
assertEquals(null,state.getRootContextObject().getValue()); assertEquals(null,state.getRootContextObject().getValue());
} }
@ -222,10 +222,10 @@ public class ExpressionStateTests extends ExpressionTestCase {
public void testTypeConversion() throws EvaluationException { public void testTypeConversion() throws EvaluationException {
ExpressionState state = getState(); ExpressionState state = getState();
String s = (String)state.convertValue(34,TypeDescriptor.valueOf(String.class)); String s = (String)state.convertValue(34,BindingPoint.valueOf(String.class));
assertEquals("34",s); assertEquals("34",s);
s = (String)state.convertValue(new TypedValue(34),TypeDescriptor.valueOf(String.class)); s = (String)state.convertValue(new TypedValue(34),BindingPoint.valueOf(String.class));
assertEquals("34",s); assertEquals("34",s);
} }

26
org.springframework.expression/src/test/java/org/springframework/expression/spel/ExpressionTestsUsingCoreConversionService.java
View File

@ -19,25 +19,25 @@ package org.springframework.expression.spel;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.core.convert.support.DefaultConversionService; import org.springframework.core.convert.support.DefaultTypeConverter;
import org.springframework.core.convert.support.GenericConversionService; import org.springframework.core.convert.support.GenericTypeConverter;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
import org.springframework.expression.Expression; import org.springframework.expression.Expression;
import org.springframework.expression.TypeConverter; import org.springframework.expression.TypeConverter;
import org.springframework.expression.spel.support.StandardEvaluationContext; import org.springframework.expression.spel.support.StandardEvaluationContext;
/** /**
* Expression evaluation where the TypeConverter plugged in is the {@link GenericConversionService} * Expression evaluation where the TypeConverter plugged in is the {@link GenericTypeConverter}
* *
* @author Andy Clement * @author Andy Clement
*/ */
public class ExpressionTestsUsingCoreConversionService extends ExpressionTestCase { public class ExpressionTestsUsingCoreConversionService extends ExpressionTestCase {
private static List<String> listOfString = new ArrayList<String>(); private static List<String> listOfString = new ArrayList<String>();
private static TypeDescriptor typeDescriptorForListOfString = null; private static BindingPoint typeDescriptorForListOfString = null;
private static List<Integer> listOfInteger = new ArrayList<Integer>(); private static List<Integer> listOfInteger = new ArrayList<Integer>();
private static TypeDescriptor typeDescriptorForListOfInteger = null; private static BindingPoint typeDescriptorForListOfInteger = null;
static { static {
listOfString.add("1"); listOfString.add("1");
@ -50,8 +50,8 @@ public class ExpressionTestsUsingCoreConversionService extends ExpressionTestCas
public void setUp() throws Exception { public void setUp() throws Exception {
super.setUp(); super.setUp();
typeDescriptorForListOfString = new TypeDescriptor(ExpressionTestsUsingCoreConversionService.class.getDeclaredField("listOfString")); typeDescriptorForListOfString = new BindingPoint(ExpressionTestsUsingCoreConversionService.class.getDeclaredField("listOfString"));
typeDescriptorForListOfInteger = new TypeDescriptor(ExpressionTestsUsingCoreConversionService.class.getDeclaredField("listOfInteger")); typeDescriptorForListOfInteger = new BindingPoint(ExpressionTestsUsingCoreConversionService.class.getDeclaredField("listOfInteger"));
} }
@ -93,23 +93,23 @@ public class ExpressionTestsUsingCoreConversionService extends ExpressionTestCas
*/ */
private static class TypeConvertorUsingConversionService implements TypeConverter { private static class TypeConvertorUsingConversionService implements TypeConverter {
private final DefaultConversionService service = new DefaultConversionService(); private final DefaultTypeConverter service = new DefaultTypeConverter();
public boolean canConvert(Class<?> sourceType, Class<?> targetType) { public boolean canConvert(Class<?> sourceType, Class<?> targetType) {
return this.service.canConvert(sourceType, TypeDescriptor.valueOf(targetType)); return this.service.canConvert(sourceType, BindingPoint.valueOf(targetType));
} }
public boolean canConvert(Class<?> sourceType, TypeDescriptor typeDescriptor) { public boolean canConvert(Class<?> sourceType, BindingPoint typeDescriptor) {
return this.service.canConvert(sourceType, typeDescriptor); return this.service.canConvert(sourceType, typeDescriptor);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public <T> T convertValue(Object value, Class<T> targetType) throws EvaluationException { public <T> T convertValue(Object value, Class<T> targetType) throws EvaluationException {
return (T) this.service.convert(value,TypeDescriptor.valueOf(targetType)); return (T) this.service.convert(value,BindingPoint.valueOf(targetType));
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public Object convertValue(Object value, TypeDescriptor typeDescriptor) throws EvaluationException { public Object convertValue(Object value, BindingPoint typeDescriptor) throws EvaluationException {
return this.service.convert(value, typeDescriptor); return this.service.convert(value, typeDescriptor);
} }
} }

8
org.springframework.expression/src/test/java/org/springframework/expression/spel/ScenariosForSpringSecurity.java
View File

@ -19,7 +19,7 @@ package org.springframework.expression.spel;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import org.springframework.core.MethodParameter; import org.springframework.core.MethodParameter;
import org.springframework.core.convert.TypeDescriptor; import org.springframework.core.convert.BindingPoint;
import org.springframework.expression.AccessException; import org.springframework.expression.AccessException;
import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException; import org.springframework.expression.EvaluationException;
@ -214,7 +214,7 @@ public class ScenariosForSpringSecurity extends ExpressionTestCase {
} }
public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException { public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
return new TypedValue(new Principal(),TypeDescriptor.valueOf(Principal.class)); return new TypedValue(new Principal(),BindingPoint.valueOf(Principal.class));
} }
public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException { public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException {
@ -244,7 +244,7 @@ public class ScenariosForSpringSecurity extends ExpressionTestCase {
} }
public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException { public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
return new TypedValue(activePerson,TypeDescriptor.valueOf(Person.class)); return new TypedValue(activePerson,BindingPoint.valueOf(Person.class));
} }
public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException { public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException {
@ -283,7 +283,7 @@ public class ScenariosForSpringSecurity extends ExpressionTestCase {
if (m.isVarArgs()) { if (m.isVarArgs()) {
args = ReflectionHelper.setupArgumentsForVarargsInvocation(m.getParameterTypes(), args); args = ReflectionHelper.setupArgumentsForVarargsInvocation(m.getParameterTypes(), args);
} }
return new TypedValue(m.invoke(null, args), new TypeDescriptor(new MethodParameter(m,-1))); return new TypedValue(m.invoke(null, args), new BindingPoint(new MethodParameter(m,-1)));
} }
catch (Exception ex) { catch (Exception ex) {
throw new AccessException("Problem invoking hasRole", ex); throw new AccessException("Problem invoking hasRole", ex);