@VisibleForTesting @SuppressWarnings("squid:S1872") boolean isOptional(ResolvedMethodParameter methodParameter) { return "java.util.Optional".equals(methodParameter.getParameterType().getErasedType().getName()); }
@Override protected boolean doEquivalent(ResolvedMethodParameter a, ResolvedMethodParameter b) { return Objects.equal(a.defaultName(), b.defaultName()) && Objects.equal(a.getParameterIndex(), b.getParameterIndex()) && Objects.equal(a.getParameterType(), b.getParameterType()); }
@Override protected int doHash(ResolvedMethodParameter self) { return Objects.hashCode( self.defaultName(), self.getParameterIndex(), self.getParameterType()); } }
private boolean handlerMethodHasFileParameter(OperationContext context) { List<ResolvedMethodParameter> methodParameters = context.getParameters(); for (ResolvedMethodParameter resolvedMethodParameter : methodParameters) { if (MultipartFile.class.isAssignableFrom(resolvedMethodParameter.getParameterType().getErasedType())) { return true; } } return false; }
private void collectParameters(RequestMappingContext context) { LOG.debug("Reading parameters models for handlerMethod |{}|", context.getName()); List<ResolvedMethodParameter> parameterTypes = context.getParameters(); for (ResolvedMethodParameter parameterType : parameterTypes) { if (parameterType.hasParameterAnnotation(RequestBody.class) || parameterType.hasParameterAnnotation(RequestPart.class)) { ResolvedType modelType = context.alternateFor(parameterType.getParameterType()); LOG.debug("Adding input parameter of type {}", resolvedTypeSignature(modelType).or("<null>")); context.operationModelsBuilder().addInputParam(modelType); } } LOG.debug("Finished reading parameters models for handlerMethod |{}|", context.getName()); } }
@Override public void apply(ParameterContext context) { ResolvedType parameterType = context.resolvedMethodParameter().getParameterType(); context.parameterBuilder().allowMultiple(isCollectionType(parameterType)); }
private List<Parameter> readParameters(final OperationContext context) { List<ResolvedMethodParameter> methodParameters = context.getParameters(); List<Parameter> parameters = newArrayList(); for (ResolvedMethodParameter methodParameter : methodParameters) { ResolvedType alternate = context.alternateFor(methodParameter.getParameterType()); if (!shouldIgnore(methodParameter, alternate, context.getIgnorableParameterTypes())) { ParameterContext parameterContext = new ParameterContext(methodParameter, new ParameterBuilder(), context.getDocumentationContext(), context.getGenericsNamingStrategy(), context); if (shouldExpand(methodParameter, alternate)) { parameters.addAll( expander.expand( new ExpansionContext("", alternate, context))); } else { parameters.add(pluginsManager.parameter(parameterContext)); } } } return FluentIterable.from(parameters).filter(not(hiddenParams())).toList(); }
@Override public void apply(OperationContext context) { List<Parameter> parameters = newArrayList(); for (ResolvedMethodParameter methodParameter : context.getParameters()) { ResolvedType resolvedType = methodParameter.getParameterType(); if (pageableType.equals(resolvedType)) { ParameterContext parameterContext = new ParameterContext(methodParameter, new ParameterBuilder(), context.getDocumentationContext(), context.getGenericsNamingStrategy(), context); parameters.add(createPageParameter(parameterContext)); parameters.add(createSizeParameter(parameterContext)); parameters.add(createSortParameter(parameterContext)); context.operationBuilder().parameters(parameters); } } }
protected Function<ResolvedType, ? extends ModelReference> createModelRefFactory(ParameterContext context) { ModelContext modelContext = inputParam( context.getGroupName(), context.resolvedMethodParameter().getParameterType(), context.getDocumentationType(), context.getAlternateTypeProvider(), context.getGenericNamingStrategy(), context.getIgnorableParameterTypes()); return modelRefFactory(modelContext, nameExtractor); }
Function<ResolvedType, ? extends ModelReference> createModelRefFactory(ParameterContext context) { ModelContext modelContext = inputParam( context.getGroupName(), context.resolvedMethodParameter().getParameterType(), context.getDocumentationType(), context.getAlternateTypeProvider(), context.getGenericNamingStrategy(), context.getIgnorableParameterTypes()); return modelRefFactory(modelContext, nameExtractor); }
@Override public void apply(ParameterContext context) { Optional<ApiParam> apiParam = context.resolvedMethodParameter().findAnnotation(ApiParam.class); context.parameterBuilder() .allowableValues(allowableValues( context.alternateFor(context.resolvedMethodParameter().getParameterType()), apiParam.transform(toAllowableValue()).or(""))); if (apiParam.isPresent()) { ApiParam annotation = apiParam.get(); context.parameterBuilder().name(emptyToNull(annotation.name())) .description(emptyToNull(descriptions.resolve(annotation.value()))) .parameterAccess(emptyToNull(annotation.access())) .defaultValue(emptyToNull(annotation.defaultValue())) .allowMultiple(annotation.allowMultiple()) .allowEmptyValue(annotation.allowEmptyValue()) .required(annotation.required()) .scalarExample(new Example(annotation.example())) .complexExamples(examples(annotation.examples())) .hidden(annotation.hidden()) .collectionFormat(annotation.collectionFormat()) .order(SWAGGER_PLUGIN_ORDER); } }
ResolvedType resolvedType = methodParameter.getParameterType();
@Override public void apply(ParameterContext context) { ResolvedMethodParameter methodParameter = context.resolvedMethodParameter(); ResolvedType parameterType = methodParameter.getParameterType(); parameterType = context.alternateFor(parameterType); ModelReference modelRef = null;
public static String findParameterType(ParameterContext parameterContext) { ResolvedMethodParameter resolvedMethodParameter = parameterContext.resolvedMethodParameter(); ResolvedType parameterType = resolvedMethodParameter.getParameterType(); parameterType = parameterContext.alternateFor(parameterType);