Clover coverage report - Code Coverage for tapestry release 4.0.1
Coverage timestamp: Fri Mar 31 2006 09:12:14 EST
file stats: LOC: 188   Methods: 7
NCLOC: 102   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
ValueConverterImpl.java 90.9% 96% 100% 94.9%
coverage coverage
 1    // Copyright 2004, 2005 The Apache Software Foundation
 2    //
 3    // Licensed under the Apache License, Version 2.0 (the "License");
 4    // you may not use this file except in compliance with the License.
 5    // You may obtain a copy of the License at
 6    //
 7    // http://www.apache.org/licenses/LICENSE-2.0
 8    //
 9    // Unless required by applicable law or agreed to in writing, software
 10    // distributed under the License is distributed on an "AS IS" BASIS,
 11    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12    // See the License for the specific language governing permissions and
 13    // limitations under the License.
 14   
 15    package org.apache.tapestry.coerce;
 16   
 17    import java.beans.PropertyEditor;
 18    import java.beans.PropertyEditorManager;
 19    import java.util.HashMap;
 20    import java.util.Iterator;
 21    import java.util.List;
 22    import java.util.Map;
 23   
 24    import org.apache.hivemind.ApplicationRuntimeException;
 25    import org.apache.hivemind.util.ConstructorUtils;
 26    import org.apache.hivemind.util.Defense;
 27   
 28    /**
 29    * Implementation of {@link org.apache.tapestry.coerce.ValueConverter}. Selects an appropriate type
 30    * converter and delegates to it.
 31    *
 32    * @author Howard M. Lewis Ship
 33    * @since 4.0
 34    */
 35    public class ValueConverterImpl implements ValueConverter
 36    {
 37    private Map _converterMap = new HashMap();
 38   
 39    /** List of {@link org.apache.tapestry.coerce.TypeConverterContribution}. */
 40   
 41    public List _contributions;
 42   
 43    private Map _primitiveToWrapper = new HashMap();
 44   
 45    private Map _wrapperToPrimitive = new HashMap();
 46   
 47    {
 48  102 store(boolean.class, Boolean.class);
 49  102 store(byte.class, Byte.class);
 50  102 store(short.class, Short.class);
 51  102 store(char.class, Character.class);
 52  102 store(int.class, Integer.class);
 53  102 store(long.class, Long.class);
 54  102 store(float.class, Float.class);
 55  102 store(double.class, Double.class);
 56    }
 57   
 58  816 private void store(Class primitive, Class wrapper)
 59    {
 60  816 _primitiveToWrapper.put(primitive, wrapper);
 61   
 62  816 _wrapperToPrimitive.put(wrapper, primitive);
 63    }
 64   
 65  84 public void initializeService()
 66    {
 67  84 Iterator i = _contributions.iterator();
 68  84 while (i.hasNext())
 69    {
 70  396 TypeConverterContribution c = (TypeConverterContribution) i.next();
 71   
 72  396 _converterMap.put(c.getSubjectClass(), c.getConverter());
 73    }
 74    }
 75   
 76  5392 public Object coerceValue(Object value, Class desiredType)
 77    {
 78  5392 Defense.notNull(desiredType, "desiredType");
 79   
 80  5392 Class effectiveType = convertType(desiredType);
 81   
 82    // Already the correct type? Go no further!
 83   
 84  5392 if (value != null && effectiveType.isAssignableFrom(value.getClass()))
 85  4858 return value;
 86   
 87  534 Object result = convertNumberToNumber(value, effectiveType);
 88   
 89  534 if (result != null)
 90  2 return result;
 91   
 92  532 result = convertUsingPropertyEditor(value, effectiveType);
 93   
 94  530 if (result != null)
 95  28 return result;
 96   
 97  502 TypeConverter converter = (TypeConverter) _converterMap.get(effectiveType);
 98   
 99    // null value and no converter for the given type? Just return null.
 100   
 101  502 if (value == null && converter == null)
 102  18 return null;
 103   
 104  484 if (converter == null)
 105  4 throw new ApplicationRuntimeException(CoerceMessages.noConverter(effectiveType));
 106   
 107  480 return converter.convertValue(value);
 108    }
 109   
 110    /**
 111    * Attempts to use {@link java.beans.PropertyEditor}to perform a conversion from a string to a
 112    * numeric type. Returns null if no property editor can be found.
 113    *
 114    * @param value
 115    * The value to convert
 116    * @param targetType
 117    * The type to convert to (must be a wrapper type, not a primitive type)
 118    */
 119   
 120  532 private Number convertUsingPropertyEditor(Object value, Class targetType)
 121    {
 122    // Convert from wrapper type back to primitive type, because
 123    // PropertyEditorManager expects primitive types not
 124    // wrapper types.
 125   
 126  532 if (value == null || value.getClass() != String.class
 127    || !Number.class.isAssignableFrom(targetType))
 128  502 return null;
 129   
 130  30 Class primitiveType = (Class) _wrapperToPrimitive.get(targetType);
 131   
 132    // Note a primitive type.
 133   
 134  30 if (primitiveType == null)
 135  0 return null;
 136   
 137    // Looks like a conversion from String to Number, let's see.
 138   
 139  30 PropertyEditor editor = PropertyEditorManager.findEditor(primitiveType);
 140   
 141    // This should not happen, since we've filtered down to just the
 142    // primitive types that do have property editors.
 143   
 144  30 if (editor == null)
 145  0 return null;
 146   
 147  30 String text = (String) value;
 148   
 149  30 try
 150    {
 151  30 editor.setAsText(text);
 152   
 153  28 return (Number) editor.getValue();
 154    }
 155    catch (Exception ex)
 156    {
 157  2 throw new ApplicationRuntimeException(CoerceMessages.stringToNumberConversionError(
 158    text,
 159    targetType,
 160    ex), ex);
 161    }
 162   
 163    }
 164   
 165  534 private Number convertNumberToNumber(Object value, Class targetType)
 166    {
 167  534 if (value == null || !Number.class.isAssignableFrom(value.getClass())
 168    || !Number.class.isAssignableFrom(targetType))
 169  532 return null;
 170   
 171  2 String valueAsString = value.toString();
 172   
 173  2 return (Number) ConstructorUtils.invokeConstructor(targetType, new Object[]
 174    { valueAsString });
 175    }
 176   
 177  5392 private Class convertType(Class possiblePrimitiveType)
 178    {
 179  5392 Class wrapperType = (Class) _primitiveToWrapper.get(possiblePrimitiveType);
 180   
 181  5392 return wrapperType == null ? possiblePrimitiveType : wrapperType;
 182    }
 183   
 184  84 public void setContributions(List contributions)
 185    {
 186  84 _contributions = contributions;
 187    }
 188    }