@Override public String getName() { return argument.getName(); }
this.mediaTypeCodecRegistry = mediaTypeCodecRegistry; this.byteBufferFactory = byteBufferFactory; Class<?> rawBodyType = bodyType != null ? bodyType.getType() : null; if (rawBodyType != null && !HttpStatus.class.isAssignableFrom(rawBodyType)) { if (HttpResponse.class.isAssignableFrom(bodyType.getType())) { Optional<Argument<?>> responseBodyType = bodyType.getFirstTypeVariable(); if (responseBodyType.isPresent()) { Argument<B> finalResponseBodyType = (Argument<B>) responseBodyType.get(); this.body = !errorStatus || isParseableBodyType(finalResponseBodyType.getType()) ? getBody(finalResponseBodyType).orElse(null) : null; } else { this.body = null;
/** * Creates a new argument representing a generic list. * * @param type list element type * @param <T> list element type * @return The argument instance */ static <T> Argument<List<T>> listOf(Class<T> type) { //noinspection unchecked return of((Class<List<T>>) ((Class) List.class), type); }
@Override public boolean equalsType(Argument<?> o) { if (this == o) { return true; } if (o == null) { return false; } return Objects.equals(type, o.getType()) && Objects.equals(typeParameters, o.getTypeVariables()); }
/** * Returns the string representation of the argument type, including generics. * * @param simple If true, output the simple name of types * @return The type string representation */ default String getTypeString(boolean simple) { Class<T> type = getType(); StringBuilder returnType = new StringBuilder(simple ? type.getSimpleName() : type.getName()); Map<String, Argument<?>> generics = getTypeVariables(); if (!generics.isEmpty()) { returnType .append("<") .append(generics.values() .stream() .map(arg -> arg.getTypeString(simple)) .collect(Collectors.joining(", "))) .append(">"); } return returnType.toString(); }
@Override public <T> Optional<ArgumentBinder<T, HttpRequest<?>>> findArgumentBinder(Argument<T> argument, HttpRequest<?> source) { Optional<Class<? extends Annotation>> opt = argument.getAnnotationMetadata().getAnnotationTypeByStereotype(Bindable.class); if (opt.isPresent()) { Class<? extends Annotation> annotationType = opt.get(); RequestArgumentBinder<T> binder = findBinder(argument, annotationType); if (binder == null) { binder = byAnnotation.get(annotationType); } if (binder != null) { return Optional.of(binder); } } else { RequestArgumentBinder<T> binder = byType.get(argument.typeHashCode()); if (binder != null) { return Optional.of(binder); } else { binder = byType.get(Argument.of(argument.getType()).typeHashCode()); if (binder != null) { return Optional.of(binder); } } } return Optional.of(new ParameterAnnotationBinder<>(conversionService)); }
boolean permitsRequestBody = HttpMethod.permitsRequestBody(httpMethod); AnnotationMetadata annotationMetadata = argument.getAnnotationMetadata(); boolean hasAnnotation = annotationMetadata.hasAnnotation(QueryValue.class); String parameterName = annotationMetadata.getValue(QueryValue.class, String.class).orElse(argument.getName()); Object value; if (Iterable.class.isAssignableFrom(argument.getType())) { value = doResolve(context, parameters, parameterName); if (value == null) { if (argument.getType() == Optional.class) { argumentType = argument.getFirstTypeVariable().orElse(argument).getType(); } else { argumentType = argument.getType();
String valueAnnStr = argument.getAnnotationMetadata().getValue(Value.class, String.class).orElse(null); Class argumentType = argument.getType(); String argumentName = argument.getName(); String valString = resolvePropertyValueName(resolutionContext, injectionPoint.getAnnotationMetadata(), argument, valueAnnStr); return value.get(); } else { if (argument.isDeclaredAnnotationPresent(Nullable.class)) { return null;
Argument<?> argument = requiredInput.get(); Supplier<Object> value; boolean isPublisher = Publishers.isConvertibleToPublisher(argument.getType()); boolean chunkedProcessing = false; Argument typeVariable; if (StreamingFileUpload.class.isAssignableFrom(argument.getType())) { typeVariable = Argument.of(PartData.class); } else { typeVariable = argument.getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT); Class typeVariableType = typeVariable.getType(); boolean streamingFileUpload = StreamingFileUpload.class.isAssignableFrom(typeVariableType); if (streamingFileUpload) { typeVariable = Argument.of(PartData.class); } else { typeVariable = typeVariable.getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT); StreamingFileUpload.class.isAssignableFrom(argument.getType())) { dataReference.upload.getAndUpdate(upload -> { if (upload == null) { String argumentName = argument.getName(); if (!routeMatch.isSatisfied(argumentName)) { routeMatch = routeMatch.fulfill(Collections.singletonMap(argumentName, value.get()));
@Override public Class<V> getType() { return argument.getType(); }
private Object getBeanForMethodArgument(BeanResolutionContext resolutionContext, BeanContext context, MethodInjectionPoint injectionPoint, Argument argument) { Class argumentType = argument.getType(); if (argumentType.isArray()) { Collection beansOfType = getBeansOfTypeForMethodArgument(resolutionContext, context, injectionPoint, argument); return bean; } catch (NoSuchBeanException e) { if (argument.isDeclaredAnnotationPresent(Nullable.class)) { path.pop(); return null;
HttpMethod httpMethod = source.getMethod(); AnnotationMetadata annotationMetadata = argument.getAnnotationMetadata(); boolean hasAnnotation = annotationMetadata.hasAnnotation(PathVariable.class); String parameterName = annotationMetadata.getValue(PathVariable.class, String.class).orElse(argument.getName()); Object value; if (Iterable.class.isAssignableFrom(argument.getType())) { value = doResolve(context, variableValues, parameterName); if (value == null) {
Optional<Argument> bodyArg = Arrays.stream(context.getArguments()).filter(arg -> arg.isAnnotationPresent(Body.class)).findFirst(); if (bodyArg.isPresent()) { body = parameterValueMap.get(bodyArg.get().getName()); } else { body = parameterValueMap; def, body, Argument.of(Maybe.class, returnType.getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT)) ); });
Argument<?>[] requiredArguments = getRequiredArguments(); for (Argument<?> requiredArgument : requiredArguments) { if (requiredArgument.getType() == BeanResolutionContext.class) { requiredArgumentValues.put(requiredArgument.getName(), resolutionContext); try { path.pushConstructorResolve(this, requiredArgument); String argumentName = requiredArgument.getName(); if (!requiredArgumentValues.containsKey(argumentName) && !requiredArgument.isAnnotationPresent(Nullable.class)) { throw new BeanInstantiationException(resolutionContext, "Missing bean argument value: " + argumentName); boolean requiresConversion = value != null && !requiredArgument.getType().isInstance(value); if (requiresConversion) { Optional<?> converted = ConversionService.SHARED.convert(value, requiredArgument.getType(), ConversionContext.of(requiredArgument)); Object finalValue = value; value = converted.orElseThrow(() -> new BeanInstantiationException(resolutionContext, "Invalid value [" + finalValue + "] for argument: " + argumentName));
private Object resolveValue(ArgumentConversionContext<T> context, ConvertibleValues<?> values, String annotationValue) { Argument<T> argument = context.getArgument(); if (StringUtils.isEmpty(annotationValue)) { annotationValue = argument.getName(); } return values.get(annotationValue, context).orElseGet(() -> conversionService.convert(argument.getAnnotationMetadata().getValue(Bindable.class, DEFAULT_VALUE_MEMBER, String.class).orElse(null), context).orElse(null) ); }
if (argument.getType() == Optional.class) { if (bindingResult.isSatisfied() || satisfyOptionals) { Optional optionalValue = bindingResult.getValue(); } else if (HttpMethod.requiresRequestBody(request.getMethod()) || argument.isAnnotationPresent(Nullable.class)) { value = (UnresolvedArgument) () -> { ArgumentBinder.BindingResult result = argumentBinder.bind(conversionContext, request);
); Argument argument = segment.getArgument(); AnnotationValue<Client> annotation = argument.getAnnotationMetadata().findAnnotation(Client.class).orElse(null); if (annotation == null) { throw new DependencyInjectionException(resolutionContext, argument, "ClientScope called for injection point that is not annotated with @Client"); if (!HttpClient.class.isAssignableFrom(argument.getType()) && !WebSocketClient.class.isAssignableFrom(argument.getType())) { throw new DependencyInjectionException(resolutionContext, argument, "@Client used on type that is not an HttpClient");
@Override public AnnotationMetadata getAnnotationMetadata() { return argument.getAnnotationMetadata(); } }
private void reportArguments(Argument... arguments) { if (ArrayUtils.isNotEmpty(arguments)) { for (Argument argument : arguments) { final Class argType = argument.getType(); if (!ClassUtils.isJavaLangType(argType)) { ClassLoadingReporter.reportBeanPresent(argType); } reportArguments(argument.getTypeParameters()); } } } }
private Qualifier resolveQualifier(BeanResolutionContext resolutionContext, Argument argument) { Qualifier qualifier = null; AnnotationMetadata annotationMetadata = argument.getAnnotationMetadata(); Optional<Class<? extends Annotation>> qualifierType = annotationMetadata.getAnnotationTypeByStereotype(javax.inject.Qualifier.class); if (qualifierType.isPresent()) { qualifier = Qualifiers.byAnnotation( annotationMetadata, qualifierType.get() ); } if (qualifier == null) { Class<?>[] byType = annotationMetadata.hasDeclaredAnnotation(Type.class) ? annotationMetadata.getValue(Type.class, Class[].class).orElse(null) : null; if (byType != null) { qualifier = Qualifiers.byType(byType); } else { Optional<Qualifier> optional = resolutionContext.get(javax.inject.Qualifier.class.getName(), Map.class) .map(map -> (Qualifier) map.get(argument)); qualifier = optional.orElse(null); if (qualifier == null && isIterable() && argument.isAnnotationPresent(Parameter.class)) { qualifier = optional.orElseGet(() -> { final Optional<String> n = resolutionContext.get(Named.class.getName(), String.class); return n.map(Qualifiers::byName).orElse(null); }); } } } return qualifier; }