Java tutorial
/* * Copyright (c) 2001-2007, Inversoft Inc., All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, * either express or implied. See the License for the specific * language governing permissions and limitations under the License. */ package org.primeframework.mvc.parameter.convert; import java.lang.reflect.Array; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.Map; import org.apache.commons.lang3.StringUtils; import org.primeframework.mvc.util.TypeTools; /** * This class is the base type converter for all the type converters that handle Object types. If you are writing a * converter for primitive types, use the {@link org.primeframework.mvc.parameter.convert.converters.AbstractPrimitiveConverter} * class. * <p/> * This class mostly delegates between the various method calls by passing in default values or performing casting. * Each * method describes how it functions. * * @author Brian Pontarelli */ public abstract class AbstractGlobalConverter implements GlobalConverter { /** * Handles the following cases: * <p/> * <ul> * <li>Null - returns null</li> * <li>Type is an array - calls stringToArray</li> * <li>Type is not an array and values length is 1 or 0 - calls stringToObject</li> * <li>Type is an array and values length is > 1 - calls stringsToArray</li> * <li>Type is not an array and values length is > 1 - calls stringsToObject</li> * </ul> * * @param convertTo The type to convert to. * @param dynamicAttributes The dynamic attributes used to assist in conversion. * @param expression The full path to the expression that is causing the conversion. * @param values The values to convert. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ public Object convertFromStrings(Type convertTo, Map<String, String> dynamicAttributes, String expression, String... values) throws ConversionException, ConverterStateException { // Handle a zero or one String Class<?> rawType = TypeTools.rawType(convertTo); if (values == null || values.length <= 1) { String value = (values != null && values.length == 1) ? values[0] : null; if (rawType.isArray()) { // Punt on multi-dimensional arrays if (rawType.getComponentType().isArray()) { throw new ConverterStateException("Converter [" + getClass() + "] does not support" + " conversion to multi-dimensional arrays of type [" + convertTo + "]"); } return stringToArray(value, convertTo, dynamicAttributes, expression); } return stringToObject(value, convertTo, dynamicAttributes, expression); } // Handle multiple strings if (rawType.isArray()) { // Punt on multi-dimensional arrays if (rawType.getComponentType().isArray()) { throw new ConverterStateException("Converter [" + getClass() + "] does not support" + " conversion to multi-dimensional arrays of type [" + convertTo + "]"); } return stringsToArray(values, convertTo, dynamicAttributes, expression); } return stringsToObject(values, convertTo, dynamicAttributes, expression); } /** * Gets the first parameter type is the given type is a parametrized type. If it isn't, this returns null. If the * type * has multiple parameters, only the first is returned. * * @param type The type. * @return The first parameter type. */ protected Class<?> parameterType(Type type) { if (type instanceof ParameterizedType) { return (Class<?>) ((ParameterizedType) type).getActualTypeArguments()[0]; } return null; } /** * Converts the value to a String. * * @param convertFrom The original Type of the value. * @param dynamicAttributes The dynamic attributes used to assist in conversion. * @param expression The full path to the expression that is causing the conversion. * @param value The value to convert. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ public String convertToString(Type convertFrom, Map<String, String> dynamicAttributes, String expression, Object value) throws ConversionException { // Handle null if (value == null) { return null; } // Check simple conversion if (value instanceof String) { return (String) value; } // Handle arrays Class<?> rawType = TypeTools.rawType(convertFrom); if (rawType.isArray()) { return arrayToString(value, convertFrom, dynamicAttributes, expression); } return objectToString(value, convertFrom, dynamicAttributes, expression); } /** * This performs the conversion from a single String value to an array of the given type. * * @param value The value to convert to an array. * @param convertTo The array type to convert to. * @param dynamicAttributes The dynamic attributes used to assist in conversion. * @param expression The full path to the expression that is causing the conversion. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ protected Object stringToArray(String value, Type convertTo, Map<String, String> dynamicAttributes, String expression) throws ConversionException { if (value == null) { return null; } Object finalArray; Class<?> rawType = TypeTools.rawType(convertTo); if (StringUtils.isBlank(value)) { finalArray = Array.newInstance(rawType.getComponentType(), 0); } else { String[] parts = value.split(","); finalArray = Array.newInstance(rawType.getComponentType(), parts.length); for (int i = 0; i < parts.length; i++) { Object singleValue = stringToObject(parts[i], rawType.getComponentType(), dynamicAttributes, expression); Array.set(finalArray, i, singleValue); } } return finalArray; } /** * This performs the conversion from an array of String values to an array of the given type. * * @param values The values to convert to an array. * @param convertTo The array type to convert to. * @param dynamicAttributes The dynamic attributes to assist in the conversion. * @param expression The full path to the expression that is causing the conversion. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ protected Object stringsToArray(String[] values, Type convertTo, Map<String, String> dynamicAttributes, String expression) throws ConversionException { if (values == null) { return null; } Object finalArray; Class<?> rawType = TypeTools.rawType(convertTo); if (values.length == 0) { finalArray = Array.newInstance(rawType.getComponentType(), 0); } else { finalArray = Array.newInstance(rawType.getComponentType(), values.length); for (int i = 0; i < values.length; i++) { Object singleValue = stringToObject(values[i], rawType.getComponentType(), dynamicAttributes, expression); Array.set(finalArray, i, singleValue); } } return finalArray; } /** * This performs the conversion from an array to a single String value. * * @param value The array value to convert to a String. * @param convertFrom The array type to convert from. * @param dynamicAttributes The dynamic attributes to assist in the conversion. * @param expression The full path to the expression that is causing the conversion. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ protected String arrayToString(Object value, Type convertFrom, Map<String, String> dynamicAttributes, String expression) throws ConversionException { Class<?> rawType = TypeTools.rawType(convertFrom); if (!rawType.isArray()) { throw new ConversionException("The convertFrom parameter must be an array type"); } // if (value == null) { // return null; // } if (!value.getClass().isArray()) { throw new ConversionException("The value is not an array"); } if (value.getClass().getComponentType().isArray()) { throw new ConversionException( "The value is a multi-dimensional array, which is not" + " supported by the AbstractConverter"); } int length = Array.getLength(value); StringBuilder str = new StringBuilder(); for (int i = 0; i < length; i++) { Object o = Array.get(value, i); str.append(convertToString(value.getClass().getComponentType(), dynamicAttributes, expression, o)); if (i + 1 < length) { str.append(","); } } return str.toString(); } /** * Converts the single String value to an Object. * * @param value The String value to convert. * @param convertTo The type to convert to. * @param dynamicAttributes The dynamic attributes to assist in the conversion. * @param expression The full path to the expression that is causing the conversion. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ protected abstract Object stringToObject(String value, Type convertTo, Map<String, String> dynamicAttributes, String expression) throws ConversionException, ConverterStateException; /** * Converts a String array to a single Object (not an array of Objects). Support for this method is uncommon. * * @param values The String values to convert. * @param convertTo The type to convert to. * @param dynamicAttributes The dynamic attributes to assist in the conversion. * @param expression The full path to the expression that is causing the conversion. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ protected abstract Object stringsToObject(String[] values, Type convertTo, Map<String, String> dynamicAttributes, String expression) throws ConversionException, ConverterStateException; /** * Converts the Object value to a String. * * @param value The Object value to convert. * @param convertFrom The type to convert from. * @param dynamicAttributes The dynamic attributes to assist in the conversion. * @param expression The full path to the expression that is causing the conversion. * @return The converted value. * @throws ConversionException If the conversion failed. * @throws ConverterStateException if the converter didn't have all of the information it needed to perform the * conversion. */ protected abstract String objectToString(Object value, Type convertFrom, Map<String, String> dynamicAttributes, String expression) throws ConversionException, ConverterStateException; }