@Override public <S, T> DefaultConversionService addConverter(Class<S> sourceType, Class<T> targetType, TypeConverter<S, T> typeConverter) { ConvertiblePair pair = newPair(sourceType, targetType, typeConverter); typeConverters.put(pair, typeConverter); converterCache.put(pair, typeConverter); return this; }
/** * Constructor. */ public DefaultConversionService() { registerDefaultConverters(); }
addConverter(Double[].class, double[].class, (object, targetType, context) -> { double[] doubles = new double[object.length]; for (int i = 0; i < object.length; i++) { addConverter(Integer[].class, int[].class, (object, targetType, context) -> { int[] integers = new int[object.length]; for (int i = 0; i < object.length; i++) { addConverter(Object.class, List.class, (object, targetType, context) -> { Optional<Argument<?>> firstTypeVariable = context.getFirstTypeVariable(); Argument<?> argument = firstTypeVariable.orElse(Argument.OBJECT_ARGUMENT); Optional converted = DefaultConversionService.this.convert(object, context.with(argument)); if (converted.isPresent()) { return Optional.of(Collections.singletonList(converted.get())); addConverter(CharSequence.class, Class.class, (object, targetType, context) -> { ClassLoader classLoader = targetType.getClassLoader(); if (classLoader == null) { addConverter(AnnotationClassValue.class, Class.class, (object, targetType, context) -> object.getType()); addConverter(AnnotationClassValue[].class, Class.class, (object, targetType, context) -> { if (object.length > 0) { final AnnotationClassValue o = object[0]; addConverter(AnnotationClassValue[].class, Class[].class, (object, targetType, context) -> { List<Class> classes = new ArrayList<>(object.length); for (AnnotationClassValue<?> annotationClassValue : object) { addConverter(URI.class, URL.class, uri -> {
@Override public <S, T> boolean canConvert(Class<S> sourceType, Class<T> targetType) { ConvertiblePair pair = new ConvertiblePair(sourceType, targetType, null); TypeConverter typeConverter = converterCache.get(pair); if (typeConverter == null) { typeConverter = findTypeConverter(sourceType, targetType, null); if (typeConverter != null) { converterCache.put(pair, typeConverter); return true; } return false; } return true; }
ConversionService<?> SHARED = new DefaultConversionService();
@SuppressWarnings("unchecked") @Override public <T> Optional<T> convert(Object object, Class<T> targetType, ConversionContext context) { if (object == null || targetType == null || context == null) { return Optional.empty(); } if (targetType == Object.class) { return Optional.of((T) object); } Class<?> sourceType = object.getClass(); targetType = ReflectionUtils.getWrapperType(targetType); if (targetType.isInstance(object) && !Iterable.class.isInstance(object) && !Map.class.isInstance(object)) { return Optional.of((T) object); } Optional<? extends Class<? extends Annotation>> formattingAnn = context.getAnnotationMetadata().getAnnotationTypeByStereotype(Format.class); Class<? extends Annotation> formattingAnnotation = formattingAnn.orElse(null); ConvertiblePair pair = new ConvertiblePair(sourceType, targetType, formattingAnnotation); TypeConverter typeConverter = converterCache.get(pair); if (typeConverter == null) { typeConverter = findTypeConverter(sourceType, targetType, formattingAnnotation); if (typeConverter == null) { return Optional.empty(); } else { converterCache.put(pair, typeConverter); } } return typeConverter.convert(object, targetType, context); }