/** * @return The return type as an argument */ default Argument<T> asArgument() { Collection<Argument<?>> values = getTypeVariables().values(); return Argument.of(getType(), values.toArray(new Argument[0])); }
private void registerSupplier(ExecutableMethod<?, ?> method, String functionId) { ClassLoadingReporter.reportBeanPresent(method.getReturnType().getType()); suppliers.put(functionId, method); }
private void processHttpMethods(Collection<BeanDefinition<?>> clientBeans) { for (BeanDefinition<?> clientBean : clientBeans) { final Optional<Class[]> additionalTypes = clientBean.getValue(TypeHint.class, Class[].class); additionalTypes.ifPresent(classes -> { for (Class aClass : classes) { ClassLoadingReporter.reportBeanPresent(aClass); } }); final Collection<? extends ExecutableMethod<?, ?>> executableMethods = clientBean.getExecutableMethods(); executableMethods.parallelStream().forEach((Consumer<ExecutableMethod<?, ?>>) executableMethod -> { if (executableMethod.hasStereotype(HttpMethodMapping.class)) { final ReturnType<?> returnType = executableMethod.getReturnType(); final Class<?> javaType = returnType.getType(); if (!ClassUtils.isJavaLangType(javaType)) { ClassLoadingReporter.reportBeanPresent(javaType); } reportArguments(returnType.getTypeParameters()); reportArguments(executableMethod.getArguments()); } }); } }
private void registerBiFunction(ExecutableMethod<?, ?> method, String functionId) { ClassLoadingReporter.reportBeanPresent(method.getReturnType().getType()); for (Class argumentType : method.getArgumentTypes()) { ClassLoadingReporter.reportBeanPresent(argumentType); } biFunctions.put(functionId, method); }
private void registerFunction(ExecutableMethod<?, ?> method, String functionId) { ClassLoadingReporter.reportBeanPresent(method.getReturnType().getType()); for (Class argumentType : method.getArgumentTypes()) { ClassLoadingReporter.reportBeanPresent(argumentType); } functions.put(functionId, method); } }
ClassLoadingReporter.reportBeanPresent(method.getReturnType().getType()); for (Class argumentType : method.getArgumentTypes()) { ClassLoadingReporter.reportBeanPresent(argumentType);
Class<Object> javaReturnType = returnType.getType(); if (Publishers.isConvertibleToPublisher(javaReturnType)) { Maybe flowable = functionDefinition.firstElement().flatMap(def -> { }); flowable = flowable.switchIfEmpty(Maybe.error(new FunctionNotFoundException(functionName))); return ConversionService.SHARED.convert(flowable, returnType.asArgument()).orElseThrow(() -> new FunctionExecutionException("Unsupported reactive type: " + returnType.getType())); } else {
Flowable<MutableHttpResponse<?>> routePublisher = buildRoutePublisher( methodBasedRoute.getDeclaringType(), methodBasedRoute.getReturnType().getType(), methodBasedRoute.getAnnotationMetadata(), requestReference,
Class<?> javaReturnType = genericReturnType.getType();
Class<?> javaReturnType = returnType.getType();
Class<?> returnJavaType = method.getReturnType().getType(); if (ClassLoadingReporter.isReportingEnabled()) { ClassLoadingReporter.reportBeanPresent(returnJavaType);
@Override public void process(BeanDefinition<?> beanDefinition, ExecutableMethod<?, ?> method) { Optional<Class<? extends Annotation>> actionAnn = method.getAnnotationTypeByStereotype(HttpMethodMapping.class); actionAnn.ifPresent(annotationClass -> { BiConsumer<BeanDefinition, ExecutableMethod> handler = httpMethodsHandlers.get(annotationClass); if (handler != null) { ClassLoadingReporter.reportBeanPresent(method.getReturnType().getType()); for (Class argumentType : method.getArgumentTypes()) { ClassLoadingReporter.reportBeanPresent(argumentType); } handler.accept(beanDefinition, method); } } ); }
@Override public String toString() { String text = Argument.toString(getArguments()); return getReturnType().getType().getSimpleName() + " " + getMethodName() + "(" + text + ")"; }
@Override public String toString() { String text = Argument.toString(getArguments()); return getReturnType().getType().getSimpleName() + " " + getMethodName() + "(" + text + ")"; }
@Override public Optional<ExecutorService> select(MethodReference method) { if (method.hasStereotype(NonBlocking.class)) { return Optional.empty(); } else { Class returnType = method.getReturnType().getType(); if (isNonBlocking(returnType)) { return Optional.empty(); } if (HttpResponse.class.isAssignableFrom(returnType)) { Optional<Argument<?>> generic = method.getReturnType().getFirstTypeVariable(); if (generic.isPresent()) { Class argumentType = generic.get().getType(); if (isNonBlocking(argumentType)) { return Optional.empty(); } } } } return Optional.of(ioExecutor); }
); ReturnType<Object> rt = context.getReturnType(); Class<?> returnType = rt.getType(); if (CompletionStage.class.isAssignableFrom(returnType)) { CompletableFuture newFuture = new CompletableFuture();
@Override public Object intercept(MethodInvocationContext<Object, Object> context) { if (context.hasStereotype(CacheConfig.class)) { ReturnType returnTypeObject = context.getReturnType(); Class returnType = returnTypeObject.getType(); if (CompletableFuture.class.isAssignableFrom(returnType)) { return interceptCompletableFuture(context, returnTypeObject, returnType); } else if (Publishers.isConvertibleToPublisher(returnType)) { return interceptPublisher(context, returnTypeObject, returnType); } else { return interceptSync(context, returnTypeObject, returnType); } } else { return context.proceed(); } }
Class<Object> javaReturnType = returnType.getType(); if (Publishers.isConvertibleToPublisher(javaReturnType)) { ConversionService<?> conversionService = ConversionService.SHARED;
/** * @param beanDefinition The bean definition to process * @param method The executable method */ @Override public void process(BeanDefinition<?> beanDefinition, ExecutableMethod<?, ?> method) { Class<?> declaringType = method.getDeclaringType(); if (method.hasStereotype(getSupportedAnnotation())) { Optional<String> endPointId = resolveActiveEndPointId(declaringType); endPointId.ifPresent(id -> { ClassLoadingReporter.reportBeanPresent(method.getReturnType().getType()); for (Class argumentType : method.getArgumentTypes()) { ClassLoadingReporter.reportBeanPresent(argumentType); } registerRoute(method, id); }); } }
/** * @param beanDefinition The bean definition to process * @param method The executable method */ @Override public void process(BeanDefinition<?> beanDefinition, ExecutableMethod<?, ?> method) { Class<?> declaringType = method.getDeclaringType(); if (method.hasStereotype(getSupportedAnnotation())) { Optional<String> endPointId = resolveActiveEndPointId(declaringType); endPointId.ifPresent(id -> { ClassLoadingReporter.reportBeanPresent(method.getReturnType().getType()); for (Class argumentType : method.getArgumentTypes()) { ClassLoadingReporter.reportBeanPresent(argumentType); } registerRoute(method, id); }); } }