Examples with TypeDescriptor org.springframework.core.convert.TypeDescriptor used on opensource projects

Example 21 with TypeDescriptor

use of org.springframework.core.convert.TypeDescriptor in project spring-framework by spring-projects.

the class ReflectionHelper method convertArguments.

/**
	 * Takes an input set of argument values and converts them to the types specified as the
	 * required parameter types. The arguments are converted 'in-place' in the input array.
	 * @param converter the type converter to use for attempting conversions
	 * @param arguments the actual arguments that need conversion
	 * @param executable the target Method or Constructor
	 * @param varargsPosition the known position of the varargs argument, if any
	 * ({@code null} if not varargs)
	 * @return {@code true} if some kind of conversion occurred on an argument
	 * @throws EvaluationException if a problem occurs during conversion
	 */
static boolean convertArguments(TypeConverter converter, Object[] arguments, Executable executable, Integer varargsPosition) throws EvaluationException {
    boolean conversionOccurred = false;
    if (varargsPosition == null) {
        for (int i = 0; i < arguments.length; i++) {
            TypeDescriptor targetType = new TypeDescriptor(MethodParameter.forExecutable(executable, i));
            Object argument = arguments[i];
            arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
            conversionOccurred |= (argument != arguments[i]);
        }
    } else {
        // Convert everything up to the varargs position
        for (int i = 0; i < varargsPosition; i++) {
            TypeDescriptor targetType = new TypeDescriptor(MethodParameter.forExecutable(executable, i));
            Object argument = arguments[i];
            arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
            conversionOccurred |= (argument != arguments[i]);
        }
        MethodParameter methodParam = MethodParameter.forExecutable(executable, varargsPosition);
        if (varargsPosition == arguments.length - 1) {
            // If the target is varargs and there is just one more argument
            // then convert it here
            TypeDescriptor targetType = new TypeDescriptor(methodParam);
            Object argument = arguments[varargsPosition];
            TypeDescriptor sourceType = TypeDescriptor.forObject(argument);
            arguments[varargsPosition] = converter.convertValue(argument, sourceType, targetType);
            // 3) the input argument was the wrong type and got converted and put into an array
            if (argument != arguments[varargsPosition] && !isFirstEntryInArray(argument, arguments[varargsPosition])) {
                // case 3
                conversionOccurred = true;
            }
        } else {
            // Convert remaining arguments to the varargs element type
            TypeDescriptor targetType = new TypeDescriptor(methodParam).getElementTypeDescriptor();
            for (int i = varargsPosition; i < arguments.length; i++) {
                Object argument = arguments[i];
                arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType);
                conversionOccurred |= (argument != arguments[i]);
            }
        }
    }
    return conversionOccurred;
}

Example 22 with TypeDescriptor

use of org.springframework.core.convert.TypeDescriptor in project spring-framework by spring-projects.

the class ReflectionHelper method compareArguments.

/**
	 * Compare argument arrays and return information about whether they match.
	 * A supplied type converter and conversionAllowed flag allow for matches to take
	 * into account that a type may be transformed into a different type by the converter.
	 * @param expectedArgTypes the types the method/constructor is expecting
	 * @param suppliedArgTypes the types that are being supplied at the point of invocation
	 * @param typeConverter a registered type converter
	 * @return a MatchInfo object indicating what kind of match it was,
	 * or {@code null} if it was not a match
	 */
static ArgumentsMatchInfo compareArguments(List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) {
    Assert.isTrue(expectedArgTypes.size() == suppliedArgTypes.size(), "Expected argument types and supplied argument types should be arrays of same length");
    ArgumentsMatchKind match = ArgumentsMatchKind.EXACT;
    for (int i = 0; i < expectedArgTypes.size() && match != null; i++) {
        TypeDescriptor suppliedArg = suppliedArgTypes.get(i);
        TypeDescriptor expectedArg = expectedArgTypes.get(i);
        if (!expectedArg.equals(suppliedArg)) {
            // The user may supply null - and that will be ok unless a primitive is expected
            if (suppliedArg == null) {
                if (expectedArg.isPrimitive()) {
                    match = null;
                }
            } else {
                if (suppliedArg.isAssignableTo(expectedArg)) {
                    if (match != ArgumentsMatchKind.REQUIRES_CONVERSION) {
                        match = ArgumentsMatchKind.CLOSE;
                    }
                } else if (typeConverter.canConvert(suppliedArg, expectedArg)) {
                    match = ArgumentsMatchKind.REQUIRES_CONVERSION;
                } else {
                    match = null;
                }
            }
        }
    }
    return (match != null ? new ArgumentsMatchInfo(match) : null);
}

Example 23 with TypeDescriptor

use of org.springframework.core.convert.TypeDescriptor in project spring-framework by spring-projects.

the class ReflectiveConstructorResolver method resolve.

/**
	 * Locate a constructor on the type. There are three kinds of match that might occur:
	 * <ol>
	 * <li>An exact match where the types of the arguments match the types of the constructor
	 * <li>An in-exact match where the types we are looking for are subtypes of those defined on the constructor
	 * <li>A match where we are able to convert the arguments into those expected by the constructor, according to the
	 * registered type converter.
	 * </ol>
	 */
@Override
public ConstructorExecutor resolve(EvaluationContext context, String typeName, List<TypeDescriptor> argumentTypes) throws AccessException {
    try {
        TypeConverter typeConverter = context.getTypeConverter();
        Class<?> type = context.getTypeLocator().findType(typeName);
        Constructor<?>[] ctors = type.getConstructors();
        Arrays.sort(ctors, new Comparator<Constructor<?>>() {

            @Override
            public int compare(Constructor<?> c1, Constructor<?> c2) {
                int c1pl = c1.getParameterCount();
                int c2pl = c2.getParameterCount();
                return (c1pl < c2pl ? -1 : (c1pl > c2pl ? 1 : 0));
            }
        });
        Constructor<?> closeMatch = null;
        Constructor<?> matchRequiringConversion = null;
        for (Constructor<?> ctor : ctors) {
            Class<?>[] paramTypes = ctor.getParameterTypes();
            List<TypeDescriptor> paramDescriptors = new ArrayList<>(paramTypes.length);
            for (int i = 0; i < paramTypes.length; i++) {
                paramDescriptors.add(new TypeDescriptor(new MethodParameter(ctor, i)));
            }
            ReflectionHelper.ArgumentsMatchInfo matchInfo = null;
            if (ctor.isVarArgs() && argumentTypes.size() >= paramTypes.length - 1) {
                // *sigh* complicated
                // Basically.. we have to have all parameters match up until the varargs one, then the rest of what is
                // being provided should be
                // the same type whilst the final argument to the method must be an array of that (oh, how easy...not) -
                // or the final parameter
                // we are supplied does match exactly (it is an array already).
                matchInfo = ReflectionHelper.compareArgumentsVarargs(paramDescriptors, argumentTypes, typeConverter);
            } else if (paramTypes.length == argumentTypes.size()) {
                // worth a closer look
                matchInfo = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
            }
            if (matchInfo != null) {
                if (matchInfo.isExactMatch()) {
                    return new ReflectiveConstructorExecutor(ctor);
                } else if (matchInfo.isCloseMatch()) {
                    closeMatch = ctor;
                } else if (matchInfo.isMatchRequiringConversion()) {
                    matchRequiringConversion = ctor;
                }
            }
        }
        if (closeMatch != null) {
            return new ReflectiveConstructorExecutor(closeMatch);
        } else if (matchRequiringConversion != null) {
            return new ReflectiveConstructorExecutor(matchRequiringConversion);
        } else {
            return null;
        }
    } catch (EvaluationException ex) {
        throw new AccessException("Failed to resolve constructor", ex);
    }
}

Example 24 with TypeDescriptor

use of org.springframework.core.convert.TypeDescriptor in project spring-framework by spring-projects.

the class ReflectiveMethodResolver method resolve.

/**
	 * Locate a method on a type. There are three kinds of match that might occur:
	 * <ol>
	 * <li>an exact match where the types of the arguments match the types of the constructor
	 * <li>an in-exact match where the types we are looking for are subtypes of those defined on the constructor
	 * <li>a match where we are able to convert the arguments into those expected by the constructor,
	 * according to the registered type converter
	 * </ol>
	 */
@Override
public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException {
    try {
        TypeConverter typeConverter = context.getTypeConverter();
        Class<?> type = (targetObject instanceof Class ? (Class<?>) targetObject : targetObject.getClass());
        List<Method> methods = new ArrayList<>(getMethods(type, targetObject));
        // If a filter is registered for this type, call it
        MethodFilter filter = (this.filters != null ? this.filters.get(type) : null);
        if (filter != null) {
            List<Method> filtered = filter.filter(methods);
            methods = (filtered instanceof ArrayList ? filtered : new ArrayList<>(filtered));
        }
        // Sort methods into a sensible order
        if (methods.size() > 1) {
            Collections.sort(methods, new Comparator<Method>() {

                @Override
                public int compare(Method m1, Method m2) {
                    int m1pl = m1.getParameterCount();
                    int m2pl = m2.getParameterCount();
                    // varargs methods go last
                    if (m1pl == m2pl) {
                        if (!m1.isVarArgs() && m2.isVarArgs()) {
                            return -1;
                        } else if (m1.isVarArgs() && !m2.isVarArgs()) {
                            return 1;
                        } else {
                            return 0;
                        }
                    }
                    return (m1pl < m2pl ? -1 : (m1pl > m2pl ? 1 : 0));
                }
            });
        }
        // Resolve any bridge methods
        for (int i = 0; i < methods.size(); i++) {
            methods.set(i, BridgeMethodResolver.findBridgedMethod(methods.get(i)));
        }
        // Remove duplicate methods (possible due to resolved bridge methods)
        Set<Method> methodsToIterate = new LinkedHashSet<>(methods);
        Method closeMatch = null;
        int closeMatchDistance = Integer.MAX_VALUE;
        Method matchRequiringConversion = null;
        boolean multipleOptions = false;
        for (Method method : methodsToIterate) {
            if (method.getName().equals(name)) {
                Class<?>[] paramTypes = method.getParameterTypes();
                List<TypeDescriptor> paramDescriptors = new ArrayList<>(paramTypes.length);
                for (int i = 0; i < paramTypes.length; i++) {
                    paramDescriptors.add(new TypeDescriptor(new MethodParameter(method, i)));
                }
                ReflectionHelper.ArgumentsMatchInfo matchInfo = null;
                if (method.isVarArgs() && argumentTypes.size() >= (paramTypes.length - 1)) {
                    // *sigh* complicated
                    matchInfo = ReflectionHelper.compareArgumentsVarargs(paramDescriptors, argumentTypes, typeConverter);
                } else if (paramTypes.length == argumentTypes.size()) {
                    // Name and parameter number match, check the arguments
                    matchInfo = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
                }
                if (matchInfo != null) {
                    if (matchInfo.isExactMatch()) {
                        return new ReflectiveMethodExecutor(method);
                    } else if (matchInfo.isCloseMatch()) {
                        if (this.useDistance) {
                            int matchDistance = ReflectionHelper.getTypeDifferenceWeight(paramDescriptors, argumentTypes);
                            if (closeMatch == null || matchDistance < closeMatchDistance) {
                                // This is a better match...
                                closeMatch = method;
                                closeMatchDistance = matchDistance;
                            }
                        } else {
                            // Take this as a close match if there isn't one already
                            if (closeMatch == null) {
                                closeMatch = method;
                            }
                        }
                    } else if (matchInfo.isMatchRequiringConversion()) {
                        if (matchRequiringConversion != null) {
                            multipleOptions = true;
                        }
                        matchRequiringConversion = method;
                    }
                }
            }
        }
        if (closeMatch != null) {
            return new ReflectiveMethodExecutor(closeMatch);
        } else if (matchRequiringConversion != null) {
            if (multipleOptions) {
                throw new SpelEvaluationException(SpelMessage.MULTIPLE_POSSIBLE_METHODS, name);
            }
            return new ReflectiveMethodExecutor(matchRequiringConversion);
        } else {
            return null;
        }
    } catch (EvaluationException ex) {
        throw new AccessException("Failed to resolve method", ex);
    }
}

Example 25 with TypeDescriptor

use of org.springframework.core.convert.TypeDescriptor in project spring-framework by spring-projects.

the class ReflectivePropertyAccessor method createOptimalAccessor.

/**
	 * Attempt to create an optimized property accessor tailored for a property of a particular name on
	 * a particular class. The general ReflectivePropertyAccessor will always work but is not optimal
	 * due to the need to lookup which reflective member (method/field) to use each time read() is called.
	 * This method will just return the ReflectivePropertyAccessor instance if it is unable to build
	 * something more optimal.
	 */
public PropertyAccessor createOptimalAccessor(EvaluationContext evalContext, Object target, String name) {
    // Don't be clever for arrays or null target
    if (target == null) {
        return this;
    }
    Class<?> type = (target instanceof Class ? (Class<?>) target : target.getClass());
    if (type.isArray()) {
        return this;
    }
    PropertyCacheKey cacheKey = new PropertyCacheKey(type, name, target instanceof Class);
    InvokerPair invocationTarget = this.readerCache.get(cacheKey);
    if (invocationTarget == null || invocationTarget.member instanceof Method) {
        Method method = (Method) (invocationTarget != null ? invocationTarget.member : null);
        if (method == null) {
            method = findGetterForProperty(name, type, target);
            if (method != null) {
                invocationTarget = new InvokerPair(method, new TypeDescriptor(new MethodParameter(method, -1)));
                ReflectionUtils.makeAccessible(method);
                this.readerCache.put(cacheKey, invocationTarget);
            }
        }
        if (method != null) {
            return new OptimalPropertyAccessor(invocationTarget);
        }
    }
    if (invocationTarget == null || invocationTarget.member instanceof Field) {
        Field field = (invocationTarget != null ? (Field) invocationTarget.member : null);
        if (field == null) {
            field = findField(name, type, target instanceof Class);
            if (field != null) {
                invocationTarget = new InvokerPair(field, new TypeDescriptor(field));
                ReflectionUtils.makeAccessible(field);
                this.readerCache.put(cacheKey, invocationTarget);
            }
        }
        if (field != null) {
            return new OptimalPropertyAccessor(invocationTarget);
        }
    }
    return this;
}