Refine search
@Test public void emptyListToList() throws Exception { conversionService.addConverter(new CollectionToCollectionConverter(conversionService)); conversionService.addConverterFactory(new StringToNumberConverterFactory()); List<String> list = new ArrayList<>(); TypeDescriptor sourceType = TypeDescriptor.forObject(list); TypeDescriptor targetType = new TypeDescriptor(getClass().getField("emptyListTarget")); assertTrue(conversionService.canConvert(sourceType, targetType)); assertEquals(list, conversionService.convert(list, sourceType, targetType)); }
public AclClassIdUtils() { GenericConversionService genericConversionService = new GenericConversionService(); genericConversionService.addConverter(String.class, Long.class, new StringToLongConverter()); genericConversionService.addConverter(String.class, UUID.class, new StringToUUIDConverter()); this.conversionService = genericConversionService; }
/** * Registers additional converters that will be available when using the {@link ConversionService} directly (e.g. for * id conversion). These converters are not custom conversions as they'd introduce unwanted conversions (e.g. * ObjectId-to-String). */ private void initializeConverters() { conversionService.addConverter(ObjectIdToStringConverter.INSTANCE); conversionService.addConverter(StringToObjectIdConverter.INSTANCE); if (!conversionService.canConvert(ObjectId.class, BigInteger.class)) { conversionService.addConverter(ObjectIdToBigIntegerConverter.INSTANCE); } if (!conversionService.canConvert(BigInteger.class, ObjectId.class)) { conversionService.addConverter(BigIntegerToObjectIdConverter.INSTANCE); } conversions.registerConvertersIn(conversionService); }
@Test(expected = ConversionFailedException.class) public void convertWrongTypeArgument() { conversionService.addConverterFactory(new StringToNumberConverterFactory()); conversionService.convert("BOGUS", Integer.class); }
/** * Checks whether we have a custom conversion registered for the given value into an arbitrary simple Mongo type. * Returns the converted value if so. If not, we perform special enum handling or simply return the value as is. * * @param value * @return */ @Nullable private Object getPotentiallyConvertedSimpleWrite(@Nullable Object value) { if (value == null) { return null; } Optional<Class<?>> customTarget = conversions.getCustomWriteTarget(value.getClass()); if (customTarget.isPresent()) { return conversionService.convert(value, customTarget.get()); } if (ObjectUtils.isArray(value)) { if (value instanceof byte[]) { return value; } return asCollection(value); } return Enum.class.isAssignableFrom(value.getClass()) ? ((Enum<?>) value).name() : value; }
/** * Checks whether we have a custom conversion for the given simple object. Converts the given value if so, applies * {@link Enum} handling or returns the value as is. * * @param value * @param target must not be {@literal null}. * @return */ @Nullable @SuppressWarnings({ "rawtypes", "unchecked" }) private Object getPotentiallyConvertedSimpleRead(@Nullable Object value, @Nullable Class<?> target) { if (value == null || target == null || ClassUtils.isAssignableValue(target, value)) { return value; } if (conversions.hasCustomReadTarget(value.getClass(), target)) { return conversionService.convert(value, target); } if (Enum.class.isAssignableFrom(target)) { return Enum.valueOf((Class<Enum>) target, value.toString()); } return conversionService.convert(value, target); }
/** * Convenience operation for converting a source object to the specified targetType, * where the target type is a descriptor that provides additional conversion context. * Simply delegates to {@link #convert(Object, TypeDescriptor, TypeDescriptor)} and * encapsulates the construction of the source type descriptor using * {@link TypeDescriptor#forObject(Object)}. * @param source the source object * @param targetType the target type * @return the converted value * @throws ConversionException if a conversion exception occurred * @throws IllegalArgumentException if targetType is {@code null}, * or sourceType is {@code null} but source is not {@code null} */ @Nullable public Object convert(@Nullable Object source, TypeDescriptor targetType) { return convert(source, TypeDescriptor.forObject(source), targetType); }
private void writeToBucket(String path, @Nullable Object value, RedisData sink, Class<?> propertyType) { if (value == null || (value instanceof Optional && !((Optional<?>) value).isPresent())) { return; } if (customConversions.hasCustomWriteTarget(value.getClass())) { Optional<Class<?>> targetType = customConversions.getCustomWriteTarget(value.getClass()); if (!propertyType.isPrimitive() && !targetType.filter(it -> ClassUtils.isAssignable(Map.class, it)).isPresent() && customConversions.isSimpleType(value.getClass()) && value.getClass() != propertyType) { typeMapper.writeType(value.getClass(), sink.getBucket().getPropertyPath(path)); } if (targetType.filter(it -> ClassUtils.isAssignable(Map.class, it)).isPresent()) { Map<?, ?> map = (Map<?, ?>) conversionService.convert(value, targetType.get()); for (Map.Entry<?, ?> entry : map.entrySet()) { sink.getBucket().put(path + (StringUtils.hasText(path) ? "." : "") + entry.getKey(), toBytes(entry.getValue())); } } else if (targetType.filter(it -> ClassUtils.isAssignable(byte[].class, it)).isPresent()) { sink.getBucket().put(path, toBytes(value)); } else { throw new IllegalArgumentException( String.format("Cannot convert value '%s' of type %s to bytes.", value, value.getClass())); } } }
@Override public boolean canConvert(@Nullable Class<?> sourceType, Class<?> targetType) { Assert.notNull(targetType, "Target type to convert to cannot be null"); return canConvert((sourceType != null ? TypeDescriptor.valueOf(sourceType) : null), TypeDescriptor.valueOf(targetType)); }
@SuppressWarnings("unchecked") @Nullable private <R> R readInternal(String path, Class<R> type, RedisData source) { if (customConversions.hasCustomReadTarget(Map.class, readType.getType())) { partial.putAll(source.getBucket().asMap()); R instance = (R) conversionService.convert(partial, readType.getType()); if (conversionService.canConvert(byte[].class, readType.getType())) { return (R) conversionService.convert(source.getBucket().get(StringUtils.hasText(path) ? path : "_raw"), readType.getType());
@Test public void convertSuperSourceType() { conversionService.addConverter(new Converter<CharSequence, Integer>() { @Override public Integer convert(CharSequence source) { return Integer.valueOf(source.toString()); } }); Integer result = conversionService.convert("3", Integer.class); assertEquals(Integer.valueOf(3), result); }
@Test(expected = ConverterNotFoundException.class) public void genericConverterDelegatingBackToConversionServiceConverterNotFound() { conversionService.addConverter(new ObjectToArrayConverter(conversionService)); assertFalse(conversionService.canConvert(String.class, Integer[].class)); conversionService.convert("3,4,5", Integer[].class); }
@Test public void collectionMapNotGenericTarget() throws Exception { Map<String, List<String>> map = new HashMap<>(); map.put("1", Arrays.asList("9", "12")); map.put("2", Arrays.asList("37", "23")); assertTrue(conversionService.canConvert(Map.class, Map.class)); assertSame(map, conversionService.convert(map, Map.class)); }
@Test public void convertObjectToPrimitiveViaConverterFactory() { assertFalse(conversionService.canConvert(String.class, int.class)); conversionService.addConverterFactory(new StringToNumberConverterFactory()); assertTrue(conversionService.canConvert(String.class, int.class)); Integer three = conversionService.convert("3", int.class); assertEquals(3, three.intValue()); }
@Test public void stringToArrayCanConvert() { conversionService.addConverter(new StringToArrayConverter(conversionService)); assertFalse(conversionService.canConvert(String.class, Integer[].class)); conversionService.addConverterFactory(new StringToNumberConverterFactory()); assertTrue(conversionService.canConvert(String.class, Integer[].class)); }
@Test public void removeConvertible() { conversionService.addConverter(new ColorConverter()); assertTrue(conversionService.canConvert(String.class, Color.class)); conversionService.removeConvertible(String.class, Color.class); assertFalse(conversionService.canConvert(String.class, Color.class)); }
@Bean public ConversionService webSocketConversionService() { return new GenericConversionService(); }
@Test public void conditionalConverterFactory() { MyConditionalConverterFactory converter = new MyConditionalConverterFactory(); conversionService.addConverter(new ColorConverter()); conversionService.addConverterFactory(converter); assertEquals(Color.BLACK, conversionService.convert("#000000", Color.class)); assertTrue(converter.getMatchAttempts() > 0); assertTrue(converter.getNestedMatchAttempts() > 0); }
/** * Create a new {@link RelaxedConversionService} instance. * @param conversionService and option root conversion service */ RelaxedConversionService(ConversionService conversionService) { this.conversionService = conversionService; this.additionalConverters = new GenericConversionService(); DefaultConversionService.addDefaultConverters(this.additionalConverters); this.additionalConverters .addConverterFactory(new StringToEnumIgnoringCaseConverterFactory()); this.additionalConverters.addConverter(new StringToCharArrayConverter()); }
@Bean public ConversionService webSocketConversionService() { GenericConversionService conversionService = new DefaultConversionService(); conversionService.addConverter(new MyTypeToStringConverter()); conversionService.addConverter(new MyTypeToBytesConverter()); conversionService.addConverter(new StringToMyTypeConverter()); conversionService.addConverter(new BytesToMyTypeConverter()); return conversionService; }