/**
* Converts the given value parameter (parameter) to a type that is accepted by the set method of
* this property. This method attempts to convert the value regardless of the value being null.
* However, this method short circuits and returns the value unchanged if value is runtime
* assignable to the type of this BaseBeanProperty.
*
* @param values The String values to convert.
* @param context The current context.
* @param field The field that the conversion is occurring for. This is used to look for
* conversion annotations.
* @return The value parameter converted to the correct type.
* @throws ConversionException If there was a problem converting the parameter.
*/
protected Object convert(final String[] values, Context context, Field field)
throws ConversionException {
Object newValue = values;
// First look for annotations
if (field != null) {
Annotation[] annotations = field.getAnnotations();
for (Annotation annotation : annotations) {
ConverterAnnotation converterAnnotation =
annotation.annotationType().getAnnotation(ConverterAnnotation.class);
if (converterAnnotation != null) {
AnnotationConverter converter = converterProvider.lookup(annotation);
return converter.convertFromStrings(
annotation, values, type, context.getAttributes(), context.getExpression());
}
}
}
// The converter does this, but pre-emptively checking these conditions will speed up conversion
// times
Class<?> typeClass = TypeTools.rawType(type);
if (!typeClass.isInstance(values)) {
GlobalConverter converter = converterProvider.lookup(typeClass);
if (converter == null) {
throw new ConverterStateException(
"No type converter found for the type [" + typeClass.getName() + "]");
}
newValue =
converter.convertFromStrings(
values, type, context.getAttributes(), context.getExpression());
}
return newValue;
}
/**
* Creates a new instance of the current type.
*
* @param key This is only used when creating arrays. It is the next atom, which is always the
* size of the array.
* @return The new value.
*/
protected Object createValue(Object key) {
Class<?> typeClass = TypeTools.rawType(type);
Object value;
if (Map.class == typeClass) {
value = new HashMap();
} else if (List.class == typeClass) {
value = new ArrayList();
} else if (Set.class == typeClass) {
value = new HashSet();
} else if (Queue.class == typeClass) {
value = new LinkedList();
} else if (Deque.class == typeClass) {
value = new ArrayDeque();
} else if (SortedSet.class == typeClass) {
value = new TreeSet();
} else if (typeClass.isArray()) {
if (key == null) {
throw new ExpressionException(
"Attempting to create an array, but there isn't an index "
+ "available to determine the size of the array");
}
value = Array.newInstance(typeClass.getComponentType(), Integer.parseInt(key.toString()) + 1);
} else {
value = instantiate(typeClass);
}
return value;
}
