/** * Attempts to convert the given object to the given target type. If conversion fails or is not possible an empty {@link Optional} is returned. * * @param object The object to convert * @param targetType The target type * @param <T> The generic type * @return The optional */ default <T> Optional<T> convert(Object object, Class<T> targetType) { return convert(object, targetType, ConversionContext.DEFAULT); }
@Override public void register(ConversionService<?> conversionService) { conversionService.addConverter(URI.class, LoadBalancer.class, (TypeConverter<URI, LoadBalancer>) (object, targetType, context) -> { try { return Optional.of(LoadBalancer.fixed(object.toURL())); } catch (MalformedURLException e) { context.reject(e); return Optional.empty(); } }); conversionService.addConverter(URL.class, LoadBalancer.class, (Function<URL, LoadBalancer>) LoadBalancer::fixed); conversionService.addConverter(String.class, LoadBalancer.class, (Function<String, LoadBalancer>) url -> { try { return LoadBalancer.fixed(new URL(url)); } catch (MalformedURLException e) { return null; } }); } }
final Object v = paramMap.get(argumentName); if (v != null) { paramMap.put(argumentName, conversionService.convert(v, ConversionContext.of(String.class).with(argument.getAnnotationMetadata()))); conversionService.convert(definedValue, String.class) .ifPresent(o -> headers.put(finalHeaderName, o)); } else if (annotationMetadata.isAnnotationPresent(CookieValue.class)) { conversionService.convert(definedValue, String.class) .ifPresent(o -> cookies.add(new NettyCookie(finalCookieName, o))); conversionService.convert(definedValue, ConversionContext.of(String.class).with(annotationMetadata)).ifPresent(o -> { if (!StringUtils.isEmpty(parameterName)) { paramMap.put(parameterName, o); conversionService.convert(definedValue, Object.class) .ifPresent(o -> attributes.put(finalAttributeName, o)); } else if (annotationMetadata.isAnnotationPresent(PathVariable.class)) { String parameterName = annotationMetadata.getValue(PathVariable.class, String.class).orElse(null); conversionService.convert(definedValue, ConversionContext.of(String.class).with(annotationMetadata)).ifPresent(o -> { if (!StringUtils.isEmpty(o)) { paramMap.put(parameterName, o); publisher = byteBufferPublisher; } else { if (conversionService.canConvert(ByteBuffer.class, argumentType)) { .map(value -> conversionService.convert(value, argumentType).get()); } else {
@Override public <S, T> boolean canConvert(Class<S> sourceType, Class<T> targetType) { return conversionService.canConvert(sourceType, targetType); }
@Override public boolean canConvert(Class<?> sourceType, Class<?> targetType) { return conversionService.canConvert(sourceType, targetType); }
/** * Registers a default converter. * * @param conversionService The conversion service */ protected void registerDefaultConverters(ConversionService<?> conversionService) { conversionService.addConverter( CharSequence.class, MediaType.class, (object, targetType, context) -> { if (StringUtils.isEmpty(object)) { return Optional.empty(); } else { final String str = object.toString(); try { return Optional.of(new MediaType(str)); } catch (IllegalArgumentException e) { context.reject(e); return Optional.empty(); } } }); }
@Override public <S, T> boolean canConvert(Class<S> sourceType, Class<T> targetType) { return conversionService.canConvert(sourceType, targetType); }
@Override public <T> Optional<T> getProperty(String name, ArgumentConversionContext<T> conversionContext) { Object value = map.get(name); return conversionService.convert(value, conversionContext); } }
@Override public <S, T> Environment addConverter(Class<S> sourceType, Class<T> targetType, Function<S, T> typeConverter) { conversionService.addConverter(sourceType, targetType, typeConverter); return this; }
@Override public boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) { return conversionService.canConvert(sourceType.getType(), targetType.getType()); }
/** * @param interval The deregisterCriticalServiceAfter as a string * @return The {@link NewCheck} instance */ public NewCheck deregisterCriticalServiceAfter(String interval) { this.deregisterCriticalServiceAfter = ConversionService.SHARED.convert(interval, Duration.class).orElseThrow(() -> new IllegalArgumentException("Invalid deregisterCriticalServiceAfter Specified")); return this; }
@Override public <S, T> Environment addConverter(Class<S> sourceType, Class<T> targetType, TypeConverter<S, T> typeConverter) { conversionService.addConverter(sourceType, targetType, typeConverter); return this; }
@Override public <T> Optional<T> get(CharSequence name, ArgumentConversionContext<T> conversionContext) { V value = map.get(name); if (value != null) { return conversionService.convert(value, conversionContext); } return Optional.empty(); }
@Override public <S, T> Environment addConverter(Class<S> sourceType, Class<T> targetType, Function<S, T> typeConverter) { conversionService.addConverter(sourceType, targetType, typeConverter); return this; }
/** * Sets the interval. * * @param interval The interval */ protected void setInterval(String interval) { this.interval = ConversionService.SHARED.convert(interval, Duration.class).orElseThrow(() -> new IllegalArgumentException("Invalid Duration Specified")); }
@Override public <S, T> Environment addConverter(Class<S> sourceType, Class<T> targetType, TypeConverter<S, T> typeConverter) { conversionService.addConverter(sourceType, targetType, typeConverter); return this; }
/** * @param deregisterCriticalServiceAfter Service to de-regsiter after */ protected void setDeregisterCriticalServiceAfter(String deregisterCriticalServiceAfter) { this.deregisterCriticalServiceAfter = ConversionService.SHARED.convert(deregisterCriticalServiceAfter, Duration.class).orElseThrow(() -> new IllegalArgumentException("Invalid deregisterCriticalServiceAfter Specified")); }
conversionService.addConverter(Maybe.class, Publisher.class, (Function<Maybe, Publisher>) Maybe::toFlowable); conversionService.addConverter(Maybe.class, Single.class, (Function<Maybe, Single>) Maybe::toSingle); conversionService.addConverter(Maybe.class, Observable.class, (Function<Maybe, Observable>) Maybe::toObservable); conversionService.addConverter(Object.class, Maybe.class, (Function<Object, Maybe>) Maybe::just); conversionService.addConverter(Observable.class, Publisher.class, (Function<Observable, Publisher>) observable -> observable.toFlowable(BackpressureStrategy.BUFFER)); conversionService.addConverter(Observable.class, Single.class, (Function<Observable, Single>) Observable::firstOrError); conversionService.addConverter(Observable.class, Maybe.class, (Function<Observable, Maybe>) Observable::firstElement); conversionService.addConverter(Object.class, Observable.class, (Function<Object, Observable>) o -> { if (o instanceof Iterable) { return Observable.fromIterable((Iterable) o); conversionService.addConverter(Single.class, Publisher.class, (Function<Single, Publisher>) Single::toFlowable); conversionService.addConverter(Single.class, Maybe.class, (Function<Single, Maybe>) Single::toMaybe); conversionService.addConverter(Single.class, Observable.class, (Function<Single, Observable>) Single::toObservable); conversionService.addConverter(Object.class, Single.class, (Function<Object, Single>) Single::just); conversionService.addConverter(Flowable.class, Single.class, (Function<Flowable, Single>) Flowable::firstOrError); conversionService.addConverter(Flowable.class, Maybe.class, (Function<Flowable, Maybe>) Flowable::firstElement); conversionService.addConverter(Flowable.class, Observable.class, (Function<Flowable, Observable>) Flowable::toObservable); conversionService.addConverter(Object.class, Flowable.class, (Function<Object, Flowable>) o -> { if (o instanceof Iterable) { return Flowable.fromIterable((Iterable) o); conversionService.addConverter( Publisher.class, Flowable.class, (Function<Publisher, Flowable>) publisher -> { conversionService.addConverter(Publisher.class, Single.class, (Function<Publisher, Single>) Single::fromPublisher);
/** * @param interval The interval as a string * @return The {@link HTTPCheck} instance */ public HTTPCheck interval(String interval) { this.interval = ConversionService.SHARED.convert(interval, Duration.class).orElseThrow(() -> new IllegalArgumentException("Invalid Duration Specified")); return this; }