Examples with TypeConverter org.springframework.expression.TypeConverter used on opensource projects

Example 6 with TypeConverter

use of org.springframework.expression.TypeConverter in project spring-security by spring-projects.

the class DelegatingEvaluationContextTests method getTypeConverter.

@Test
public void getTypeConverter() {
    TypeConverter expected = mock(TypeConverter.class);
    when(this.delegate.getTypeConverter()).thenReturn(expected);
    assertThat(this.context.getTypeConverter()).isEqualTo(expected);
}

Example 7 with TypeConverter

use of org.springframework.expression.TypeConverter in project spring-framework by spring-projects.

the class ConstructorReference method createArray.

/**
	 * Create an array and return it.
	 * @param state the expression state within which this expression is being evaluated
	 * @return the new array
	 * @throws EvaluationException if there is a problem creating the array
	 */
private TypedValue createArray(ExpressionState state) throws EvaluationException {
    // First child gives us the array type which will either be a primitive or reference type
    Object intendedArrayType = getChild(0).getValue(state);
    if (!(intendedArrayType instanceof String)) {
        throw new SpelEvaluationException(getChild(0).getStartPosition(), SpelMessage.TYPE_NAME_EXPECTED_FOR_ARRAY_CONSTRUCTION, FormatHelper.formatClassNameForMessage(intendedArrayType.getClass()));
    }
    String type = (String) intendedArrayType;
    Class<?> componentType;
    TypeCode arrayTypeCode = TypeCode.forName(type);
    if (arrayTypeCode == TypeCode.OBJECT) {
        componentType = state.findType(type);
    } else {
        componentType = arrayTypeCode.getType();
    }
    Object newArray;
    if (!hasInitializer()) {
        // Confirm all dimensions were specified (for example [3][][5] is missing the 2nd dimension)
        for (SpelNodeImpl dimension : this.dimensions) {
            if (dimension == null) {
                throw new SpelEvaluationException(getStartPosition(), SpelMessage.MISSING_ARRAY_DIMENSION);
            }
        }
        TypeConverter typeConverter = state.getEvaluationContext().getTypeConverter();
        // Shortcut for 1 dimensional
        if (this.dimensions.length == 1) {
            TypedValue o = this.dimensions[0].getTypedValue(state);
            int arraySize = ExpressionUtils.toInt(typeConverter, o);
            newArray = Array.newInstance(componentType, arraySize);
        } else {
            // Multi-dimensional - hold onto your hat!
            int[] dims = new int[this.dimensions.length];
            for (int d = 0; d < this.dimensions.length; d++) {
                TypedValue o = this.dimensions[d].getTypedValue(state);
                dims[d] = ExpressionUtils.toInt(typeConverter, o);
            }
            newArray = Array.newInstance(componentType, dims);
        }
    } else {
        // There is an initializer
        if (this.dimensions.length > 1) {
            // is not currently supported
            throw new SpelEvaluationException(getStartPosition(), SpelMessage.MULTIDIM_ARRAY_INITIALIZER_NOT_SUPPORTED);
        }
        TypeConverter typeConverter = state.getEvaluationContext().getTypeConverter();
        InlineList initializer = (InlineList) getChild(1);
        // If a dimension was specified, check it matches the initializer length
        if (this.dimensions[0] != null) {
            TypedValue dValue = this.dimensions[0].getTypedValue(state);
            int i = ExpressionUtils.toInt(typeConverter, dValue);
            if (i != initializer.getChildCount()) {
                throw new SpelEvaluationException(getStartPosition(), SpelMessage.INITIALIZER_LENGTH_INCORRECT);
            }
        }
        // Build the array and populate it
        int arraySize = initializer.getChildCount();
        newArray = Array.newInstance(componentType, arraySize);
        if (arrayTypeCode == TypeCode.OBJECT) {
            populateReferenceTypeArray(state, newArray, typeConverter, initializer, componentType);
        } else if (arrayTypeCode == TypeCode.INT) {
            populateIntArray(state, newArray, typeConverter, initializer);
        } else if (arrayTypeCode == TypeCode.BOOLEAN) {
            populateBooleanArray(state, newArray, typeConverter, initializer);
        } else if (arrayTypeCode == TypeCode.CHAR) {
            populateCharArray(state, newArray, typeConverter, initializer);
        } else if (arrayTypeCode == TypeCode.LONG) {
            populateLongArray(state, newArray, typeConverter, initializer);
        } else if (arrayTypeCode == TypeCode.SHORT) {
            populateShortArray(state, newArray, typeConverter, initializer);
        } else if (arrayTypeCode == TypeCode.DOUBLE) {
            populateDoubleArray(state, newArray, typeConverter, initializer);
        } else if (arrayTypeCode == TypeCode.FLOAT) {
            populateFloatArray(state, newArray, typeConverter, initializer);
        } else if (arrayTypeCode == TypeCode.BYTE) {
            populateByteArray(state, newArray, typeConverter, initializer);
        } else {
            throw new IllegalStateException(arrayTypeCode.name());
        }
    }
    return new TypedValue(newArray);
}